In questo tutorial imparerai come utilizzare il registro a scorrimento 74HC595 per espandere il numero di uscite del tuo Arduino.
Il popolare Arduino UNO dispone di 14 pin GPIO che puoi usare per output (o input) dati. In molti casi questo numero di pin di uscita è sufficiente, ma a volte non lo è. Potresti acquistare un Arduino più costoso e più grande, ad esempio Arduino Mega con 54 pin GPIO o un GPIO expander board. Ma il modo più economico è usare un registro a scorrimento come il 74HC595.
Il 74HC595 fornisce 8 uscite, richiede solo 3 pin dal tuo Arduino e può essere concatenato per creare quante uscite vuoi. Gli unici svantaggi sono che è più lento rispetto all’uso diretto dei pin GPIO di Arduino e che può essere usato solo per uscite.
Ma se ti servono molte uscite e la velocità non è un problema, allora il registro a scorrimento 74HC595 è fantastico. Iniziamo con i componenti necessari prima di approfondire il funzionamento di un registro a scorrimento.
Componenti necessari
Di seguito la lista dei componenti necessari. Ho usato un Arduino Uno per questo progetto, ma qualsiasi altra scheda Arduino, o scheda ESP8266/ESP32 funzionerà altrettanto bene. Inoltre, useremo il registro a scorrimento 74HC595, ma ci sono alcune alternative possibili come il 74LS595, 74HC164 e MCP23017.
Arduino Uno
Set di fili Dupont
Breadboard
Cavo USB per Arduino UNO
Registro a scorrimento 74HC595
Kit resistori & LED
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Funzione del registro a scorrimento 74HC595
Il registro a scorrimento 74HC595 è un circuito integrato (IC) che converte un flusso di dati seriali in dati paralleli. Questo ti permette di controllare molte più uscite aggiuntive usando solo tre pin del tuo Arduino.
Un registro a scorrimento ha tre componenti principali: l’ingresso seriale (SER), l’orologio seriale (SRCLK) e l’orologio latch (RCLK). Il pin di ingresso seriale serve per inserire i bit di dati uno alla volta. L’orologio seriale sposta i dati attraverso i registri ad ogni impulso di clock. Infine, il pin latch clock serve per aggiornare le uscite con i dati spostati.
Diagramma a blocchi funzionale
L’immagine sotto mostra il diagramma a blocchi funzionale con gli 8 registri interni del 74HC595. Puoi vedere gli ingressi di controllo (OE, RCLK, SRCLR, SRCLK, SER) e le 8 uscite (Q A … Q H ).
Conversione dei dati seriali in uscita parallela
Quando invii un byte di dati al registro a scorrimento, esso memorizza i bit nei suoi registri interni. Una volta che tutti i bit sono stati inseriti, puoi aggiornare le uscite attivando il pin latch clock. Questo fa sì che il registro trasferisca i dati memorizzati ai suoi 8 pin di uscita.
Quindi stiamo convertendo un flusso seriale di bit in un’uscita parallela di 8 bit. Qui sotto puoi vedere una bellissima animazione da Last Minute ENGINEERS che mostra il processo. Nota il cambiamento dei bit di uscita rossi quando il segnale latch dati va alto.
Controllo del 74HC595
I passaggi precisi per controllare il 74HC595 tramite i pin RCLK, SER e SRCLK sono i seguenti:
- Imposta il pin latch (RCLK) su LOW per assicurarti che i pin di uscita non vengano aggiornati mentre i dati vengono spostati.
- Invia i dati bit per bit al pin di ingresso seriale (SER).
- Per ogni bit, genera un impulso sul pin clock (SRCLK) per spostare i dati nel registro a scorrimento.
- Ripeti i passaggi 2 e 3 finché tutti i bit non sono stati inseriti nel registro a scorrimento.
- Una volta inseriti tutti i bit, genera un impulso sul pin latch (RCLK) per trasferire i dati dal registro a scorrimento al registro di uscita.
- I dati paralleli sono ora disponibili sui pin di uscita (Q A , …, Q H ) del 74HC595, che possono essere collegati a dispositivi esterni come LED, relè o altri componenti digitali.
L’immagine sotto mostra il diagramma temporale di questi passaggi:
Oltre ai pin RCLK, SER e SRCLK, puoi usare il pin OE per abilitare o disabilitare le uscite. Questo è utile se vuoi inviare un segnale PWM. Ne parleremo più dettagliatamente in seguito. La tabella sotto elenca le modalità funzionali del 74HC595 basate sui segnali di controllo in ingresso.
Specifiche del 74HC595
In questa sezione diamo uno sguardo rapido alle specifiche del 74HC595. Puoi trovare il datasheet completo con informazioni più dettagliate qui.
Pinout
L’immagine sotto mostra il pinout del 74HC595. Nota che in alcuni altri datasheet i pin sono nominati diversamente, ad esempio Q0, …, Q7 invece di Q A , …, Q H per gli 8 pin di uscita. Ma la disposizione e la funzione dei pin sono le stesse.
Oltre ai pin di uscita, ci sono massa (GND), i pin di controllo in ingresso (RCLK, SER, SRCLK, SRCLR, OE) e il Q H’ , che permette di concatenare più 74HC595. La tabella seguente elenca tutti i pin e le loro funzioni.
| Pin | Nome | Funzione |
|---|---|---|
| 1 | Q B | Uscita: B |
| 2 | Q C | Uscita: C |
| 3 | Q D | Uscita: D |
| 4 | Q E | Uscita: E |
| 5 | Q F | Uscita: F |
| 6 | Q G | Uscita: G |
| 7 | Q H | Uscita: H |
| 8 | GND | Massa |
| 9 | Q H’ | Uscita: concatenamento |
| 10 | SRCLR | Ingresso: azzeramento registro a scorrimento |
| 11 | SRCLK | Ingresso: clock registro a scorrimento |
| 12 | RCLK | Ingresso: clock reset, latch uscita |
| 13 | OE | Ingresso: abilitazione uscita |
| 14 | SER | Ingresso: seriale, invio dati seriali |
| 15 | Q A | Uscita: A |
| 16 | V CC | Alimentazione (2V…6V) |
Tensioni e correnti
Il 74HC595 funziona con una tensione di alimentazione (V CC ) da 2V a 6V e richiede solo 80μA per operare. In totale il carico sul 74HC595 non deve superare i 70mA.
Puoi alimentare il 74HC595 con logica a 5V o 3.3V (e alimentazione). Quindi è facile da usare anche con ESP8266 o ESP32.
Mentre le uscite possono pilotare fino a 35mA singolarmente, la tensione di uscita inizia a calare se superi i 6mA. Quindi anche per pilotare LED a basso consumo serve una resistenza di limitazione corrente. Tipicamente si usano almeno 470Ω o meglio 560Ω.
Schema tipico di applicazione
L’immagine seguente mostra uno schema tipico di applicazione per il 74HC595. Usa un microcontrollore per accendere 8 LED con resistenze di limitazione da 560Ω. C’è anche un piccolo condensatore da 0.1µF per la protezione dai disturbi.
Ti mostrerò come costruire questo circuito con un Arduino nella sezione successiva.
Collegamenti del registro a scorrimento 74HC595
L’immagine sotto mostra il cablaggio completo del registro a scorrimento 74HC595 con un Arduino per controllare 8 LED. Segue essenzialmente lo schema tipico mostrato prima, con l’eccezione che uso resistenze da 470Ω per i LED e ometto il condensatore da 0.1µF. Sentiti libero di aggiungere il condensatore se noti comportamenti instabili del circuito.
Il cablaggio sembra un po’ complesso ma in realtà è semplice. Inizia collegando il 5V e GND dell’Arduino alle linee di alimentazione positiva e negativa della breadboard (fili rossi e neri).
Poi aggiungi gli 8 LED e assicurati che il pin più corto dei LED sia collegato alla linea negativa (blu) della breadboard. Per ogni LED inserisci una resistenza da 470Ω (o 560Ω) nella breadboard. Assicurati che ogni resistenza sia collegata al pin più lungo del LED e che attraversi il gap della breadboard.
Ora collega tutte le resistenze ai pin di uscita Q A , …, Q H del 74HC595 (fili viola). Fai attenzione al collegamento insolito a Q A , che si trova sul lato opposto del circuito integrato (pin 15).
Poi colleghiamo l’alimentazione positiva al pin 16 (filo rosso) e la massa al pin 8 (filo nero) del 74HC595. Rimangono i pin di controllo. OE, che è al pin 13, è fissato a massa (filo nero) e SRCLR al pin 10 è collegato all’alimentazione positiva (filo rosso).
Infine, colleghiamo SER al pin 14 del 74HC595 al pin 4 dell’Arduino (filo verde). RCLK al pin 12 va collegato al pin 5 dell’Arduino (filo giallo). E SRCLK al pin 11 va collegato al pin 6 dell’Arduino (filo arancione). Qui sotto c’è una foto del circuito completo su una breadboard reale.
E con questo il cablaggio è completo. Nella sezione successiva scriveremo un codice semplice per testare il cablaggio.
Codice per controllare i LED usando il registro a scorrimento 74HC595
Il codice seguente usa il 74HC595 per accendere in sequenza gli 8 LED collegati. Dai un’occhiata veloce al codice completo prima di entrare nei dettagli.
// Light up LEDs in sequence using Shift Register
const int dataPin = 4; // SER
const int latchPin = 5; // RCLK
const int clockPin = 6; // SRCLK
void setRegister(byte val) {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, val);
digitalWrite(latchPin, HIGH);
delay(1000);
}
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
void loop() {
byte leds = 0b00000000;
setRegister(leds);
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
}
Costanti e variabili
Iniziamo definendo le costanti dataPin, latchPin e clockPin. Questi pin sono collegati ai corrispondenti pin del registro a scorrimento. Il dataPin serve per inviare dati al registro, il latchPin serve per bloccare i dati sulle uscite, e il clockPin serve per spostare i dati.
const int dataPin = 4; // SER const int latchPin = 5; // RCLK const int clockPin = 6; // SRCLK
Funzione di impostazione del registro
La funzione setRegister() è responsabile di impostare il valore del registro a scorrimento. Riceve un byte come input, che rappresenta lo stato degli 8 LED collegati. All’interno della funzione, prima impostiamo il latchPin su LOW per preparare lo spostamento dei dati. Poi usiamo la funzione shiftOut() per inviare i dati al registro. Infine impostiamo il latchPin su HIGH per bloccare i dati e aggiornare le uscite. Aggiungiamo anche un ritardo di 1000ms per rallentare l’accensione sequenziale dei LED.
void setRegister(byte val) {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, val);
digitalWrite(latchPin, HIGH);
delay(1000);
}
Nota che puoi invertire l’ordine in cui i bit del byte vengono inviati cambiando il parametro bitOrder da MSBFIRST (Most Significant Bit FIRST) a LSBFIRST (Least Significant Bit FIRST). I LED si accenderanno allora in ordine inverso.
Funzione setup
Nella funzione setup() impostiamo i pin latchPin, dataPin e clockPin come uscite usando la funzione pinMode(). Questo è necessario per assicurare che questi pin possano essere usati per inviare dati al registro.
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
Funzione loop
Nella funzione loop() inizializziamo una variabile byte leds con valore 0b00000000. Questo rappresenta lo stato iniziale dei LED, tutti spenti. Chiamiamo poi la funzione setRegister() per impostare lo stato iniziale del registro.
Successivamente entriamo in un ciclo for che va da 0 a 7. In ogni iterazione usiamo la funzione bitSet() per impostare un bit specifico nella variabile byte leds, rappresentando il LED aggiuntivo che vogliamo accendere.
Chiamiamo poi di nuovo la funzione setRegister() per aggiornare lo stato del registro e accendere il LED corrispondente. Ripetendo questo processo nel ciclo, possiamo accendere sequenzialmente tutti i LED collegati al registro. Quando il ciclo ricomincia, spegniamo tutti i LED.
void loop() {
byte leds = 0b00000000;
setRegister(leds);
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
}
Se costruisci questo circuito ed esegui questo codice vedrai la seguente sequenza di luci.
Invece di un set di 8 LED singoli potresti usare anche una barra LED. Dai un’occhiata al nostro tutorial: LED Bar Graph With Arduino UNO. E se hai difficoltà con il controllo dei LED in generale, leggi How To Blink An LED Using Arduino (4 Different Ways) e Control Multiple LEDs With Different Delays with Arduino.
Note
Nota che puoi facilmente inviare pattern (di accensione) come numeri binari per attivare i LED. Poiché un byte ha 8 bit, possiamo usare un byte per descrivere lo stato di ciascuno dei nostri 8 LED (1 acceso, 0 spento). Per esempio, per attivare ogni secondo LED potresti usare il valore binario 0b10101010 e inviarlo tramite setRegister.
void loop() {
setRegister(0b10101010);
}
Oppure, se vuoi inviare un’intera sequenza di pattern, è facile anche questo:
byte patterns[] = { 0b00000000,
0b10101010,
0b11111111 };
void loop() {
for (int i = 0; i < 3; i++) {
setRegister(patterns[i]);
}
}
Invece di codificare i pattern a mano, potresti creare pattern che simulano un grafico a barre e controllarli tramite un potenziometro, vedi How use Arduino to control an LED with a Potentiometer.
Infine, nota che esiste una funzione bitClear() che opera come opposto della funzione bitSet(), che ti permette di azzerare bit. Con questo puoi implementare luci in movimento e altri effetti.
void loop() {
uint8_t leds = 0b00000000;
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
for (int i = 7; i >=0; i--) {
bitClear(leds, i);
setRegister(leds);
}
}
Per altre idee di pattern o applicazioni dai un’occhiata al nostro tutorial Spin the Wheel Game.
Nel codice sopra abbiamo acceso o spento completamente i LED. Anche se non possiamo regolare la luminosità di singoli LED, possiamo regolare la luminosità di tutti i LED attivi usando il segnale OE (output enable). Come si fa, è l’argomento della prossima sezione.
Segnale PWM per controllare il registro a scorrimento 74HC595
Il pin OE (Output Enable) del 74HC595 ti permette di abilitare o disabilitare tutti i pin di uscita Q A , …, Q H . Nel circuito precedente abbiamo collegato OE a massa, abilitando tutte le uscite. Nota la linea sopra OE nel pinout che indica che la logica del pin è invertita. Impostare OE su basso abilita le uscite, mentre impostarlo su alto le disabilita.
Invece di accendere e spegnere completamente le uscite, possiamo inviare un segnale PWM al pin OE, che ci permette di “regolare” la luminosità di tutte le uscite. Nota che questo influenzerà sempre tutte le uscite Q A , …, Q H , quindi non possiamo regolare la luminosità di singoli LED.
Cablaggio
L’immagine seguente mostra il cablaggio modificato. Invece di collegare il pin OE del 74HC595 a massa (filo nero), dobbiamo collegarlo a un pin PWM dell’Arduino. In questo caso scelgo il pin ~3. Tutti gli altri fili rimangono uguali.
Codice
Nel codice ora possiamo usare il pin 3 dell’Arduino per inviare un segnale PWM al pin OE del 74HC595 per regolare la luminosità di tutte le uscite. Qui sotto un esempio di codice che fa essenzialmente la stessa cosa di quello sopra ma alla fine del ciclo attenua tutti i LED da luminosità piena a zero, prima di ricominciare il ciclo.
int dataPin = 4; // SER
int latchPin = 5; // RCLK
int clockPin = 6; // SRCLK
int enablePin = 3; // OE
void setRegister(uint8_t val) {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, val); // LSBFIRST
digitalWrite(latchPin, HIGH);
delay(100);
}
void setBrightness(byte brightness) {
analogWrite(enablePin, 255 - brightness);
}
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(enablePin, OUTPUT);
}
void loop() {
uint8_t leds = 0b00000000;
setRegister(leds);
setBrightness(255);
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
for (byte b = 255; b > 0; b--) {
setBrightness(b);
delay(2);
}
}
L’unica novità è la funzione setBrightness() che scrive il PWM su enablePin usando la funzione analogWrite(). Di solito la luminosità massima dei LED si ottiene con valore 255. Ma poiché la logica del pin OE è invertita, dobbiamo sottrarre il valore desiderato brightness da 255 per compensare l’inversione.
Usiamo la funzione setBrightness() nel secondo ciclo per abbassare la luminosità b da 255 a 0 con un ritardo molto breve di 2ms.
for (byte b = 255; b > 0; b--) {
setBrightness(b);
delay(2);
}
Se carichi questo codice sul tuo Arduino e lo esegui, vedrai il seguente effetto. I LED si accendono in sequenza e quando tutti sono accesi, si attenuano lentamente fino a zero e il ciclo ricomincia.
Nella sezione successiva vedremo come creare più di 8 uscite concatenando più 74HC595.
Concatenamento di registri a scorrimento 74HC595
Un singolo 74HC595 ha 8 uscite Q A , …, Q H e richiede tre fili di controllo. La buona notizia è che puoi concatenare più registri a scorrimento 74HC595 per aggiungere quante uscite vuoi (entro limiti ragionevoli) usando sempre solo tre fili di controllo.
Concatenare 74HC595 è molto semplice. Per esempio, se vuoi concatenare due 74HC595, collega il pin Q H ‘ del primo 74HC595 al pin SER del secondo. Vedi l’immagine sotto.
Cablaggio
Tutte le altre connessioni rimangono uguali e sono duplicate per il secondo 74HC595. L’immagine sotto mostra il cablaggio completo di due 74HC595 concatenati che ti permettono di controllare 16 LED.
Codice
Per controllare i 16 LED puoi usare il seguente codice. Come prima accende tutti i LED in sequenza, li resetta a zero e poi ricomincia il ciclo.
// Light up 16 LEDs in sequence using two Shift Registers
const int dataPin = 4; // SER
const int latchPin = 5; // RCLK
const int clockPin = 6; // SRCLK
const int nRegister = 2;
const int nOutput = nRegister * 8;
void setRegister(byte vals[]) {
digitalWrite(latchPin, LOW);
for (int i = nOutput - 1; i >= 0; i--) {
digitalWrite(clockPin, LOW);
digitalWrite(dataPin, vals[i]);
digitalWrite(clockPin, HIGH);
}
digitalWrite(latchPin, HIGH);
delay(100);
}
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
void loop() {
byte leds[nOutput];
for (int i = 0; i < nOutput; i++) {
leds[i] = HIGH;
setRegister(leds);
}
for (int i = 0; i < nOutput; i++) {
leds[i] = LOW;
}
setRegister(leds);
}
Invece di impostare i bit di un byte che rappresenta lo stato di 8 LED, usiamo un array di byte leds[] qui. Memorizza gli stati di tutti i 16 LED singolarmente. Questo spreca un po’ di memoria ma è più facile da usare e funziona per un numero arbitrario di registri concatenati. Basta impostare la costante nRegister al numero di registri collegati.
Di conseguenza dobbiamo modificare un po’ la funzione setRegister(). Ora prende un array di byte e scrive i valori nell’array iterativamente nel dataPin. Nota che il ciclo è invertito per imitare l’ordine MSBFIRST usato nel codice precedente.
void setRegister(byte vals[]) {
digitalWrite(latchPin, LOW);
for (int i = nOutput - 1; i >= 0; i--) {
digitalWrite(clockPin, LOW);
digitalWrite(dataPin, vals[i]);
digitalWrite(clockPin, HIGH);
}
digitalWrite(latchPin, HIGH);
delay(100);
}
Infine impostiamo lo stato nell’array leds[] iterativamente e lo impostiamo su HIGH o LOW, a seconda se vogliamo il LED acceso o spento. Il primo ciclo accende tutti i LED uno per uno, mentre il secondo li spegne tutti insieme. Nota che setRegister è chiamata dentro il primo ciclo ma dopo il secondo.
for (int i = 0; i < nOutput; i++) {
leds[i] = HIGH;
setRegister(leds);
}
for (int i = 0; i < nOutput; i++) {
leds[i] = LOW;
}
setRegister(leds);
E questo è tutto. Ora sai praticamente tutto quello che ti serve sul registro a scorrimento 74HC595 e puoi usarlo per aggiungere uscite al tuo Arduino.
Riepilogo
In questo post abbiamo imparato come espandere il numero di uscite su una scheda Arduino usando un registro a scorrimento 74HC595. Utilizzando questo registro, possiamo aumentare significativamente il numero di dispositivi o componenti controllabili dall’Arduino.
Abbiamo iniziato parlando dei componenti necessari per questo progetto, che includono una scheda Arduino, un registro a scorrimento 74HC595, resistori, LED e fili jumper.
Poi abbiamo esplorato la funzione del registro a scorrimento 74HC595. Questo circuito integrato ci permette di convertire un segnale di ingresso seriale in un segnale di uscita parallelo, moltiplicando efficacemente il numero di uscite disponibili. Funziona spostando i bit di dati attraverso i suoi registri interni.
Successivamente abbiamo visto il cablaggio del registro a scorrimento 74HC595. Abbiamo fornito uno schema dettagliato e spiegato come collegare il registro all’Arduino, ai LED e ai resistori.
Dopo aver completato il cablaggio, abbiamo implementato il codice necessario per controllare il registro a scorrimento 74HC595. Abbiamo fornito un esempio di codice che mostra come spostare i dati nel registro e controllare i pin di uscita di conseguenza. Il codice è spiegato passo passo, rendendolo facile da capire e modificare per le tue esigenze.
Inoltre, abbiamo esplorato come usare segnali PWM per controllare il registro a scorrimento 74HC595. Il PWM ci permette di regolare la luminosità dei LED collegati ai pin di uscita del registro. Abbiamo fornito un esempio di codice e spiegato come regolare il segnale PWM per ottenere l’effetto desiderato.
Abbiamo anche discusso la possibilità di concatenare più registri a scorrimento 74HC595 per espandere ulteriormente il numero di uscite.
Se hai altre domande, consulta la sezione Domande Frequenti qui sotto o lascia un commento.
Buon divertimento con il Tinkering 😉
Domande Frequenti
Ecco alcune domande frequenti sull’uso del registro a scorrimento 74HC595 per aggiungere più uscite al tuo Arduino:
D: Cos’è un registro a scorrimento?
R: Un registro a scorrimento è un circuito digitale che può memorizzare e spostare dati. È comunemente usato per espandere il numero di uscite su un microcontrollore come Arduino. Il 74HC595 è un popolare circuito integrato registro a scorrimento che può controllare fino a 8 uscite usando solo 3 pin dell’Arduino.
D: Come funziona il registro a scorrimento 74HC595?
R: Il registro a scorrimento 74HC595 funziona usando un ingresso seriale per caricare dati nei suoi registri interni. I dati possono poi essere spostati verso i pin di uscita un bit alla volta. Concatenando più registri a scorrimento, puoi controllare ancora più uscite usando lo stesso numero di pin Arduino.
D: Quali sono i vantaggi di usare un registro a scorrimento?
R: Usare un registro a scorrimento come il 74HC595 ha diversi vantaggi. Primo, ti permette di controllare molte uscite usando pochi pin Arduino, utile quando i pin sono limitati. Secondo, riduce la quantità di cablaggio, rendendo il progetto più ordinato e facile da gestire. Infine, libera pin Arduino per altri usi, permettendoti di aggiungere più funzionalità al progetto.
D: Posso controllare la luminosità dei LED usando il registro a scorrimento 74HC595?
R: Sì, puoi controllare la luminosità dei LED usando il 74HC595. Usando la modulazione di larghezza di impulso (PWM), puoi variare il duty cycle dei pin di uscita collegati ai LED. Questo ti permette di controllare i livelli di luminosità, creando effetti come dissolvenza o pulsazione.
D: Posso concatenare più registri a scorrimento 74HC595 insieme?
R: Sì, puoi concatenare più registri a scorrimento 74HC595 per controllare ancora più uscite. Collegando l’uscita seriale (Q7′) di un registro all’ingresso seriale (SER) del registro successivo, puoi creare una configurazione a catena. Questo ti permette di controllare un gran numero di uscite usando pochi pin Arduino.
D: Ci sono limitazioni nell’uso del registro a scorrimento 74HC595?
R: Anche se il 74HC595 è un componente versatile e utile, ha alcune limitazioni. Primo, può controllare solo uscite digitali, quindi non è adatto per controllare dispositivi analogici direttamente. Secondo, ha una capacità limitata di erogazione corrente, quindi per dispositivi ad alta corrente come motori o relè serve un circuito aggiuntivo. Infine, il registro richiede una configurazione, quindi potrebbe non essere adatto a progetti molto semplici dove la semplicità è prioritaria.
D: Posso usare il registro a scorrimento 74HC595 con altri microcontrollori oltre Arduino?
R: Sì, il 74HC595 può essere usato con altri microcontrollori oltre Arduino. Finché il microcontrollore può comunicare con segnali digitali e ha i pin necessari, puoi usare il registro per espandere le uscite.
D: Come collego il registro a scorrimento 74HC595 al mio Arduino?
R: Per collegare il 74HC595 al tuo Arduino devi collegare i pin: SER (ingresso seriale) a un pin digitale Arduino, SRCLK (clock registro a scorrimento) a un altro pin digitale, RCLK (clock registro) a un terzo pin digitale, e OE (abilitazione uscita) a massa. Inoltre, se concatenati più registri, collega QH’ (uscita seriale) di un registro al SER (ingresso seriale) del successivo.
D: Posso usare il registro a scorrimento 74HC595 anche per leggere ingressi?
R: No, il 74HC595 è progettato solo per il controllo delle uscite. Non può leggere ingressi. Se devi leggere ingressi, devi usare un componente diverso, come un registro a scorrimento con capacità di ingresso o un pin microcontrollore diverso.
D: Posso usare il registro a scorrimento 74HC595 con altri componenti digitali oltre ai LED?
R: Sì, puoi usare il 74HC595 con altri componenti digitali oltre ai LED. Il registro può controllare qualsiasi componente digitale che richiede un segnale digitale per accendersi o spegnersi, come transistor, relè o altri circuiti integrati.
D: Posso usare il 74HC595 con altri circuiti integrati registro a scorrimento?
R: Sì, puoi usare il 74HC595 con altri IC registro a scorrimento purché abbiano configurazioni pin e requisiti di tensione compatibili. Tuttavia, diversi IC possono avere funzionalità diverse, quindi devi consultare i datasheet e adattare il codice di conseguenza.
D: Posso usare il 74HC595 con altri linguaggi di programmazione oltre Arduino IDE?
R: Sì, il 74HC595 è un componente hardware che può essere controllato con qualsiasi linguaggio di programmazione che comunichi con il microcontrollore. Devi però adattare il codice alla sintassi e alle librerie del linguaggio usato.
D: Posso usare il 74HC595 con microcontrollori che operano a tensioni diverse?
R: Sì, puoi usare il 74HC595 con microcontrollori a tensioni diverse, ma devi assicurarti che i livelli di tensione siano compatibili. Se il microcontrollore ha una tensione più alta, potresti dover usare level shifter o partitori di tensione per garantire una comunicazione corretta.
D: Quanti registri a scorrimento posso concatenare?
R: Il numero di registri concatenabili dipende da vari fattori, inclusi i pin disponibili sul microcontrollore e la funzionalità desiderata. In teoria puoi concatenare un numero illimitato di registri, ma aumentando il numero aumenta la complessità e il tempo di spostamento dati. È consigliato testare e validare il progetto per garantirne l’affidabilità.
D: Posso usare il 74HC595 con altri tipi di registri a scorrimento, come il 74HC164?
R: Sì, puoi usare il 74HC595 con altri tipi di registri a scorrimento come il 74HC164. Tuttavia, diversi registri possono avere pinout e funzionalità differenti. Devi consultare i datasheet di entrambi e adattare i collegamenti e il codice di conseguenza.
D: Posso usare il 74HC595 per controllare altri tipi di display digitali, come display a 7 segmenti o LCD?
R: Sì, puoi usare il 74HC595 per controllare display digitali come display a 7 segmenti o LCD. Tuttavia, ti serviranno circuiti aggiuntivi e codice per interfacciarti con questi display. Per esempio, potresti dover usare tecniche di multiplexing per i display a 7 segmenti o una libreria LCD dedicata.
D: Posso usare il 74HC595 per controllare servomotori o motori passo-passo?
R: No, il 74HC595 non è adatto per controllare direttamente servomotori o motori passo-passo. Questi dispositivi richiedono temporizzazioni precise e segnali di controllo specifici. Devi usare moduli driver motore o controller servo dedicati.
D: Posso usare il 74HC595 in progetti alimentati a batteria?
R: Sì, il 74HC595 consuma pochissima energia, quindi non influirà molto sulla durata della batteria. Tuttavia, considera il consumo dei componenti collegati, come LED o altri dispositivi digitali, che possono avere un impatto maggiore.
Queste sono alcune delle domande frequenti sull’uso del registro a scorrimento 74HC595 per aggiungere uscite al tuo Arduino. Se hai altre domande, sentiti libero di chiedere nella sezione commenti qui sotto.
