74HC595 Arduino: shift register per comandare 8+ LED con 3 pin

Il 74HC595 è un integrato a 16 pin, uno shift register (registro a scorrimento) molto economico che ti permette di controllare 8 uscite indipendenti usando solo 3 pin digitali del tuo Arduino. Un Arduino Uno ha 20 pin utilizzabili, e finiscono in fretta quando provi a costruire un effetto Supercar con 16 LED, un tabellone segnapunti a due cifre o una scheda con 8 relè. Il 74HC595 risolve il problema ricevendo i dati bit per bit su una sola linea: il chip accoglie i bit uno dopo l'altro e, quando gli dici che sei pronto, li copia contemporaneamente sulle sue otto uscite. Collegando più chip in cascata, gli stessi 3 pin gestiscono 16, 24 o addirittura 80 uscite.

In questa guida imparerai la piedinatura del 74HC595 (DS, SH_CP, ST_CP, OE, MR e Q7'), la struttura interna che trasforma i dati seriali in uscite parallele, la funzione shiftOut() di Arduino e la differenza tra l'ordine dei bit MSBFIRST e LSBFIRST. Poi monterai un contatore binario, dei LED in sequenza, una catena di 16 LED e un display a 7 segmenti, e piloterai lo stesso circuito decine di volte più velocemente con l'SPI hardware. Nelle ultime sezioni trovi il codice per ESP32 e Raspberry Pi Pico (MicroPython), i limiti di corrente del chip e le soluzioni agli errori di latch più comuni.

Cos'è il 74HC595 e come funziona?

Dentro il chip ci sono due registri a 8 bit collegati uno dopo l'altro. Il primo è il registro a scorrimento: a ogni fronte di salita sul pin SH_CP (clock), lo 0 o l'1 presente sul pin DS entra nella prima cella e i bit già presenti avanzano di una posizione. Dopo otto impulsi di clock, tutti gli otto bit che hai inviato sono dentro. Il secondo è il registro di memorizzazione (latch): con un fronte di salita sul pin ST_CP, gli otto bit del registro a scorrimento vengono copiati in un colpo solo e compaiono sulle uscite Q0–Q7. Grazie a questa struttura a due stadi i LED non sfarfallano mentre i bit scorrono; le uscite cambiano solo quando attivi il pin di latch.

Puoi paragonarlo a una stazione ferroviaria: i vagoni (i bit) arrivano al binario uno dopo l'altro su un'unica rotaia, ma le porte si aprono solo quando il treno è completamente fermo, e tutti i passeggeri scendono nello stesso momento. Aprire le porte è il compito del pin di latch. Poiché i dati entrano in serie ed escono in parallelo, il 74HC595 viene chiamato anche registro SIPO (serial-in, parallel-out). Il suo fratello che fa l'opposto, cioè ti permette di leggere 8 pulsanti su una sola linea, è il 74HC165 (PISO). Entrambi appartengono alla famiglia logica della serie 74; puoi consultare le porte e le sigle dei chip di questa famiglia nello strumento Porte logiche.

Piedinatura del 74HC595 (pinout)

La tacca a mezzaluna o il piccolo puntino sul chip indica il pin 1. Con la tacca in alto e guardando il chip dall'alto, i pin 1–8 scendono lungo il lato sinistro e i pin 9–16 risalgono lungo il lato destro. I produttori danno ai pin nomi diversi: NXP e la maggior parte delle risorse Arduino usano DS, SH_CP e ST_CP, mentre Texas Instruments usa SER, SRCLK e RCLK. Nella tabella qui sotto li trovi entrambi. OE e MR sono ingressi attivi bassi, cioè svolgono la loro funzione quando sono a LOW, e nei datasheet sono indicati con una barra sopra il nome.

Collegamento ad Arduino Uno, ESP32 e Pico

Tutti gli esempi Arduino di questa guida usano lo stesso circuito. Scegliere fin dall'inizio i pin dell'SPI hardware (D11 e D13) per le linee di dati e di clock ti evita di spostare anche un solo filo quando passerai il codice all'SPI. La gamba lunga (anodo) di ogni LED va a un'uscita e quella corta (catodo) va a GND attraverso una resistenza. Non dimenticare un condensatore ceramico da 100 nF tra i pin VCC e GND del chip, il più vicino possibile a esso; attenua i brevi cali di tensione quando molti LED commutano insieme ed evita errori casuali. Puoi anche verificare i pin SPI della tua scheda con lo strumento Pinout.

La funzione shiftOut() e l'ordine dei bit (MSBFIRST / LSBFIRST)

Il modo più semplice per inviare dati al 74HC595 con Arduino è la funzione integrata shiftOut(dataPin, clockPin, bitOrder, value). Scrive gli otto bit del byte value uno dopo l'altro sul pin dei dati e, dopo ogni bit, porta il pin di clock prima a HIGH e poi a LOW; il 74HC595 acquisisce il bit proprio su quel fronte di salita. shiftOut() non tocca il pin di latch, quindi devi portare ST_CP a LOW prima dell'invio e a HIGH dopo. Dato che la funzione lavora sui fronti di salita, anche il pin di clock deve essere a LOW prima della chiamata, altrimenti il primo bit può andare perso.

Il parametro bitOrder stabilisce da quale estremità partono i bit. Il primo bit inviato, dopo otto scorrimenti, arriva all'estremità opposta, cioè a Q7, mentre l'ultimo resta su Q0. Con MSBFIRST parte per primo il bit più significativo (bit 7), quindi ogni bit del byte finisce sull'uscita con lo stesso numero: il bit 0 su Q0, il bit 7 su Q7. Con LSBFIRST l'ordine si inverte e il bit 0 compare su Q7, il bit 7 su Q0. Tutti gli esempi di questa guida usano MSBFIRST, così i bit del numero nel codice corrispondono esattamente ai numeri dei LED. Se vuoi ripassare i numeri binari e la notazione 0b, leggi la guida su sistemi di numerazione e operazioni sui bit.

Passo dopo passo: contatore binario con 8 LED

1. Posiziona il 74HC595 a cavallo della scanalatura centrale della breadboard, in modo che le due file di piedini finiscano su lati opposti. Se non conosci i collegamenti interni di una breadboard, leggi prima Cos'è una breadboard?.
2. Collega VCC (pin 16) e MR (pin 10) a 5V, GND (pin 8) e OE (pin 13) a GND. Inserisci il condensatore da 100 nF tra VCC e GND.
3. Collega DS (14) a D11, SH_CP (11) a D13 e ST_CP (12) a D10.
4. Collega le gambe lunghe di otto LED alle uscite Q0–Q7 e quelle corte a GND tramite resistenze da 470 Ω. Ricorda che Q0 è il pin 15.
5. Carica il codice qui sotto. I LED devono contare in binario da 0 a 255; il LED su Q0 lampeggia più velocemente e quello su Q7 più lentamente.

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}

Il cuore del codice è la funzione write595(): porta il latch a LOW, invia otto bit con shiftOut() e riporta il latch a HIGH per copiarli tutti insieme sulle uscite. Qui sta anche il motivo per cui i LED non sfarfallano: durante lo scorrimento le uscite mantengono il valore precedente. Quando n vale 5 (0b00000101) si accendono i LED su Q0 e Q2; con 200 (0b11001000) si accendono quelli su Q3, Q6 e Q7. Sull'Uno potresti notare il LED integrato L su D13 tremolare leggermente con il segnale di clock; è normale e non influisce sul circuito.

LED in sequenza ed effetto Supercar

Per una sequenza di luci basta mettere a 1 un solo bit a ogni passo. La macro bit(i) di Arduino genera un numero in cui solo il bit i vale 1: bit(0) vale 1, bit(3) vale 8 e bit(7) vale 128. Il codice qui sotto riproduce tre effetti di fila: un LED che corre da Q0 a Q7, una scansione avanti e indietro in stile Supercar e una barra che si riempie a poco a poco. Per confrontarlo con la versione classica collegata direttamente ai pin, guarda Effetto Supercar e LED in sequenza con Arduino; lì ogni LED occupa un pin, qui bastano 3 pin in tutto.

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}

Nella parte Supercar il ciclo di andata va da 0 a 6 e quello di ritorno da 7 a 1, così i LED alle estremità non si accendono due volte di seguito e il movimento risulta fluido. Nella barra, l'operazione |= (OR bit a bit) aggiunge un nuovo LED lasciando accesi i precedenti; è la base di un indicatore a barra di LED che mostra il valore di un potenziometro o di un sensore. Poiché il codice usa delay(), durante l'effetto Arduino non può fare altro. Se vuoi leggere un pulsante o cambiare la velocità in tempo reale mentre l'effetto gira, gestisci i tempi con millis(); trovi il metodo nella guida millis() e delay().

Collegare più 74HC595 in cascata (Q7')

Il pin 9 del chip, Q7' (QH'), fa uscire il bit che trabocca dal registro a scorrimento. Collegalo all'ingresso DS di un secondo 74HC595 e i due chip si comportano come un unico registro a 16 bit. Le linee SH_CP e ST_CP sono in comune a tutti i chip: che la catena ne abbia tre o dieci, da Arduino escono sempre solo 3 fili. Ogni nuovo byte spinge il precedente nel chip successivo. Per questo il primo byte inviato finisce nell'ultimo chip della catena, mentre l'ultimo byte resta nel primo chip, quello collegato ad Arduino. Quando scatta il latch, le uscite di tutti i chip si aggiornano nello stesso istante.

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() e lowByte() dividono il numero a 16 bit in due byte. Il byte alto viene inviato per primo, quindi viaggia fino all'ultimo chip della catena e controlla i LED 8–15, mentre il byte basso resta nel primo chip. Per aggiungere un terzo chip basta inviare un byte in più, partendo sempre dal chip più lontano; con molti chip è più ordinato tenere i byte in un array e inviarli con un ciclo. La catena non ha un limite teorico, ma ogni chip allunga l'aggiornamento e carica di più la linea di clock comune. Nelle catene lunghe, dai a ogni chip il suo condensatore da 100 nF, tieni corti i fili di clock e latch e, se la linea diventa molto lunga, rinforza il clock con un buffer come il 74HC244.

Pilotare un display a 7 segmenti con il 74HC595

Un display a 7 segmenti a una cifra contiene esattamente otto LED: sette segmenti dalla a alla g e un punto (dp). Le otto uscite di un 74HC595 bastano quindi alla perfezione per una cifra. Se colleghi Q0 al segmento a, Q1 al b e così via, Q6 arriva a g e Q7 al punto; il bit 0 del byte rappresenta allora il segmento a e il bit 6 il segmento g. La tabella qui sotto mostra il collegamento di un comune display a 10 pin a catodo comune. I pin comuni (3 e 8) vanno a GND e ogni segmento ha la sua resistenza da 470 Ω. La disposizione delle lettere dei segmenti e la differenza tra anodo comune e catodo comune sono spiegate in dettaglio nella guida Display a 7 segmenti 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}

In un display ad anodo comune, i pin comuni vanno a 5V e un segmento si accende quando la sua uscita è a LOW. Se nel codice imposti COMMON_ANODE a true, l'operatore ~ inverte tutti i bit e la stessa tabella continua a funzionare. Per un contatore a due cifre aggiungi un secondo 74HC595 alla catena e invia prima lo schema della cifra più lontana, poi quello della cifra più vicina ad Arduino. Con questo metodo ogni cifra ha il suo chip, quindi non serve il multiplexing, il display non sfarfalla mai e usare delay() in loop() non è un problema. Per quattro o più cifre puoi fare multiplexing con due 74HC595 oppure passare a driver come il TM1637 o il MAX7219, che si occupano da soli della scansione.

Pilotaggio veloce con SPI

shiftOut() è lenta perché scrive ogni bit separatamente con digitalWrite(): su un Arduino Uno, inviare un byte richiede circa 100 µs. Con pochi LED non te ne accorgi, ma non basta più se vuoi aggiornare una catena di 10 chip migliaia di volte al secondo, regolare la luminosità dei LED via software o scansionare un cubo di LED in multiplexing. La buona notizia è che il protocollo del 74HC595 è in pratica SPI: DS corrisponde a MOSI, SH_CP a SCK e ST_CP al pin di selezione (CS). L'SPI hardware dell'Uno invia un byte in circa 1 µs a 8 MHz; anche contando il costo delle chiamate di funzione è decine di volte più veloce di shiftOut(). Scopri come funziona l'SPI nella guida Cos'è l'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}

In SPI_MODE0 i dati vengono campionati sul fronte di salita del clock, esattamente come fa il 74HC595. MSBFIRST invia di nuovo il bit 7 a Q7, quindi gli schemi degli esempi precedenti funzionano senza modifiche. Sull'Uno, D10 deve essere un'uscita perché l'SPI hardware resti in modalità master; SPI.begin() lo imposta già, ed è anche il motivo per cui D10 è il pin migliore per il latch. Se nella catena ci sono più chip, basta chiamare SPI.transfer() una volta per chip tra il latch a LOW e a HIGH. MISO (D12) non si usa in questo circuito e resta libero per un altro dispositivo SPI.

Luminosità con OE e azzeramento con MR

Il pin OE (output enable) è un interruttore che accende o spegne tutte le uscite in un colpo solo. Se lo colleghi a uno dei pin PWM dell'Uno, per esempio D9, invece che a GND, puoi regolare la luminosità di tutti i LED insieme con il PWM. Poiché OE è attivo a LOW, la logica è invertita: analogWrite(9, 0) significa luminosità massima e analogWrite(9, 255) tutto spento. Scrivere analogWrite(9, 255 - luminosita) nel codice ti semplifica la vita. Questo metodo agisce su tutti i LED allo stesso modo; per regolare la luminosità di ogni LED separatamente devi farlo via software con aggiornamenti SPI veloci oppure passare a LED indirizzabili come i WS2812B.

Quando il pin MR (master reset) va a LOW, tutti i bit del registro a scorrimento si azzerano, ma le uscite non si spengono subito, perché il registro di memorizzazione conserva il valore precedente. Per spegnere anche le uscite devi inviare un fronte di salita al pin di latch mentre MR è a LOW. In pratica, collegare MR direttamente a VCC e azzerare via software con write595(0) ti fa risparmiare un pin e un filo. C'è poi la questione dell'accensione: quando dai alimentazione, il registro di memorizzazione parte con un valore casuale e i LED possono accendersi per un istante in modo disordinato. Su una scheda relè può essere pericoloso; per evitarlo, porta OE a VCC con una resistenza da 10 kΩ, chiama prima write595(0) in setup() e poi porta il pin OE a LOW.

74HC595 con ESP32: 3,3 V e SPI

I pin dell'ESP32 forniscono 3,3 V. Se alimenti il 74HC595 a 5 V, un ingresso ha bisogno di circa 0,7 × VCC, cioè 3,5 V, per essere letto come HIGH; 3,3 V restano sotto questa soglia e il funzionamento diventa instabile. La soluzione più pulita è alimentare anche il chip dal pin 3V3 dell'ESP32, dato che il 74HC595 funziona già da 2 V. Se proprio devi alimentare il chip a 5 V, usa il 74HCT595, i cui ingressi riconoscono come HIGH qualsiasi tensione sopra i 2 V, oppure aggiungi un convertitore di livello logico. A 3,3 V una resistenza da 220 Ω va bene per i LED rossi, gialli e verdi; quelli blu e bianchi, con una tensione diretta intorno ai 3 V, a 3,3 V si accendono molto debolmente.

L'esempio qui sotto usa i pin VSPI dell'ESP32 (SCK su GPIO 18, MOSI su GPIO 23) per riprodurre l'effetto Supercar su 16 LED collegati a due 74HC595 in cascata; GPIO 5 fa da latch. La velocità SPI è impostata a 4 MHz perché il limite di velocità del 74HC595 scende con la tensione di alimentazione, e 4 MHz lasciano un ampio margine di sicurezza a 3,3 V. Anche shiftOut() funziona sull'ESP32 ed è molto più veloce che sull'Uno grazie al processore a 240 MHz; usare l'SPI, però, lascia il processore libero per compiti come il Wi-Fi. Per le basi della scheda e la scelta dei pin sicuri, consulta Cos'è l'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 e MicroPython

Anche sulla Pico alimenta il 74HC595 dal pin 3V3(OUT). MicroPython non ha un equivalente pronto di shiftOut() di Arduino, ma l'SPI hardware fa il lavoro senza fatica: si usano i pin GP18 (SCK) e GP19 (MOSI) dell'unità SPI0, e qualsiasi GPIO può fare da latch; qui è stato scelto GP17. MicroPython riserva all'SPI anche il pin MISO di SPI0 (GP16), quindi non collegarci altro. Se passi più byte a spi.write(), aggiorni tutti i chip della catena in una volta sola, e anche qui il primo byte va al chip più lontano. Per l'installazione e i primi passi, consulta Cos'è il 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)

Carichi più grandi: transistor, ULN2803 e TPIC6B595

Le uscite del 74HC595 vanno bene solo per piccole correnti di LED. Non collegare direttamente carichi come la bobina di un relè (70–90 mA), un piccolo motore, più buzzer o una striscia LED a 12 V. Puoi mettere un transistor NPN dietro ogni uscita oppure usare l'ULN2803, che riunisce otto transistor Darlington in un solo contenitore: commuta fino a 500 mA per canale lato GND e integra diodi di protezione per i carichi induttivi; perché funzionino, collega il suo pin COM all'alimentazione del carico. Una soluzione più compatta è il TPIC6B595, che si programma esattamente come il 74HC595 ma ha robuste uscite open drain: regge 150 mA continui per uscita e può commutare carichi fino a 50 V. Ha 20 pin, quindi una piedinatura diversa, e i carichi si collegano tra il positivo e l'uscita.

74HC595, MAX7219 o TM1637?

Se ti serve una semplice barra di LED, una scheda con 8 relè o uscite digitali che svolgono ognuna un compito diverso, il 74HC595 è la scelta più economica e flessibile. Per matrici di LED 8x8 o display a più cifre, il MAX7219, che gestisce da solo il multiplexing, ti semplifica molto le cose. Se vuoi luci colorate controllabili una per una, i LED WS2812B NeoPixel funzionano con un solo pin dati.

Idee di progetti con il 74HC595

• Supercar a 16 LED: Realizza l'effetto avanti e indietro con due chip in cascata e regolane la velocità con un potenziometro.
• Indicatore di livello a barra: Mostra il valore di un sensore o un livello sonoro su una barra di 8–16 LED.
• Sensore di parcheggio: Accendi sempre più LED, dal verde al rosso, man mano che la distanza misurata con un HC-SR04 si accorcia.
• Segnapunti a due cifre: Costruisci un contatore con pulsanti e senza sfarfallio usando due display a 7 segmenti e due chip in cascata.
• Orologio binario: Mostra ore, minuti e secondi come numeri binari su colonne di LED, prendendo l'ora da un modulo orologio RTC.
• Cubo di LED 3x3x3: Crea animazioni 3D pilotando i piani con transistor e le colonne con i 74HC595; i dettagli sono nella guida Cubo di LED con Arduino.
• Scheda con 8 relè: Controlla otto relè da 3 pin con un ULN2803 o un TPIC6B595.

Errori comuni e soluzioni

Il 74HC595 è il modo più economico e istruttivo per risolvere la mancanza di pin. Una volta capita l'idea dello scorrimento e del latch, la riconoscerai nei dispositivi SPI, nei driver per matrici di LED e nei moduli display, e anche quando leggerai pulsanti con un 74HC165. Parti dal contatore a 8 LED, poi allunga la catena e passa all'SPI. Nell'app BlueGrays trovi progetti di LED in sequenza, effetto Supercar, effetti a velocità regolabile e contatori a 7 segmenti per Arduino, ESP32 e Raspberry Pi Pico, passo dopo passo con schemi e codice.