74HC164 -skiftregistret och din Arduino: 9 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:48

Skiftregister är en mycket viktig del av digital logik, de fungerar som lim mellan parallell- och serievärlden. De minskar trådräkningen, stiftanvändningen och hjälper till och med att ta bort din cpu genom att kunna lagra deras data. De finns i olika storlekar, med olika modeller för olika användningsområden och olika funktioner. Den jag kommer att diskutera idag är 74HC164 8 -bitars, seriell parallellt ut, icke -låst, skiftregister. Varför? För en är det ett av de mest grundläggande skiftregistren som finns, vilket gör det lättare att lära sig om det, men det var bara det enda jag hade (lol!) Denna instruerbara täcker hur detta chip fungerar, hur man kopplar det, och gränssnitt det med en arduino inklusive några provskisser och ledkretsar. Jag hoppas att ni alla kommer att trivas!

Steg 1: Så, vad är skiftregister?

Som nämnts tidigare finns de i alla olika smaker, och jag nämnde också att jag använder en 74HC164 8 -bitars, seriell parallell ut, icke -låst, skiftregister, vad betyder det då?!? För det första betyder namnet 74-dess del av 74xx-logikfamiljen, och eftersom dess logik inte direkt kan styra mycket mycket ström (16-20ma för hela chipet är vanligt), skickar det bara signaler runt, men det betyder inte den signalen går inte till en transistor som kan växla en högre strömbelastning. HC betyder att det är en cmos -enhet med hög hastighet, du kan läsa om det på länken nedan, men vad du i grunden behöver veta om det är att det är en låg strömförsörjningsenhet och kommer att gå från 2 till 5 volt (så om du använder en 3,3 volt arduino är det ok) Det kan också fungera korrekt vid höga hastigheter, det här chipet har en typisk hastighet på 78 MHz, men du kan gå lika långsamt eller lika snabbt (tills det börjar tjata) som du vill. www.kpsec.freeuk.com/components/74series.htm164 är modellnumret för detta chip, det finns ett stort diagram över dem på wikipediaen.wikipedia.org/wiki/List_of_7400_series_integrated_circuits Nästa, 8 bitar Ett skiftregister består av flip -flop -kretsar, en flip -flop är 1 bit minne, den här ha s 8 (eller 1 byte minne). Eftersom det är minne, om du inte behöver uppdatera registret kan du bara sluta "prata" med det och det kommer att förbli i vilket tillstånd du lämnade det, tills du "pratar" med det igen eller återställer strömmen. andra 7400 logikseriens skiftregister kan gå upp till 16 bitars parallellt ut Detta betyder att din arduino skickar data seriellt (på av -pulser efter varandra) och skiftregistret placerar varje bit på rätt utgångsstift. Denna modell kräver bara 2 ledningar för att styras, så du kan använda 2 digitala stift på arduinoen och bryta dessa 2 till 8 fler digitala utgångar. Vissa andra modeller är parallella i seriell ut, de gör samma sak men som ingångar till arduino (till exempel en NES gamepad) icke -låst Detta kan vara ett underlag för detta chip om du behöver det. När data går in i ett skiftregister via seriell, visas det på den första utgångsstiften, när en klockpuls går in, den första biten skiftar över en plats, vilket skapar en rullningseffekt på utgångarna, till exempel 00000001 skulle dyka upp på utgångarna som 101001000100001000001000000100000001 Om du pratar med andra logiska enheter som delar samma klocka och inte förväntar sig detta kan det orsaka problem. Spärrade skiftregister har en extra uppsättning minne, så när data är klara att gå in i registret kan du vända en omkopplare och visa utgångarna, men det lägger till ytterligare en tråd, programvara och saker att hänga med i. vi styr LED -displayer, rullningseffekten sker så snabbt att du inte kan se den (förutom när du först sätter på chipet), och när byten är i skiftregistret finns det ingen mer rullningVi kommer att styra stapeldiagramtyp, 7 segment och en 16LED 4x4 -punktmatris med detta chip och programvara på arduino med endast 2 digitala stift (+ ström och jord)

Steg 2: Grundläggande kabeldragning och drift

Kabeldragning 74HC164 är ett 14 -stifts chip, den har 4 ingångsstift, 8 utgångsstift, ström och jord, så låt oss börja från toppen. Stift 1 och 2 är båda seriella ingångar, de är konfigurerade som en logisk OCH -grind, vilket betyder att de måste båda vara logiska höga (dvs. 5 volt) för att biten ska ses som en 1, ett lågt tillstånd (0 volt) på endera kommer att läsas som en nolla. Vi behöver verkligen inte detta och det är lättare att hantera i programvara, så välj en och knyt den till V+ så den alltid läser högt. Jag väljer att använda en bygel från stift 1 till stift 14 (V+) eftersom du bara kan slå en brödbräda över bygeln. Den återstående seriella ingången (stift 2 i mina scheman) kommer att gå till digital stift 2 på arduinoen. Stift 3, 4, 5 och 6 i 74HC164 är de första 4 byten i utgången Pin 7 ansluts till marken Hoppning till höger, stift 8 är klockstiftet, så vet skiftregistret att nästa seriella bit är redo att läsas, detta bör anslutas till digital stift 3 på arduino. Pin 9 är att rensa hela registret på en gång, om det blir lågt, du har möjlighet att använda den, men ingenting i det här obegripliga gör det, så bind det till V+stift 10, 11 12 och 13 är de sista 4 byten i utgångsnål 14 är chipsets effekt Operation först måste du ställa in serieingången i registret (digital stift 2 på arduino) hög eller låg, därefter måste du vända klockstiftet (digitalt stift 3) från lågt till högt, skiftregistret kommer att läsa data på den seriella ingången och flytta utgångsstiften med 1, upprepa 8 gånger och du har ställt in alla 8 utgångar. Detta kan göras för hand med slingor och digitala skrivningar i arduino IDE, men eftersom t hans är en mycket vanlig hårdvarunivåkommunikation (SPI) de har en enda funktion som gör det åt dig. shiftOut (dataPin, clockPin, bitOrder, värde) Berätta bara var data och klockpinnar är anslutna till arduino, vilket sätt att skicka data och vad som ska skickas, och det tas om hand för dig (praktiskt)

Steg 3: Projekt

Okej, nog med föreläsning och teori, låt oss göra några roliga saker med det här chipet! Det finns 3 projekt att testa i detta instruerbara, de två första är enkla och kan brödas ut på ett ögonblick. Den tredje, 4x4 led -matrisen, kräver mer tid och tanke för att konstruera, på grund av ledningskablarna. Lista över delar Projekt 1: '2 Wire' bargraph LED display controller 1 * 74HC164 Skiftregister1 * lödfritt brödbräda1 * arduino eller arduino kompatibel (5v) 1 * 330 ohm 1/4 watt motstånd 8 * normal utgång röda lysdioder 12 * bygelkablar Project 2: '2 Wire' 7 segment display controller 1 * 74HC164 Skiftregister1 * lödfritt brödbräda1 * arduino eller arduino kompatibel (5v) 1 * 330 ohm 1/4 watt motstånd 1 * gemensam katod sju segment display9 * bygelkablar Projekt 3: '2 Wire' 4x4 led matris display 1 * 74HC164 Skiftregister 1 * arduino eller arduino kompatibel (5v) 4 * 150 ohm 1 1/4 watt motstånd 8 * 1Kohm 1/8 watt motstånd (eller större) 8 * NpN transistor (2n3904 eller bättre) 16 * normal utgång röd lysdiod är ett sätt att konstruera det och reglerad 5 volt effekt som klarar 160+ma (du kan slå på alla lysdioder samtidigt som ett bromsljus)

Steg 4: Projekt 1 [pt 1]: '2 Wire' Bargraph LED Display Display Hardware

Anslut arduino- och skiftregistret enligt schemat, jag har redan en 10 -segmentars stapeldiagramskärm klar för användning på brödbräda och det är vad du kommer att se på bilden, men du kan göra samma sak med individuella lysdioder På den andra sidan Jag konstaterade att dessa inte var drivrutiner, att de var logiska enheter, med små mängder ström som kunde passera genom dem. För att köra 8 lysdioder, samtidigt som kretsen är enkel och inte tillagas skiftregistret, kräver vi att vi begränsar strömmen ganska mycket. Lysdioderna är parallellkopplade och delar en gemensam jord (gemensam katod) innan vi går in i strömmen strömförsörjning måste de passera genom ett 330 ohm motstånd, vilket begränsar den totala mängden ström som alla lysdioder eventuellt kan använda till 10ma (vid 5 volt). i det här exemplet, för att driva lysdioderna i rätt ström måste du sätta in en transistor där skiftregistret kan slå på / av en högre strömkälla (se projekt 3) Datapinnen för skiftregistret (stift 2) behöver för att ansluta till arduino digital pin # 2 Klockstiftet på skiftregistret (pin 8) måste anslutas till arduino digital pin # 3

Steg 5: Projekt 1 [pt 2]: '2 Wire' Bargraph LED Display Display Controller Software

Exempel 1: Öppna filen "_164_bas_ex.pde" Inuti arduino IDE, Det är en enkel skiss som bara låter dig definiera på eller av lysdioder i stapeldiagrammen. De två första raderna definierar stiftnumren vi ska använda för data och klocka, I använd #define över konstant heltal, jag tycker att det är lättare att komma ihåg, och det finns ingen fördel med den ena eller den andra när vi har sammanställt #definiera data 2 #definiera klockan 3 nästa är void setup -funktionen, den körs bara en gång, så arduino vänder på, ställer in skiftregistret och har inget annat att göra. Inuti void -inställningsfunktionen ställer vi in klockan och datastiften som OUTPUT -stift, sedan använder vi shiftOut -funktionen vi skickar data till skiftregistret void setup () {pinMode (klocka, OUTPUT); // gör klocknålen till en utgång pinMode (data, OUTPUT); // göra datapinnen till en output shiftOut (data, klocka, LSBFIRST, B10101010); // skicka detta binära värde till skiftregistret} I shiftOut -funktionen kan du se dess argumentdata är datapinnen, klockan är klockstiftet LSBFIRST hänvisar till vilken ordning det är, när du skriver ut det i binär notation (Bxxxxxxxx) den 7: e element förbi B är den minst signifikanta biten Först matas detta in först så att det hamnar på den sista utgången när alla 8 bitarna matas inB10101010 är det binära värdet som skickas till skiftregistret, och det tänds varje udda ljus, försök spela med olika värden för att slå på eller stänga av olika mönster och slutligen en tom tomrumsslinga (eftersom du behöver en även om du inte använder den) void loop () {} // tom loop för nu Exempel 2: de första 8 raderna är samma som de första 8 raderna i det första exemplet, de kommer faktiskt inte att ändras för något av de andra projekten, så #define data 2 #definiera klocka 3void setup () {pinMode (clock, OUTPUT); // gör klocknålen till en utgång pinMode (data, OUTPUT); // gör datapinnen till en utgång Men nu i tomrumsinställningen finns det 8 räkningar för slinga, det tar en tom byte och flyttar in 1 bit åt gången från den längst till vänster och flyttar åt höger. Detta är bakåt från det första exemplet där vi började från den högra biten och arbetade till vänster, men med MSBFIRST skickar utskjutningsfunktionen data på rätt sätt. Dessutom lägger vi till en fördröjning i for -slingan så att den saktar ner tillräckligt för att vara synlig. för (int i = 0; i <8; ++ i) // för 0 - 7 gör {shiftOut (data, klocka, MSBFIRST, 1 << i); // bitskift ett logiskt högt (1) värde med i fördröjning (100); // fördröj 100 ms annars kan du inte se det}} void loop () {} // tom loop för nu ladda upp skriptet och du bör nu se stapeldiagrammet tända varje ljus ett i taget

Steg 6: Projekt 2: '2 Wire' 7 Segment Display Controller

Titta på pinout på din 7 -segmentskärm (jag hade bara en dubbel men bara med hälften) och använd ritningen nedan för att ansluta varje segment till rätt bit på skiftregistret 1 = stift 3bit 2 = stift 4bit 3 = stift 5bit 4 = stift 6bit 5 = stift 10bit 6 = stift 11bit 7 = stift 12bit 8 = stift 13 (om du vill använda decimalpunkten) Och katod på displayen genom 330ohm -motståndet och till nätaggregatet, öppna nu Seven_seg_demo.pde i arduino ID Först ser du var vi definierar data och klocknålar #definierar data 2 #definierar klocka 3 Därefter ställer vi in alla karaktärsmönster i binärt, det här är ganska enkelt, titta på ritningen nedan, om du behöver mittsegmentet skriv in ett, nästa behöver du det övre segmentet, i så fall skriver du in ett annat, fortsätt med det här tills du täcker alla 8 segmenten, märk att min bit längst till höger (bit 8) alltid är 0, det är för att jag aldrig slår på decimalen punkt. byte noll = B01111110; byte en = B00000110; byte två = B11011010; byte tre = B11010110; byte fyra = B10100110; byte fem = B11110100; byte sex = B11111100; byte sju = B01000110; byte åtta = B11111110; byte nio = B111101 nästa i void setup ställer vi in våra data och klockpinnar för att mata ut void setup () {pinMode (clock, OUTPUT); // gör klocknålen till en utgång pinMode (data, OUTPUT); // gör datapinnen till en utgång3} sedan i void loop använder vi shiftOut för att visa varje mönster (antal) vänta 1/2 sekund och visa nästa, 0 till 9, eftersom det görs i void loop funktionen kommer det att räkna 0-9 och upprepa för alltid. void loop () {shiftOut (data, klocka, LSBFIRST, noll); fördröjning (500); shiftOut (data, klocka, LSBFIRST, en); fördröjning (500); shiftOut (data, klocka, LSBFIRST, två); fördröjning (500); shiftOut (data, klocka, LSBFIRST, tre); fördröjning (500); shiftOut (data, klocka, LSBFIRST, fyra); fördröjning (500); shiftOut (data, klocka, LSBFIRST, fem); fördröjning (500); shiftOut (data, klocka, LSBFIRST, sex); fördröjning (500); shiftOut (data, klocka, LSBFIRST, sju); fördröjning (500); shiftOut (data, klocka, LSBFIRST, åtta); fördröjning (500); shiftOut (data, klocka, LSBFIRST, nio); fördröjning (500);}

Steg 7: Projekt 3 [pt 1]: '2 Wire' 4x4 Led Matrix Display

4x4 LED -matrisprojektet är lite mer komplext, men det är nästan allt i konstruktion, jag väljer att göra mitt lödt på perfboard, men det borde vara möjligt att replikera på ett brödbräda, bara mycket mer åtskilt. Kretsarna också skiljer sig genom att skiftregistret inte direkt driver lysdioderna, istället skickas skiftregisterutgångarna via ett 1Kohm -motstånd till basen på en NpN -transistor, när bitens utgång är hög låter den tillräckligt med ström och spänning passera in i transistorn för att växla anslutningen mellan kollektorn och sändaren, är kollektorerna bundna till en "robust" reglerad 5 volt. Transistorernas sändare är anslutna till 150 ohm motstånd och motstånden är bundna till anoderna på 4 lysdioder i rad och begränsar raden till 20ma, men när du ritar bilder på displayen är bara 1 lysdiod tänd i taget, och därför nära full ljusstyrka (nära eftersom de slås på och av riktigt snabbt för att bilda hela bilden) Det finns 4 rader och 4 kolumner, var rad får ett motstånd och en transistor, på varje kolumn är LED: s katoder bundna ihop, sprang in i kollektorn på en transistor, vars bas också styrs av skiftregistret och slutligen ut till marken. Stor version av schematisk www.instructables.com/files/orig/F7J/52X0/G1ZGOSRQ/F7J52X0G1ZGOSRQ.jpg

Steg 8: Projekt 3 [pt 2]: "2 Wire" 4x4 Led Matrix Display

Skiftregistret styr både anoden och katoderna på lysdioderna i ett YX -format, titta på följandebit 1 = kolumn 1 (längst till höger) bit 2 = kolumn 2bit 3 = kolumn 3bit 4 = kolumn 4bit 5 = rad 1 (överst) bit 6 = rad 2bit 7 = rad 3bit 8 = rad 4 För att göra en bild rita ut en fyrkant på 4x4 på grafpapper och fyll i vilka du vill visa, gör sedan en YX -tabell. Nedan ser du en kartläggning för en liknelse, liksom det bästa man kan göra på 4x4 "pixlar" För varje ifyllt avsnitt skriver jag ner vilken kolumn (Y) det är i, sedan vilken rad det är i (X) Öppna nu _4x4.pde -filen i arduino IDE kommer du att se våra gamla 2 vänner #definiera data 2 #definiera klocka 3 sedan en rad heltal int img = {1, 1, 4, 1, 1, 3, 4, 3, 2, 4, 3, 4}; Om du bara tittar på en lista över mina nedskrivna YX -koordinater, skulle det vara en stor smärta i rumpan att konvertera dessa värden för hand, och vi har en dator … låt det göra det! vår klocka och datapinnar OUTPUTS void setup () {pinMode (clock, OUTPUT); // gör klocknålen till en utgång pinMode (data, OUTPUT); // göra datapinnen till en utgång3} Och en förvirrande tomrumsslinga, för att starta saker måste vi deklarera några lokala variabler void loop () {int Y; int X; byte ut; Sedan en for loop, denna loop måste vara lika lång som antalet poster i img -matrisen, för den här bilden använde jag bara 6 pixlar, så det gör 12 YX -koordinater. Jag får det att hoppa över vartannat nummer med hjälp av i += 2, eftersom vi läser 2 koordinater per slinga för (int i = 0; i <12; i += 2) // antal punkter i img -matrisen, detta fall 12 {Nu läser vi Y -enteriet vid i arrayen och subtraherar ett från dess värde, eftersom byte inte börjar med ett, de börjar på noll, men vi räknade från 1 // få det första paret av YX -kablar Y = (img - 1); // subtrahera en eftersom biträkningen börjar vid 0 Därefter läser vi X -entery vid [i + 1] i matrisen och subtraherar en från dess värde på grund av samma anledning X = (img [i + 1] - 1); När vi har pixelns YX -värden gör vi lite bitvis eller matematik och flyttar åt vänster. Först måste vi läsa X -värdet, och oavsett dess värde är det så många platser + 4 kvar, så om X är 4 och lägg till 4 det är bit 8 (MSB), tittar på diagrammet igen … bit 1 = kolumn 1 (längst till höger) bit 2 = kolumn 2bit 3 = kolumn 3bit 4 = kolumn 4bit 5 = rad 1 (överst) bit 6 = rad 2bit 7 = rad 3bit 8 = rad 4 Bit 8 är den sista raden Därefter förskjuts Y -värdet också till vänster, den här gången bara av sig själv, ingenting läggs till. Slutligen sammanförs de två till 1 byte istället för 2 halvbyte (nibbles), med hjälp av bitvis eller (symbolen |) tar två byte och lägger dem i princip tillsammans, låt oss anta X = 10000000Y = 00000001 -------------------- ELLER = 10000001rad 4 kolumn 1 ut = 1 << (X + 4) | 1 << Y; Och slutligen shiftOut för att visa den aktuella bilden och fortsätt med det tills vi inte har mer data i arrayen … fördröja ett ögonblick och loopa för alltid, eftersom vi flyttade data till vänster och vi behöver MSB för att vara på den sista utmatningsstiftet i skiftregistret skicka ut det först. shiftOut (data, klocka, MSBFIRST, ut); // flytta byten ut till vår registerfördröjning (1); // fördröj det så att det har en chans att lämna en ljuspunkt i ögonen. Gör gärna dina egna bilder och effekter, det finns 3 exempelfiler, smiley -ansiktet och en rutan (som ser mer ut som ränder), och slutligen en slumpmässig gnistrare

Steg 9: Slutsats

Över allt detta är ett ganska praktiskt litet chip, och jag är glad att jag tog bort det från en gammal elektronik som gick till papperskorgen. Den kan användas för andra saker än displaysystem, men alla gillar lampor och omedelbar feedback om att se vad som händer är oerhört hjälpsamt för visuella tänkare som jag. Förlåt också min kod, jag har bara haft arduino sedan den tredje veckan i oktober, och det har varit en ganska stor kraschkurs. Men det är det fantastiska med systemet, om du sätter dig ner och arbetar med det är det fullt av snygga funktioner som gör det enkelt att styra världen med en 8 -bitars mikrokontroller. Som alltid är frågor och kommentarer varmt välkomna, och tack för Jag hoppas att du har lärt dig mycket