74HC595 con Arduino: registro de desplazamiento para 8+ LEDs

El 74HC595 es un circuito integrado de 16 pines, un registro de desplazamiento (shift register) muy barato que te permite controlar 8 salidas independientes usando solo 3 pines digitales de tu Arduino. Un Arduino Uno tiene 20 pines utilizables y se agotan enseguida cuando intentas montar un coche fantástico de 16 LEDs, un marcador de dos dígitos o una placa de 8 relés. El 74HC595 lo resuelve recibiendo los datos bit a bit por una sola línea: el chip va guardando los bits que llegan y, cuando le indicas que estás listo, los copia a la vez en sus ocho salidas. Si conectas varios chips en cascada, los mismos 3 pines controlan 16, 24 o incluso 80 salidas.

En esta guía aprenderás el patillaje del 74HC595 (DS, SH_CP, ST_CP, OE, MR y Q7'), la estructura interna que convierte datos en serie en salidas en paralelo, la función shiftOut() de Arduino y la diferencia entre el orden de bits MSBFIRST y LSBFIRST. Después montarás un contador binario, una secuencia de LEDs, una cadena de 16 LEDs y un display de 7 segmentos, y controlarás el mismo circuito decenas de veces más rápido con SPI por hardware. Las últimas secciones incluyen código para ESP32 y Raspberry Pi Pico (MicroPython), los límites de corriente del chip y la solución a los errores de latch más comunes.

¿Qué es el 74HC595 y cómo funciona?

Dentro del chip hay dos registros de 8 bits conectados uno tras otro. El primero es el registro de desplazamiento: en cada flanco de subida del pin SH_CP (reloj), el 0 o el 1 presente en el pin DS entra en la primera celda y los bits que ya estaban dentro avanzan una posición. Tras ocho pulsos de reloj, los ocho bits que enviaste están dentro. El segundo es el registro de almacenamiento (latch): con un flanco de subida en el pin ST_CP, los ocho bits del registro de desplazamiento se copian de golpe a este registro y aparecen en las salidas Q0–Q7. Gracias a esta estructura en dos etapas, los LEDs no parpadean mientras los bits se desplazan; las salidas solo cambian cuando activas el pin de latch.

Puedes compararlo con una estación de tren: los vagones (bits) llegan al andén uno tras otro por una sola vía, pero las puertas solo se abren cuando el tren está completamente parado, y todos los pasajeros bajan a la vez. Abrir las puertas es tarea del pin de latch. Como los datos entran en serie y salen en paralelo, al 74HC595 también se le llama registro SIPO (serial-in, parallel-out). Su hermano, que hace lo contrario y te permite leer 8 botones por una sola línea, es el 74HC165 (PISO). Ambos pertenecen a la familia lógica de la serie 74; puedes consultar las puertas y los números de chip de esta familia en la herramienta Puertas lógicas.

Patillaje del 74HC595 (pinout)

La muesca en forma de media luna o el pequeño punto del chip marca el pin 1. Con la muesca arriba y mirando el chip desde arriba, los pines 1–8 bajan por el lado izquierdo y los pines 9–16 suben por el lado derecho. Cada fabricante nombra los pines a su manera: NXP y la mayoría de recursos de Arduino usan DS, SH_CP y ST_CP, mientras que Texas Instruments usa SER, SRCLK y RCLK. En la tabla de abajo tienes ambos. OE y MR son entradas activas a nivel bajo, es decir, actúan cuando están en LOW, y en las hojas de datos aparecen con una barra sobre el nombre.

Conexión con Arduino Uno, ESP32 y Pico

Todos los ejemplos de Arduino de esta guía usan el mismo circuito. Elegir desde el principio los pines de SPI por hardware (D11 y D13) para las líneas de datos y reloj hace que, cuando pases el código a SPI, no tengas que mover ni un solo cable. La pata larga (ánodo) de cada LED va a una salida y la pata corta (cátodo) va a GND a través de una resistencia. No olvides un condensador cerámico de 100 nF entre los pines VCC y GND del chip, lo más cerca posible de él; suaviza las pequeñas caídas de tensión cuando muchos LEDs conmutan a la vez y evita fallos aleatorios. También puedes comprobar los pines SPI de tu placa en la herramienta Pinout.

La función shiftOut() y el orden de bits (MSBFIRST / LSBFIRST)

La forma más sencilla de enviar datos al 74HC595 desde Arduino es la función integrada shiftOut(dataPin, clockPin, bitOrder, value). Escribe los ocho bits del byte value uno tras otro en el pin de datos y, después de cada bit, pone el pin de reloj en HIGH y luego en LOW; el 74HC595 toma el bit justo en ese flanco de subida. shiftOut() no toca el pin de latch, así que tienes que poner ST_CP en LOW antes de enviar y en HIGH después. Como la función trabaja con flancos de subida, el pin de reloj también debe estar en LOW antes de la llamada; si no, el primer bit se puede perder.

El parámetro bitOrder indica desde qué extremo se envían los bits. El primer bit enviado acaba en el otro extremo, Q7, tras ocho desplazamientos, y el último bit enviado se queda en Q0. Con MSBFIRST sale primero el bit más significativo (bit 7), así que cada bit del byte cae en la salida con el mismo número: el bit 0 en Q0 y el bit 7 en Q7. Con LSBFIRST el orden se invierte y el bit 0 aparece en Q7 y el bit 7 en Q0. Todos los ejemplos de esta guía usan MSBFIRST, de modo que los bits del número en el código coinciden uno a uno con los números de los LEDs. Si quieres repasar los números binarios y la notación 0b, lee la guía sobre sistemas de numeración y operaciones con bits.

Paso a paso: contador binario con 8 LEDs

1. Coloca el 74HC595 sobre el canal central de la protoboard, de forma que las dos filas de patas queden a lados distintos. Si no conoces las conexiones internas de una protoboard, lee primero ¿Qué es una protoboard?.
2. Conecta VCC (pin 16) y MR (pin 10) a 5V, y GND (pin 8) y OE (pin 13) a GND. Pon el condensador de 100 nF entre VCC y GND.
3. Conecta DS (14) a D11, SH_CP (11) a D13 y ST_CP (12) a D10.
4. Conecta las patas largas de ocho LEDs a las salidas Q0–Q7 y las patas cortas a GND mediante resistencias de 470 Ω. Recuerda que Q0 es el pin 15.
5. Sube el código de abajo. Los LEDs deben contar en binario de 0 a 255; el LED de Q0 parpadea más rápido y el de Q7 más despacio.

1// 74HC595 ile 8 LED'de ikilik sayaç / Binary counter on 8 LEDs with a 74HC595
2const int DATA_PIN = 11;   // DS (14)
3const int CLOCK_PIN = 13;  // SH_CP (11)
4const int LATCH_PIN = 10;  // ST_CP (12)
5
6void write595(byte value) {
7  digitalWrite(LATCH_PIN, LOW);                    // latch'i indir / pull the latch low
8  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, value);  // 8 biti kaydır / shift the 8 bits in
9  digitalWrite(LATCH_PIN, HIGH);                   // yükselen kenar: çıkışlara aktar / rising edge: copy to the outputs
10}
11
12void setup() {
13  pinMode(DATA_PIN, OUTPUT);
14  pinMode(CLOCK_PIN, OUTPUT);
15  pinMode(LATCH_PIN, OUTPUT);
16  digitalWrite(CLOCK_PIN, LOW);                    // saat LOW başlamalı / the clock must start low
17  write595(0);                                     // açılışta hepsi sönük / all off at startup
18}
19
20void loop() {
21  for (int n = 0; n < 256; n++) {
22    write595(n);                                   // n'in bitleri Q0–Q7'de / the bits of n on Q0–Q7
23    delay(200);
24  }
25}

El corazón del código es la función write595(): pone el latch en LOW, envía ocho bits con shiftOut() y pone el latch en HIGH para pasarlos todos a la vez a las salidas. Aquí está también la respuesta a por qué los LEDs no parpadean: mientras se desplazan los bits, las salidas mantienen su valor anterior. Cuando n vale 5 (0b00000101) se encienden los LEDs de Q0 y Q2; con 200 (0b11001000) se encienden los de Q3, Q6 y Q7. En el Uno puede que veas el LED integrado L de D13 titilar levemente con la señal de reloj; es normal y no afecta al circuito.

Secuencia de LEDs y efecto coche fantástico

Para una secuencia de luces basta con poner un único bit a 1 en cada paso. La macro bit(i) de Arduino genera un número en el que solo el bit i vale 1: bit(0) es 1, bit(3) es 8 y bit(7) es 128. El código de abajo reproduce tres efectos seguidos: un LED que corre de Q0 a Q7, un barrido de ida y vuelta al estilo coche fantástico y una barra que se va llenando. Si quieres compararlo con la versión clásica conectada directamente a los pines, mira Coche fantástico y secuencia de LEDs con Arduino; allí cada LED gasta un pin propio, aquí bastan 3 pines en total.

1// Yürüyen LED, karaşimşek ve dolan çubuk / Running light, Knight Rider and filling bar
2const int DATA_PIN = 11;   // DS
3const int CLOCK_PIN = 13;  // SH_CP
4const int LATCH_PIN = 10;  // ST_CP
5const int STEP_MS = 80;    // adım süresi (ms) / step time (ms)
6
7void write595(byte value) {
8  digitalWrite(LATCH_PIN, LOW);
9  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, value);
10  digitalWrite(LATCH_PIN, HIGH);
11}
12
13void setup() {
14  pinMode(DATA_PIN, OUTPUT);
15  pinMode(CLOCK_PIN, OUTPUT);
16  pinMode(LATCH_PIN, OUTPUT);
17  digitalWrite(CLOCK_PIN, LOW);
18  write595(0);
19}
20
21void loop() {
22  // 1) Yürüyen LED: Q0'dan Q7'ye / running light: Q0 to Q7
23  for (int i = 0; i < 8; i++) {
24    write595(bit(i));               // yalnızca i. bit 1 / only bit i is 1
25    delay(STEP_MS);
26  }
27
28  // 2) Karaşimşek: git-gel, 3 tur / Knight Rider: back and forth, 3 rounds
29  for (int r = 0; r < 3; r++) {
30    for (int i = 0; i < 7; i++) { write595(bit(i)); delay(STEP_MS); }
31    for (int i = 7; i > 0; i--) { write595(bit(i)); delay(STEP_MS); }
32  }
33
34  // 3) Dolan çubuk / filling bar
35  byte bar = 0;
36  for (int i = 0; i < 8; i++) {
37    bar |= bit(i);                  // bir LED daha ekle / add one more LED
38    write595(bar);
39    delay(STEP_MS * 2);
40  }
41  write595(0);
42  delay(300);
43}

En la parte del coche fantástico, el bucle de ida va de 0 a 6 y el de vuelta de 7 a 1; así los LEDs de los extremos no se encienden dos veces seguidas y el movimiento se ve fluido. En la barra, la operación |= (OR bit a bit) añade un LED nuevo y deja encendidos los anteriores; es la base de un vúmetro o indicador de barra que muestra el valor de un potenciómetro o un sensor. Como el código usa delay(), el Arduino no puede hacer nada más mientras dura el efecto. Si quieres leer un botón o cambiar la velocidad en directo durante el efecto, controla los tiempos con millis(); encontrarás el método en la guía millis() y delay().

Conectar varios 74HC595 en cascada (Q7')

El pin 9 del chip, Q7' (QH'), saca el bit que desborda del registro de desplazamiento. Si lo conectas a la entrada DS de un segundo 74HC595, los dos chips se comportan como un único registro de 16 bits. Las líneas SH_CP y ST_CP son comunes a todos los chips; tanto si la cadena tiene tres como diez, del Arduino siguen saliendo solo 3 cables. Cada byte nuevo empuja al anterior hacia el siguiente chip. Por eso el primer byte que envías acaba en el último chip de la cadena, mientras que el último byte se queda en el primer chip, el que está conectado al Arduino. Al activar el latch, las salidas de todos los chips se actualizan a la vez.

1// İki zincirli 74HC595 ile 16 LED / 16 LEDs on two daisy-chained 74HC595s
2const int DATA_PIN = 11;   // 1. entegrenin DS'si / DS of chip 1
3const int CLOCK_PIN = 13;  // iki entegrede ortak SH_CP / shared SH_CP
4const int LATCH_PIN = 10;  // iki entegrede ortak ST_CP / shared ST_CP
5
6void write16(uint16_t value) {
7  digitalWrite(LATCH_PIN, LOW);
8  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, highByte(value));  // önce uzaktaki entegre (LED 8–15) / far chip first (LEDs 8–15)
9  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, lowByte(value));   // sonra yakındaki (LED 0–7) / then the near chip (LEDs 0–7)
10  digitalWrite(LATCH_PIN, HIGH);                             // 16 çıkış aynı anda değişir / all 16 outputs change at once
11}
12
13void setup() {
14  pinMode(DATA_PIN, OUTPUT);
15  pinMode(CLOCK_PIN, OUTPUT);
16  pinMode(LATCH_PIN, OUTPUT);
17  digitalWrite(CLOCK_PIN, LOW);
18  write16(0);
19}
20
21void loop() {
22  for (int i = 0; i < 16; i++) {    // ileri / forward
23    write16(bit(i));
24    delay(50);
25  }
26  for (int i = 14; i > 0; i--) {    // geri / backward
27    write16(bit(i));
28    delay(50);
29  }
30}

highByte() y lowByte() dividen el número de 16 bits en dos bytes. El byte alto se envía primero, así que viaja hasta el último chip de la cadena y controla los LEDs 8–15; el byte bajo se queda en el primer chip. Para añadir un tercer chip basta con enviar un byte más, empezando de nuevo por el chip más lejano; con muchos chips es más ordenado guardar los bytes en un array y enviarlos con un bucle. La cadena no tiene un límite teórico, pero cada chip alarga la actualización y carga más la línea de reloj común. En cadenas largas, pon a cada chip su propio condensador de 100 nF, mantén cortos los cables de reloj y latch y, si la línea crece mucho, refuerza el reloj con un buffer como el 74HC244.

Controlar un display de 7 segmentos con el 74HC595

Un display de 7 segmentos de un dígito tiene exactamente ocho LEDs: siete segmentos de la a a la g y un punto (dp). Por tanto, las ocho salidas de un 74HC595 encajan perfectamente con un dígito. Si conectas Q0 al segmento a, Q1 al b y así sucesivamente, Q6 acaba en g y Q7 en el punto; el bit 0 del byte representa entonces el segmento a y el bit 6 el segmento g. La tabla de abajo muestra el conexionado de un display habitual de 10 pines y cátodo común. Los pines comunes (3 y 8) van a GND y cada segmento lleva su propia resistencia de 470 Ω. La disposición de las letras de los segmentos y la diferencia entre ánodo común y cátodo común las tienes en detalle en la guía Display de 7 segmentos con Arduino.

1// 74HC595 ile tek haneli 7 segment: 0–9 sayacı / Single-digit 7-segment 0–9 counter with a 74HC595
2const int DATA_PIN = 11;
3const int CLOCK_PIN = 13;
4const int LATCH_PIN = 10;
5const bool COMMON_ANODE = false;    // ortak anotsa true / true for common anode
6
7// bit 0 = a ... bit 6 = g, bit 7 = dp (1 = yanar / 1 = on)
8const byte DIGITS[10] = {
9  0b00111111, // 0
10  0b00000110, // 1
11  0b01011011, // 2
12  0b01001111, // 3
13  0b01100110, // 4
14  0b01101101, // 5
15  0b01111101, // 6
16  0b00000111, // 7
17  0b01111111, // 8
18  0b01101111  // 9
19};
20
21void write595(byte value) {
22  if (COMMON_ANODE) value = ~value;   // ortak anotta LOW yakar / LOW lights a common-anode segment
23  digitalWrite(LATCH_PIN, LOW);
24  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, value);
25  digitalWrite(LATCH_PIN, HIGH);
26}
27
28void setup() {
29  pinMode(DATA_PIN, OUTPUT);
30  pinMode(CLOCK_PIN, OUTPUT);
31  pinMode(LATCH_PIN, OUTPUT);
32  digitalWrite(CLOCK_PIN, LOW);
33}
34
35void loop() {
36  for (int n = 0; n < 10; n++) {
37    byte pattern = DIGITS[n];
38    if (n % 2 == 1) pattern |= 0b10000000;   // tek sayılarda nokta yanar / dot on for odd numbers
39    write595(pattern);
40    delay(800);
41  }
42}

En un display de ánodo común, los pines comunes van a 5V y un segmento se enciende cuando su salida está en LOW. Si pones COMMON_ANODE en true en el código, el operador ~ invierte todos los bits y la misma tabla sigue funcionando. Para un contador de dos dígitos, añade un segundo 74HC595 a la cadena y envía primero el patrón del dígito más lejano y después el del dígito más cercano al Arduino. Con este método cada dígito tiene su propio chip, así que no hace falta multiplexar, el display nunca parpadea y usar delay() en loop() no es un problema. Para cuatro dígitos o más puedes multiplexar con dos 74HC595 o pasarte a drivers como el TM1637 o el MAX7219, que hacen el barrido por su cuenta.

Control rápido con SPI

shiftOut() es lento porque escribe cada bit por separado con digitalWrite(): en un Arduino Uno, enviar un byte tarda unos 100 µs. Con unos pocos LEDs no se nota, pero se queda corto si quieres actualizar una cadena de 10 chips miles de veces por segundo, regular el brillo de los LEDs por software o barrer un cubo de LEDs multiplexado. La buena noticia es que el protocolo del 74HC595 es en realidad SPI: DS corresponde a MOSI, SH_CP a SCK y ST_CP al pin de selección (CS). La unidad SPI por hardware del Uno envía un byte en aproximadamente 1 µs a 8 MHz; incluso sumando la sobrecarga de las llamadas, es decenas de veces más rápida que shiftOut(). Puedes ver cómo funciona SPI en la guía ¿Qué es SPI?.

1// 74HC595'i donanım SPI ile sürmek (Arduino Uno) / Driving a 74HC595 over hardware SPI (Arduino Uno)
2#include <SPI.h>
3
4const int LATCH_PIN = 10;   // ST_CP; D11 (MOSI) = DS, D13 (SCK) = SH_CP
5
6void write595(byte value) {
7  SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));  // 8 MHz, mod 0 / 8 MHz, mode 0
8  digitalWrite(LATCH_PIN, LOW);
9  SPI.transfer(value);              // 8 bit yaklaşık 1 µs'de / 8 bits in about 1 µs
10  digitalWrite(LATCH_PIN, HIGH);    // çıkışlara aktar / copy to the outputs
11  SPI.endTransaction();
12}
13
14void setup() {
15  pinMode(LATCH_PIN, OUTPUT);
16  SPI.begin();                      // D11 ve D13 SPI'ye geçer / D11 and D13 switch to SPI
17  write595(0);
18}
19
20void loop() {
21  static byte pattern = 0b00000001;
22  write595(pattern);
23  pattern = (pattern << 1) | (pattern >> 7);   // sola döndür / rotate left
24  delay(100);
25}

En SPI_MODE0 los datos se muestrean en el flanco de subida del reloj, exactamente igual que en el 74HC595. MSBFIRST vuelve a enviar el bit 7 a Q7, así que los patrones de los ejemplos anteriores funcionan sin cambios. En el Uno, D10 debe ser una salida para que el SPI por hardware se mantenga en modo maestro; SPI.begin() ya lo configura, y por eso D10 es el mejor pin para el latch. Si la cadena tiene varios chips, basta con llamar a SPI.transfer() una vez por chip entre el latch en LOW y en HIGH. MISO (D12) no se usa en este circuito y queda libre para otro dispositivo SPI.

Brillo con OE y borrado con MR

El pin OE (output enable) es un interruptor que activa o desactiva todas las salidas de una vez. Si lo conectas a uno de los pines PWM del Uno, por ejemplo D9, en lugar de a GND, puedes regular el brillo de todos los LEDs a la vez con PWM. Como OE es activo en LOW, la lógica va al revés: analogWrite(9, 0) significa brillo máximo y analogWrite(9, 255) totalmente apagado. Escribir analogWrite(9, 255 - brillo) en el código te lo pone más fácil. Este método afecta a todos los LEDs por igual; para ajustar el brillo de cada LED por separado tendrás que hacerlo por software con actualizaciones SPI rápidas o pasarte a LEDs direccionables como el WS2812B.

Cuando el pin MR (master reset) pasa a LOW, se borran todos los bits del registro de desplazamiento, pero las salidas no se apagan al momento porque el registro de almacenamiento conserva el valor anterior. Para apagar también las salidas, hay que enviar un flanco de subida al pin de latch mientras MR está en LOW. En la práctica, conectar MR directamente a VCC y borrar por software con write595(0) te ahorra un pin y un cable. Además está el tema del arranque: al dar alimentación, el registro de almacenamiento empieza con un valor aleatorio y los LEDs pueden encenderse un instante sin orden. En una placa de relés esto puede ser peligroso; para evitarlo, pon OE a VCC con una resistencia de 10 kΩ, llama primero a write595(0) en setup() y después pon el pin OE en LOW.

74HC595 con ESP32: 3,3 V y SPI

Los pines del ESP32 dan 3,3 V. Si alimentas el 74HC595 a 5 V, una entrada necesita unos 0,7 × VCC, es decir 3,5 V, para considerarse HIGH; 3,3 V se queda por debajo de ese umbral y el funcionamiento se vuelve inestable. La solución más limpia es alimentar también el chip desde el pin 3V3 del ESP32, ya que el 74HC595 funciona a partir de 2 V. Si de verdad necesitas alimentar el chip a 5 V, usa el 74HCT595, cuyas entradas ya ven como HIGH cualquier tensión por encima de 2 V, o añade un conversor de nivel lógico. A 3,3 V, 220 Ω va bien para LEDs rojos, amarillos y verdes; los azules y blancos, con una tensión directa de unos 3 V, lucen muy poco a 3,3 V.

El ejemplo de abajo usa los pines VSPI del ESP32 (SCK en GPIO 18, MOSI en GPIO 23) para reproducir el efecto coche fantástico en 16 LEDs conectados a dos 74HC595 en cascada; GPIO 5 hace de latch. La velocidad SPI se fija en 4 MHz porque el límite de velocidad del 74HC595 baja con la tensión de alimentación, y 4 MHz deja un amplio margen de seguridad a 3,3 V. shiftOut() también funciona en el ESP32 y es mucho más rápido que en el Uno gracias al procesador de 240 MHz; aun así, usar SPI libera al procesador para tareas como el Wi-Fi. Para lo básico de la placa y la elección de pines seguros, consulta ¿Qué es el ESP32?.

1// ESP32 + iki 74HC595 (SPI) ile 16 LED karaşimşek / 16-LED Knight Rider on ESP32 with two 74HC595s (SPI)
2#include <SPI.h>
3
4const int SCK_PIN = 18;    // SH_CP
5const int MOSI_PIN = 23;   // DS
6const int LATCH_PIN = 5;   // ST_CP
7
8void write16(uint16_t value) {
9  SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));  // 3,3 V için 4 MHz yeterli / 4 MHz is plenty at 3.3 V
10  digitalWrite(LATCH_PIN, LOW);
11  SPI.transfer(highByte(value));    // önce uzaktaki entegre / far chip first
12  SPI.transfer(lowByte(value));     // sonra yakındaki / then the near chip
13  digitalWrite(LATCH_PIN, HIGH);
14  SPI.endTransaction();
15}
16
17void setup() {
18  pinMode(LATCH_PIN, OUTPUT);
19  SPI.begin(SCK_PIN, -1, MOSI_PIN, -1);   // MISO ve SS kullanılmıyor / MISO and SS unused
20  write16(0);
21}
22
23void loop() {
24  for (int i = 0; i < 16; i++) { write16(bit(i)); delay(40); }   // ileri / forward
25  for (int i = 14; i > 0; i--) { write16(bit(i)); delay(40); }   // geri / backward
26}

74HC595 con Raspberry Pi Pico y MicroPython

En la Pico, alimenta también el 74HC595 desde el pin 3V3(OUT). MicroPython no tiene un equivalente directo de shiftOut() de Arduino, pero el SPI por hardware hace el trabajo de sobra: se usan los pines GP18 (SCK) y GP19 (MOSI) de la unidad SPI0, y cualquier GPIO sirve como latch; aquí se eligió GP17. MicroPython reserva también el pin MISO de SPI0 (GP16) para SPI, así que no lo conectes a otra cosa. Si pasas varios bytes a spi.write(), actualizas todos los chips de la cadena de una vez, y otra vez el primer byte va al chip más lejano. Para la instalación y los primeros pasos, consulta ¿Qué es la Raspberry Pi Pico?.

1# Pico + 74HC595: yürüyen LED ve ikilik sayaç (SPI) / Pico + 74HC595: running light and binary counter (SPI)
2from machine import Pin, SPI
3import time
4
5# GP18 = SCK -> SH_CP, GP19 = MOSI -> DS; GP16 (MISO) boş kalır / GP16 (MISO) stays unconnected
6spi = SPI(0, baudrate=4000000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
7latch = Pin(17, Pin.OUT, value=1)    # ST_CP
8
9def write595(*values):
10    # birden çok bayt = zincirdeki entegreler, ilk bayt en uzaktakine
11    # several bytes = chained chips, the first byte goes to the far chip
12    latch.value(0)
13    spi.write(bytes(values))
14    latch.value(1)                   # yükselen kenar: çıkışlara aktar / rising edge: copy to the outputs
15
16write595(0)
17while True:
18    for i in range(8):               # yürüyen LED / running light
19        write595(1 << i)
20        time.sleep_ms(80)
21    for n in range(256):             # ikilik sayaç / binary counter
22        write595(n)
23        time.sleep_ms(20)

Cargas mayores: transistor, ULN2803 y TPIC6B595

Las salidas del 74HC595 solo sirven para corrientes pequeñas de LED. No conectes directamente cargas como la bobina de un relé (70–90 mA), un motor pequeño, varios zumbadores o una tira LED de 12 V. Puedes poner un transistor NPN detrás de cada salida o usar el ULN2803, que reúne ocho transistores Darlington en un solo encapsulado: conmuta hasta 500 mA por canal en el lado de GND y lleva integrados diodos de protección para cargas inductivas; para que actúen, conecta su pin COM a la alimentación de la carga. Una solución más compacta es el TPIC6B595, que se programa igual que el 74HC595 pero tiene potentes salidas en drenador abierto: soporta 150 mA continuos por salida y puede conmutar cargas de hasta 50 V. Tiene 20 pines, así que su patillaje es distinto, y las cargas se conectan entre el positivo y la salida.

¿74HC595, MAX7219 o TM1637?

Si necesitas una barra de LEDs sencilla, una placa de 8 relés o salidas digitales que hagan cada una un trabajo distinto, el 74HC595 es la opción más barata y flexible. Para matrices de LEDs de 8x8 o displays de varios dígitos, el MAX7219, que se encarga él solo del multiplexado, te facilita mucho la vida. Si quieres luces de colores controladas una a una, los LEDs WS2812B NeoPixel funcionan con un solo pin de datos.

Ideas de proyectos con el 74HC595

• Coche fantástico de 16 LEDs: Monta el efecto de ida y vuelta con dos chips en cascada y ajusta su velocidad con un potenciómetro.
• Indicador de nivel con barra de LEDs: Muestra el valor de un sensor o un nivel de sonido en una barra de 8–16 LEDs.
• Sensor de aparcamiento: Enciende más LEDs, de verde a rojo, a medida que se acorta la distancia medida con un HC-SR04.
• Marcador de dos dígitos: Haz un contador con botones y sin parpadeos usando dos displays de 7 segmentos y dos chips en cascada.
• Reloj binario: Muestra horas, minutos y segundos como números binarios en columnas de LEDs, tomando la hora de un módulo de reloj RTC.
• Cubo de LEDs 3x3x3: Crea animaciones en 3D controlando las capas con transistores y las columnas con 74HC595; los detalles están en la guía Cubo de LEDs con Arduino.
• Placa de 8 relés: Controla ocho relés desde 3 pines con un ULN2803 o un TPIC6B595.

Errores comunes y cómo solucionarlos

El 74HC595 es la forma más barata y didáctica de resolver la falta de pines. Cuando entiendes la idea de desplazar y fijar con el latch, la reconoces en los dispositivos SPI, en los drivers de matrices de LEDs y en los módulos de display, y también al leer botones con un 74HC165. Empieza con el contador de 8 LEDs, alarga después la cadena y pásate a SPI. En la app BlueGrays encontrarás proyectos de secuencia de LEDs, coche fantástico, efectos con velocidad regulable y contadores de 7 segmentos para Arduino, ESP32 y Raspberry Pi Pico, paso a paso con esquemas y código.