Tutorial de controlador LED de Arduino: Controla más LEDs con 74HC595 y MAX7219

En los proyectos con muchos LED, los pines GPIO de Arduino se agotan enseguida. Si usas drivers de LED dedicados y CI de expansión, puedes reducir drásticamente el número de pines necesarios, eliminar los bucles de multiplexación que tanto cargan el procesador y simplificar el cableado de la pantalla.

En esta guía vas a ver cómo funcionan internamente el registro de desplazamiento 74HC595 y el driver de LED MAX7219, cómo se cablean, cómo conectarlos en cascada y cómo sacarles el máximo partido.

Por qué los proyectos con Arduino necesitan CI drivers de LED

Limitaciones de GPIO y de corriente de Arduino

Un Arduino Uno basado en el ATmega328P tiene unos límites físicos que hacen imposible controlar directamente una gran cantidad de LED:

• Corriente máxima por pin: un pin de E/S digital puede entregar o absorber con seguridad un máximo de 20 mA de forma continua (el límite absoluto de pico es de 40 mA).
• Límite total del encapsulado: la corriente total que circula por los pines VCC y GND principales del microcontrolador no debe superar los 200 mA.
• Pocos pines físicos: el Arduino Uno solo tiene 14 pines de E/S digitales y 6 entradas analógicas.

Si intentas encender a la vez dieciséis LED estándar de 15 mA, le pedirás 240 mA al encapsulado del microcontrolador. Eso supera su zona de funcionamiento seguro y puede provocar la destrucción térmica inmediata del chip.

Multiplexación de LED frente a CI drivers de LED

Para controlar matrices habituales (como matrices de 8x8 o displays de 7 segmentos), tienes que elegir entre multiplexar directamente por software o usar CI drivers de hardware dedicados:

• Multiplexación directa por GPIO: la CPU de Arduino tiene que ejecutar continuamente un bucle de alta frecuencia que recorra filas y columnas. Si el bucle principal se bloquea por la lectura de un sensor, una comunicación serie o una llamada a delay(), la pantalla se congela o parpadea al instante.
• Registros de desplazamiento (74HC595): amplían las salidas digitales mediante una sencilla interfaz serie de 3 pines. Resuelven de forma barata la falta de pines, pero el microcontrolador sigue teniendo que ejecutar por software el bucle de barrido rápido para multiplexar las matrices.
• Drivers de display dedicados (MAX7219): liberan por completo a la CPU de la multiplexación. Incorporan RAM estática para guardar los datos de la pantalla y osciladores de hardware que hacen el barrido de filas y columnas de forma automática, así que la CPU de Arduino queda totalmente libre.

74HC595 o MAX7219: ¿qué driver de LED elegir?

• Elige el 74HC595 si necesitas ampliar salidas digitales de uso general (por ejemplo, para controlar un grupo de relés, barras de LED personalizadas o indicadores de estado sueltos) con un coste de componentes muy bajo.
• Elige el MAX7219 si tu proyecto trata específicamente con matrices de LED de 8x8, letreros de texto en movimiento o displays de 7 segmentos de varios dígitos, ya que se encarga de la limitación de corriente, el barrido y la regulación del brillo en un solo chip.

Comparativa de CI drivers de LED para Arduino

En la siguiente tabla tienes las principales diferencias entre un expansor de salidas estándar y un controlador de display dedicado.

Cómo usar el 74HC595 con Arduino para LED y matrices de LED

El registro de desplazamiento 74HC595 es un chip muy económico para ampliar los pines de salida.

Patillaje del 74HC595

El 74HC595 contiene un registro de desplazamiento de 8 bits y un registro de almacenamiento tipo D de 8 bits. Estos son sus pines principales:

• DS (pin 14): entrada de datos serie.
• SH_CP (pin 11): reloj del registro de desplazamiento. Activo en el flanco de subida.
• ST_CP (pin 12): reloj del registro de almacenamiento (latch). Actualiza las salidas paralelas.
• OE (pin 13): habilitación de salida. Activo a nivel bajo.
• MR (pin 10): reset general. Activo a nivel bajo.
• Q0 - Q7 (pines 15 y 1-7): salidas paralelas.
• Q7' (pin 9): salida serie (para conectar varios en cadena).

Figura: patillaje del CI de registro de desplazamiento de 8 bits 74HC595 en encapsulado DIP-16.

Esquema de conexiones de una matriz de LED 8x8 con Arduino y 74HC595

Para montar una configuración con dos registros de desplazamiento que controle una matriz de LED de 8x8, conecta en paralelo al Arduino los pines de reloj y de latch de ambos registros, y encadena sus líneas de datos serie.

Figura: esquema de conexiones detallado de un Arduino Uno que controla dos registros de desplazamiento 74HC595 conectados en cadena. El primer registro controla los ánodos de las filas y el segundo, los cátodos de las columnas con resistencias en serie; ambos comparten las señales de latch y de reloj.

Código para matriz de LED con Arduino y 74HC595 usando shiftOut()

Este código muestra cómo hacer el barrido de una imagen almacenada en un búfer (como un corazón) en una matriz de LED de 8x8 usando dos registros en cadena. Al enviar dos bytes seguidos, se actualizan las columnas y las filas en cada línea de barrido.

Claves del código:

• Desplazamiento en cascada: mantiene el latch a nivel bajo mientras envía dos valores de 8 bits seguidos. El primer byte pasa al registro 2 (columnas) y el segundo se queda en el registro 1 (filas).
• Polaridad de columnas y filas: invierte los valores de las columnas (~patrón) para llevar los cátodos a nivel bajo, y pone a nivel alto cada pin de fila mediante un desplazamiento de bits.
• Refresco estable línea a línea: usa un bucle con un retardo mínimo para recorrer las líneas de barrido una tras otra, de modo que la imagen se ve estable y sin parpadeos.

const int latchPin = 10;
const int clockPin = 9;
const int dataPin = 11;

// 8x8 heart pattern representation (1 = active LED, 0 = off LED)
byte heartPattern[8] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00000000
};

// Setup
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

// Main Loop
void loop() {
  // Scan through all 8 rows sequentially
  for (int row = 0; row < 8; row++) {
    // Columns (active LOW): Invert the pattern so that 1s are driven LOW (sinking current)
    byte colData = ~heartPattern[row];

    // Rows (active HIGH): Turn on only the current row (e.g. Row 0 -> B00000001, Row 1 -> B00000010)
    byte rowData = (1 << row);

    // Ground the latch pin and hold it LOW as long as we are transmitting data
    digitalWrite(latchPin, LOW);

    // 1. Shift out column data first (this byte overflows into Register 2, controlling Columns)
    shiftOut(dataPin, clockPin, MSBFIRST, colData);

    // 2. Shift out row data second (this byte stays in Register 1, controlling Rows)
    shiftOut(dataPin, clockPin, MSBFIRST, rowData);

    // Return the latch pin HIGH to output the updated states simultaneously
    digitalWrite(latchPin, HIGH);

    // Delay interval per scan line (1.25 ms per row achieves ~100 Hz frame refresh rate)
    delayMicroseconds(1250);
  }
}

La función shiftOut() por software es sencilla y cómoda, pero conmuta manualmente los pines de reloj y de datos, lo que añade carga de ejecución. Para displays muy exigentes y de alta frecuencia, puedes pasarte al bus SPI (Serial Peripheral Interface) por hardware de Arduino. El SPI por hardware usa la circuitería interna de desplazamiento dedicada del ATmega328P, lo que libera ciclos de CPU y permite velocidades de transferencia de hasta 8 MHz.

Conexión en cadena de varios registros de desplazamiento 74HC595

Para controlar más de 8 salidas, puedes encadenar varios registros de desplazamiento sin gastar más pines del Arduino. Conecta la salida serie Q7' (pin 9) del primer registro a la entrada de datos serie DS (pin 14) del segundo. Conecta en paralelo los pines de reloj (SH_CP) y de latch (ST_CP) de ambos chips a las mismas líneas de control del Arduino.

Como el desplazamiento serie funciona como una cola FIFO (First-In, First-Out: el primero que entra es el primero que sale), al enviar 16 bits los primeros 8 bits que entran salen del primer chip y acaban en el segundo. Por eso, si transmites con MSBFIRST, el byte destinado al segundo registro de la cadena tiene que enviarse primero.

Control de brillo por PWM del 74HC595 con el pin OE

Para controlar el brillo de todos los LED a la vez, conecta el pin OE (habilitación de salida) del 74HC595 a uno de los pines PWM de Arduino (como D3 o D9) en lugar de llevarlo directamente a masa. Escribiendo un valor analógico con analogWrite(OEPin, brightnessValue) (donde 0 es el brillo máximo y 255 es apagado), puedes modular el tiempo durante el que están habilitadas las salidas de los registros.

Cómo usar un módulo de matriz de LED MAX7219 con Arduino

Montar circuitos integrados (CI) sueltos en una protoboard está muy bien para aprender lo básico, pero en la práctica los makers y los desarrolladores de producto usan casi siempre los módulos de matriz de LED 8x8 con MAX7219, que se encuentran en cualquier tienda. Son placas listas para usar y muy económicas que traen ya soldados en una PCB compacta el CI MAX7219 de montaje superficial, los condensadores de desacoplo y el zócalo de la matriz, así que la integración del hardware es plug-and-play.

Cómo funciona la matriz de LED 8x8 con MAX7219

Un módulo de matriz de LED 8x8 con MAX7219 se encarga por completo del refresco de la multiplexación en la propia placa. El módulo incluye una RAM estática interna de doble puerto de 8x8.

Cuando tu Arduino envía los datos de los píxeles a la placa por su bus SPI de alta velocidad, esos estados se escriben directamente en esa memoria integrada. Después, el driver recorre la matriz de forma automática y continua a una frecuencia interna fija de 800 Hz.

Como el refresco lo hace el propio módulo por hardware, tu Arduino se libra por completo del bucle de persistencia de la visión (PoV), que tanto carga la CPU, y la pantalla no parpadea aunque el bucle principal esté haciendo tareas más lentas.

Patillaje y conexiones de la matriz de LED 8x8 con MAX7219

Los módulos estándar de matriz de LED 8x8 con MAX7219 suelen sacar todas las líneas SPI necesarias a dos conectores de 5 pines, sencillos de usar, situados en los extremos opuestos de la PCB (normalmente marcados como lado de entrada y lado de salida).

Figura: módulo de matriz de LED 8x8 con MAX7219, con el conector de entrada estándar de 5 pines (izquierda) para la comunicación con Arduino y el conector de salida de 5 pines (derecha) para conectar más módulos en cadena.

• VCC: entrada de alimentación (normalmente +5 V CC).
• GND: referencia de masa del sistema.
• DIN (entrada de datos): entrada de datos serie conectada a la línea MOSI del microcontrolador.
• CS (selección de chip / LOAD): se pone a nivel bajo para empezar la transmisión y a nivel alto para cargar (latch) los bytes recibidos.
• CLK (reloj serie): sincroniza la transmisión de los bytes, a hasta 10 MHz.
• DOUT (salida de datos): está en el conector de salida y sirve para encadenar varios módulos.

Resistencia R_iset integrada en la placa

Si usas el chip suelto, tienes que ajustar la corriente de pico de los segmentos LED con una resistencia externa calculada (R_iset) conectada al pin ISET.

En los módulos estándar de matriz de LED 8x8 con MAX7219, esta resistencia de ajuste de corriente ya viene integrada en la placa (normalmente una resistencia SMD de 10 kΩ). Esta resistencia fija la corriente de pico de los segmentos en unos seguros 40 mA para LED rojos estándar, así que no tienes que calcular, probar en protoboard ni soldar ninguna resistencia por tu cuenta.

Figura: esquema de conexiones entre un Arduino Uno y un módulo de matriz de LED 8x8 con MAX7219.

Registros de control del MAX7219

A bajo nivel, la comunicación con el módulo consiste en enviar un paquete de 16 bits formado por una dirección de registro de 8 bits seguida de un byte de datos de 8 bits:

Byte de comando = [Dirección (D15-D8)] + [Byte de datos (D7-D0)]

Estos son los principales registros de control que tiene mapeados internamente:

Librerías de Arduino dedicadas frente a control de bajo nivel

Enviar los códigos de registro en bruto con la librería SPI.h por hardware es muy didáctico para entender cómo funcionan los registros por dentro, pero programar desde cero gráficos complejos o texto en movimiento es muy laborioso.

En proyectos reales, lo habitual es recurrir a librerías de código abierto dedicadas y muy optimizadas, que hacen que controlar los módulos de matriz de LED con MAX7219 sea facilísimo:

1. LedControl (librería oficial de Arduino): una librería ligera y pensada para principiantes que te permite controlar módulos sueltos o cadenas cortas, encender o apagar LED concretos por coordenadas (setLed()) o mostrar caracteres.
2. MD_MAX72XX y MD_Parola: la referencia tanto en proyectos comerciales como de aficionados. Gestionan las distintas variantes de hardware (como la disposición de los módulos FC-16), búferes de texto en movimiento de varios dígitos, fuentes, efectos de animación de entrada y salida del texto y zonas de varias líneas, todo con muy poco código.

Ejemplo: control SPI de bajo nivel (conceptual)

El siguiente código muestra cómo interactúa por dentro una librería dedicada con los registros internos del MAX7219 usando el bus SPI por hardware nativo de Arduino (SPI.h).

// Pin Definitions
// Includes and Definitions
#include <SPI.h>
const int csPin = 10;

// MAX7219 Register Addresses
const byte REG_NOOP         = 0x00;
const byte REG_DIGIT0       = 0x01;
const byte REG_DECODE_MODE  = 0x09;
const byte REG_INTENSITY    = 0x0A;
const byte REG_SCAN_LIMIT   = 0x0B;
const byte REG_SHUTDOWN     = 0x0C;
const byte REG_DISPLAY_TEST = 0x0F;


// Display Pattern Buffer
byte heartPattern[8] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00000000
};

// Helper Function to Write to Register
void writeRegister(byte address, byte data) {
  digitalWrite(csPin, LOW);
  SPI.transfer(address);
  SPI.transfer(data);
  digitalWrite(csPin, HIGH);
}

// Setup Function
void setup() {
  pinMode(csPin, OUTPUT);
  digitalWrite(csPin, HIGH);
  SPI.begin();
  SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  writeRegister(REG_DISPLAY_TEST, 0x00);
  writeRegister(REG_DECODE_MODE, 0x00);
  writeRegister(REG_INTENSITY, 0x03);
  writeRegister(REG_SCAN_LIMIT, 0x07);
  writeRegister(REG_SHUTDOWN, 0x01);
  for (int i = 1; i <= 8; i++) {
    writeRegister(i, 0x00);
  }
}

// Main Loop
void loop() {
  for (int col = 0; col < 8; col++) {
    writeRegister(REG_DIGIT0 + col, heartPattern[col]);
  }
  delay(1000);
}

Conexión en cadena de módulos de matriz de LED 8x8 con MAX7219

Conectar en cascada varios módulos de matriz de LED 8x8 con MAX7219 para montar un letrero alargado es sorprendentemente sencillo.

Basta con colocar los módulos uno al lado del otro. Conecta en paralelo las líneas comunes (VCC, GND, CLK y CS) en todas las placas (normalmente se hace sin complicaciones con los típicos cables DuPont hembra-hembra).

Para el camino de los datos serie, lleva el pin DOUT (salida de datos) del conector de salida, en el lado derecho del primer módulo, directamente al pin DIN (entrada de datos) del conector de entrada, en el lado izquierdo del módulo de al lado.

Si usas librerías de alto nivel como MD_Parola, solo tienes que indicar en la configuración el número total de módulos conectados (por ejemplo, #define MAX_DEVICES 4). La librería se encarga automáticamente de desplazar los búferes de texto por las placas encadenadas, para que el texto se desplace de forma fluida y sincronizada por todos los módulos.

Requisitos de alimentación de los displays de matriz de LED con Arduino

Un solo módulo puede funcionar sin problemas con el regulador de 5 V integrado en tu Arduino, pero las matrices en cascada más grandes superan enseguida lo que puede dar un puerto USB:

• Límite de alimentación del USB 2.0: los puertos USB estándar de un ordenador limitan la corriente a 500 mA.
• Consumo de los módulos en cascada: un display de 8x32 (4 módulos) a brillo máximo puede consumir fácilmente entre 600 mA y 1 A si hay muchos píxeles encendidos.
• La solución: conecta una fuente de alimentación externa regulada de 5 V, de al menos 2 A, directamente a las líneas VCC y GND de tus módulos de LED. Y, muy importante, conecta siempre el GND de la fuente externa al pin GND del Arduino para que compartan la misma referencia de masa.

Solución de problemas con drivers de LED en Arduino

#1 Las salidas del 74HC595 no se actualizan

Si tus LED no cambian de estado, revisa el cable del latch (ST_CP). Si esta línea está desconectada o cortocircuitada a GND, el registro de desplazamiento recibirá los datos, pero nunca los pasará a los pines de salida.

#2 Los LED se encienden en orden incorrecto tras conectarlos en cascada

Si tus LED se encienden en orden inverso o los datos acaban en el registro equivocado, tienes un error con el orden FIFO. Recuerda que el byte que envías primero termina en el segundo chip de la cadena. Prueba a intercambiar el orden de las llamadas a shiftOut() en tu código.

#3 La matriz con MAX7219 no muestra el texto

Si una matriz en cascada se queda totalmente en blanco, lo más habitual es que falte la secuencia de activación. El MAX7219 arranca por defecto en el modo de apagado (Shutdown) de bajo consumo.

Tu código de configuración tiene que escribir explícitamente 0x01 en el registro Shutdown (0x0C) y poner el registro Scan Limit (0x0B) a 0x07 para activar las 8 filas.

#4 La matriz de LED se ve tenue o con brillo desigual

Si los LED se ven tenues o van perdiendo brillo a lo largo de la cadena, revisa cómo distribuyes la alimentación. La resistencia de los cables puente finos provoca una caída de tensión.

Lleva siempre cable de sección gruesa directamente desde la fuente de 5 V hasta la entrada de alimentación de cada módulo, en lugar de ir encadenando los cables VCC finos de una placa a otra.

#5 El display de LED parpadea

El parpadeo casi siempre se debe a que falta la referencia de masa. Si alimentas los módulos con un adaptador externo y te has olvidado de unir con un cable el terminal negativo del adaptador y el pin GND del Arduino, las señales SPI de alta velocidad fluctuarán muchísimo respecto a una referencia flotante.

#6 Problemas al arrancar

Al encender el circuito, las salidas del registro de desplazamiento pueden quedar flotantes o arrancar con valores aleatorios, lo que provoca un breve destello no deseado de todos los LED conectados.

Para evitarlo, coloca una resistencia pull-up de 10 kΩ entre el pin OE y VCC. Así las salidas quedan en alta impedancia (deshabilitadas) durante el arranque. Cuando el Arduino termine de arrancar, tu código de configuración puede poner el pin OE a nivel bajo para habilitar las salidas en un estado limpio.

Proyectos con drivers de LED para Arduino

Display de texto en movimiento de 8x32 con MAX7219

Conectando en cascada cuatro módulos estándar de 8x8 y usando la librería MD_Parola, puedes montar un gran letrero de texto en movimiento con animaciones fluidas de entrada y salida del texto.

Figura: cuatro módulos de matriz de LED 8x8 conectados en cadena para un proyecto de display de texto con Arduino

Barra de LED grande con 74HC595

Encadenando tres registros de desplazamiento 74HC595, puedes controlar un indicador de nivel de audio de 24 segmentos muy sensible o un indicador de batería, con un brillo excelente y sin gastar más pines.

Multiplexación de displays de 7 segmentos con Arduino

En los proyectos que necesitan mostrar números, multiplexar displays de 7 segmentos con Arduino es una solución clásica. Un display de 7 segmentos de varios dígitos se basa en una disposición estándar de siete LED de segmento, identificados como a, b, c, d, e, f y g, más un octavo segmento opcional para el punto decimal (dp).

En un display de 4 dígitos, esto supone 12 pines físicos en total: 8 pines conectados en paralelo que controlan los segmentos de todos los dígitos y 4 pines de cátodo común o de ánodo común para seleccionar qué dígito está activo.

Muchos proyectos de multiplexación de 7 segmentos con Arduino usan registros de desplazamiento 74HC595 o drivers MAX7219 para ahorrar pines GPIO y simplificar la temporización del refresco. Es una solución muy versátil, tanto si usas displays de ánodo común como de cátodo común.

En lugar de usar 32 pines para controlar directamente los cuatro dígitos, la multiplexación va activando uno tras otro los cuatro pines comunes mientras envía los datos de segmento correspondientes. Si el barrido es lo bastante rápido, los dígitos se funden y se ve un display continuo de varios dígitos sin parpadeo apreciable.

Del prototipo en protoboard a tu propia PCB de display de LED

Solicita presupuesto gratis

• Si vas a pasar de un prototipo en protoboard a una PCB de display de LED a medida, planifica desde el principio los caminos de corriente, la ubicación de los conectores, los condensadores de desacoplo y las huellas de los CI drivers.
• Los servicios de fabricación y montaje de PCB de JLCPCB te ayudan a convertir tus prototipos de drivers de LED con Arduino en placas compactas listas para producción.

Conclusión

Los drivers de LED para Arduino permiten que microcontroladores pequeños controlen displays sorprendentemente grandes gracias a una temporización cuidadosa del barrido y a un cableado compartido. El barrido de matrices, los registros de desplazamiento 74HC595, el Charlieplexing y los drivers MAX7219 resuelven cada uno distintos problemas de escalado, según los límites de GPIO, el brillo necesario, la carga de la CPU y la complejidad del circuito.

Preguntas frecuentes sobre drivers de LED para Arduino