Lección 1.10: Display de 7 segmentos

Cuatro dígitos suman 32 segmentos, y el Uno no tiene tantos pines. Esta lección lo resuelve con dos técnicas que verás en muchos aparatos: el registro de desplazamiento y el multiplexado.

Material

Cómo funciona

En un display de cátodo común, los cuatro dígitos comparten los pines de segmento —de A a G y el punto— y cada uno tiene su propio cátodo. Un dígito se enciende cuando su cátodo está a LOW, y muestra los segmentos que estén a HIGH.

El multiplexado consiste en encender un dígito cada vez, con su cifra, durante unos milisegundos, y pasar al siguiente. Por encima de unos 50 ciclos por segundo, el ojo no ve el parpadeo y percibe los cuatro encendidos.

El 74HC595 recibe los ocho segmentos en serie por un solo pin de datos, al ritmo de un pin de reloj, y los presenta en sus ocho salidas al recibir un pulso en el latch. Con tres pines se manejan los ocho segmentos.

Cada cifra es un byte: el bit 0 es el segmento A y el bit 6 el G. El 0, que enciende todos menos el G, es 0b00111111, o 0x3F.

Conexiones

Componente	Se conecta a	Nota
74HC595, VCC (16) y MR (10)	5V
74HC595, GND (8) y OE (13)	GND
74HC595, DS (14)	Pin 8
74HC595, ST_CP (12)	Pin 9
74HC595, SH_CP (11)	Pin 10
74HC595, Q0–Q6 (15, 1–6)	Display, segmentos A–G (pines 11, 7, 4, 2, 1, 10, 5)	En orden: Q0 a A, Q1 a B…
74HC595, Q7 (7)	Display, punto DP (pin 3)
Display, dígitos 1–4 (pines 12, 9, 8, 6)	Pines 2, 3, 4 y 5	Cada uno a través de una resistencia de 220 Ω

Código

// Contador de 0000 a 9999 en un display multiplexado.
const int DATA_PIN = 8;   // DS
const int LATCH_PIN = 9;  // ST_CP
const int CLOCK_PIN = 10; // SH_CP
const int DIGIT_PINS[4] = {2, 3, 4, 5}; // cátodos de los dígitos 1-4

// Bit 0 = segmento A ... bit 6 = G, bit 7 = punto.
const byte DIGITS[10] = {
  0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F
};

int number = 0;
unsigned long lastTick = 0;

void setup() {
  pinMode(DATA_PIN, OUTPUT);
  pinMode(LATCH_PIN, OUTPUT);
  pinMode(CLOCK_PIN, OUTPUT);

  for (int i = 0; i < 4; i++) {
    pinMode(DIGIT_PINS[i], OUTPUT);
    digitalWrite(DIGIT_PINS[i], HIGH); // HIGH = dígito apagado
  }
}

void writeSegments(byte segments) {
  digitalWrite(LATCH_PIN, LOW);
  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, segments);
  digitalWrite(LATCH_PIN, HIGH); // las salidas cambian aquí, todas a la vez
}

void loop() {
  if (millis() - lastTick >= 1000) {
    lastTick = millis();
    number = (number + 1) % 10000;
  }

  // De derecha a izquierda: unidades, decenas, centenas, millares.
  int value = number;
  for (int digit = 3; digit >= 0; digit--) {
    writeSegments(DIGITS[value % 10]);
    digitalWrite(DIGIT_PINS[digit], LOW);  // enciende este dígito
    delay(4);
    digitalWrite(DIGIT_PINS[digit], HIGH); // y lo apaga antes del siguiente
    value /= 10;
  }
}

Qué hace el código

DIGITS guarda el patrón de segmentos de cada cifra, del 0 al 9.
writeSegments() baja el latch, envía el byte bit a bit con shiftOut() y lo vuelve a subir: las ocho salidas cambian a la vez, al final.
value % 10 es la última cifra y value /= 10 la quita, así que el bucle recorre los dígitos de derecha a izquierda.
Cada dígito se apaga antes de cambiar los segmentos. Si no, la cifra nueva se vería un instante en el dígito anterior.
El contador avanza con millis() y no con delay(): el multiplexado no puede detenerse, o solo se vería un dígito.

Paso a paso

Coloca el 74HC595 y el display a caballo sobre el canal central de la protoboard. La muesca del integrado marca el lado de los pines 1 y 16.
Cablea la alimentación y el control del 74HC595, después sus ocho salidas al display y por último los cuatro dígitos con sus resistencias.
Sube el código.

Resultado

El display cuenta de 0000 a 9999, un número por segundo, con las cuatro cifras encendidas a la vez.

Si no funciona

Si se encienden segmentos equivocados, alguna salida del 74HC595 va a un segmento que no le toca: repasa Q0–Q7 en la tabla.
Si no se enciende nada, comprueba que MR esté a 5V y OE a GND: con MR a LOW el registro se borra, y con OE a HIGH las salidas se apagan.
Si tu display es de ánodo común, la lógica se invierte: los dígitos se activan con HIGH y los segmentos con LOW. Envía ~DIGITS[n] en lugar de DIGITS[n].
Que el 8 se vea más tenue que el 1 es normal con las resistencias en los dígitos: la corriente se reparte entre los segmentos encendidos.