bclose

Display de 7 segmentos

Mostrando informacion numérica
tienda online prometec

Objetivos

 

 

    • Nuestro primer display numérico de 1 digito.
    • Mas sobre los arrays.
 

Material requerido.

Imagen de Arduino UNO

 Arduino Uno o similar.

Esta sesión acepta cualquier otro modelo de Arduino.

 

Protoboard

 Una Protoboard.

conexiones

 Cables  de protoboard

componente

 Una resistencia.

BCD 1 digito  Un display de 1 dígito.

 

Los displays LED

 

En cuanto empecéis a plantearos hacer un circuito que realice alguna función práctica, hay un 50% de probabilidades de que acabéis necesitando enviar información al mundo exterior (y claro no vais a dejar vuestro portátil pegado al invento).

Así que es el momento de ver que nos ofrece el mercado para mostrar información y para empezar, nada mejor que un sencillo display LED de 1 digito.

Los diodos LED ya no guardan secretos para los que nos siguen, pero esto de un display parece otra cosa.
Pues no. Es lo mismo pero en lugar de ser un punto luminoso como los familiares LED, tiene forma de barra: 7 barras más 1 punto.

Estos displays nos son bastante familiares en despertadores y similares, están formados por 7 líneas, que a dependiendo de qué segmentos  se iluminan, muestran los dígitos del 0 al 9.

A cada uno de los 7 segmentos se les adjudica una letra para representarlos y suele ser a, b, c, e, f, g y aparte un punto (o dos, o dos puntos según el fabricante) y es un buen momento para echar un vistazo a las especificaciones de cada fabricante para estar seguros de que pin es cual.

Todos los circuitos, los displays incluidos, llevan un código de fabricante rotulado. Es buena política buscar en internet la hoja de especificaciones(o data sheet) y echarle un ojo. Si no entendéis nada, es lo normal de momento, pero desde luego habrá un dibujo diciéndoos que es cada pin. Yo he buscado el modelo que tengo delante, (un Kingbright SC08-11HWA ), pero no os fieis, el vuestro puede ser distinto.

pinout patillaje
 
  • Desde que existe Internet, localizar una hoja de características es algo trivial (No como antes, que para conseguirlas había que pedir favores y mostrar las debidas muestras de respeto y sumisión a quien disponía de catálogos de componentes).
  • Probad a buscar en Google algo así como XXXXX data sheet, donde XXXXX son los códigos que habéis encontrado rotulado en el display o componente que sea.  

Lo importante es que sepáis que es cada pin, y que veáis que segmento es cual. En realidad es bastante más fácil de lo que parece, localizad primero un GND. En el de arriba son el 3, 5, 11 y 16.

Poned una resistencia (de 330Ω como siempre) de la salida del display a GND. Este es un display de cátodo común, o sea que todos los LEDS comparten la masa, pero necesitamos poner una resistencia de limitación o fundiréis el display, y este vale ya lo suficiente, como para que os cueste verle la gracia al tema.

Una vez que hayáis conectado la masa común con una resistencia, empezad cableando solo un LED, el a por ejemplo y conectadlo al pin 2 de Arduino. Escribid un programa en Arduino para iluminar el LED en el pin 2 y veréis como se enciende el segmento a.

Podéis ir conectando y probando el resto de los pines poco a poco, asegurando las conexiones. Es muy fácil equivocarse si no andáis con tiento.

 

Kit de Inicio Prometec.net 

Para los que uséis el nuevo kit de inicio de Prometec, el display que viene es un 5161AS que tiene un patillaje y cuyo diagrama es este:

patillaje del 6161AS

Para saber cual es el pin 1, poner el display de modo que viendo los numeros el punto decimal quede abajo a vuestra derecha. El pin numero 1 es en la parte inferior el primero por la izquierda, y luego ir contando en el sentido contrario a las agujas del reloj.

Numeracion de pines

 

 

Esquema eléctrico del circuito

 

Display 1 digito

El circuito no puede ser más sencillo, son como cuando hicimos un circuito con 8 diodos, solo que esta vez los 8 diodos están en una cajita y con forma para dibujar números.

 
  • Es importante que sigáis el esquema de aquí encima para que luego el programa coincida con vuestras conexiones.
  • Por eso no es importante que pin de vuestro display es el segmento C (Que dependerá del fabricante y modelo), pero si que es importante que el segmento C vaya al pin digital 4 de Arduino y lo mismo para los demás.  

No vamos a incluir el diagrama de protoboard, porque es difícil dejarlo más claro

Programa de control

 

Tenemos que comprobar que las conexiones son correctas lo primero. Probad esto:

void setup()
   {
        for (int i = 2; i<11; i++)
        pinMode(i, OUTPUT);
   }

void loop()
   {
        for ( int j= 2; j<11 ; j++)   // Va encendiendo los segmentos
           {
              digitalWrite(j, HIGH);
              delay(400) ;
           }
        for ( int j= 2; j<11 ; j++)   //Apaga todos los segmentos
              digitalWrite(j, LOW);
        delay(400) ;
   }

En el setup, inicializamos los 8 pines de salida con for (recordar que somos vagos) y en el loop usamos una primera iteración que va iluminando los 8 segmentos con un delay, y en la segunda los borra y vuelta a empezar. La idea es comprobar que las conexiones son correctas.Vereis algo así:

Lo siguiente es mostrar los dígitos del 0 al 9.

Para ello, lo más rápido es hacerte una tabla para ver que segmentos tienes que iluminar para cada digito decimal, y vas apuntando cuales son 1 (encendido) o 0 (apagado).

  DIGITO a b c d e f g punto
 Nombres de segmentos 0 1 1 1 1 1 1 0 0
1 0 1 1 0 0 0 0 0
2 1 1 0 1 1 0 1 0
3 1 1 1 1 0 0 1 0
4 0 1 1 0 0 1 1 0
5 1 0 1 1 0 1 1 0
6 1 0 1 1 1 1 1 0
7 1 1 1 0 0 0 0 0
8 1 1 1 1 1 1 1 0
9 1 1 1 0 0 1 1 0
 
  • Aunque os damos los deberes hechos, haced la prueba con alguno de los dígitos, simplemente, para aseguraros de que entendéis la idea
 

Ahora solo queda escribir el programa que dibuja los números en el display, así que vamos a ello.

Programa que dibuja los dígitos

 

La primera idea que se nos ocurre a todos es hacer una función por cada digito que queramos representar. Por ejemplo podríamos hacer:

void Display7()
   {
       digitalWrite(2, 1) ;        // Si, podemos decir 1 y 0 en lugar de HIGH y LOW
       digitalWrite(3,1);
       digitalWrite(4,1);
       digitalWrite(5,0);
       …………..
   }

Es decir, encendemos los pines correspondientes a cada segmento a imagen de la tabla previa.

El problema de este enfoque es que hay que hacer 10 funciones como esta y luego escribir en el programa principal algo que llame a la función correspondiente según el número que queramos mostrar.

Esta es, de nuevo, la solución de fuerza bruta y no, aquí no permitimos esas cosas, nos gustan las soluciones elegantes (y porque, además, somos muy vagos y nos cansamos solo de pensar en hacerlo así).

 
  • Por cierto, para ser alguien en la comunidad freaky, hay que hablar de la elegancia de tu código siempre que surja la ocasión, si queréis ser programadores es muy importante que empecéis a adoptar las poses del gremio. 
 

Así que vamos a buscar otra solución más elegante. Para empezar, todos los que al ver  la última tabla, con los segmentos que hay que iluminar, hayáis pensado que se parece sospechosamente a un array de 10 x 8 podéis anotaros un punto por listos.

Porque por supuesto vamos a crear una array con todo eso (No, no tenemos comisiones por vender los arrays) y veréis que el programa se simplifica mucho.

De nuevo, como con todo en la vida, es mucho más fácil de lo que parece. Vamos a empezar definiendo el array de dos dimensiones (porque es una tabla, otra cosa son el número de elementos por dimensión):

byte  Digit[10][8] =                // Arduino UNO va muy justo de memoria. Por eso lo
{                                   // definimos como byte y no como int
   { 1,1,1,1,1,1,0,0 },    // 0   
   { 0,1,1,0,0,0,0,0 },    // 1
   { 1,1,0,1,1,0,1,0 },    // 2
   { 1,1,1,1,0,0,1,0 },    // 3
   { 0,1,1,0,0,1,1,0 },    // 4
   { 1,0,1,1,0,1,1,0 },    // 5
   { 1,0,1,1,1,1,1,0 },    // 6
   { 1,1,1,0,0,0,0,0 },    // 7
   { 1,1,1,1,1,1,1,0 },    // 8
   { 1,1,1,0,0,1,1,0 }     // 9
};

Si os fijáis, he copiado directamente la tabla de mostrar los dígitos, pero en un array de 10 elementos, cada uno de los cuales es un array de 8(segmentos). La sintaxis es más o menos complicada, pero no hay más y esto ya lo habíamos hecho antes.

Podemos ahora crear una función, que pasándole un número de 0 a 9, elija la fila del array en función de ese mismo número y busque el array interno correspondiente.

void Display(int N)
   {
       for (int i= 0 ; i<8 ; i++)
            {   int valor = Digit[N][i] ;
                int pin = i+2;
                digitalWrite(pin , valor) ;
            }
   }

Buscamos  valor en la tabla cuyo índice principal N apunta al array interno correspondiente.  El for i, va leyendo los 8 elementos del array para escribirlos en el pin correspondiente de salida, que lo calculamos como i +2, (Porque usamos los pines 2 al 10 para conectar los segmentos del display y así unos valores de 1 de 0 a 8 se convierten en pines de 2 al 10).

void setup()
   {   for (int i= 2; i<11; i++)
            pinMode(i, OUTPUT);
   }

void loop()
   {
       for ( int k=0 ; k<10 ; k++)    // Llama a Display para k de 0 a 9, los digitos
         {  Display(k);
            delay(1000);
         }
   }

void Display(int N)
   {
      for (int i= 0 ; i<8 ; i++)
           {   int valor = Digit[N][i] ;
               int pin = i+2; 
               digitalWrite(pin , valor) ;    // digitalWrite(i+2 , Digit[N][i] ) ;
           }
   }

Fijaros que podíamos haber escrito así (El código compacto también puntúa con los colegas):

void Display(int N)
   {      for (int i= 0 ; i<8 ; i++)
               digitalWrite(i+2 , Digit[N][i] ) ;
   }

He aprovechado este ejemplo para insistir con los arrays, porque son muy útiles para resolver problemas que de otro modo se pueden complicar bastante.

Un problema que a priori, era muy pesado, o complejo, se transforma en una nimiedad recorriendo la tabla. He visto varios ejemplos por internet de este programa y la mayor parte de ellos me ha dado dolor de cabeza (Con algunas muy honrosas excepciones).

La cosa ha ido bastante bien con un digito, pero… ¿Y si queremos mostrar 4 dígitos? ¿Vamos a multiplicar 8 cables x 4 dígitos más tensión y GND = 34 pines?

En la próxima sesión veremos cómo manejar un display de 4 dígitos, porque para eso los venden hechos, y no es necesario volvernos locos enchufando no sé cuántos cables para hacer un reloj.

 
  • Como esta sesión ya es suficientemente densa, no incluiré el ejemplo de conectar un único digito a un shift register para gobernarlo, pero os recomiendo que lo hagáis como práctica, y si es preciso, colgamos el ejemplo en la página web.
 

 

 

Resumen de la sesión

 

 
    • Hemos presentado los displays LED de 7 segmentos y un dígito.
    • Son LEDs completamente normales, solo que en forma de líneas y no de puntos.
    • Algunas de las funciones que hemos definido nos seran útiles en los siguientes capítulos para gobernar mas display
 

 

 

 

(49) Comments

    • Bryan Rivera

    Hola necesito ayuda urgente, con mi proyecto de graduacion, si no lo entrego en 2 dias no me graduare, por favor.

    • Hola Bryan, ¿que problema tienes?

    • María

    Muchas gracias, me gustó mucho, como dices, una forma elegante de programar.
    Te quiero preguntar cómo podríamos hacer que en lugar de que aparecieran los números en forma ordenada, aparecieran aleatoriamente.
    Gracias 🙂

    • Hola Maria, puedes usar la funcion random() de arduino para generar numeros seudo aleatorios

    • Osael

    excelente tu solucion con una matriz, tomando encuata tu metodo, use un vector para minimizar el usa de ram

    byte Digit[] = // Arduino UNO va muy justo de memoria. Por eso lo
    { // definimos como byte y no como int
    0x3F, // 0
    0x6, // 1
    0x5B, // 2
    0x4F, // 3
    0x66, // 4
    0x6D, // 5
    0x7D, // 6
    0x7, // 7
    0x7F, // 8
    0x67 // 9
    };

    void setup()
    { for (int i = 2; i < 11; i++)
    pinMode(i, OUTPUT);
    }

    void loop()
    {
    for ( int k = 0 ; k < 10 ; k++) // Llama a Display para k de 0 a 9, los digitos
    { for (int i = 0 ; i < 8 ; i++)
    digitalWrite(i + 2 , bitRead( Digit[k], i) );
    delay(1000);
    }
    }

    • Hola Osael, muy buen aporte. Gracias y un saludo.

Give a Reply

WordPress Anti-Spam by WP-SpamShield