Cuando creamos un proyecto con Arduino, normalmente mostramos los datos a través del monitor serie. Es una manera rápida de poder comprobar los valores de variables y entradas, tanto digitales como analógicas. Existen diferentes interfaces hardware que permiten que las máquinas se comuniquen con nosotros. Una de ellas es el display 7 segmentos, un componente muy típico. Pero podemos encontrar otros como un LCD o una matriz de LEDs.
En este artículo te voy a explicar como utilizar un display 7 segmentos con Arduino. Vamos a verlo con un caso práctico, crearemos un dado electrónico que nos permita seleccionar un número al azar entre 6 posibles.
Esto lo mostraremos en el display LED 7 segmentos con Arduino. Aprenderás todo lo que necesitas saber sobre este componente, veremos cómo programarlo y descubrirás a obtener números aleatorios desde el código nativo de Arduino.
Indice de contenidos
Display 7 segmentos, el componente electrónico
Siempre que nos enfrentemos a un nuevo componente, es recomendable documentarse. Para ello tenemos las hojas de características técnicas o datasheet. Todo dependerá del modelo de display LED 7 segmentos. Pero, ¿cómo puedes saber que modelo tienes? Todos los componentes suelen tener una numeración inscrita en alguna parte.
Solo tenemos que descubrirla y meter esa numeración en Google seguido de datasheet. Esto nos mostrará una serie de páginas donde encontramos información muy valiosa. En mi caso el display 7 segementos es el 5101AS.
De los resultados obtenidos nos vamos a uno de ellos (preferible buscar en algún PDF) y miramos que características tiene este componente. Pero ojo, no nos debemos fiar siempre de lo que nos diga Google. En algunos casos, encontramos cosas que están erróneas. [icon name=»lightbulb-o» class=»» unprefixed_class=»»] Hay varias páginas donde nos ofrecen fichas técnicas de componentes. Dos de las más famosas son Datasheet Catalog y All Datasheet.
Analizando el display de 7 segmentos
Un display 7 segmentos es un componente que tiene 7 segementos LEDs, más un LED que hará de punto. Este punto nos indica cómo hay que colocar el display, y siempre irá hacia abajo. Por lo tanto, debemos trabajar como si tuviéramos 7 LEDs conectados a nuestro Arduino.
Existen dos tipos de displays de 7 segmentos, los de ánodo común y los de cátodo común. Esto quiere decir que en los primeros, todos los LEDs comparten un mismo ánodo, y en los segundos, que todos los LEDs comparten un mismo cátodo. Veremos más adelante un esquema de cada uno de ellos y cómo identificarlos.
Relación pines del display de 7 segmentos con los LEDs
Dentro del datasheet, encontrarás un dibujo parecido al que te muestro a continuación.
Identifica cada segemento LED con una letra. Así tenemos identificados cada uno de ellos. Este componente tiene 10 pines. Antes de hacer ninguna conexión debemos identificar los pines.
Fíjate bien que el punto siempre va hacia abajo.
Ahora lo único que nos falta es asociar cada pin a cada segmento LED. En la siguiente imagen puedes ver esa relación.
Podemos resumir todo lo anterior en la siguiente tabla.
| Pines | Segmentos |
| 1 | e |
| 2 | d |
| 4 | c |
| 6 | b |
| 7 | a |
| 9 | f |
| 10 | g |
¿Y qué pasa con el resto de pines? Nos quedan por saber qué hacer con los pines 3, 5 y 8. ¿Te acuerdas que hemos visto que hay un punto para indicar la orientación del display 7 segmentos?, pues este va conectado al pin número 5.
Los otros dos pines funcionarán como cátodo o ánodo, dependiendo del tipo de display de 7 segementos con el que estemos trabajando. Solo debemos utilizar una de esas dos conexiones, se trata de pines redundantes.
Al final, la tabla que relaciona los pines con los LEDs quedaría de la siguiente manera.
| Pines | Segmentos |
| 1 | e |
| 2 | d |
| 3 | ánodo/cátodo común |
| 4 | c |
| 5 | DP (punto) |
| 6 | b |
| 7 | a |
| 8 | ánodo/cátodo común |
| 9 | f |
| 10 | g |
Bueno, pues ya tenemos relacionados los pines con los segmentos (circuito eléctrico interno), ahora vamos a ver cómo mostrar un número en el display de 7 segmentos.
Mostrando un número en el display 7 segmentos
Para poder mostrar un número en el display 7 segmentos, lo que tenemos que hacer es iluminar aquellos segmentos para formar dicho número. Por ejemplo, si queremos mostrar el 4, debemos activar los segmentos f, g, b y c y desactivar el resto de segmentos.
Como estos tienen una relación con los pines de Arduino, solo tendríamos que poner en estado alto (HIGH) o bajo (LOW) esos pines (en la siguiente sección veremos los tipos de displays que tenemos a nuestra disposición). Todo esto lo haremos a nivel de programación. En el ejemplo de código, podrás ver cómo se hace.
Ánodo común o cátodo común, los dos tipos de display de 7 segmentos
Un diodo funciona de una manera muy particular, solo permite fluir la corriente a través de él en un sentido, de ánodo a cátodo. Un LED no deja de ser un diodo con otra particularidad, que emite luz. Ya lo vimos en el ejemplo dónde creábamos un semáforo inteligente con múltiples LEDs.
Un display 7 segmentos funciona de la misma manera, vamos a tener ánodos y cátodos, en concreto 8. Veamos el esquema eléctrico de los dos tipos de displays.
En mi caso, tengo un display de cátodo común. Pero si no estamos seguros de qué tipo de display tenemos entre mano, podemos hacer una simple prueba.
¿Cómo saber el display 7 segmentos que tengo?
La prueba es sencilla. Para saber si es de ánodo común lo único que tenemos que hacer es poner el pin 3 o pin 8 a la alimentación de 3,3 V o 5 V (poner una resistencia de 220 Ω en serie, luego veremos porqué), y el pin número 5 (DP punto) a tierra (pin GND de nuestro Arduino).
Si lo que tenemos un display ánodo común, la corriente pasará y se iluminará el punto. Si tenemos un display del tipo cátodo común, no se encenderá el LED (recuerda que en un LED la corriente solo fluye en un único sentido).
Dependiendo del resultado, sabremos el tipo de display de 7 segmentos que tenemos.
Voltaje de operación del display de 7 segmentos
Ya por último, debemos conocer el voltaje de operación del componente. Esto deberíamos de verlo en la hoja de característica técnicas de cada modelo. Lo típico es que funcione entre 1,8 V y 2,2 V (funcionamiento normal de un LED). Utilizando la Ley de Ohm, podemos calcular la resistencia que necesitamos para los dos casos, el mínimo (1,8 V) y el máximo (2,2 V).
Para el voltaje de 1,8 V:
Para el voltaje de 2,2 V:
Siempre y cuando el voltaje no supere el máximo, podemos alimentar el LED. Por lo tanto, si ponemos una resistencia mayor lo único que sucederá es que el LED iluminará menos.
Componentes necesarios para el dado electrónico
Ya hemos visto cómo funciona el display 7 segmentos. Lo tenemos todo claro para poder conectarlo a la protoboard y empezar a trabajar. Antes de ver las conexiones vamos a dar un repaso por el material que vamos a utilizar para crear el dado electrónico.
- Arduino UNO
- Protoboar (placa de prototipado)
- Cables para hacer conexiones
- 1 pulsador
- 1 resistencia de 10 kΩ
- 1 resistencia de 220 Ω
- 1 display de 7 segmentos
Display 7 segmentos y pulsador, montando el circuito
Vamos a montar el circuito de un display de 7 segmentos con un pulsador. Te voy a dejar las dos configuraciones, para cátodo común y para ánodo común.
Cátodo común
Ánodo común
[icon name=»lightbulb-o» class=»» unprefixed_class=»»] Como ves en las imágenes anteriores, no hay gran diferencia. Solo la conexión del pin número 3. En cátodo común va a tierra (GND) y en ánodo común va a la fuente (5 V). Donde si veremos diferencia es a la hora de programar. [icon name=»exclamation-triangle» class=»» unprefixed_class=»»] El pulsador siempre debe ir acompañado de una resistencia pull down o pull up. Dependerá del estado que queramos tener cuando la conexión con la entrada digital esté al aire.
Programando el dado eléctrico con el display 7 segmentos
Comenzamos con la programación. En términos de lógica, da lo mismo tener un display 7 segmentos en configuración de cátodo común que ánodo común. Donde si que encontraremos diferencias es a la hora de implementar la lógica.
Comenzaremos con el algoritmo, una breve descripción de los pasos que debemos seguir. Es recomendable plantear las ideas antes de ponerse a programar.
- Leemos el pulsador
- Si está en estado alto
- Obtenemos número aleatorio
- Mostramos el número en el display
- Esperamos un tiempo hasta permitir otra jugada
- Si está en estado bajo
- No hacemos nada
- Si está en estado alto
Es un código muy sencillo. Quizás, donde encontremos más dificultad, sea a la hora de mostrar los números en el display. Eso lo veremos ahora.
Variables y constantes
Comenzamos con una buena práctica. Declarar todas las constantes que relacionan los pines con los componentes. En este caso solo vamos a declarar una constante, el pulsador.
|
1 2 |
// Constantes pines #define PULSADOR 2 |
Para los pines del display 7 segementos, vamos a utilizar un array multidimensional. Lo primero es saber qué es un array o matriz. Este tipo de variables nos permite agrupar datos del mismo tipo.
Cuando hablo de array multidemensional, quiero decir que tendremos un array de arrays. Es sencillo, cada elemento del array principal es otro array. En este caso tendremos profundidad de 2, pero podríamos tener más profundidad.
Este tipo de arrays, donde tenemos 2 dimensiones, lo podemos ver como una tabla. Para acceder a un elemento tenemos que indicar la fila y la columna donde se encuentra dicho elemento. Esto viene indicado por el valor entre corchetes [columna] [fila].
En este caso crearemos un array con 10 elementos que serían los 10 números posibles, del 0 al 9. Cada elemento contendrá 1 array de 8 elementos que serían los pines a los que está conectado el display de 7 segmentos (7 para cada segmento y el punto).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// Array multidimensional para mostrar los números byte numero[10][8] = { { 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 }; |
Este array solo sirve para cátodo común. Si tenemos el otro tipo de display 7 segmentos, debemos cambiar los unos por los ceros y los ceros por unos.
Función setup
En esta función tenemos que establecer las condiciones iniciales. Lo primero es iniciar el monitor serie.
|
1 2 3 |
void setup() { // Iniciamos el monitor serie Serial.begin(9600); |
Luego seguimos con los segmentos del display. Hay que poner todos los pines donde está conectado (del 2 al 9) en modo salida (OUTPUT). Podemos hacerlo de dos maneras, hacerlo de uno a uno o con un bucle. La dificultad de este bucle es que no debemos empezar por el cero. Los pines que utilizamos son del 2 al 9, haremos un bucle que recorra todos estos números.
Dentro utilizaremos la variable del bucle como número de pin. Es muy sencillo, lo puedes comprobar a continuación.
|
1 2 3 4 5 |
// Ponemos los pines de los segmentos en modo OUTPUT (salida) for (int i = 3; i < 10; i++) { pinMode(i, OUTPUT); } |
A continuación, el pin del pulsador lo ponemos en modo entrada.
|
1 2 |
// Ponemos el pin del pulsador en modo INPUT (entradda) pinMode(PULSADOR, INPUT); |
Por último, establecemos la semilla fija para obtener el valor aleatorio a través de la función random. Esta semilla será una entrada analógica.
|
1 2 3 |
//Establecemos la semilla fija randomSeed(analogRead(A0)); } |
Como semilla, elegir un pin analógico que no se utilice. Como ya hemos visto con el pulsador, no establecer una resistencia pull down o pull up produce una indeterminación. Esto nos permitirá seleccionar un número aleatorio verdadero.
Función loop
Ahora vamos con la parte que se repite constantemente. Como hemos visto en la descripción del algoritmo, lo primero es leer el pin digital donde tenemos conectado el pulsador. Luego comprobamos si está en estado alto (pulsado).
|
1 2 3 4 5 6 7 |
void loop() { // Leemos el valor del pulsador int valor = digitalRead(PULSADOR); // Si está pulsado if (valor == HIGH) { |
Una vez que estemos seguro que se ha pulsado es cuando empezamos la secuencia de obtener un número aleatorio entre 1 y 6, con la función random, y mostramos el número que ha salido. La función random(min, max) admite dos parámetros el mínimo y el máximo.
Este máximo es exclusivo lo que quiere decir que debemos elegir el número entero superior al número máximo que queremos elegir. En nuestro caso sería random(1,7) para elegir un número entre 1 y 6.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
//Genera un numero aleatorio entre 1 y 6 int randomNumber = random(1, 7); // Ponemos los pines en estado correcto para mostrar el número randomNumber for (int e = 0; e < 8; e++) { digitalWrite(e + 3, numero[randomNumber][e]); } delay(500); } } |
Voy a describir el funcionamiento del bucle. Al final, para mostrar un número en el display, lo que tenemos que hacer es encender un LED y apagar los demás.
Por ejemplo, si queremos encender el número 1, tenemos que ir al elemento 1 (recuerda que antes hay otro elemento que es el elemento 0. Será el array con 8 valores).
|
1 |
{ 0, 1, 1, 0, 0, 0, 0, 0 } |
El primer elemento indica el primer LED (corresponde con la letra e y el pin 2). Por lo tanto, el pin 2 al valor que nos indica el array, 0 V (LOW).
El siguiente elemento es el pin 3 (letra c), lo tenemos que poner a nivel alto 5 V (HIGH). Y así con todos los elementos.
El orden nos dirá el pin (hay que sumar dos ya que hemos empezado a conectar por el pin 2) y el valor nos dirá en que estado 0 (LOW) y 1 (HIGH).
Código completo
A continuación te dejo todo el código para que lo puedas copiar fácilmente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
// Constantes pines #define PULSADOR 2 // Array multidimensional para mostrar los números byte numero[10][8] = { { 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 }; void setup() { // Iniciamos el monitor serie Serial.begin(9600); // Ponemos los pines de los segmentos en modo OUTPUT (salida) for (int i = 3; i < 10; i++) { pinMode(i, OUTPUT); } // Ponemos el pin del pulsador en modo INPUT (entradda) pinMode(PULSADOR, INPUT); //Establecemos la semilla fija randomSeed(analogRead(A0)); } void loop() { // Leemos el valor del pulsador int valor = digitalRead(PULSADOR); // Si está pulsado if (valor == HIGH) { //Genera un numero aleatorio entre 1 y 6 int randomNumber = random(1, 7); // Ponemos los pines en estado correcto para mostrar el número randomNumber for (int e = 0; e < 8; e++) { digitalWrite(e + 3, numero[randomNumber][e]); } delay(500); } } |
Conclusión
Una de las ventajas que tenemos de mostrar la información con un display de 7 segmentos, es que es muy sencillo y vistoso. Aquí hemos visto un ejemplo para mostrar un número del 1 al 6. Resultaría muy sencillo modificar este ejemplo y utilizarlo para otro proyecto.
Te animo a que lo hagas y me mandes tus resultados. Estaría encantado de verlos :). Recuerda, si te ha gustado comparte y si tienes alguna duda lo puedes poner en los comentarios de este artículo.
Gracias a Shutterstock por ceder los derechos de la imagen
