Het 74HC164 Shift Register en uw Arduino: 9 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:20

Schuifregisters zijn een zeer belangrijk onderdeel van digitale logica, ze fungeren als lijm tussen de parallelle en seriële werelden. Ze verminderen het aantal draden, het pingebruik en helpen zelfs om uw CPU te ontlasten door hun gegevens op te kunnen slaan. Ze zijn er in verschillende maten, met verschillende modellen voor verschillende toepassingen en verschillende functies. Degene die ik vandaag zal bespreken is de 74HC164 8 bit, serieel in parallel uit, niet vergrendeld, schuifregister. Waarom? Welnu, het is een van de meest elementaire schuifregisters die er zijn, wat het leren ervan gemakkelijker maakt, maar het was toevallig de enige die ik had (lol!) Deze instructable behandelt hoe deze chip werkt, hoe deze te bedraden, en koppel het aan een arduino, inclusief enkele voorbeeldschetsen en led-circuits. Ik hoop dat jullie er allemaal van genieten!

Stap 1: Dus, wat zijn schuifregisters?

Zoals eerder vermeld, zijn ze er in alle verschillende smaken, en ik zei ook dat ik een 74HC164 8 bit gebruik, serieel in parallel uit, niet-vergrendeld, schuifregister dus wat betekent dat allemaal?!? Ten eerste, de naam 74 -- betekent dat het deel uitmaakt van de 74xx logische familie, en aangezien de logica ervan niet direct veel stroom kan regelen (16-20 ma voor de hele chip is gebruikelijk), geeft het alleen signalen door, maar dat betekent niet dat dat signaal gaat niet naar een transistor die een hogere stroombelasting kan schakelen. HC betekent dat het een high-speed cmos-apparaat is, dat kun je lezen op de onderstaande link, maar wat je in principe moet weten, is dat het een lage stroomapparaat en werkt van 2 tot 5 volt (dus als je een 3.3 volt arduino gebruikt, is je ok) totdat het begint op te vallen) zoals je wilt www.kpsec.freeuk.com/components/74series.htm164 is het modelnummer voor deze chip, er is een grote grafiek van hen op wikipediaen.wikipedia.org/wiki/List_of_7400_series_integrated_circuits Volgende, 8 bit Een schuifregister is opgebouwd uit flip-flopschakelingen, een flip-flop is 1 bit geheugen, deze heeft s 8 (of 1 byte geheugen). Aangezien het een geheugen is, kunt u, als u het register niet hoeft bij te werken, gewoon stoppen met "praten" en het zal in de staat blijven waarin u het hebt achtergelaten, totdat u er weer tegen "praat" of de stroom opnieuw instelt. andere 7400 logische serie schuifregisters kunnen tot 16 bit serieel parallel gaan. Dit betekent dat uw arduino het serieel verzendt (aan-uit-pulsen na elkaar) en het schuifregister plaatst elk bit op de juiste uitgangspen. Dit model heeft slechts 2 draden nodig om te worden bestuurd, dus je kunt 2 digitale pinnen op de arduino gebruiken en die 2 uitbreken tot 8 meer digitale uitgangen. (bijvoorbeeld een NES-gamepad) niet vergrendeld Dit kan een ondergang van deze chip zijn als je hem nodig hebt. Als gegevens via serieel een schuifregister binnenkomen, verschijnt het op de eerste uitgangspen, wanneer een klokpuls binnenkomt, verschuift het eerste bit over 1 plaats, waardoor een scrollend effect op de uitgangen ontstaat, bijvoorbeeld 00000001 zou op de uitgangen verschijnen als 101001000100001000001000000100000001Als u praat met andere logische apparaten die dezelfde klok delen en dit niet verwachten, kan dit problemen veroorzaken. Vergrendelde schuifregisters hebben een extra set geheugen, dus zodra de gegevens zijn ingevoerd in het register, kunt u een schakelaar omdraaien en de uitgangen weergeven, maar het voegt nog een draad, software en dingen toe om bij te houden. In het geval van dit instructable we besturen LED-displays, het scroll-effect gebeurt zo snel dat je het niet kunt zien (behalve wanneer je de chip voor het eerst aanzet), en zodra de byte in het schuifregister is, is er niet meer scrollen We zullen het staafdiagramtype besturen, 7 segment, en een 16LED 4x4 dot-matrix met deze chip en software op de Arduino met slechts 2 digitale pinnen (+ voeding en aarde)

Stap 2: Basisbedrading en bediening

Bedrading De 74HC164 is een 14-pins chip, hij heeft 4 ingangspinnen, 8 uitgangspinnen, voeding en aarde, dus laten we van bovenaf beginnen. Pin 1 en 2 zijn beide seriële ingangen, ze zijn ingesteld als een logische EN-poort, wat betekent dat ze moeten allebei logisch hoog zijn (dwz 5 volt) om het bit als een 1 te zien, een lage toestand (0 volt) op een van beide zal als een nul worden gelezen. We hebben dit niet echt nodig en het is gemakkelijker om mee om te gaan in software, dus kies er een en koppel deze aan V + zodat deze altijd hoog aangeeft. Ik kies ervoor om een jumper van pin 1 naar pin 14 (V+) te gebruiken, omdat je gewoon een breadboard-jumper over de chip kunt knallen. De enige overgebleven seriële ingang (pin 2 in mijn schema) gaat naar digitale pin 2 van de arduino. Pins 3, 4, 5 en 6 van de 74HC164 zijn de eerste 4 bytes van outputPin 7 verbindt met aarde Springen naar rechts, pin 8 is de klokpen, dit is hoe het schuifregister weet dat het volgende seriële bit klaar is om te lezen, dit moet worden aangesloten op digitale pin 3 op de arduino. Pin 9 is om het hele register in één keer te wissen, als het laag wordt, je hebt de mogelijkheid om het te gebruiken, maar niets in dit ondoorgrondelijke doet het, dus bind het aan V + pinnen 10, 11 12 en 13 zijn de laatste 4 bytes van outputpin 14 is de stroom van de chips Werking Eerst moet je de seriële ingang instellen van het register (digitale pin 2 op de arduino) hoog of laag, vervolgens moet je de klokpin (digitale pin 3) van laag naar hoog omdraaien, het schuifregister leest de gegevens op de seriële ingang en verschuift de uitgangspinnen door 1, herhaal 8 keer en je hebt alle 8 uitgangen ingesteld. Dit kan met de hand worden gedaan met for-lussen en digitale schrijfbewerkingen in de arduino IDE, maar sinds dit is een veel voorkomende hardware-niveau communicatie (SPI) ze hebben een enkele functie die het voor u doet. shiftOut (dataPin, clockPin, bitOrder, value) Vertel het gewoon waar de data- en klokpinnen zijn aangesloten op de Arduino, op welke manier de gegevens moeten worden verzonden en wat te verzenden, en het wordt voor je geregeld (handig)

Stap 3: Projecten

Oké, genoeg lezing en theorie, laten we wat leuke dingen doen met deze chip! Er zijn 3 projecten om te proberen in deze instructable, de eerste 2 zijn eenvoudig en kunnen in enkele ogenblikken worden uitgerold. De derde, de 4x4 led-matrix, vereist meer tijd en denkwerk om te bouwen, vanwege de led-bedrading. Lijst met onderdelen Project 1: '2-draads' bargraph LED-displaycontroller 1 * 74HC164 Schakelregister1 * soldeerloze breadboard1 * arduino, of arduino compatibel (5v)1 * 330 ohm 1/4 watt weerstand 8 * normale output rode LED's 12 * jumperdraden Project 2: '2 Wire' 7 segment display controller 1 * 74HC164 Shift register1 * soldeerloze breadboard1 * arduino, of arduino compatibel (5v)1 * 330 ohm 1/4 watt weerstand 1 * gemeenschappelijke kathode zeven segmenten display9 * jumperdraden Project 3: '2-draads' 4x4 led matrix display 1 * 74HC164 Schakelregister1 * arduino, of arduino compatibel (5v)4 * 150 ohm 1 1/4 watt weerstand8 * 1Kohm 1/8 watt weerstand (of groter)8 * NpN transistor (2n3904 of beter)16 * normale output rode LED's een middel om het te construeren en gereguleerde 5 volt stroom die 160+ma aankan (u kunt zet alle LED's tegelijk aan als een remlicht)

Stap 4: Project 1 [pt 1]: '2-draads' staafdiagram LED-displaycontroller-hardware

Sluit de arduino en het schuifregister aan volgens het schema, ik heb al een 10-segment bargraph-display klaar voor gebruik als breadboard en dat is wat je in de afbeelding zult zien, maar je kunt hetzelfde doen met individuele led's op de tweede pagina Ik zei dat dit geen stuurprogramma's waren, dat het logische apparaten waren, waar kleine hoeveelheden stroom doorheen konden gaan. Om 8 LED's te laten werken, terwijl het circuit eenvoudig blijft en het schuifregister niet kookt, moeten we de stroom behoorlijk beperken. De LED's zijn parallel bedraad en delen een gemeenschappelijke aarde (gemeenschappelijke kathode), voordat ze in de stroom gaan voeding die ze nodig hebben om door een weerstand van 330 ohm te gaan, waardoor de totale hoeveelheid stroom die alle LED's zouden kunnen gebruiken tot 10 ma (bij 5 volt) wordt beperkt. Dit laat de LED's in een ziekelijke staat, maar ze lichten wel op en dienen dus voor dit voorbeeld, om de LED's op hun juiste stroom te laten lopen, moet u een transistor plaatsen waar het schuifregister een hogere stroombron kan in- / uitschakelen (zie project 3) De datapin van het schuifregister (pin 2) heeft om verbinding te maken met arduino digitale pin # 2De klokpin van het schuifregister (pin 8) moet verbinding maken met arduino digitale pin # 3

Stap 5: Project 1 [pt 2]: '2-draads' Bargraph LED-displaycontrollersoftware

Voorbeeld 1: Open het bestand " _164_bas_ex.pde" In de arduino IDE, het is een eenvoudige schets waarmee u alleen aan of uit LED's in het staafdiagram kunt definiëren. De eerste 2 regels definiëren de pinnummers die we zullen gebruiken voor gegevens en klok, ik gebruik #define over const integer, ik vind het gemakkelijker te onthouden, en er is geen voordeel voor de een of de ander als ze eenmaal zijn gecompileerd #define data 2#define clock 3 volgende is de void setup-functie, deze wordt maar één keer uitgevoerd, dus de arduino draait aan, stelt het schuifregister in en heeft verder niets te doen. Binnen de void setup-functie stellen we de klok- en datapinnen in als OUTPUT-pinnen, en met behulp van de shiftOut-functie sturen we de gegevens naar het schuifregister void setup(){ pinMode(clock, OUTPUT); // maak de klokpin een output pinMode (data, OUTPUT); // maak van de data-pin een output shiftOut (data, clock, LSBFIRST, B1010010); // stuur deze binaire waarde naar het schuifregister} In de shiftOut-functie kun je zien dat de argumentendata de datapin is, klok de klokpin is LSBFIRST verwijst naar de volgorde waarin het zich bevindt, wanneer het wordt weggeschreven in binaire notatie (Bxxxxxxxx) de 7e element voorbij de B is de minst significante bit Eerst, dit wordt als eerste ingevoerd, zodat het op de laatste uitgang terechtkomt zodra alle 8 bits zijn ingevoerd B10101010 is de binaire waarde die naar het schuifregister wordt verzonden en het zal elk oneven licht aangaan, probeer met verschillende waarden te spelen om verschillende patronen aan of uit te zetten en tot slot een lege lege lus (omdat je er een nodig hebt, zelfs als je hem niet gebruikt) void lus(){} // lege lus voor nu Voorbeeld 2: de eerste 8 regels zijn hetzelfde als de eerste 8 regels van het eerste voorbeeld, in feite zullen ze niet veranderen voor een van de andere projecten, dus #define data 2#define clock 3void setup(){ pinMode(clock, OUTPUT); // maak de klokpin een output pinMode (data, OUTPUT); // maak van de data-pin een output. Maar nu in de void setup is er een 8 count for lus, het neemt een lege byte en verschuift 1 bit per keer, beginnend vanaf het meest linkse bit en naar rechts gaand. Dit is achteruit van het eerste voorbeeld waar we begonnen vanaf het meest rechtse bit en naar links werkten, maar met MSBFIRST stuurt de shift out-functie de gegevens op de juiste manier. We voegen ook een vertraging toe aan de for-lus, zodat deze voldoende vertraagt om zichtbaar te zijn. for(int i = 0; i < 8; ++i) // for 0 - 7 do { shiftOut(data, clock, MSBFIRST, 1 << i); // bit shift een logische hoge (1) waarde met i delay (100); // vertraag 100 ms of je zou het niet kunnen zien } }void loop(){} // lege lus voor nu upload het script en je zou nu de staafgrafiek elk licht één voor één moeten zien oplichten

Stap 6: Project 2: '2 Wire' 7 Segment Display Controller

Kijk naar de pinout van je 7-segments display (ik had alleen een dubbele maar gebruikte de helft) en gebruik de onderstaande tekening om elk segment te verbinden met het juiste bit op het schuifregisterbit 1 = pin 3bit 2 = pin 4bit 3 = pin 5bit 4 = pin 6bit 5 = pin 10bit 6 = pin 11bit 7 = pin 12bit 8 = pin 13 (als je de decimale punt wilt gebruiken)En de kathode van het display via de 330ohm weerstand en naar de voeding, open nu de seven_seg_demo.pde in de arduino IDEEerst zie je waar we de data en klokpinnen definiëren #define data 2#define clock 3 Vervolgens stellen we alle karakterpatronen in binair, dit is vrij eenvoudig, kijk naar de onderstaande tekening, als je het middensegment nodig hebt typ er een in, vervolgens heb je het bovenste segment nodig, zo ja, typ dan een ander, blijf dit doen totdat je alle 8 segmenten hebt bedekt, merk op dat mijn meest rechtse bit (bit 8) altijd 0 is, dat komt omdat ik nooit het decimaalteken aanzet punt. byte nul = B01111110;byte één = B00000110;byte twee = B11011010;byte drie = B11010110;byte vier = B10100110;byte vijf = B11110100;byte zes = B11111100;byte zeven = B01000110;byte acht = B11111110;byte negen = B11110110; vervolgens stellen we in void setup onze gegevens en klokpinnen in op outputs void setup(){ pinMode(clock, OUTPUT); // maak de klokpin een output pinMode (data, OUTPUT); // maak van de data-pin een output3} dan gebruiken we in de void loop shiftOut om elk patroon (nummer) weer te geven, wacht een halve seconde en toon de volgende, 0 tot 9, aangezien het wordt gedaan in de void loop-functie, het zal tellen 0-9 en herhaal voor altijd. void loop(){ shiftOut(data, klok, LSBFIRST, nul); vertraging (500); shiftOut (gegevens, klok, LSBFIRST, één); vertraging (500); shiftOut(data, klok, LSBFIRST, twee); vertraging (500); shiftOut(data, klok, LSBFIRST, drie); vertraging (500); shiftOut(data, klok, LSBFIRST, vier); vertraging (500); shiftOut(data, klok, LSBFIRST, vijf); vertraging (500); shiftOut(data, klok, LSBFIRST, zes); vertraging (500); shiftOut(data, klok, LSBFIRST, zeven); vertraging (500); shiftOut(data, klok, LSBFIRST, acht); vertraging (500); shiftOut(data, klok, LSBFIRST, negen); vertraging (500);}

Stap 7: Project 3 [pt 1]: '2 Wire' 4x4 Led Matrix Display

Het 4x4 LED-matrixproject is een stuk complexer, maar het is bijna allemaal in constructie, ik kies ervoor om de mijne op perfboard te solderen, maar het zou mogelijk moeten zijn om te repliceren op een breadboard, alleen veel meer gespreid. De circuits ook verschilt doordat het schuifregister niet direct de led's aanstuurt, maar dat de schuifregisteruitgangen via een weerstand van 1 Kohm naar de basis van een NpN-transistor worden gestuurd, wanneer de uitgang van het bit hoog is, laat het voldoende stroom en spanning door in de transistor om de verbinding tussen collector en emitter te schakelen, de collectoren zijn verbonden met een "stevige" gereguleerde 5 volt. De emitters van de transistors zijn verbonden met 150 ohm weerstanden en de weerstanden zijn verbonden met de anodes van 4 led's op een rij beperkt de rij tot 20ma, hoewel bij het tekenen van afbeeldingen op het scherm slechts 1 led tegelijk aan is, en daarom bijna op volledige helderheid (bijna omdat ze heel snel aan en uit gaan om het hele beeld te vormen) Er zijn 4 rijen en 4 kolommen, elk rij krijgt een weerstand en een transistor, op elke kolom zijn de kathodes van de LED's aan elkaar gebonden, liepen in de collector van een transistor, waarvan de basis ook wordt bestuurd door het schuifregister, en uiteindelijk naar aarde. Grote versie van schema www.instructables.com/files/orig/F7J/52X0/G1ZGOSRQ/F7J52X0G1ZGOSRQ.jpg

Stap 8: Project 3 [pt 2]: '2-draads' 4x4 led-matrixdisplay

Het schuifregister bestuurt zowel de anode als de kathodes van de LED's in een YX formaat, kijk naar het volgende bit 1 = kolom 1 (meest rechtse) bit 2 = kolom 2bit 3 = kolom 3bit 4 = kolom 4bit 5 = rij 1 (bovenste) bit 6 = rij 2bit 7 = rij 3bit 8 = rij 4Om een afbeelding te maken, teken een 4x4 vierkant op ruitjespapier en vul in welke je wilt weergeven, maak vervolgens een YX-tabel. Hieronder ziet u een afbeelding voor een vergelijking, het beste wat men kan doen op 4x4 "pixels"Voor elke ingevulde sectie noteer ik in welke kolom (Y) het staat, en vervolgens in welke rij het staat (X) Open nu het bestand _4x4.pde in de arduino IDE, je zult onze oude 2 vrienden zien #define data 2#define clock 3 dan een array van gehele getallen int img = {1, 1, 4, 1, 1, 3, 4, 3, 2, 4, 3, 4}; Als je kijkt, het is gewoon een lijst van mijn opgeschreven YX-coördinaten, het zou een grote pijn in de kont zijn om die waarden met de hand om te zetten, en we hebben een computer … laat het het doen! Verderop is er een ongeldige setup waar we maken onze klok- en datapinnen OUTPUTS void setup(){ pinMode(clock, OUTPUT); // maak de klokpin een output pinMode (data, OUTPUT); // maak van de data pin een output3} En een verwarrend ogende void loop, om te beginnen moeten we enkele lokale variabelen declareren void loop(){ int Y; int X; byte uit; Dan een for-lus, deze lus moet zo lang zijn als het aantal items in de img-array, voor deze afbeelding heb ik slechts 6 pixels gebruikt, dus dat maakt 12 YX-coördinaten. Ik laat het elk ander nummer overslaan door i +=2 te gebruiken, omdat we 2 coördinaten per lus lezen voor (int i = 0; i < 12; i += 2) // aantal punten in de img-array, dit geval 12 { Nu lezen we de Y-invoer bij in de array en trekken er één af van de waarde, omdat bytes niet bij één beginnen, ze beginnen bij nul, maar we telden vanaf 1 // haal het eerste paar YX-snoeren Y = (img - 1); // trek er één af omdat het aantal bits begint bij 0. Vervolgens lezen we de X-invoer op [i + 1] in de array, en trekken één van zijn waarde af, om dezelfde reden X = (img[i+1] - 1); Nadat we de YX-waarden van de pixel hebben, doen we wat bitsgewijze of wiskunde en verschuiven naar links. Eerst moeten we de X-waarde lezen, en wat de waarde ervan ook is, verschuif het zoveel plaatsen + 4 over, dus als X 4 is en voeg 4 toe, het is bit 8 (MSB), als we nog eens naar de grafiek kijken …bit 1 = kolom 1 (meest rechtse) bit 2 = kolom 2bit 3 = kolom 3bit 4 = kolom 4bit 5 = rij 1 (bovenste) bit 6 = rij 2bit 7 = rij 3bit 8 = rij 4Bit 8 is de laatste rijVervolgens is de Y-waarde ook naar links verschoven, deze keer alleen door zichzelf, niets toegevoegd. Eindelijk worden de twee samengevoegd tot 1 byte in plaats van 2 halve bytes (knabbels), met bitsgewijze of (het symbool |) neemt twee bytes en voegt ze in feite bij elkaar, laten we aannemen dat X = 10000000Y = 00000001--------------------OR = 100001rij 4 kolom 1 uit = 1 << (X + 4) | 1 << J; En ten slotte shiftOut om de huidige afbeelding weer te geven, en blijf dat doen totdat we geen gegevens meer in de array hebben … wacht even en loop voor altijd, omdat we gegevens naar links verschuiven en we de MSB op de laatste uitvoerpin nodig hebben van het schuifregister stuur het eerst uit. shiftOut(gegevens, klok, MSBFIRST, uit); // verschuif de byte naar onze registervertraging (1); // vertraag het een beetje zodat het een kans heeft om een lichtpuntje in je ogen achter te laten. Voel je vrij om je eigen afbeeldingen en effecten te maken. Er zijn 3 voorbeeldbestanden, het smileygezicht en een dambord (dat meer op strepen lijkt), en tot slot een willekeurige schitteringmaker

Stap 9: Conclusie

Al met al is dit een vrij handige kleine chip, en ik ben blij dat ik hem van een oud stuk elektronica heb geschrapt dat naar de prullenbak gaat. Het kan voor andere dingen worden gebruikt dan weergavesystemen, maar iedereen houdt van lichten en de directe feedback van zien wat er aan de hand is, is buitengewoon nuttig voor visuele denkers zoals ik. Vergeef me ook mijn code, ik heb de arduino pas sinds de derde week van oktober en het is een behoorlijk grote spoedcursus geweest. Maar dat is het mooie van het systeem, als je er voor gaat zitten en ermee werkt, het zit vol met handige functies die het besturen van de wereld met een 8-bits microcontroller vrij eenvoudig maken. Zoals altijd zijn vragen en opmerkingen van harte welkom, en bedankt voor lezen, ik hoop dat je veel hebt geleerd