Funcionamiento y conexión de un display de siete segmentos con Arduino

¿Alguna vez has visto esas intensas escenas en películas clásicas donde el héroe intenta desactivar una bomba antes de que destruya la ciudad? A medida que el héroe observa ansiosamente el temporizador decreciente, cada segundo se convierte en un recurso valioso. En muchas de estas películas, los temporizadores de cuenta atrás utilizan pantallas de siete segmentos para mostrar el tiempo restante. Este tipo de tecnología no solo es útil en el cine, sino que también está presente en muchos dispositivos cotidianos, como microondas, relojes despertadores y tableros de automóviles.

En este artículo, exploraremos en profundidad cómo funcionan las pantallas de siete segmentos y cómo se pueden utilizar con Arduino. Así que asegúrate de tener tu Arduino y tu pantalla de siete segmentos listos, ¡comencemos!

Conociendo la pantalla de siete segmentos

Una pantalla de siete segmentos parece una unidad completa, pero en realidad está compuesta por siete LEDs (diodos emisores de luz) organizados en la forma del número “8”. Cada uno de estos LEDs se denomina segmento. Además, suele haber un octavo segmento que representa el punto decimal (DP), permitiendo mostrar números decimales.

Los LEDs trabajan en conjunto para generar números y algunas letras, y es fundamental entender sus conexiones internas. Cada segmento tiene dos puntos de conexión eléctrica, similar a cualquier LED estándar. Sin embargo, solo uno de estos puntos se extiende fuera de la carcasa de plástico como un pin individual que se puede conectar. Estos pines están etiquetados con letras de la ‘a’ a la ‘g’. Los otros puntos de conexión de los siete LEDs no tienen pines individuales, sino que están cableados internamente para formar un único pin compartido llamado pin común (COM).

Al encender cada pin de un segmento (HIGH) o apagarlo (LOW), puedes controlar cada segmento de manera independiente. Encendiendo diferentes combinaciones de segmentos, puedes mostrar todos los números del 0 al 9 y, con un poco de creatividad, incluso algunas letras del alfabeto.

Pinout de la pantalla de siete segmentos

Para entender cómo se controla cada segmento, es esencial conocer el arreglo de los pines:

• a, b, c, d, e, f, g y DP son los pines que controlan cada segmento de la pantalla.
• Los pines COM (generalmente los pines 3 y 8) se conectan entre sí dentro de la pantalla.
• Dependiendo del tipo de pantalla, el pin COM debe conectarse a tierra (GND) en el caso de una pantalla común de cátodo o a 5V en el caso de una pantalla común de ánodo.

Esta conexión común (COM) completa el circuito para todos los segmentos, lo que permite que se iluminen cuando se activan.

Tipos de pantallas de siete segmentos: común cátodo vs común ánodo

Existen dos tipos principales de pantallas de siete segmentos: común cátodo (CC) y común ánodo (CA). A pesar de que parecen idénticas, su funcionamiento interno es diferente debido a cómo están conectidos sus LEDs.

Pantallas de cátodo común (CC)

En una pantalla de cátodo común, todos los terminales negativos (cátodos) de los LEDs de los segmentos están conectados entre sí. Para que esta pantalla funcione, el pin común (COM) se conecta a tierra (GND), y cada segmento se controla aplicando un voltaje positivo a su pin correspondiente.

Pantallas de ánodo común (CA)

En una pantalla de ánodo común, todos los terminales positivos (ánodos) de los LEDs de los segmentos están conectados entre sí. Para que esta pantalla funcione, el pin común (COM) se conecta a un voltaje positivo (VCC), y cada segmento se controla aplicando tierra (GND) o un voltaje bajo a su pin correspondiente.

¿Cuál es más común?

Las pantallas de ánodo común son generalmente más populares. Esto se debe principalmente a que los circuitos de absorción de corriente (donde el chip controlador absorbe corriente) ofrecen varias ventajas sobre los circuitos de suministro de corriente (donde el chip empuja corriente) en muchas aplicaciones.

Funcionamiento de la pantalla de siete segmentos

Una pantalla de siete segmentos funciona iluminando combinaciones específicas de segmentos para crear números y algunas letras. Por ejemplo:

• Para mostrar el número “8”, necesitas encender los siete segmentos (A, B, C, D, E, F y G).
• Para mostrar el número “1”, solo necesitas encender dos segmentos (B y C).
• Para mostrar la letra “A”, enciendes los segmentos A, B, C, E, F y G.

A través de combinaciones de encendido y apagado de estos segmentos, se pueden representar todos los dígitos del 0 al 9 y algunas letras del alfabeto, como se muestra en las tablas de verdad que detallan cuáles segmentos deben estar encendidos o apagados para cada carácter.

Es importante tener en cuenta que las pantallas de ánodo y cátodo común tienen conexiones eléctricas opuestas, por lo que la tabla de verdad para una pantalla de ánodo común es idéntica a la de una pantalla de cátodo común, pero invertida.

Selección de un resistor limitador de corriente

Dado que una pantalla de siete segmentos está compuesta por siete LEDs individuales, es fundamental usar resistores limitadores de corriente para protegerlos. Los LEDs solo pueden manejar una cantidad limitada de corriente eléctrica; un exceso de corriente puede hacer que se quemen rápidamente. Cada segmento necesita su propio resistor limitador de corriente.

Para una pantalla de siete segmentos roja típica, cada segmento funciona mejor con unos 15 miliamperios (mA) de corriente. Para calcular el valor correcto del resistor en un circuito de 5 voltios, usamos la siguiente fórmula:

Considerando los valores:

• Tensión de suministro = 5 voltios
• Caída de tensión del LED = aproximadamente 2 voltios
• Corriente deseada = 15 mA (o 0.015 amperios)

Al aplicar estos números a la fórmula, se redondea a 220 ohmios como valor estándar. Usar un resistor de 220 ohmios hará que la pantalla sea ligeramente menos brillante que su máximo, lo cual es preferible ya que las pantallas de siete segmentos suelen ser bastante brillantes. Esto también ayuda a prolongar su vida útil.

Si necesitas un brillo máximo (como para uso exterior), podrías usar un resistor de 150 ohmios, pero esto acercará los LEDs a sus límites. Si utilizas una pantalla de diferente color y no estás seguro de los requisitos de corriente, un resistor de 330 ohmios es un buen punto de partida; limitará la corriente suficiente para proteger los LEDs mientras ofrece un brillo razonable.

Los resistores se conectan entre tu circuito de control (como un Arduino u otro microcontrolador) y cada pin de segmento de la pantalla, formando una barrera protectora que permite que la pantalla funcione correctamente sin quemarse.

Conexión de una pantalla de siete segmentos a un Arduino

Ahora que entendemos cómo funciona una pantalla de siete segmentos, aprendamos a conectarla a un Arduino, poniendo en práctica nuestro conocimiento.

Empieza colocando tu pantalla de siete segmentos en la placa de pruebas, de tal manera que cada lado de la pantalla esté en lados opuestos del divisor central. Asegúrate de que el punto decimal esté orientado hacia abajo. Los pines están numerados en un patrón específico; en la fila inferior, encontrarás los pines del 1 al 5 de izquierda a derecha, y en la fila superior, los pines del 10 al 6, también de izquierda a derecha.

Dependiendo del tipo de pantalla, deberás hacer diferentes conexiones. Para una pantalla de ánodo común, conecta uno de los pines COM al pin de 5V del Arduino. Para una pantalla de cátodo común, conecta el pin COM al pin GND del Arduino.

Luego, conecta cada pin de segmento a un pin digital en tu Arduino. Conecta los cuatro pines superiores (b, a, f y g) a los pines digitales 2 a 5 del Arduino. Después, conecta los cuatro pines inferiores (e, d, c y DP) a los pines digitales 6 a 9 del Arduino.

Aunque la pantalla podría funcionar sin resistores limitadores de corriente, siempre es recomendable incluirlos para proteger tu pantalla de daños. Para este proyecto, necesitarás ocho resistores de 220Ω, uno para cada segmento. Estos resistores se colocan entre los pines digitales del Arduino y los pines de segmento de la pantalla.

A continuación, se presenta una tabla de referencia rápida para las conexiones de pines:

Con todo correctamente conectado y protegido, ¡estás listo para programar tu Arduino y mostrar números y letras en tu pantalla de siete segmentos!

Uso de la librería SevSeg

Al trabajar con pantallas de siete segmentos, no es necesario escribir todo el código desde cero. Existen librerías que pueden hacer gran parte del trabajo complicado por ti. Una de las más populares es la librería SevSeg.

Esta librería maneja los aspectos complejos del control de una pantalla de siete segmentos. En lugar de recordar qué segmentos encender para cada número, puedes simplemente indicarle qué número deseas mostrar, y la librería se encargará de averiguar qué segmentos deben iluminarse. Esto simplifica tu código, haciéndolo más comprensible.

Para instalar la librería:

1. Abre tu programa IDE de Arduino y haz clic en el ícono de Library Manager en la barra lateral izquierda.
2. Escribe “sevseg” en la caja de búsqueda para filtrar los resultados.
3. Busca la librería “SevSeg” de Dean Reading.
4. Haz clic en el botón Install para añadirla a tu IDE de Arduino.

Código de ejemplo para Arduino

¡Ahora es el momento de dar vida a nuestra pantalla de siete segmentos!

El siguiente código de prueba hará que la pantalla cuente del 0 al 9. Prueba a ejecutarlo y, una vez que lo veas en acción, lo analizaremos juntos.

#include "SevSeg.h"
SevSeg sevseg;

void setup() {
  // Set to 1 for single digit display
  byte numDigits = 1;

  // defines common pins while using multi-digit display. Left empty as we have a single digit display
  byte digitPins[] = {};

  // Defines arduino pin connections in order: A, B, C, D, E, F, G, DP
  byte segmentPins[] = {3, 2, 8, 7, 6, 4, 5, 9};
  bool resistorsOnSegments = true;

  // Display type
  // Uncomment appropriate line
  byte hardwareConfig = COMMON_ANODE;
  // byte hardwareConfig = COMMON_CATHODE;

  // Initialize sevseg object
  sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);

  sevseg.setBrightness(90);
}

void loop() {
  // Display numbers one by one with 2 seconds delay
  for (int i = 0; i < 10; i++) {
    sevseg.setNumber(i);
    sevseg.refreshDisplay();
    delay(1000);
  }
}

Explicación del código:

Al inicio del código, incluimos la librería SevSeg y creamos un objeto SevSeg que utilizaremos a lo largo del programa. Este objeto se encargará de las partes complicadas del control de nuestra pantalla.

// Include library
#include "SevSeg.h"

// Create object
SevSeg sevseg;

A continuación, le decimos al programa cuántos dígitos tiene nuestra pantalla. Dado que estamos utilizando una pantalla de un solo dígito, establecemos esto en 1. Si usas una pantalla de cuatro dígitos, lo establecerías en 4.

// Number of digits in display
byte numDigits = 1;

El arreglo digitPins se utiliza para especificar los números de pin de Arduino que están conectados a los pines comunes de cada dígito en una pantalla multipantalla. Sin embargo, como estamos utilizando una pantalla de un solo dígito, no necesitamos definir ningún pin de dígito, así que dejamos este arreglo vacío.

// Specifies the 'common pins' while using multi-digit display.
// If you have a single digit display, leave it blank.
byte digitPins[] = {};

Luego, definimos qué pines de Arduino están conectados a qué segmentos de nuestra pantalla. Recuerda esos segmentos A, B, C, D, E, F, G y DP de los que hablamos antes. Aquí le decimos a Arduino qué pin controla cada segmento.

// Display segment pins A,B,C,D,E,F,G,DP
byte segmentPins[] = {3, 2, 8, 7, 6, 4, 5, 9};

También usamos una variable booleana llamada resistorsOnSegments para indicar al programa si estamos utilizando resistores limitadores de corriente en nuestro circuito (¡lo cual deberíamos estar haciendo!).

// Dropping resistors used
bool resistorsOnSegments = true;

Luego, necesitamos especificar qué tipo de pantalla de siete segmentos estamos utilizando, ya sea de ánodo común o de cátodo común. Esto es importante porque afecta cómo Arduino controlará la pantalla. La variable hardwareConfig almacena esta información y puede tener uno de dos valores válidos: COMMON_ANODE o COMMON_CATHODE.

// Display type
byte hardwareConfig = COMMON_ANODE;

En la función setup(), inicializamos nuestra pantalla con todas las configuraciones definidas anteriormente y ajustamos el brillo de la pantalla a un nivel cómodo (90 en una escala de 0 a 150).

void setup() {
  // Start display object
  sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
  // Set brightness
  sevseg.setBrightness(90);
}

El bucle principal de nuestro programa utiliza un bucle for para contar del 0 al 9. Para cada número:

• Indicamos a la pantalla qué número mostrar utilizando la función setNumber().
• Refrescamos la pantalla usando la función refreshDisplay() para que el número aparezca.
• Esperamos un segundo antes de mostrar el siguiente número.

Esto crea una visualización simple de conteo que recorre todos los diez dígitos, deteniéndose durante un segundo en cada uno.

for (int i = 0; i < 10; i++) {
  sevseg.setNumber(i);
  sevseg.refreshDisplay();
  delay(1000);
}

Al comprender cómo funciona este programa básico, puedes comenzar a hacer modificaciones para crear tus propias visualizaciones personalizadas y patrones.

Proyecto Arduino – Dados electrónicos

Vamos a crear un divertido dado electrónico utilizando nuestra pantalla de siete segmentos. Este proyecto generará automáticamente números aleatorios del 1 al 6 cuando presiones un botón, perfecto para juegos como Yahtzee, Monopoly o Ludo.

A continuación, describimos lo que crearemos.

Conexiones

Utilizaremos la misma configuración de Arduino que en nuestro ejemplo anterior, pero con una adición importante: un interruptor táctil (botón pulsador) que actuará como nuestro botón de “tirar”. Conectaremos un botón a la pin digital 10 en el Arduino. El botón nos permitirá activar un nuevo número aleatorio cada vez que queramos “tirar” el dado.

Código para Arduino

#include "SevSeg.h"
SevSeg sevseg;
const int buttonPin = 10;  // el número del pin del botón

// variables que cambiarán:
int buttonState = 0;  // variable para leer el estado del botón

void setup() {
  byte numDigits = 1;
  byte digitPins[] = {};
  byte segmentPins[] = {3, 2, 8, 7, 6, 4, 5, 9};
  bool resistorsOnSegments = true;

  sevseg.begin(COMMON_ANODE, numDigits, digitPins, segmentPins, resistorsOnSegments);
  sevseg.setBrightness(90);

  // inicializa el pin del botón como entrada:
  pinMode(buttonPin, INPUT);
}

void loop() {
  // lee el estado del botón:
  buttonState = digitalRead(buttonPin);

  if (buttonState == HIGH) {
    sevseg.setNumber(random(1, 7));
    sevseg.refreshDisplay();
  }
}

Explicación del código del dado electrónico:

Este código es similar al anterior; configuramos la pantalla de siete segmentos de la misma forma, utilizando los mismos pines de conexión y configuraciones. Sin embargo, hay algunas diferencias clave.

Primero, declaramos el pin de Arduino donde está conectado el botón pulsador y definimos una nueva variable, buttonState, para rastrear si el botón está presionado.

// el número del pin del botón
const int buttonPin = 10;     

// variable para leer el estado del botón
int buttonState = 0;

A continuación, en la función setup(), configuramos buttonPin como una entrada para que el Arduino pueda detectar cuándo se presiona el botón.

// inicializa el pin del botón como entrada:
pinMode(buttonPin, INPUT);

En el bucle principal, el Arduino verifica continuamente el estado del botón. Cuando detecta que se ha presionado (cuando buttonState es HIGH), el programa genera un número aleatorio entre 1 y 6 utilizando la función incorporada random(min, max).

Es importante notar que esta función incluye el valor mínimo pero excluye el valor máximo. Llamar a random(1,7) nos dará números del 1 al 6, lo cual es ideal para simular un dado de seis caras.

Una vez que se genera el número aleatorio, se muestra de inmediato en la pantalla de siete segmentos. La próxima vez que presiones el botón, aparecerá un nuevo número aleatorio.

void loop() {
  // lee el estado del botón:
  buttonState = digitalRead(buttonPin);
  
  if (buttonState == HIGH) {
    sevseg.setNumber(random(1, 7));
    sevseg.refreshDisplay(); 
  }
}

Este proyecto simple pero divertido demuestra cómo puedes combinar una pantalla de siete segmentos con la entrada del usuario para crear proyectos interactivos. Podrías expandir esta idea para construir juegos de mesa electrónicos, generadores de números aleatorios o incluso una bola de decisiones mágica.