Il registro a scorrimento 74HC164 e il tuo Arduino: 9 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:06

I registri a scorrimento sono una parte molto importante della logica digitale, fungono da collante tra il mondo parallelo e quello seriale. Riducono il numero di fili, l'uso dei pin e aiutano persino a scaricare la CPU grazie alla possibilità di memorizzare i loro dati. Sono disponibili in diverse dimensioni, con modelli diversi per usi diversi e caratteristiche diverse. Quello di cui parlerò oggi è il 74HC164 8 bit, serial in parallel out, non latched, shift register. Perché? Beh, per prima cosa è uno dei registri a scorrimento più basilari là fuori, il che rende più facile l'apprendimento, ma è capitato che fosse l'unico che avevo (lol!) Questo istruibile spiega come funziona questo chip, come cablarlo, e interfaccialo con un arduino che include alcuni schizzi di esempio e circuiti a led. Spero che ti diverta!

Passaggio 1: quindi, cosa sono i registri a scorrimento?

Come accennato in precedenza, sono disponibili in tutti i gusti diversi, e ho anche detto che sto usando un 74HC164 a 8 bit, uscita seriale in parallelo, non latch, registro a scorrimento, quindi cosa significa tutto questo?!? Innanzitutto, il nome 74 -- indica la sua parte della famiglia logica 74xx, e poiché la sua logica non può controllare direttamente molta corrente (16-20 mA per l'intero chip è comune), passa solo segnali in giro, ma ciò non significa quel segnale non sta andando a un transistor che può commutare un carico di corrente più elevato. HC significa che è un dispositivo cmos ad alta velocità, puoi leggerlo sul link qui sotto, ma quello che devi sapere fondamentalmente è che è un basso dispositivo di alimentazione e funzionerà da 2 a 5 volt (quindi se usi un arduino da 3,3 volt va bene) Inoltre può funzionare correttamente ad alte velocità questo particolare chip ha una velocità tipica di 78 mhz, ma puoi andare lento o veloce (fino a quando non inizia a pasticciare) come vuoiwww.kpsec.freeuk.com/components/74series.htm164 è il numero di modello per questo chip, c'è un grande grafico su wikipediaen.wikipedia.org/wiki/List_of_7400_series_integrated_circuits Avanti, 8 bit Un registro a scorrimento è costituito da circuiti flip flop, un flip flop è 1 bit di memoria, questo ha s 8 (o 1 byte di memoria). Trattandosi di memoria, se non hai bisogno di aggiornare il registro puoi semplicemente smettere di "parlare" con esso e rimarrà nello stato in cui lo hai lasciato, finché non "parlerai" di nuovo o ripristinerai l'alimentazione. altri registri a scorrimento della serie 7400 logica possono andare fino a 16 bit seriali in uscita parallela Ciò significa che il tuo arduino invia i dati in serie (on off impulsi uno dopo l'altro) e il registro a scorrimento posiziona ciascun bit sul pin di uscita corretto. Questo modello richiede solo 2 fili per essere controllato, quindi puoi usare 2 pin digitali sull'arduino e rompere quei 2 su 8 più uscite digitali alcuni altri modelli sono paralleli in uscita seriale, fanno la stessa cosa ma come ingressi all'arduino (ad esempio un gamepad NES) non bloccato Questo potrebbe essere un fallimento di questo chip se ne hai bisogno. Quando i dati entrano in un registro a scorrimento via seriale, si presenta sul primo pin di uscita, quando entra un impulso di clock, il primo bit si sposta di 1 posizione, creando un effetto di scorrimento sulle uscite, ad esempio 00000001 si presenterebbe sulle uscite come 101001000100001000001000000100000001Se stai parlando con altri dispositivi logici che condividono lo stesso clock e non se lo aspettano, potrebbe causare problemi. I registri a scorrimento latch hanno un set di memoria aggiuntivo, quindi una volta che i dati sono entrati nel registro puoi capovolgere un interruttore e mostrare le uscite, ma aggiunge un altro filo, software e cose con cui stare al passo. Nel caso di questo istruibile stiamo controllando i display a LED, l'effetto di scorrimento avviene così velocemente che non puoi vederlo (tranne quando accendi il chip per la prima volta), e una volta che il byte è nel registro a scorrimento non c'è più scorrimento Controlleremo il tipo di grafico a barre, 7 segmenti e una matrice di punti 16LED 4x4 con questo chip e software sull'arduino utilizzando solo 2 pin digitali (+ alimentazione e massa)

Passaggio 2: cablaggio e funzionamento di base

Cablaggio Il 74HC164 è un chip a 14 pin, ha 4 pin di ingresso, 8 pin di uscita, alimentazione e massa, quindi iniziamo dall'alto. I pin 1 e 2 sono entrambi ingressi seriali, sono impostati come una porta logica AND, il che significa che entrambi devono essere logici alti (cioè 5 volt) affinché il bit venga visto come 1, uno stato basso (0 volt) su entrambi verrà letto come zero. Non ne abbiamo davvero bisogno ed è più facile da gestire nel software, quindi scegline uno e collegalo a V+ in modo che sia sempre alto. Scelgo di utilizzare un ponticello dal pin 1 al pin 14 (V+) poiché puoi semplicemente inserire un ponticello della breadboard sul chip. L'unico ingresso seriale rimanente (pin 2 nei miei schemi) andrà al pin digitale 2 dell'arduino. I pin 3, 4, 5 e 6 del 74HC164 sono i primi 4 byte di output Il pin 7 si collega a massa Salta a destra, pin 8 è il pin dell'orologio, questo è il modo in cui il registro a scorrimento sa che il prossimo bit seriale è pronto per essere letto, questo dovrebbe essere collegato al pin digitale 3 su arduino. Il pin 9 serve per cancellare l'intero registro in una volta, se va basso, hai la possibilità di usarlo, ma nulla in questo imperscrutabile lo fa, quindi collegalo a V + pin 10, 11 12 e 13 sono gli ultimi 4 byte di outputpin 14 è la potenza del chip Operazione Per prima cosa devi impostare l'ingresso seriale del registro (pin digitale 2 su arduino) alto o basso, successivamente è necessario capovolgere il pin del clock (pin digitale 3) da basso ad alto, il registro a scorrimento leggerà i dati sull'ingresso seriale e sposterà i pin di uscita di 1, ripeti 8 volte e hai impostato tutte e 8 le uscite. Questo può essere fatto a mano con i cicli for e le scritture digitali nell'IDE arduino, ma poiché t questa è una comunicazione a livello hardware (SPI) molto comune, hanno una sola funzione che lo fa per te. shiftOut(dataPin, clockPin, bitOrder, value) Basta dirgli dove i dati e i pin dell'orologio sono collegati ad arduino, in che modo inviare i dati e cosa inviare, e se ne prende cura per te (utile)

Passaggio 3: progetti

Ok, basta lezioni e teoria, facciamo alcune cose divertenti con questo chip! Ci sono 3 progetti da provare in questo tutorial, i primi 2 sono facili e possono essere realizzati in un attimo. Il terzo, la matrice led 4x4, richiede più tempo e pensiero per la costruzione, a causa del cablaggio del led. Elenco delle parti Progetto 1: Controller display LED grafico a barre '2 Wire' 1 * 74HC164 Registro di scorrimento1 * breadboard senza saldatura1 * arduino o arduino compatibile (5v) 1 * 330 ohm resistenza 1/4 watt 8 * uscita normale LED rossi 12 * cavi jumper Progetto 2: controller display a 7 segmenti "2 fili" 1 * 74HC164 Registro di scorrimento1 * breadboard senza saldatura1 * compatibile con arduino o arduino (5 v) 1 * 330 ohm resistenza 1/4 watt 1 * display a sette segmenti a catodo comune9 * cavi di collegamento Progetto 3: display a matrice di led '2 Wire' 4x4 1 * 74HC164 Registro di scorrimento1 * arduino o compatibile con arduino (5v)4 * 150 ohm 1 Resistore da 1/4 watt8 * 1Kohm Resistore da 1/8 watt (o più grande)8 * Transistor NpN (2n3904 o superiore)16 * LED rosso con uscita normale un mezzo per costruirlo e una potenza regolata di 5 volt in grado di gestire 160+ma (puoi accendi tutti i LED contemporaneamente come una luce di stop)

Fase 4: Progetto 1 [pt 1]: Hardware controller display LED grafico a barre "2 fili"

Collega l'arduino e il registro a scorrimento secondo lo schema, ho già un display a barre a 10 segmenti pronto per l'uso della breadboard ed è quello che vedrai nell'immagine, ma puoi fare la stessa cosa con i singoli led Nella seconda pagina Ho affermato che questi non erano dispositivi driver, che erano dispositivi logici, con piccole quantità di corrente in grado di attraversarli. Per far funzionare 8 LED, mantenendo il circuito semplice, e non cucinando il registro a scorrimento, è necessario limitare un po' la corrente. I LED sono collegati in parallelo e condividono una massa comune (catodo comune), prima di entrare nell'alimentazione alimentazione di massa di cui hanno bisogno per passare attraverso un resistore da 330 ohm, limitando la quantità totale di corrente che tutti i LED potrebbero utilizzare a 10 mA (a 5 volt) Questo lascia i LED in uno stato malaticcio ma si accendono e quindi servono per questo esempio, per pilotare i LED alla loro corretta corrente sarà necessario inserire un transistor dove il registro a scorrimento può accendere / spegnere una sorgente di corrente più alta (vedi progetto 3) Il pin Data dello shift register (pin 2) ha bisogno per connettersi al pin # 2 di arduino digitale Il pin Clock del registro a scorrimento (pin 8) deve essere collegato al pin # 3 digitale di arduino

Passaggio 5: Progetto 1 [pt 2]: Software controller display LED con grafico a barre "2 fili"

Esempio 1: Apri il file " _164_bas_ex.pde" All'interno dell'IDE di arduino, è un semplice schizzo che ti consente solo di definire i LED accesi o spenti nel display del grafico a barre Le prime 2 righe definiscono i numeri di pin che utilizzeremo per i dati e l'orologio, I usa #define su const integer, lo trovo più facile da ricordare, e non c'è alcun vantaggio per l'uno o l'altro una volta compilato #define data 2#define clock 3 next è la funzione void setup, viene eseguita solo una volta, quindi l'arduino gira on, imposta il registro a scorrimento e non ha altro da fare. All'interno della funzione void setup impostiamo i pin clock e data come pin OUTPUT, quindi utilizzando la funzione shiftOut inviamo i dati allo shift register void setup(){ pinMode(clock, OUTPUT); // rende il pin dell'orologio un output pinMode(data, OUTPUT); // rende il pin dati un output shiftOut(data, clock, LSBFIRST, B10101010); // invia questo valore binario al registro a scorrimento} Nella funzione shiftOut puoi vedere i suoi argomentidata è il pin dei dati, clock è il pin dell'orologio LSBFIRST si riferisce all'ordine in cui è inserito, quando lo si scrive in notazione binaria (Bxxxxxxxx) il settimo l'elemento oltre la B è il bit meno significativo Primo, questo viene inserito per primo in modo che finisca sull'ultima uscita una volta che tutti gli 8 bit sono stati inseriti in B10101010 è il valore binario inviato al registro a scorrimento e si accenderà ogni luce dispari, prova a giocare con valori diversi per attivare o disattivare modelli diversi e infine un loop vuoto vuoto (perché ne hai bisogno anche se non lo usi) void loop(){} // loop vuoto per ora Esempio 2: le prime 8 righe sono le stesse delle prime 8 righe del primo esempio, infatti non cambieranno per nessuno degli altri progetti, quindi #define data 2#define clock 3void setup(){ pinMode(clock, OUTPUT); // rende il pin dell'orologio un output pinMode(data, OUTPUT); // rende il pin dei dati un output Ma ora nell'impostazione void c'è un conteggio di 8 per il ciclo, che prende un byte vuoto e si sposta di 1 bit alla volta partendo dal bit più a sinistra e spostandosi a destra. Questo è all'indietro rispetto al primo esempio in cui siamo partiti dal bit più a destra e abbiamo lavorato a sinistra, ma usando MSBFIRST la funzione shift out invia i dati nel modo corretto Inoltre aggiungiamo un ritardo nel ciclo for in modo che rallenti abbastanza da essere visibile. for(int i = 0; i < 8; ++i) //for 0 - 7 do { shiftOut(data, clock, MSBFIRST, 1 << i); // sposta il bit di un valore logico alto (1) di i delay(100); // ritarda 100ms o non saresti in grado di vederlo } }void loop(){} // loop vuoto per ora carica lo script e ora dovresti vedere il grafico a barre illuminarsi una alla volta

Passaggio 6: Progetto 2: Controller display a 7 segmenti "2 fili"

Guarda il pinout del tuo display a 7 segmenti (ne avevo solo uno doppio ma ne usavo solo la metà) e usa il disegno qui sotto per collegare ogni segmento al bit corretto sul registro a scorrimento bit 1 = pin 3 bit 2 = pin 4 bit 3 = pin 5 bit 4 = pin 6 bit 5 = pin 10 bit 6 = pin 11 bit 7 = pin 12 bit 8 = pin 13 (se si desidera utilizzare il punto decimale) e il catodo del display tramite la resistenza da 330 ohm e per l'alimentazione di massa ora aprire il Seven_seg_demo.pde nell'IDE di arduino Prima vedi dove definiamo i pin di dati e clock #define data 2#define clock 3 Successivamente impostiamo tutti i modelli di caratteri in binario, questo è abbastanza semplice, guarda il disegno qui sotto, se hai bisogno del segmento centrale digitane uno, poi hai bisogno del segmento superiore, in tal caso digitane un altro, continua a farlo finché non copri tutti gli 8 segmenti, nota che il mio bit più a destra (bit 8) è sempre 0, perché non accendo mai il decimale punto. byte zero = B01111110;byte uno = B00000110;byte due = B11011010;byte tre = B11010110;byte quattro = B10100110;byte cinque = B11110100;byte sei = B11111100;byte sette = B01000110;byte otto = B11111110;byte nove = B11110110; successivamente in void setup impostiamo i nostri pin data e clock sugli output void setup(){ pinMode(clock, OUTPUT); // imposta il pin dell'orologio come output pinMode(data, OUTPUT); // rendi il pin dei dati un output3} quindi in void loop usiamo shiftOut per visualizzare ogni pattern (numero) aspetta 1/2 secondo e visualizza il successivo, da 0 a 9, poiché viene eseguito nella funzione void loop conterà 0-9 e ripeti per sempre. void loop(){ shiftOut(data, clock, LSBFIRST, zero); ritardo (500); shiftOut(dati, orologio, LSBFIRST, uno); ritardo (500); shiftOut(dati, orologio, LSBFIRST, due); ritardo (500); shiftOut(dati, orologio, LSBFIRST, tre); ritardo (500); shiftOut(dati, orologio, LSBFIRST, quattro); ritardo (500); shiftOut(dati, orologio, LSBFIRST, cinque); ritardo (500); shiftOut(dati, orologio, LSBFIRST, sei); ritardo (500); shiftOut(dati, orologio, LSBFIRST, sette); ritardo (500); shiftOut(dati, orologio, LSBFIRST, otto); ritardo (500); shiftOut(dati, orologio, LSBFIRST, nove); ritardo(500);}

Passaggio 7: Progetto 3 [pt 1]: Display a matrice di LED 4x4 '2 Wire'

Il progetto della matrice LED 4x4 è un po' più complesso, ma è quasi tutto in costruzione, ho scelto di fare il mio saldato su perfboard, ma dovrebbe essere possibile replicare su una breadboard, solo molto più distanziata. Anche i circuiti differisce dal fatto che il registro a scorrimento non pilota direttamente i led, ma le uscite del registro a scorrimento vengono inviate tramite un resistore da 1Kohm alla base di un transistor NpN, quando l'uscita del bit è alta, lascia passare abbastanza corrente e tensione nel transistor per commutare la connessione tra collettore ed emettitore, i collettori sono legati ad un "robusto" regolato a 5 volt. Gli emettitori dei transistor sono collegati a resistori da 150 ohm e i resistori sono legati ai nodi di 4 led in fila e limita la riga a 20mA, anche se quando si disegnano le immagini sul display si accende solo 1 led alla volta, e quindi quasi a piena luminosità (quasi perchè si accendono e si spengono molto velocemente per comporre l'intera immagine)Ci sono 4 righe e 4 colonne, ciascuna riga riceve un resistore e un transistor, su ogni colonna i catodi del LED sono legati insieme, sono passati nel collettore di un transistor, la cui base è controllata anche dal registro a scorrimento, e infine a massa. Versione grande dello schema www.instructables.com/files/orig/F7J/52X0/G1ZGOSRQ/F7J52X0G1ZGOSRQ.jpg

Passaggio 8: Progetto 3[pt 2]: Display a matrice di LED 4x4 '2 Wire'

Il registro a scorrimento controlla sia l'anodo che i catodi dei LED in un formato YX, guarda quanto segue bit 1 = colonna 1 (più a destra) bit 2 = colonna 2 bit 3 = colonna 3 bit 4 = colonna 4 bit 5 = riga 1 (più in alto) 6 = riga 2 bit 7 = riga 3 bit 8 = riga 4 Per fare in modo che un'immagine disegna un quadrato 4x4 su carta millimetrata e inserisci quelli che vuoi visualizzare, crea una tabella YX. Sotto vedrai una mappatura per una similitudine, così come il meglio che si può fare su 4x4 "pixel" Per ogni sezione compilata scrivo in quale colonna (Y) si trova, quindi in quale riga si trova (X)Ora apri il file _4x4.pde nell'IDE arduino vedrai i nostri vecchi 2 amici #define data 2#define clock 3 quindi un array di interi int img = {1, 1, 4, 1, 1, 3, 4, 3, 2, 4, 3, 4}; Se guardi è solo un elenco delle mie coordinate YX scritte, sarebbe una grossa seccatura convertire quei valori a mano, e abbiamo un computer … lascia che lo faccia! Andando avanti c'è una configurazione vuota dove facciamo i nostri pin di clock e dati OUTPUTS void setup(){ pinMode(clock, OUTPUT); // rende il pin dell'orologio un output pinMode(data, OUTPUT); // rende il pin dei dati un output3} E un loop void dall'aspetto confuso, per iniziare dobbiamo dichiarare alcune variabili locali void loop(){ int Y; int X; byte in uscita; Quindi un ciclo for, questo ciclo deve essere lungo quanto la quantità di voci nell'array img, per questa immagine ho usato solo 6 pixel, in modo da ottenere 12 coordinate YX. Faccio saltare ogni altro numero usando i +=2, perché leggiamo 2 coordinate per ciclo for(int i = 0; i < 12; i += 2) // numero di punti nell'array img, in questo caso 12 { Ora leggiamo la voce Y in nell'array e sottraiamo uno dal suo valore, perché i byte non iniziano da uno, iniziano da zero, ma abbiamo contato da 1 // otteniamo la prima coppia di cavi YX Y = (img - 1); // sottrae uno poiché il conteggio dei bit inizia da 0 Quindi leggiamo l'immissione X in [i + 1] nell'array e sottraiamo uno dal suo valore, per lo stesso motivo X = (img[i+1] - 1); Dopo aver ottenuto i valori YX del pixel, facciamo un po 'di bit o matematica e ci spostiamo a sinistra. Per prima cosa dobbiamo leggere il valore X, e qualunque sia il suo valore spostalo di tanti posti + 4 rimasti, quindi se X è 4 e aggiungi 4 è il bit 8 (MSB), guardando di nuovo il grafico …bit 1 = colonna 1 (più a destra) bit 2 = colonna 2 bit 3 = colonna 3 bit 4 = colonna 4 bit 5 = riga 1 (più in alto) bit 6 = riga 2 bit 7 = riga 3 bit 8 = riga 4 bit 8 è l'ultima riga Successivamente anche il valore Y viene spostato a sinistra, questa volta da solo, senza aggiunta di nulla. (nibbles), usando bit a bit o (il simbolo |) prende due byte e sostanzialmente li somma insieme, supponiamo X = 10000000Y = 00000001--------------------OR = 10000001riga 4 colonna 1 uscita = 1 << (X + 4) | 1 << Y; E infine shiftOut per visualizzare l'immagine corrente e continuare a farlo fino a quando non abbiamo più dati nell'array … ritardare un momento e fare un ciclo per sempre, poiché stavamo spostando i dati a sinistra e abbiamo bisogno che l'MSB si trovi sull'ultimo pin di uscita del registro a turni invialo per primo. shiftOut(data, clock, MSBFIRST, out); // sposta il byte nel nostro registro delay(1); // ritardalo un po' in modo che abbia la possibilità di lasciare una macchia di luce nei tuoi occhi Sentiti libero di creare le tue immagini ed effetti, ci sono 3 file di esempio, la faccina sorridente e una scacchiera (che assomiglia più a strisce), e infine un creatore di scintillio casuale

Passaggio 9: conclusione

Nel complesso questo è un piccolo chip piuttosto utile, e sono contento di averlo scartato da un vecchio pezzo di elettronica diretto nella spazzatura. Può essere usato per altre cose oltre ai sistemi di visualizzazione, ma a tutti piacciono le luci e il feedback istantaneo di vedere quello che sta succedendo è estremamente utile per i pensatori visivi come me. Inoltre, ti prego di perdonare il mio codice, ho avuto l'arduino solo dalla terza settimana di ottobre, ed è stato un corso accelerato piuttosto grande. Ma questa è la cosa grandiosa del sistema, se ti siedi e lavori con esso, è pieno di funzioni interessanti che rendono il controllo del mondo con un microcontrollore a 8 bit abbastanza facile da fare. Come sempre domande e commenti sono i benvenuti, e grazie per leggendo, spero che tu abbia imparato molto