Die 74HC164 -skofregister en u Arduino: 9 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:29

Skuifregisters is 'n baie belangrike deel van die digitale logika; hulle dien as gom tussen die parallelle en reekswêrelde. Dit verminder die aantal draad, die gebruik van penne en help selfs om u CPU af te laai deurdat hulle hul data kan stoor. Hulle kom in verskillende groottes, met verskillende modelle vir verskillende gebruike en verskillende funksies. Die een wat ek vandag sal bespreek, is die 74HC164 8 -bis, seriële parallel uit, nie -vergrendelde, skofregister. Hoekom? Dit is een van die mees basiese skofregisters wat dit moontlik maak, maar dit is toevallig die enigste een wat ek gehad het (lol!) Hierdie instruksies dek hoe hierdie chip werk, hoe om dit te bedraad. en koppel dit met 'n arduino, insluitend 'n paar voorbeeldsketse en geleide stroombane. Ek hoop dat u almal dit geniet!

Stap 1: So, wat is skofregisters?

Soos vroeër genoem, kom dit in alle verskillende geure, en ek het ook genoem dat ek 'n 74HC164 8 -bisse gebruik, seriële parallel uit, nie -grendel, skofregister, wat beteken dit dan alles?!? Eerstens beteken die naam 74-dit is deel van die 74xx-logika-familie, en aangesien dit logies nie baie sterk stroom kan beheer nie (16-20ma vir die hele chip is algemeen), gee dit slegs seine rond, maar dit beteken nie die sein gaan nie na 'n transistor wat 'n hoër stroomlading kan skakel nie. HC beteken dat dit 'n hoë spoed cmos -toestel is; u kan daaroor lees op die onderstaande skakel, maar wat u basies moet weet, is dat dit 'n lae spoed is kragtoestel en werk van 2 tot 5 volt (dus as u 'n 3,3 volt arduino gebruik, is dit ok) Dit kan ook behoorlik werk teen hoë snelhede, hierdie spesifieke chip het 'n tipiese snelheid van 78mhz, maar u kan so stadig of so vinnig gaan (totdat dit begin goof) soos u wil www.kpsec.freeuk.com/components/74series.htm164 is die modelnommer vir hierdie chip, daar is 'n groot grafiek daarvan op wikipediaen.wikipedia.org/wiki/List_of_7400_series_integrated_circuits Volgende, 8 bis 'N Skuifregister bestaan uit flip -flop -stroombane, 'n flip -flop is 'n bietjie geheue, hierdie een ha s 8 (of 1 greep geheue). Aangesien dit geheue is, kan u net ophou om daarmee te praat, as u nie die register hoef op te dateer nie, en dit bly in die toestand waarin u dit gelaat het, totdat u weer daaroor 'praat' of die krag herstel. ander 7400 logiese reeks verskuiwingsregisters kan parallel tot 16 bit seriële styg, dit beteken dat u arduino data in serie (aan die een na die ander afslagpulse) stuur en dat die skofregister elke bis op die regte uitsetpen plaas. Hierdie model benodig slegs 2 drade om beheer te word, sodat u 2 digitale penne op die arduino kan gebruik, en die 2 na 8 meer digitale uitsette kan breek. (byvoorbeeld 'n NES -gamepad) nie vasgemaak nie Dit kan 'n ondergang van hierdie chip wees as u dit nodig het. Namate data 'n skofregister via seriële binnegaan, verskyn dit op die eerste uitsetpen, as 'n klokpuls inkom, verskuif die eerste bis oor 1 plek, wat 'n roleffek op die uitsette skep, byvoorbeeld 00000001 sal op die uitsette verskyn as 101001000100001000001000000100000001000 As u met ander logiese toestelle praat wat dieselfde horlosie deel en dit nie verwag nie, kan dit probleme veroorsaak. Skuifregisters wat vasgevang is, het 'n ekstra stel geheue, dus sodra die data in die register ingeskryf is, kan u 'n skakelaar omdraai en die uitsette wys, maar dit voeg nog 'n draad, sagteware en dinge by om by te bly. ons beheer LED's, en 'n 16LED 4x4 -puntmatriks met hierdie chip en sagteware op die arduino met slegs 2 digitale penne (+ krag en grond)

Stap 2: Basiese bedrading en werking

Bedrading Die 74HC164 is 'n 14 -pen chip, dit het 4 invoerpenne, 8 uitvoerpenne, krag en grond, sodat ons van bo af kan begin. Pennetjies 1 en 2 is beide seriële insette, dit is opgestel as 'n logiese EN -hek, wat beteken dat hulle moet beide logies hoog wees (dws 5 volt) om die bit as 'n 1, 'n lae toestand (0 volt) op een van die twee as 'n nul te sien. Ons het dit nie regtig nodig nie, en dit is makliker om te hanteer in sagteware, dus kies een en bind dit aan V+ sodat dit altyd hoog lees. Ek kies om 'n trui van pen 1 tot pen 14 (V+) te gebruik, aangesien jy net 'n broodbord -trui oor die skyf kan gooi. Die een oorblywende seriële invoer (pen 2 in my skematika) gaan na digitale pen 2 van die arduino. Spelde 3, 4, 5 en 6 van die 74HC164 is die eerste 4 grepe van uitvoer Pin 7 word met grond verbind Spring na regs, pen 8 is die klokpen, so weet die skofregister dat die volgende seriële bietjie gereed is om te lees, dit moet aan die digitale pen 3 op die arduino gekoppel word. Pin 9 is om die hele register tegelyk skoon te maak, as dit laag word, u het die opsie om dit te gebruik, maar niks in hierdie ondeurgrondelike doen dit nie, so bind dit aan V+penne 10, 11 12 en 13 is die laaste 4 grepe outputpin 14 is die chips krag Operasie Eerstens moet u die seriële invoer stel van die register (digitale pen 2 op die arduino) hoog of laag, daarna moet u die klokpen (digitale pen 3) van laag na hoog draai, die skofregister sal die data op die reeksinvoer lees en die uitsetpenne verskuif 1, herhaal 8 keer en u het al 8 uitgange ingestel. Dit kan met die hand gedoen word vir lusse en digitale skryfwerk in die arduino IDE, maar sedert t sy is 'n baie algemene hardeware vlak kommunikasie (SPI) hulle het 'n enkele funksie wat dit vir jou doen. shiftOut (dataPin, clockPin, bitOrder, waarde) Vertel dit net waar die data en klokpenne aan die arduino gekoppel is, watter manier om die data te stuur en wat om te stuur, en dit word vir u versorg (handig)

Stap 3: Projekte

Goed, genoeg lesing en teorie, laat ons 'n paar lekker dinge doen met hierdie chip! Daar is 3 projekte om in hierdie instruksies te probeer, die eerste 2 is maklik en kan binne 'n rukkie uitgebrei word. Die derde een, die 4x4 geleide matriks, verg meer tyd en gedagtes om te bou, as gevolg van die geleide bedrading. Lys van onderdele Projek 1: '2 Wire' staafgrafiek LED -skermbeheerder 1 * 74HC164 Skakelregister1 * soldeerlose broodbord1 * arduino of arduino versoenbaar (5v) 1 * 330 ohm 1/4 watt weerstand 8 * normale uitset rooi LED's * * jumperdrade Projek 2: '2 Wire' 7 segment vertoonbeheerder 1 * 74HC164 Skuifregister1 * soldeerlose broodbord1 * arduino, of arduino versoenbaar (5v) 1 * 330 ohm 1/4 watt weerstand 1 * gemeenskaplike katode sewe segment display9 * springdrade Projek 3: '2 Wire' 4x4 led matriks display 1 * 74HC164 Shift register1 * arduino, of arduino versoenbaar (5v) 4 * 150 ohm 1 1/4 watt weerstand 8 * 1Kohm 1/8 watt weerstand (of groter) 8 * NpN transistor (2n3904 of beter) 16 * normale uitset rooi LED's is 'n manier om dit te bou en gereguleerde 5 volt krag wat 160+ma kan hanteer (u kan skakel al die LED's tegelyk aan soos 'n remlig)

Stap 4: Projek 1 [pt 1]: '2 Wire' Bargraph LED Display Controller Hardware

Sluit die arduino en die skyfregister aan volgens die skematiese weergawe; ek het reeds 'n staafgrafiek van 10 segmente wat gereed is vir gebruik op broodbord, en dit is wat u in die prent sal sien, maar u kan dieselfde doen met individuele LED's Op die tweede bladsy Ek het gesê dat dit nie bestuurders is nie, maar dat dit logiese toestelle is, met klein hoeveelhede stroom wat daardeur kan beweeg. Om 8 LED's te laat werk, terwyl die kring eenvoudig is en die skofregister nie gaargemaak word nie, moet ons die stroom 'n bietjie beperk. wat hulle nodig het om deur 'n weerstand van 330 ohm te gaan, wat die totale hoeveelheid stroom wat alle LED's moontlik kan gebruik tot 10ma (by 5 volt) beperk. Dit laat die LED's in 'n sieklike toestand, maar hulle brand maar In hierdie voorbeeld, om die LED's op hul regte stroom te dryf, moet u 'n transistor insit waar die skofregister 'n hoër stroombron kan aan / uit skakel (sien projek 3) om aan te sluit op arduino digitale pen # 2 Die klokpen van die skofregister (pen 8) moet verbind word met arduino digitale pen # 3

Stap 5: Projek 1 [pt 2]: '2 Wire' Bargraph LED Display Controller Software

Voorbeeld 1: Maak die lêer "_164_bas_ex.pde oop" In die arduino IDE is dit 'n eenvoudige skets waarmee u LED's in die staafgrafiek kan aan- of uitskakel. gebruik #define oor konst heelgetal, ek vind dit makliker om te onthou, en daar is geen voordeel vir die een of die ander een keer saamgestel nie #definieer data 2 #definieer klok 3 volgende is die leemte -opstelfunksie, dit loop slegs een keer, sodat die arduino draai aan, stel die skofregister in en hoef niks anders te doen nie. Binne die leemte -opstelfunksie stel ons die klok en datapennetjies in as OUTPUT -penne, en dan stuur ons die data na die opstelling van die skofregister () {pinMode (klok, OUTPUT); // maak die klokpen 'n uitvoer pinMode (data, UITGANG); // maak die dataspeld 'n uitvoer shiftOut (data, klok, LSBFIRST, B10101010); // stuur hierdie binêre waarde na die verskuiwingsregister} In die shiftOut -funksie kan u sien dat die argumente data is die dataspeld, klok is die klokpen LSBFIRST verwys na die volgorde waarin dit in is, as u dit in binêre notasie (Bxxxxxxxx) die 7de uitskryf element verby die B is die minste beduidende bietjie. Eerstens word dit eers ingevoer, sodat dit op die laaste uitset beland sodra al 8 bisse ingevoer is B10101010 is die binêre waarde wat na die skofregister gestuur word, en dit sal elke onewe lig aanskakel Probeer om met verskillende waardes te speel om verskillende patrone aan of uit te skakel, en uiteindelik 'n leë leemte -lus (want u benodig dit, selfs al gebruik u dit nie) leemte -lus () {} // leë lus vir nou Voorbeeld 2: die eerste 8 reëls is dieselfde as die eerste 8 reëls van die eerste voorbeeld, in werklikheid sal dit nie vir enige van die ander projekte verander nie, dus #define data 2 #definieer klok 3void setup () {pinMode (klok, OUTPUT); // maak die klokpen 'n uitvoer pinMode (data, UITGANG); // maak die gegewenspen 'n uitset, maar nou in die leemte -opstelling is daar 'n telling van 8 vir 'n lus, dit neem 'n leë byte en skuif 1 -bit in op 'n slag, begin vanaf die linkerkantste bit en beweeg regs. Dit is agteruit van die eerste voorbeeld, waar ons vanaf die bietjie regs begin en links gewerk het, maar met behulp van MSBFIRST stuur die verskuiwingsfunksie die data op die regte manier. Ons voeg ook 'n vertraging in die for -lus by sodat dit stadiger genoeg is om sigbaar te wees. for (int i = 0; i <8; ++ i) // vir 0 - 7 doen {shiftOut (data, klok, MSBFIRST, 1 << i); // bit shift 'n logiese hoë (1) waarde met i delay (100); // vertraag 100 ms, anders kan u dit nie sien nie}} leemte -lus () {} // leë lus, laai die skrip nou op, en u moet nou die staafgrafiek elke lig een vir een sien brand

Stap 6: Projek 2: '2 Wire' 7 -segment vertoonbeheerder

Kyk na die pinout van u 7 -segment -skerm (ek het slegs 'n dubbele een gehad, maar net die helfte) en gebruik die onderstaande tekening om elke segment aan die korrekte bietjie op die skofregisterbit 1 = pen 3bit 2 = pen 4bit 3 = pen 5bit te koppel. 4 = pen 6bit 5 = pen 10bit 6 = pen 11bit 7 = pen 12bit 8 = pen 13 (as u die desimale punt wil gebruik) En die katode van die skerm deur die 330ohm weerstand en na die kragtoevoer, maak nou die seven_seg_demo.pde oop in die arduino ID Eerstens sien u waar ons die data en klokpenne definieer #definieer data 2 #definieer klok 3 Vervolgens stel ons al die karakterpatrone in binêre, dit is redelik maklik, kyk na die onderstaande tekening as u die middelste segment benodig tik 'n een in, dan benodig u die boonste segment; as dit so is, tik 'n ander een, hou aan totdat u al 8 segmente bedek, let op dat my regterkantste bit (bit 8) altyd 0 is, dit is omdat ek nooit die desimaal aanskakel nie punt. byte nul = B01111110; byte een = B00000110; byte twee = B11011010; byte drie = B11010110; byte vier = B10100110; byte vyf = B11110100; byte ses = B11111100; byte sewe = B01000110; byte agt = B11111110; byte nege = B111101 volgende in die leemte -opstelling stel ons ons data en klokpennetjies in op die uitsette van die opstelling van die leemte () {pinMode (klok, OUTPUT); // maak die klokpen 'n uitvoer pinMode (data, UITGANG); // maak die gegewenspen 'n uitvoer3} dan gebruik ons in die leegte -lus shiftOut om elke patroon (getal) te vertoon, wag 1/2 'n sekonde en vertoon die volgende, 0 tot 9, aangesien dit in die leemte -lusfunksie gedoen word, sal dit tel 0-9 en herhaal vir ewig. leemte -lus () {shiftOut (data, klok, LSBFIRST, nul); vertraging (500); shiftOut (data, klok, LSBFIRST, een); 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, vyf); vertraging (500); shiftOut (data, klok, LSBFIRST, ses); vertraging (500); shiftOut (data, klok, LSBFIRST, sewe); vertraging (500); shiftOut (data, klok, LSBFIRST, agt); vertraging (500); shiftOut (data, klok, LSBFIRST, nege); vertraging (500);}

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

Die 4x4 LED -matriksprojek is nogal meer ingewikkeld, maar dit is amper alles in aanbou; ek kies om myne op perfboard te laat soldeer, maar dit moet moontlik wees om dit op 'n broodbord te herhaal, net baie meer uitmekaar. verskil deurdat die skofregister nie die LED's direk dryf nie, maar die uitset van die skuifregister word deur 'n 1Kohm -weerstand na die basis van 'n NpN -transistor gestuur, as die uitset van die bietjie hoog is, laat dit genoeg stroom en spanning in die transistor om die verbinding tussen die kollektor en emitter te skakel, word die kollektors vasgemaak aan 'n "stewige" gereguleerde 5 volt. Die transistors se emittors is gekoppel aan 150 ohm weerstande en die resistors is vasgemaak aan die annodes van 4 LED's in 'n ry en beperk die ry tot 20ma, alhoewel slegs 1 led op 'n slag aan is om beelde op die skerm te teken, en dus naby volle helderheid (naby omdat hulle vinnig in- en uitskakel om die hele beeld te vorm) Daar is 4 rye en 4 kolomme, elk ry kry 'n weerstand en 'n transistor, op elke kolom word die LED se katodes aan mekaar vasgemaak, vasgeloop in die kollektor van 'n transistor, waarvan die basis ook deur die skofregister beheer word, en uiteindelik grond toe. Groot weergawe van skematiese www.instructables.com/files/orig/F7J/52X0/G1ZGOSRQ/F7J52X0G1ZGOSRQ.jpg

Stap 8: Projek 3 [pt 2]: '2 Wire' 4x4 Led Matrix Display

Die skofregister beheer beide die anode en die katodes van die LED's in 'n YX -formaat, kyk na die volgende bit 1 = kolom 1 (regs) bietjie 2 = kolom 2bit 3 = kolom 3bit 4 = kolom 4bit 5 = ry 1 (boonste) bit 6 = ry 2bit 7 = ry 3bit 8 = ry 4 Om 'n prent te maak, trek 'n 4x4 -vierkant op grafiekpapier en vul die een in wat u wil vertoon, maak dan 'n YX -tabel. Hieronder sien u 'n kartering vir 'n gelykenis, sowel as die beste wat u kan doen op 4x4 "pixels". Vir elke ingevulde afdeling skryf ek neer watter kolom (Y) dit is, dan in watter ry dit is (X) Maak nou oop die _4x4.pde -lêer in die arduino IDE sien ons ons ou vriende #definieer data 2 #definieer klok 3 dan 'n verskeidenheid heelgetalle int img = {1, 1, 4, 1, 1, 3, 4, 3, 2, 4, 3, 4}; As u net 'n lys van my neergeskrewe YX -koördinate sien, sou dit 'n groot pyn in die boude wees om die waardes met die hand om te skakel, en ons het 'n rekenaar … laat dit regkom! ons horlosie en datapennetjies UITGEDE leegte opstelling () {pinMode (klok, UITGANG); // maak die klokpen 'n uitvoer pinMode (data, UITGANG); // maak die gegewenspen 'n uitvoer3} En 'n verwarrende leemte -lus, om dinge te begin, moet ons 'n paar plaaslike veranderlikes leemte () {int Y; int X; byte uit; Dan 'n vir lus, hierdie lus moet so lank wees as die hoeveelheid inskrywings in die img -skikking, vir hierdie beeld het ek slegs 6 pixels gebruik, wat 12 YX -koördinate maak. Ek laat dit elke ander getal oorslaan deur i += 2 te gebruik, want ons lees 2 koördinate per lus vir (int i = 0; i <12; i += 2) // aantal punte in die img -skikking, hierdie geval 12 {Nou lees ons die Y -enterie by in die skikking en trek een van die waarde daarvan af, want grepe begin nie by een nie, hulle begin by nul, maar ons het getel van 1 // kry die eerste paar YX -toue Y = (afb - 1); // trek een af, aangesien die bitselling by 0 begin. Vervolgens lees ons die X -enterie by [i + 1] in die skikking en trek een van die waarde daarvan af, om dieselfde rede X = (img [i + 1] - 1); Nadat ons die YX -waardes van die pixel het, doen ons bietjie of wiskundig en skuif na links. Eerstens moet ons die X -waarde lees, en wat ook al die waarde daarvan is, verskuif dit soveel plekke + 4, dus as X 4 is en voeg 4 by, dit is bit 8 (MSB), kyk weer na die grafiek … bit 1 = kolom 1 (regs) bit 2 = kolom 2bit 3 = kolom 3bit 4 = kolom 4bit 5 = ry 1 (bo) bit 6 = ry 2bit 7 = ry 3bit 8 = ry 4 Bit 8 is die laaste ry Volgende word die Y -waarde ook na links verskuif, hierdie keer net vanself, niks bygevoeg nie. Uiteindelik word die twee saamgevoeg in 1 byte in plaas van 2 halwe grepe (knibbel), deur bitwise te gebruik of (die simbool |) neem twee grepe en voeg dit basies bymekaar, laat ons aanneem X = 10000000Y = 00000001 -------------------- OF = 10000001rooi 4 kolom 1 uit = 1 << (X + 4) | 1 << Y; En laastens skuif Uiteindelik om die huidige prentjie te vertoon, en hou aan totdat ons geen data meer in die skikking het nie … vertraag 'n oomblik en loop vir ewig, aangesien ons data na links verskuif het en ons die MSB nodig het om op die laaste uitvoerpen te wees van die skofregister stuur dit eers uit. shiftOut (data, klok, MSBFIRST, uit); // skuif die greep uit na ons registervertraging (1); // vertraag dit so dat dit 'n kans om 'n ligpunt in u oë te laat, maak gerus u eie beelde en effekte, daar is drie voorbeeldlêers, die smiley en 'n dambord (wat meer soos strepe lyk), en uiteindelik 'n ewekansige skittermaker

Stap 9: Gevolgtrekking

Al hierdie is 'n baie handige klein skyfie, en ek is bly dat ek dit van 'n ou elektronika weggegooi het, wat na die asblik kan gaan. Dit kan ook vir ander dinge benewens die skermstelsels gebruik word, maar almal hou van ligte en die onmiddellike terugvoer om te sien Wat aan die gang is, is baie nuttig vir die visuele denkers soos ek. Vergewe ook my kode, ek het eers die arduino gehad sedert die derde week van Oktober, en dit was 'n redelike groot ongelukskursus. Maar dit is die wonderlike ding van die stelsel: as u gaan sit en daarmee werk, is dit vol netjiese funksies wat dit maklik maak om die wêreld te beheer met 'n 8 -bis -mikrobeheerder. Soos altyd is vrae en kommentaar baie welkom, en dankie vir lees, ek hoop jy het baie geleer