Cómo usar un display de 7 segmentos: mostrar números con Arduino, ánodo o cátodo común

Un display de 7 segmentos es un indicador sencillo formado por siete LED en forma de barra colocados como el número «8», más un pequeño punto. Lo usan los relojes digitales, los temporizadores de microondas, los marcadores y los surtidores de gasolina. Es barato, muy luminoso y se lee bien incluso de lejos. En los proyectos con Arduino es una de las salidas clásicas para hacer contadores, dados, cronómetros y relojes.

¿Cómo funciona un display de 7 segmentos?

Los segmentos se nombran con letras: empezando por la a de arriba y siguiendo en sentido horario vienen b (arriba a la derecha), c (abajo a la derecha), d (abajo), e (abajo a la izquierda) y f (arriba a la izquierda); la barra central es la g y el punto es dp. Cada segmento es en realidad un LED distinto y, según cuáles se enciendan, se forman los diferentes números. Para el «1», por ejemplo, solo se encienden b y c; para el «8», los siete.

¿Cátodo común o ánodo común?

Igual que en un LED RGB, un extremo de todos los segmentos se une en un pin común. En un display de cátodo común el pin común va a GND y un segmento se enciende al darle HIGH. En uno de ánodo común el pin común va a 5V y el segmento se enciende con LOW. Por fuera son iguales; para saber cuál tienes, conecta el pin común a GND y toca 5V con un pin de segmento a través de una resistencia de 220 Ω. Si el segmento se enciende, es de cátodo común; si no, invierte la conexión y vuelve a probar.

Pines y conexión con Arduino

En los displays habituales de un dígito y 10 pines, con la cara frontal hacia ti, los pines se numeran en sentido antihorario empezando por abajo a la izquierda. Los dos pines centrales (3 y 8) son el terminal común y están unidos por dentro. La tabla muestra los pines del display y los pines de Arduino que usa el código de este artículo:

Contar de 0 a 9 con Arduino

Guardar en un array, como bits, qué segmentos enciende cada número acorta mucho el código. En el ejemplo siguiente, el bit de la izquierda de cada byte es el segmento a y el de la derecha el segmento g. La función showDigit() lee esos bits uno a uno y los escribe en los pines; si tu display es de ánodo común, basta con poner COMMON_ANODE a true.

1const int SEG_PINS[7] = {2, 3, 4, 5, 6, 7, 8};   // a, b, c, d, e, f, g
2const bool COMMON_ANODE = false;                 // ortak anotsa true / true for common anode
3
4// her rakam için a–g segmentleri (1 = yanar) / a–g segments per digit (1 = on)
5const byte DIGITS[10] = {
6  0b1111110, // 0
7  0b0110000, // 1
8  0b1101101, // 2
9  0b1111001, // 3
10  0b0110011, // 4
11  0b1011011, // 5
12  0b1011111, // 6
13  0b1110000, // 7
14  0b1111111, // 8
15  0b1111011  // 9
16};
17
18void showDigit(int n) {
19  for (int i = 0; i < 7; i++) {
20    bool on = DIGITS[n] & (1 << (6 - i));       // a en soldaki bit / a is the leftmost bit
21    digitalWrite(SEG_PINS[i], COMMON_ANODE ? !on : on);
22  }
23}
24
25void setup() {
26  for (int i = 0; i < 7; i++) pinMode(SEG_PINS[i], OUTPUT);
27}
28
29void loop() {
30  for (int n = 0; n <= 9; n++) {
31    showDigit(n);
32    delay(1000);
33  }
34}

Display de 4 dígitos y multiplexado

Un display de cuatro dígitos no tiene 32 pines de segmento, sino solo 12 pines: 8 líneas de segmento (a–g y dp) que comparten todos los dígitos y 4 pines que eligen qué dígito se enciende. Como las líneas de segmento son compartidas, no puedes mostrar números distintos en dígitos distintos al mismo tiempo. La solución es el multiplexado: enciendes solo el 1.er dígito unos milisegundos, luego el 2.º, el 3.º y el 4.º. Cuando este ciclo se repite más de 50 veces por segundo, el ojo ve los cuatro dígitos encendidos a la vez. En lugar de programar este barrido a mano, es mucho más fácil usar la librería SevSeg:

1#include "SevSeg.h"
2
3SevSeg sevseg;
4
5void setup() {
6  byte digitPins[] = {2, 3, 4, 5};                    // hane seçme pinleri / digit select pins
7  byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12, 13};  // a, b, c, d, e, f, g, dp
8  sevseg.begin(COMMON_CATHODE, 4, digitPins, segmentPins, true);  // dirençler segmentlerde / resistors on segments
9  sevseg.setBrightness(90);
10}
11
12void loop() {
13  sevseg.setNumber(millis() / 1000);   // geçen saniye / elapsed seconds
14  sevseg.refreshDisplay();             // sürekli çağrılmalı / must be called continuously
15}

El módulo TM1637: 4 dígitos con solo 2 cables

Si 12 cables y un barrido continuo te parecen demasiado trabajo, el módulo TM1637 es para ti. Su chip controlador hace el multiplexado por sí mismo; Arduino solo le indica qué número mostrar a través de los pines CLK y DIO. La mayoría de las versiones tienen además dos puntos (:) en el centro para hacer relojes. Instala desde el Gestor de librerías la librería TM1637 de Avishay Orpaz; el código siguiente muestra minutos y segundos con los dos puntos:

1#include <TM1637Display.h>
2
3TM1637Display display(2, 3);   // CLK, DIO
4
5void setup() {
6  display.setBrightness(5);    // 0–7
7}
8
9void loop() {
10  int minutes = (millis() / 60000) % 60;
11  int seconds = (millis() / 1000) % 60;
12  // ortadaki iki noktayla dakika:saniye / minutes:seconds with the colon
13  display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
14  delay(200);
15}

Display de 7 segmentos con el ESP32 y la Raspberry Pi Pico

Puedes conectar un display de un dígito directamente a un ESP32 o a una Pico; como los pines dan 3,3 V, los segmentos brillan algo menos, así que usa resistencias más pequeñas, de 100–150 Ω. El módulo TM1637 también funciona a 3,3 V y en el ESP32 se usa con la misma librería de Arduino. Para MicroPython en la Pico, basta con copiar el archivo tm1637.py (la librería de mcauser) en la Pico:

1import tm1637
2from machine import Pin
3import time
4
5tm = tm1637.TM1637(clk=Pin(16), dio=Pin(17))   # tm1637.py Pico'da olmalı / tm1637.py must be on the Pico
6tm.brightness(4)                               # 0–7
7
8count = 0
9while True:
10    tm.number(count)        # -999 … 9999
11    count += 1
12    time.sleep(1)

¿7 segmentos, LCD u OLED?

Si solo vas a mostrar números y es importante que se lean de lejos, el display de 7 segmentos no tiene rival. Si necesitas texto, unidades y menús, echa un vistazo a Cómo usar una pantalla LCD I2C.

Ideas de proyectos con display de 7 segmentos

• Dado electrónico: muestra un número al azar del 1 al 6 al pulsar un botón.
• Contador con botones: un contador que sube con un botón y se pone a cero con otro.
• Reloj digital: un reloj con TM1637 y un módulo RTC que no pierde la hora aunque se vaya la luz.
• Cuenta atrás: un temporizador ajustable para juegos de mesa o experimentos.
• Indicador de temperatura: muestra en números grandes la temperatura medida con un DHT11.
• Test de reacción: muestra en milisegundos lo rápido que pulsas el botón después de que se encienda un LED.

Errores comunes y cómo solucionarlos

• No se enciende ningún segmento: el pin común está en el sitio equivocado; puede que hayas conectado a GND un display de ánodo común.
• Los números salen mal: la correspondencia entre segmentos y pines de Arduino es incorrecta; compruébala encendiendo cada segmento por separado.
• Algunos números se ven apagados: hay una sola resistencia en el pin común; usa una para cada segmento.
• En el de 4 dígitos solo se enciende uno o todo parpadea: hay un delay() en loop() o el barrido no se hace con suficiente frecuencia.
• Los segmentos que deberían encenderse están apagados y el resto encendidos: se han confundido ánodo y cátodo común; cambia COMMON_ANODE.
• No llegan los pines: reduce los pines necesarios con un módulo TM1637, un controlador MAX7219 o un registro de desplazamiento 74HC595.

Saber que cada segmento es en realidad un LED es la clave para entender los displays de 7 segmentos; para lo básico, echa un vistazo a ¿Qué es un LED? En la app BlueGrays encontrarás proyectos de contar de 0 a 9, contador con botón, dado, reloj digital de 4 dígitos y animación de bomba, paso a paso con esquemas y código.