Arduino: gestire 8 output con solo 3 pin digitali
Guida per l'utilizzo dei registri a scorrimento con schede Arduino

I registri a scorrimento, in inglese shift register, sono dei circuiti integrati basati sui flip-flop che prevedono una serie di memorie ad 1 bit connesse tra loro e gestite da un segnale di clock che, a sua volta, permette di traslare lo stato logico da una memoria alla memoria più vicina.
La gestione di uno (o più) registri a scorrimento avviene tramite tre segnali: il segnale di clock, il segnale di latch e il segnale del dato. Queste informazioni vengono fornite dal microcontrollore e quindi sono gestite a livello software. Nel caso di Arduino vi è una funzione specifica del core (shiftOut) che si occupa dell’intera gestione dei segnali.
Il registro a scorrimento 74HC595
Nel nostro esempio sfrutteremo lo stesso integrato utilizzato nelle guide ufficiali del progetto Arduino, ovvero il componente 74HC595. Si tratta di un registro a scorrimento a 8 bit integrato avente 16 pin. Permette sia la gestione serial-in che la gestione parallel-out. Di seguito viene riportato il pinout.
| Pin | Nome | Funzione |
|---|---|---|
| 15, 1–7 | QA, QB–QH | uscite parallele |
| 8 | GND | massa |
| 9 | QH’ | uscita seriale per collegare in cascata un secondo 74HC595 |
| 10 | SRCLR (MR) | reset del registro a scorrimento, attivo basso: va collegato a VCC |
| 11 | SRCLK (SH_CP) | clock del registro a scorrimento |
| 12 | RCLK (ST_CP) | latch: clock del registro di memoria (uscite) |
| 13 | OE | abilitazione delle uscite, attivo basso: va collegato a GND |
| 14 | SER (DS) | ingresso dati seriale |
| 16 | VCC | alimentazione |
Internamente l’integrato contiene due registri da 8 bit: il registro a scorrimento, in cui a ogni fronte di salita di SRCLK il bit presente su SER entra e i bit già presenti avanzano di una posizione, e il registro di memoria (storage register), che sul fronte di salita di RCLK (latch) copia il contenuto del registro a scorrimento sulle uscite QA–QH. In questo modo, mentre il nuovo byte viene trasmesso, le uscite restano ferme e cambiano tutte insieme solo al comando di latch.
Limiti elettrici
Nella seguente tabella, prelevata dal datasheet completo, vengono riportati i parametri limite del componente integrato oltre ai quali non è garantito un corretto funzionamento.
Di seguito, invece, sono riportati i parametri consigliati per il normale funzionamento per gli shift-register SN54HC595 e SN74HC595.
Da notare la tensione nominale di 5V: la famiglia HC funziona comunque con alimentazione da 2 a 6 V, quindi il 74HC595 si può usare anche a 3,3 V (ESP32, Raspberry Pi), con correnti d’uscita disponibili minori. Il valore di 35 mA per singola uscita riportato nel datasheet è un limite massimo assoluto, non un valore di utilizzo, e la corrente totale che attraversa i pin VCC e GND non deve superare 70 mA: con 8 LED accesi a 20 mA (160 mA) si danneggerebbe l’integrato. Con 8 LED conviene quindi limitare la corrente a circa 5–6 mA per uscita, con resistenze da 470 Ω–1 kΩ in serie a ciascun LED (per un LED rosso con Vf ≈ 2 V: I = (5 − 2) / 470 ≈ 6,4 mA e I = (5 − 2) / 1000 = 3 mA; con LED verdi o blu, a Vf maggiore, la corrente è ancora più bassa); per carichi maggiori si usano driver come l’ULN2803 o shift register di potenza come il TPIC6B595.
Schema di collegamento
Il nostro obiettivo è la gestione di 8 OUTPUT digitali sfruttando solo 3 pin della scheda Arduino (o microcontrollore generico). Per prima cosa è necessario realizzare fisicamente su breadboard (o altro supporto) il seguente schema elettrico e dobbiamo interfacciarlo al microcontrollore tramite i pin digitali clock, latch e data. Nel programma di esempio i pin di Arduino utilizzati sono D11 per il dato (pin 14, SER), D12 per il clock (pin 11, SRCLK) e D13 per il latch (pin 12, RCLK). In ogni caso è necessario un condensatore ceramico da 100 nF tra VCC e GND, montato il più vicino possibile ai pin dell’integrato (disaccoppiamento). Se la nostra alimentazione Vcc (5V) non è stabilizzata è consigliato inserire anche un condensatore elettrolitico di valore tra i 10uF e i 220uF tra Vcc e GND; solo quest’ultimo si può omettere se l’alimentazione proviene da una porta USB di un computer.
Sarà compito del programma gestire i terminali data, latch e clock in modo opportuno.
Ordine dei bit: MSBFIRST e LSBFIRST
Il sistema verrà gestito da un byte trasmesso dalla linea data e, via software, è essenziale specificare l’ordine dei bit da seguire indicando se si vuole trasmettere per primo il bit LSB (meno significativo) o il bit MSB (più significativo). Ciò cambia profondamente il risultato finale: a seconda del metodo, il byte sottostante può essere 10101010 se si segue l’ordine da MSB a LSB, oppure 01010101 se si segue da LSB verso MSB. La modalità verrà indicata a livello software grazie alla funzione shiftOut() del core Arduino, con i parametri MSBFIRST o LSBFIRST.
Procediamo ora a capire come gestire il sistema. Prendiamo come esempio il seguente disegno dove si vogliono attivare i led: LED2, LED3, LED7 e LED8. I corrispettivi bit verranno portati al valore 1 e di conseguenza il byte si potrà riportare in numero decimale avente il valore 27+26+22+21 = 128+64+4+2 = 198. Con MSBFIRST il bit più significativo viene trasmesso per primo e, dopo 8 impulsi di clock, si trova su QH, mentre il bit 0 finisce su QA (LED1): è la mappatura usata anche nel programma successivo. Con LSBFIRST l’ordine si inverte (bit 0 su QH) e lo stesso effetto si otterrebbe inviando 99 (01100011).
Se vogliamo quindi inviare il dato per impostare i led come da esempio basterà seguire il seguente codice:
digitalWrite(latchPin, LOW); //latch basso: le uscite restano invariate durante l'invio
shiftOut(dataPin, clockPin, MSBFIRST, 198); //imposto il valore 198 (11000110)
digitalWrite(latchPin, HIGH); //fronte di salita del latch: il byte passa alle uscite
Programma esempio
Realizzare un sistema basato sui registri a scorrimento che gestisca 8 diodi led. Si vuole attivare un led alla volta, dall’uscita Qa a Qh con intervalli di 500ms.
Un piccolo trucco è creare un array contenente i valori decimali dei bit da attivare. Dato che si vogliono attivare un led alla volta basterà seguire le potenze di 2, quindi l’array dovrà contenere i seguenti valori: 0, 1, 2, 4, 8, 16, 32, 64, 128
0 –> tutti i led off
1 –> led 1 ON
2 –> led 2 ON
4 –> led 3 ON
8 –> led 4 ON
16 –> led 5 ON
32–> led 6 ON
64 –> led 7 ON
128 –> led 8 ON
// pin per la gestione del shiftregister
int latchPin = 13;
int clockPin = 12;
int dataPin = 11;
//array con i valori decimali dei byte da inviare
int attivazione[] = {0, 1, 2, 4, 8,16,32,64,128};
void setup() {
//imposto i pin di gestione come output
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop() {
for (int i = 0; i <= 8; i++) {
digitalWrite(latchPin, LOW); //latch basso: le uscite restano invariate
shiftOut(dataPin, clockPin,MSBFIRST, attivazione[i]); //imposto shiftregister
digitalWrite(latchPin, HIGH); //fronte di salita del latch: aggiorno le uscite
delay(500); //attendo 500ms
}
}
Articoli collegati
- Logisim: studiamo e simuliamo circuiti logici
- Arduino registri e bit manipulation: guida pratica per ATmega328P
- Introduzione alla programmazione Arduino





