¿Alguna vez intentaste mostrar un número de varios dígitos en displays de 7 segmentos y terminaste peleando con el multiplexado, las tablas de segmentos y un loop() lleno de digitalWrite? Es uno de esos ejercicios clásicos de Arduino que enseñan mucho, pero que se vuelven tediosos apenas pasas de un dígito. La librería GFDisplay7S, creada por Geek Factory, ataca justamente ese problema: maneja por ti la secuencia de refresco y la conversión de números a segmentos, y te deja una API tan simple como la de la conocida LiquidCrystal.

En esta guía vas a entender cómo funciona un arreglo de displays de 7 segmentos multiplexados, cómo instalar la librería desde el gestor de Arduino IDE, y cómo imprimir números con un par de líneas usando print(). Al final vas a poder armar tu propio marcador, reloj o voltímetro con dígitos grandes y rojos, sin escribir el motor de multiplexado desde cero.

Display de 7 segmentos de 4 dígitos multiplexado, rojo, ánodo común

Qué es un display de 7 segmentos (y por qué se multiplexan)

Un display de 7 segmentos es, en el fondo, un paquete de LEDs ordenados en forma de "8": siete segmentos (etiquetados de la a a la g) más el punto decimal (dp). Encendiendo la combinación correcta de segmentos dibujas cualquier dígito del 0 al 9. La foto de arriba muestra un módulo de cuatro dígitos: son cuatro displays de un dígito metidos en una sola pieza.

El detalle incómodo aparece cuando quieres mostrar varios dígitos a la vez. Si cableaste cada segmento de cada dígito por separado, un display de 6 dígitos te pediría 48 pines, algo imposible en un Arduino Uno. La solución es el multiplexado: se comparten las ocho líneas de segmentos entre todos los dígitos y se enciende un dígito a la vez, muy rápido, ciclando entre ellos. Si el refresco es lo bastante veloz (cientos de veces por segundo), tu ojo percibe los cuatro o seis dígitos encendidos al mismo tiempo. Con ese truco, seis dígitos necesitan apenas 8 líneas de segmentos más 6 de control: 14 pines en total.

Escribir esa rutina de multiplexado a mano es justo lo que GFDisplay7S te ahorra.

Qué hace la librería GFDisplay7S

La idea de diseño es clara: que usar un arreglo de displays se sienta igual de fácil que usar una pantalla LCD con LiquidCrystal. Sus métodos son equivalentes, con la diferencia de que está pensada solo para caracteres numéricos. Estas son sus capacidades reales:

  • Maneja arreglos de 2 a 10 displays de 7 segmentos.
  • Funciona con displays de ánodo común y de cátodo común.
  • Puedes usar cualquier combinación de pines para los segmentos y los comunes.
  • Soporta el punto decimal, ideal para imprimir variables de tipo flotante.
  • Imprimes números con los métodos estándar print() y println() de Arduino.
  • La velocidad de refresco se ajusta por software.
  • El código es simple y legible a propósito: es un buen ejemplo para aprender cómo se construye una librería de Arduino.

Un punto fino: la librería deja deliberadamente fuera el manejo de interrupciones y timers, pero el método de refresco puede llamarse sin problemas desde una rutina de servicio de interrupción (ISR). Eso te da dos formas de actualizar los dígitos: la simple, dentro del loop(), o la avanzada, desde un timer.

Plataformas probadas

El autor reporta que la librería fue probada en:

  • Arduino Uno y Mega (tarjetas basadas en AVR).
  • Raspberry Pi Pico (RP2040).
  • ESP32.

Una nota importante de compatibilidad: la librería incluye un ejemplo que refresca los displays desde una ISR de timer, pero ese ejemplo en particular solo funciona en placas AVR como el Arduino Uno Rev3. En ESP32 y Pico podrás usar la librería igual, pero el ejemplo de interrupciones tendrás que adaptarlo a su hardware de timers.

Cómo conectar el arreglo en la práctica

Antes de subir código conviene tener clara la electrónica, porque la librería asume un patrón de conexión muy concreto. El siguiente esquemático, tomado del proyecto de reloj de Geek Factory que usa esta misma técnica, muestra el cableado típico de seis dígitos con un Arduino Nano:

Esquemático de un arreglo de seis displays de 7 segmentos con Arduino Nano, resistencias de segmento y transistores 2N2222 en los comunes

Fíjate en dos cosas que después vas a reconocer en el código:

  1. Las ocho líneas de segmentos (a hasta dp) salen del microcontrolador, pasan por una resistencia limitadora cada una y se reparten en paralelo a todos los dígitos. En el código, ese orden {a, b, c, d, e, f, g, dp} es exactamente el arreglo segmentPins[].
  2. El pin común de cada dígito se controla por separado. Como un dígito completo puede pedir más corriente de la que entrega un pin del Arduino, se usa un transistor (en el esquema, un 2N2222 con resistencia de base) por cada dígito a modo de interruptor. Esos pines de control son el arreglo commonPins[], de izquierda a derecha.

Si tu arreglo es chico (dos o tres dígitos de bajo consumo) podrías prescindir de los transistores y manejar los comunes directo desde los pines, pero para seis dígitos los transistores evitan sobrecargar el micro. La resistencia de cada segmento depende del color y del brillo que busques; valores entre 220 y 330 ohm son un buen punto de partida para displays rojos.

Instalación de la librería

La forma recomendada es desde el gestor de librerías del Arduino IDE. Abre el gestor, busca por el nombre GFDisplay7S y presiona Instalar. Te conviene siempre instalar la última versión disponible para evitar errores ya corregidos.

Gestor de librerías del Arduino IDE mostrando la librería GFDisplay7S de Geek Factory lista para instalar

Si prefieres hacerlo a mano, también puedes descargar el repositorio GFDisplay7S desde GitHub e instalarlo como ZIP. El gestor es más cómodo porque te avisa de nuevas versiones, pero la instalación manual te sirve si quieres revisar o modificar el código fuente.

Uso básico: imprimir números

El flujo para mostrar información en el arreglo tiene cuatro pasos:

  1. Incluir la librería en tu sketch con #include <GFDisplay7S.h>.
  2. Crear una instancia de la clase GFDisplay7S, pasándole tres parámetros: el arreglo de pines de segmento, el arreglo de pines comunes y la cantidad de dígitos.
  3. Llamar a begin() dentro de setup().
  4. Refrescar el display llamando periódicamente a process() dentro de loop(), aproximadamente cada 3 milisegundos.

Para escribir en el display usas write() y print(). El ejemplo más simple que incluye la librería se ve así (este es el código original del autor, sin modificaciones):

C++ 
/**
   GeekFactory - "INNOVATING TOGETHER"
   www.geekfactory.mx
   Basic example for GFDisplay7S, this example illustrates how to print numbers on the display array.
*/
#include <GFDisplay7S.h>
// Array that defines the pins used for segments
// Order: {a, b, c, d, e, f, g, dp}
// Use GFDISPLAY7S_UNUSED_PIN if DP is not connected
const uint8_t segmentPins[] = { 5, 6, 7, 8, 9, 10, 11, GFDISPLAY7S_UNUSED_PIN };
// Array that defines the pins used to drive each digit's common pin (left to right)
const uint8_t commonPins[] = { 12, 13, A0, A1, A2, A3 };
// Instantiate an object to drive the display array.
// First array = segment pins {a, b, c, d, e, f, g, dp}
// Second array = common pins for each digit (left to right)
// Third parameter = number of digits
GFDisplay7S display7s(segmentPins, commonPins, 6);
void setup() {
  // call begin() to prepare object for use
  display7s.begin();
  // call print() to display numeric data
  display7s.print("123456");
  // make the last digit (index 5, zero-based) blink
  display7s.blinkDigit(5);
}
void loop() {
  // Refresh the display (call this frequently)
  display7s.process();
  // Small delay to control refresh rate
  // Smaller delays = smoother display, but more CPU usage
  // In practical use, replace this with a timer ISR for best performance
  delay(3);
}

Tres detalles que vale la pena entender de este sketch:

  • El último elemento de segmentPins[] es GFDISPLAY7S_UNUSED_PIN. Esa constante le dice a la librería que el punto decimal no está conectado, así no intenta manejarlo.
  • commonPins[] usa pines digitales (5 a 13) y también analógicos (A0 a A3) como salidas digitales: la librería acepta cualquier combinación.
  • La llamada a delay(3) controla el ritmo de refresco. Delays más cortos dan una imagen más estable pero consumen más CPU; en un proyecto serio reemplazarías esa espera por un timer con ISR, como ya mencionamos.

blinkDigit(5) es un buen ejemplo de los extras de la librería: hace parpadear el sexto dígito (índice 5, base cero), útil para señalar el campo que estás editando en un reloj o un menú.

Variantes y mejoras

Una vez que domines el ejemplo básico, estas extensiones te dan ideas concretas para llevarlo más lejos:

  • Reloj digital con RTC: combina el arreglo de seis dígitos con un módulo de reloj en tiempo real DS3231 por I2C y tienes un reloj de pared con dígitos grandes y rojos. El propio Geek Factory documenta este proyecto, y la foto siguiente muestra el resultado armado en protoboard, con el Arduino Nano, el DS3231 y los botones para ajustar la hora.

Reloj digital armado en protoboard con Arduino Nano, módulo DS3231 y arreglo de displays de 7 segmentos mostrando la hora

  • Voltímetro de tablero: lee una tensión con el ADC del Arduino, aprovecha el punto decimal de la librería para mostrar valores con decimales (por ejemplo 12.4) y arma un voltímetro casero de dígitos visibles a distancia.
  • Marcador o contador: con dos o cuatro dígitos puedes mostrar un puntaje, un contador de vueltas o una cuenta regresiva. Como print() acepta enteros directamente, actualizar el número es trivial.
  • Refresco por interrupción: si tu programa principal tiene que hacer otras tareas pesadas, mueve la llamada a process() a una ISR de timer (en AVR usa el ejemplo incluido como base). Así los dígitos se mantienen estables aunque tu loop() esté ocupado.

Personalización para Chile

En Chile puedes conseguir todo lo necesario en MechatronicStore, con stock local y despacho a todo el país:

  • Display 7 segmentos de 4 dígitos (SKU D-206), CLP $1.400: un arreglo multiplexado de cuatro dígitos de color rojo, perfecto para estrenar la librería con un reloj o un contador.
  • Arduino Uno R3 (SKU X4-8), CLP $9.990: la placa AVR de referencia donde la librería está probada, incluido el ejemplo de refresco por interrupción.
  • Protoboard base robusta 2900 puntos (SKU C-230), CLP $15.990: amplia y con borneras, cómoda para repartir las ocho líneas de segmentos a varios dígitos sin quedarte sin espacio.
  • Kit 140 cables macho macho para protoboard (SKU C-206), CLP $2.190: para cablear segmentos y comunes con orden.

Para un arreglo de seis dígitos como el del esquemático vas a querer además resistencias de 220 a 330 ohm (una por segmento) y transistores NPN tipo 2N2222 (uno por dígito) para los comunes; ambos forman parte de los packs de componentes del catálogo. Si en otro tutorial ves un módulo de la marca "SparkFun" o "Adafruit", el display de 4 dígitos y el Arduino Uno compatibles cumplen la misma función a una fracción del precio.

Recursos

  • Tutorial original (español): Librería de Arduino para displays de 7 segmentos GFDisplay7S de Geek Factory.
  • Repositorio GitHub: la librería GFDisplay7S está publicada por Geek Factory en GitHub; búscala por ese nombre para instalarla como ZIP o revisar el código fuente.
  • Proyecto relacionado: reloj digital con Arduino y displays de 7 segmentos (Geek Factory), de donde proviene el esquemático y la foto del montaje.
  • Instalación rápida: gestor de librerías del Arduino IDE, buscando "GFDisplay7S".

Crédito del código, las imágenes y el concepto original a Geek Factory. Versión chilena, re explicada con foco en el multiplexado y con componentes en stock local en MechatronicStore.