Grunderna för mikrokontroller utforskas

En sak är jättebra med mikrokontroller IC: er, de finns nästan i alla delar av världen och elektroniska återförsäljare.

Introduktion

I grund och botten används mikrokontroller-enheter i applikationer som involverar bedömningar av den omgivande miljön och i liknande elektronik.

Du kan hitta att dessa enheter används för att visa en viss parameter, i motorstyrningsapplikationer, LED-belysning, sensorer av olika slag, såsom lutningssensor, accelerometer, hastighetsmätare, dataloggare, temperaturregulatorer, tangentbord etc.

Den primära förståelsen för mikrokontroller kan erhållas genom att hänvisa till AVR Amega32 mikrokontroller som är så avancerad att det ibland kallas en dator i ett chip.

Denna enhet är tilldelad att utföra serier av kommandon för att bilda ett program.

Programmet som du ser här är C ++. Du får lära dig detta språk på djupet i kursen här.

När det gäller MCU: er får du möjlighet att kontrollera och konfigurera alla dess pinouts.

Om du blir lite trött på detta, bara kyla för det är ingenting komplext alls, du kommer att bli lättad genom alla aspekter stadigt men bestämt när vi går vidare.

I ett MCU-chip kan alla stift utom Vdd och Vss som är chipets power pins tilldelas med exklusiva beteckningar.

Pinout-detaljer

Om du tittar på chipet uppifrån skulle du hitta ett litet triangulärt hack som indikerar startpunkten där pinouts börjar det räknas, det är chipets nummer 1 som börjar precis under detta hack.

Med utgångspunkt från denna stift hittar du 20 stift upp till botten på den sidan (vänster) och ytterligare 20 stift på andra sidan (höger), fortsätter från botten till toppen på höger sida.

De första 8 stiften som börjar från skåran är PBO-7 som bildar IC-stiften för IC eftersom allt program här börjar med indexet noll.

Ovanstående serie pinouts kallas PORT B, medan det finns andra identiska uppsättningar portar som tilldelats A till D.

Dessa portar kan tilldelas för att acceptera och känna igen en matad data som heter INPUT, och även för att sända data i någon specifik form som kallas OUTPUT.

Två av stiften som ingår i den allmänna kategorin är (+) / (-) stift som också kallas Vdd och GND.

En stift från PORT D (PDO-6) kan ses placerad på chipets vänstra sida i bottenområdet.

PD7, som är stift nr 7 i PORT D, kan spåras ensam och påbörja den högra sidan av pinouts.

När vi nu går vidare från chipets högra sida där PORT D slutar börjar PORT C sin räkning uppåt i ordningen.

Dessa bidrar till MCU: s många intressanta stift, direkt från analoga till digitala.

Dessa stift finns för att bli avkänningsingångar för att detektera de många parametrarna genom externt konfigurerade analoga kretssteg.

Ovanstående stift utgör PORT A.

Den analoga till digitala omvandlingen över ovanstående stift kan förstås med hjälp av ett exempel, varvid en analog temperaturnivå detekterad med användning av en vanlig sensor såsom en termister appliceras på en av PORT A-stiften som lätt accepteras och omvandlas av MCU för att producera en digital avläsning från noll till 255 grader F (en 8-bitars siffra som kan uppgraderas för att uppnå en 10-bitars utgång).

En annan funktion som kan ses i MCU: er är också det tillgängliga programmeringsutrymmet eller minnet som bestämmer utrymmet för variablerna och programmet som specificeras för mikrokontrollern.

Dessutom har MCU: erna en inbyggd klocka tilldelad för att räkna relevanta parametrar.

Klockfunktionerna gör det möjligt för MCU att tillämpa sig själv för många olika räkneprocesser som kan vara snabba inom intervallet av mikrosekunder beroende på specifikationen för den specifika anordningen, och kan också vara långsammare i önskat omfång.

Nu har du kanske förstått mikrokontroller-konceptet i viss utsträckning och angående dess portar och stift.

Hur man skapar en SPI-anslutning från programmeraren till mikrokontrollern

Nu är det dags att gå lite djupare in i ämnet och undersöka programmeringsvärlden.

Med detta sagt måste vi hitta ett rätt sätt att integrera SPI-kontakten (Serial Peripheral Interface) med MCU innan vi hänför oss till en programladdningsprocedur i chipet.

Men även efter detta kan vi inte bara trycka SPI i MCU-pinouts, eller hur? Vi kan inte heller låta de förlängda ledningarna från SPI direkt sättas in i brödbrädan. Detta kan också orsaka felaktig trådinställning kopplad till fel stift som gör dåliga anslutningar.

För att göra saker helt oklanderliga gör vi procedurerna över ett litet veroboard där vi får de nödvändiga anslutande metallstift som också kallas 'header' lödda. Dessa sidhuvudstift kan nu användas för att ansluta till SPI-kontakten. Anslutningarna från denna rubrik kan avslutas till en annan parallell huvudstift som kan användas för panelerna.

Således bildar ovanstående sammansättning nu en tät och pålitlig mellanliggande anslutningsplattform för SPI till MCU.

Upptäck nu ser allt bra ut perfekt, så låt oss gå vidare för att tjäna för programmeraren som krävs mellan din dator och MCU.

Det kan finnas en mängd företag som tillverkar och säljer dessa programmeringsenheter, så att skaffa dessa borde inte vara ett problem för dig, som Adafruit Industries, USBtinyISP eller Sparkfun etc.

Några av dessa kan se helt annorlunda ut än konventionella typer, men har i princip allt identiskt och följer standardprogrammeringsreglerna och kan användas som ett gränssnitt mellan din dator och AVR-mikrokontrollern.

Men se till att man tänker, om du använder någon annan MCU och inte en AVR Atmega32, kan du behöva söka efter en motsvarande kompatibel programmerare för just det MCU-chipet.

Det kan observeras att en hel del av dessa programmerare använder identiska drivrutiner, något som måste tas om hand och vi lär oss mer om det i våra efterföljande kapitel.

Att ansluta din dator till mikrokontrollerchipet är verkligen grundläggande, och du skulle vara glad att veta hur enkelt proceduren krävs för detta. Så låt oss trycka direkt på knappenJ

Att göra det ovan beskrivna SPI-gränssnittskortet är inte svårt, det handlar om att få ditt lödjärn att arbeta igenom alla anslutningar över de visade två huvudraderna på stift på ett litet allmänt ändamål.

Bilden ovan visar anslutningsdetaljerna som du måste följa när du kopplar ihop ledningarna mellan rubrikerna.

För att göra saker ännu enklare, låt oss gå igenom följande anslutningsdetaljer för samma genom att hänvisa till bilden ovan:

SPI-stift från början uppe till vänster går till 'Master IN, Slave OUT' (MISO)

SPI-stift från mitten till vänster ansluter till klockstiftet (SCK)

SPI-stift längst ner till vänster ansluter till Återställ. (Vi lär oss detaljerat om denna stift i följande självstudier)

SPI som är relevant för botten till höger ansluter till GND-stiftet på MCU, GND hänvisar till stiftet som bildar nollförsörjningsledningen eller den negativa (relativa) skenan på matningen.

SPI som avslutas från den mellersta högra rubriken kopplas samman med 'Master Out, Slave IN' (MOSI) -stift på MCU.

SPI som kommer ut från den övre högra rubriken är ansluten till (+) på MCU: n, vilket helt uppenbarligen är Vdd eller MCU: s positiva försörjningsstift.

Det är allt.

Anslut de två kontakterna enligt förklaringen så är ditt SPI-gränssnittskort redo för de åtgärder som krävs.

För ytterligare hjälp kan du läsa figuren som visas ovan, ditt sista gränssnittskort bör se ut så här efter att alla trådanslutningar har gjorts på lämpligt sätt med hjälp av ovanstående diskussion.

Jag hoppas att du kanske redan har konstruerat SPI-gränssnittet som förklarats i föregående handledning, och nu är det dags att se till att vår dator accepterar programmeraren som vi behöver integrera mellan PC och MCU.

Skapa en enkel programmeringskod för en MCU

Vi tar en USBTinyISP-enhet tillgänglig från Sparkfun för att länka datorn till mikrokontrollern.

Vi vet att alla datoroperativsystem som Windows kräver drivrutiner utan vilka det är värdelöst att ladda någonting i datorn, så vår programmerare behöver drivrutiner för att ladda in i din dator.

Låt oss granska de procedurer som krävs för att installera drivrutinerna i ditt dators operativsystem, här tar vi exemplet med Windows 7 OS med antingen 32-bitars eller 64-bitars specifikationer.

Öppna sparkfun.com och klicka på “pocket AVR programmerar sida”. Länken kan enkelt visualiseras på sidan.

Hitta sedan 'Windows-drivrutin' under dokument och klicka bara på den.

Detta ger dig pocketprog-driver.zip-filen på din dator.

Gå till din dator, hitta nedladdningsplatsen och packa bara upp den nedladdade filen i en mapp.

Om din dator är ett 64-bitars operativsystem måste du följa några fler steg enligt nedan, med ett 32-bitars operativsystem kan du direkt börja installationen från den uppackade filen.

För en 64-bitars följ dessa, för 32-bitar helt enkelt ignorera:

Google “libusb sourceforge” och klicka på den här länkarna senaste versionen.

Du skulle stöta på några ytterligare filer, men du skulle vara intresserad av att hitta bib-filen, det vill säga: libusb-win32-bin - #. #. #. #. Zip

Gå nu och hitta den här nedladdningsplatsen på din dator, packa upp den och spara den i en av mapparna.

I den här mappen navigerar du över bin-mappen och fortsätter till mappen amd64.

Du ser ett par mappar här som: ghcalled libusb0.dll och libusb0.sys.

Du vill byta namn på dessa som: libusb0_x64.dll och libusb0_x64.sys.

Nu måste du kopiera ovanstående filer till pocketprog-driver-mappen, helt enkelt skriva över filerna på den befintliga versionen.

För att installera ovanstående drivrutiner skulle följande metod som är ganska icke-konventionell i sin typ intressera dig:

Det är ett 'lägg till äldre hårdvara' -läge.

Klicka på “Startmeny”

Fortsätt sedan genom att högerklicka på “dator”

Klicka på “Hantera” och slutligen klicka på “enhetshanteraren”

Välj sedan 'Lägg till äldre hårdvara' i menyn.

Fortsätt att trycka på 'nästa' tills guiden sätts in

Följ instruktionerna och klicka på “Installera hårdvaran som du skulle behöva välja från en avancerad lista” så kommer alternativknappikonen att visas i det valet. Det är faktiskt en windows-kontrollknapp som nu ser ut som en liten cirkel med en rundblå arkivering inuti.

Klicka bara på “Nästa”

Detta visar dig 'Visa alla enheter' -menyn som du måste klicka på.

Efter detta fortsätter du att klicka på ikonen 'Har disk'.

Med hjälp av 'Bläddra' -ikonen, gå vidare till platsen för pocketprog-driver-mappen. Om valet gjordes korrekt av dig skulle du visualisera pocketprog.inf-filen som placerades i den specifika mappen.

Dubbelklicka över den här filen och du skulle säkert bevittna att drivrutinen installerades på din dator.

Klart slut!! Låt oss fortsätta med vår nästa handledning på nästa sida.

Nu kanske du har installerat den nödvändiga programvaran och byggt SPI-gränssnittet.

Hur man överför ett program till ett mikrokontrollerchip

Nästa steg kommer att kräva några komponenter som en brädbräda, en LED och ett beräknat motstånd för den avsedda applikationen.

I det här avsnittet lär vi oss testprogrammet för programmeraren och bekräftar installationen av relevanta drivrutiner och programvaran.

För att verifiera om drivrutinerna och programvaran har installerats korrekt implementerar vi ett enkelt program som kallas avrdude.

AVRdude är ett program associerat med den senaste WinAVR-installationen utan vilken den faktiska överföringen av filen till MCU inte kan vara möjlig.

Detta program är ett .hex-filformat som i huvudsak blir förståeligt för MCU för de nödvändiga körningarna.

Om verifieringen inte lyckas kommer programmeraren inte att kunna överföra filen.

Låt oss snabbt se hur vi kan genomföra testproceduren med hjälp av följande instruktioner:

Öppna DOS (Diskoperativsystem) -prompten genom att klicka på 'startmeny' och skriva cmd.exe i den angivna sökrutan.

Nu kan du genomföra AVRdude genom att helt enkelt skriva avrdude –c usbtiny –p m32 över DOS-prompten. Så snart detta implementeras kommer DOS omedelbart att erkänna om anslutningen lyckades.

I ovanstående kommando är '-c' en meddelande-flagga som inkluderar 'usbtiny' programmeringsparameterspecifikationen, medan '-p' -taggen identifierar mikrokontrollenheten ('m32 indikerar Atmega32).

Om du har använt en annan MCU måste du inkludera relevanta prefix för implementeringen.

När proceduren ovan är klar kan du skriva “exit” över DOS-prompten, och det kommer att flytta dig ut ur fönstret.

Om du allvarligt undrar angående de faktiska programmeringsdetaljerna, ja för det skulle vi först behöva lödda och konstruera den externa analoga LED-kretsen över vilken programmet skulle kunna implementeras, för såvida det inte finns ett system för att bekräfta svaret från MCU, programmeringen och körning av mikrokontrollern skulle vara ganska meningslöst.

Att göra LED-kortet är väldigt enkelt, det handlar om att löda de två ledningarna på LED-lampan över ett stycke veroboard och ansluta motståndet med en av LED-lamporna. Denna lysdiods roll är bara att begränsa strömmen till lysdioden så att den inte brinner på grund av överflödets adström från MCU-utgången.

Motståndets värde kan beräknas med följande enkla formel:

R = (Ub - LEDfwd) / I

Där Ub är matningsspänningen är LEDfwd den optimala driftspänningen för den använda LED och jag är dess optimala förstärkare.

Antag att vi använder en RÖD LED som har en LED-framspänning = 2,5V och ström I = 20mA, ovanstående ekvation kan lösas enligt följande:

Eftersom spänningen från MCU skulle vara 5V kan den uttryckas som:

R = (5 - 2,5) /. 02 = 125 ohm, ¼ watt, närmaste värde är 120 ohm.

Nu har vi lysdioden, ett motstånd på 120 ohm och en veroboard, kopplar helt enkelt samman ovanstående komponenter som anges i diagrammet med mikrokontrollern.

När detta är gjort kan MCU programmeras för det avsedda svaret på ovanstående LED-inställning.

Därefter programmeringen av MCU.

För att låta mikrokontrollern utföra några meningsfulla implementeringar är det viktigt att skriva lämpliga instruktioner i MCU.

Hur man installerar en programmeringsmiljö och undersöker WinAVR

För detta skulle vi förmodligen kunna använda vår egen 'textredigerare' på vår dator, även om vi av oss skulle uppskatta användningen av en mer professionell 'programmeringsmiljö' istället för en vanlig textredigerare, enkelt eftersom det här tillvägagångssättet gör att du kan njuta av lite inbyggda intressanta funktioner i detta 'programmeringsmiljö' -paket.

Det skulle stödja att skapa och redigera program via olika språk och också sammanställa dem till ett leveransläge som är lätt att förstå och acceptera av ett mikrokontrollerchip.

I slutändan skulle detta stödjas av WinAVR och överföras till det berörda MCU-chipet.

WinAVR kan också vara utrustat för att utföra många andra operationer som att felsöka programmen och varna oss för eventuell syntax och sammanställa misstag och fel. Vi diskuterar dessa i våra senare handledning.

Du skulle vilja att installationen av WinAVR skulle vara extremt snabb och snygg. Låt oss dyka in i detaljerna med följande punkter:

Du måste ladda ner de senaste versionerna från mappen WinAVR source forge files. Du kommer att stöta på användbar information om denna nedladdning från dess officiella webbplats.

Du uppmanas över en säkerhetsfråga, så att du kan svara om du vill att nedladdningen ska ske, detta är fråga om att filen som ska laddas ner är en körbar fil.

Ladda ner filen och starta körningen genom att klicka på den. Låt installationen börja.

Processen kommer att vägleda dig med några svarbara frågor så att du kanske kan effektivisera installationen enligt din komfort. Du skulle vilja ignorera många av dessa till deras standardformulär, det är allt upp till dig att välja de som du tycker är bäst lämpade för åtgärderna.

Hittills skulle du hitta allt helt normalt och lättsamt och hitta några alternativ jag startmenyn kastas på dig. Inga bekymmer, bara några av dessa skulle faktiskt bara använda en av tem som heter 'programmers notepad'.

När du väl har klickat på den här ikonen skulle du starta användargränssnittet så att du kanske kan använda skrivningen av programmen (som att skapa och redigera). Du skulle också bevittna programmet som består av menykommandon för att hjälpa dig att sammanställa koder och bädda in dem i mikrokontrollern.

Det grundläggande jobbet för ovanstående programmeringsanteckningsblock är att omvandla en mänsklig läsbar kod som du skulle skriva till en serie instruktioner som bara är förståeliga för MCU.

Nästa handledning kommer att täcka testningen av ovanstående programmerare så att vi kan vara säkra på dess kompatibilitet med Windows och om den perfekt 'skakar hand' med din mikrokontroller IC.

Hur man programmerar en MCU för att tända en LED

När detta har bekräftats fortsätter vi med att skapa en liten 'ingenting' -kod, bara för att säkerställa att proceduren för kodöverföring inte stöter på fel.

Naturligtvis är vi nu redo att implementera vårt första program inuti MCU, men innan det skulle det vara intressant att snabbt sammanfatta vad vi gjorde under våra tidigare tutorials:

Vi anskaffade AVR Atmel-mikrokontrollern enligt den önskade specifikationen här, vi har använt ATMega32 för illustrationerna. Därefter lärde vi oss grunderna för mikrokontroller och programmeringsenheten som ansvarar för att överföra ett program till MCU-chipet.

Vidare byggde vi SP-gränssnittsanslutningen, vilket är viktigt så att din dator kan kopplas till mikrokontrollern för programmeringsåtgärderna.

Efter detta bekräftade vi om drivrutinerna installerades korrekt i datorn för ett 32-bitars samt ett 64-men operativsystem.

Därefter installerade vi programmeringsmiljön som heter Win AVR för att underlätta enkel överföring av koder till mikrokontrollern, följt av implementeringen av avrdude för att verifiera programmeraren med din dator och mikroprocessorn sammankopplad.

Slutligen i föregående kapitel slutade vi bygga LED / motståndskretsen och ansluta den till relevanta MCU-utgångar.

Det är mycket arbete, det är ändå dags att gå direkt in i några riktiga programmeringssaker!

Till att börja med vill vi dela upp mikrokontrollern i tre kategorier, vilket skulle förenkla vår förståelse mycket:

Kontroll, upptäckt och kommunikation

Det skulle vara intressant att veta att ovanstående funktioner kan programmeras på många olika sätt.

I vårt första program skulle vi försöka beställa mikrokontrollern att 'styra' en extern parameter, ja du har rätt det skulle vara den LED som vi byggde nyligen.

För att vara exakt, säger vi till MCU att sätta på den anslutna lysdioden, ja jag vet att det här ser ganska primitivt ut, men startfasen måste alltid vara enkel.

Att gå vidare med det nuvarande jobbet och göra MCU-kontrollen till LED är faktiskt ganska enkelt:

För detta instruerar vi stift nr 0 på PORT B ​​att producera den nödvändiga 5V för LED.

Kom ihåg från föregående handledning, vi anslöt LED-anoden till den ovan nämnda stiftet på MCU.

Det finns två viktiga saker som krävs för att adresseras till denna stift av MCU: 1) utgång och 2) 5 volt

Vi lär oss ett sätt genom vilket vi instruerar den specifika stiftet att bli utgången för MCU.

När det väl har ställts ut som chipets utgång kan vi instruera det att vara antingen “högt” (5V) eller “lågt” (0V) enligt önskemål för en applikation.

Eftersom alla logiska kretsar, såsom en MCU, kan stiften vara en utgång eller en ingång och kan konfigureras för att producera antingen en logisk hög eller logisk låg, behöver stiften endast tilldelas antingen för att vara en logisk hög eller en logisk låg , det finns inte några mellanliggande eller odefinierade tillstånd förutom dessa par stater för mikrokontroller eller för någon digital IC för den delen. Detsamma gäller också för varje stift i MCU: n.

När det gäller ingångs- och utgångsstifttilldelningarna skulle ingångarna vara positionerade för att acceptera signaler från externa analoga steg, medan utgångarna skulle vara ansvariga för att tolka dessa till de angivna logiska tillstånden eller en frekvens.

Även om ovanstående uppdrag kunde göras på många olika sätt skulle vi diskutera en av dem för enkelhets skull. Det måste dock noteras att även om den som skulle presenteras just nu ser enkel och intressant ut, är den inte så livskraftig och inte en rekommenderad typ för alla MCU-applikationer, av samma anledning skulle du introduceras till mer populära programmeringsmetoder senare under kursen . Dessa program tillåter endast de önskade stiften att tilldelas enligt specifikationerna utan att påverka de andra angränsande som eventuellt redan kan tilldelas för att göra några andra funktioner.

Men just nu bryr vi oss inte så mycket om de andra stiften och skulle bara använda relevanta stift av intresse, för att undvika komplikationer i viss utsträckning.

För att tilldela en stift som en utgång måste vi använda Data Direction Register (DDR). Om du undrar vad registret här betyder är det helt enkelt ett mellanslag i MCU som gör det möjligt för mikrokontrollern att svara på något specificerat sätt.

Med DDR kan vi ställa in stiftet för att antingen skicka data som är som en 'utgång' eller acceptera data som är i form av en 'inmatning'.

Men du kan vara förvirrad när det gäller ordet, vad innebär detta? En data lägger till en tredje dimension till stiften som kan tilldelas kontinuerligt vid logisk noll (0V) eller logisk hög (5V), men vad sägs om signalerna som kan variera snabbt, såsom frekvensen av pulser. En frekvens skulle åtföljas av höga och låga logik (5V och 0V) oscillerande med vissa specificerade intervall eller perioder, så det blir tidsorienterat och kan justeras med avseende på tid, det är därför vi identifierar som 'data' vilket betyder en parameter som indikerar en funktion relativt en annan funktion (logiska tillstånd och tid).

En metod för att tilldela pin0 som en utgång är genom att skriva följande kod:

DDRB = 0b00000001

I ovanstående program betyder DDRB Data Direction Register för PORT B ​​0b instruerar kompilatorn angående följande binära uttryck av ett tal medan '1' i slutet av uttrycket indikerar positionen för pin0, det vill säga dess plats i formen av den första stiftet i PORT B.

Om du kommer ihåg lärde vi oss att PORT B ​​associerar 8 stift med den (från 0 till pin7), och om du märker att ovanstående kod också har 8 siffror i sig, vilket betyder att varje siffra betyder dessa 8 stift av PORT B.

Nu skulle nästa procedur vara att tilldela 5V till denna stift (pin0). Återigen är driftsprincipen identisk med DDR som ovan uttryckt genom följande binära kod:

PORTB = 0b00000001

Som framgår är den enda skillnaden mellan ovanstående kod och den tidigare att vi i denna kod har använt PORT-registret. Detta register hanterar specifikt stiftuppgifterna för den specifika porten för vilken den har placerats inuti MCU. På så sätt kan vi tilldela den verkliga datalogiken (0 eller 1) för dessa pinouts.

Nu kan vi vara intresserade av att diskutera några angående de ungefärliga detaljerna i vårt program. Som vi vet kräver alla program ett visst utrymme för att starta körningen, detta kan jämföras med en kock som känner till alla ingredienser angående ett visst recept men inte får instruktioner varifrån man ska börja.

'Huvud' -funktionen här är den plats där vart och ett av C / C ++ - programmen initierar körningen. Därför kan huvudet skapas som:

int main (ogiltigt)
{
}

Men för att programmet ska kunna tolka DDR- och PORT-registerdetaljerna och deras funktion inuti MCU-chipet måste ett ytterligare uttalande inkluderas som kan bestå av all data angående AVR MCU. Kanske skulle vi vilja lägga till denna inkludering i alla våra program.

#omfatta
int main (ogiltigt)
{
}

Så snart kompileringen startar fokuserar förprocessorsektionen i kompilatorn på AVR-katalogen för att identifiera filen “io.h”. Tillägget '.h' här indikerar att det är en rubrikfil, och att den här koden i filen skulle introduceras i början (huvudet) av källfilen som skapas, därav namnet 'rubrik'.

Här kan vi introducera DDR- och PORT-uttalandena i vår kod, eftersom tillägget av io.h-rubrikfilen skulle ha riktat kompilatorn angående dem.

#omfatta

int main (ogiltigt)

{

DDRB = 0b00000001 // Datariktningsregister ställer in pin0 till utgång och de återstående stiften som ingång

PORTB = 0b00000001 // Ställ pin0 till 5 volt

}

Ovanstående fixerar pin0-orienteringen som utgången, med en storlek på 5V. Det finns dock fortfarande ett problem som inte bestäms för denna stift, det vill säga att denna stift ännu inte ska instrueras att sättas PÅ på obestämd tid så länge som MCU-enheten är påslagen. Denna oändliga återkopplingsslinga skulle säkerställa att denna stift från MCU inte stängs av utan snarare fortsätter med 5V-utgången på obestämd tid.

Även om det finns många olika metoder för att tillämpa en loopinstruktion för en pin, skulle vi försöka använda 'while' -slingan här. Som namnet antyder säger 'while' -slingan mikrokontrollern att 'medan' strömmen är tillgänglig måste du vara aktiverad med den tilldelade 5V för den tilldelade pinout.

#omfatta

int main (ogiltigt)

{

DDRB = 0b00000001 // Datariktningsregister ställer in pin0 till utgång och de återstående stiften som ingång

PORTB = 0b00000001 // Ställ pin0 till 5 volt

medan (1)

{

// Kod skulle vara här om det behövde köras om och om igen ... oändligt

}

}

Du kanske vill notera att här har vi använt '1' i form av ett argument för 'while' -slingan, eftersom allt utom '0' kan betraktas som en logisk 'sant'.

Det antyder att 'while' -slingan aldrig skulle vara ansvarig för något annat än en logisk 'true', vilket innebär att den specifika stiftet skulle hänga fast med det angivna tillståndet på obestämd tid.

Lysdioden kan ses att den är PÅ över den tilldelade stiftet så länge som MCU fick ström över sin Vdd och Vss.

Det är det, nu har vi det resultat som vi önskade att få och äntligen kan se det hända efter så mycket hårt arbete, men ändå att se det söta resultatet av vårt hårda arbete är så tillfredsställande.

Under nästa handledning lär vi oss hur man lägger till en 'tids' -dimension i ovanstående lysdiod, det är hur man får den att blinka med viss specificerad hastighet.

Egentligen blinkar lysdioden faktiskt i ovanstående implementering men slingfrekvensen är så snabb att det nästan är som en permanent strömbrytare PÅ över LED-belysningen.

Vi får se hur den här slingan kan läggas till med en fördröjning enligt önskemål för att lysdioden ska blinka med den fördröjda hastigheten.

Hur man gör en LED-blinkning med hjälp av AVR-mikrokontroller

I den senaste diskussionen lärde vi oss hur man gör en LED-strömbrytare PÅ via en mikrokontroller, det var enastående, eller hur? Kan inte vara så mycket!

Här lär vi oss att krydda ovanstående LED-belysning genom att tillskriva en dubbelriktad funktionalitet, det vill säga vi ska försöka få den att blinka eller blinka med en viss frekvens eller frekvens. Vi ser också hur den här hastigheten kan höjas eller sänkas efter önskemål av användaren.

Låt oss ta en titt på detta:

#omfatta

#omfatta

int main (ogiltigt)

{

DDRB | = 1<< PINB0

medan (1)

{

PORTB ^ = 1<< PINB0

_fördröja_ms (100)

}

}

Om du känner dig förvirrad av de konstiga symbolerna (&, ^, | etc) som används i ovanstående uttryck (& ​​finns inte där men kan användas i andra liknande koder), här är den relaterade informationen som du skulle vara intresserad av att veta om dessa :

Den innehåller många standardlogiska algoritmer som AND, OR, NOT och XOR som vanligtvis används med ovanstående kod.

Dessa logiska funktioner jämför specifikt de två bitarna '1' och '0' enligt deras tilldelade sanningstabeller.

Vi får en idé genom att analysera följande bitarrangemang:

01001011 &
10001101
är lika med
00001001

I ovanstående kod hänvisas till OCH som används vid C-programmering.

Att läsa raderna vertikalt antyder att 0 och 1 är lika med 0, 1 och 0 också är lika med 0, 0 och 0 är lika med 0, 1 och 1 är lika med 1. Att läsa det är så enkelt som det. Dessa är enligt sanningstabellen för en AND-operatör.

Om vi ​​bedömer följande tabell indikerar den symbolen '|' betecknar användningen av 'ELLER' -funktionalitet, '|' kan hittas till vänster om 'bakre utrymme' på datorns tangentbord:

01001011 |
10001101
är lika med
11001111

Denna sanningstabell för en ELLER-logikfunktion indikerar att bitar 0 eller 1 är lika med 1, 1 eller 0 också lika med 1, 0 eller 0 är lika med 0, medan 1 eller 1 är lika med 1.

Följande bitkombination är för XOR-logikoperatör betecknad med ^ och kan studeras precis som vi gjorde med AND-, ELLER sanningstabellerna:

01001011 ^
10001101
är lika med
11000110

Låt oss nu fortsätta med det första programmet och lära oss vad följande rad i det betyder:

#omfatta

Genom våra tidigare handledning vet vi hur uttrycket fungerar, så vi kommer inte att upprepa det men deras verkar vara ett nytt 'inkludera' uttryckt av #include som måste undersökas.

I det här 'inkludera' tillåter fördröjningen oss några enkla metoder för implementering.

Som namnet antyder gör fördröjningen oss möjliga att fördröja det specifika programmet.

Nästa uttryck int main (void) kan utelämnas från den pågående diskussionen eftersom vi redan har täckt detta i våra tidigare inlägg.

Därefter kommer den förändrade DDRB.

Följande visar den tidigare formen som inte är ett bättre sätt att tilldela stiften eftersom alla stiften från 0 till 7 byttes för att bilda ingångarna. Men tänk dig hur skulle det vara om vi ville skapa ett längre program som kräver dessa stift för någon annan funktion? Till exempel kan pin2 behövas för att tillämpa en fjärrväxling av en apparat. I så fall skulle vi inte uppskatta att tilldela samma som en inmatning bara genom försök och fel. Det kan innebära felaktigt svar från fjärrsändaren till apparatens mottagare.

DDRB = 0b00000001

Vi vill hellre påverka bara en bit, hat pin0 bit, titta på “ELLER” -funktionaliteten, detta kan utföras genom en binär maskering.

DDRB = DDRB | 0b00000001

Här är den dold med en 'ELLER' -mask: 0b00000001, även om det verkar vara ett autentiskt binärt nummer, om den tidigare DDRB till exempel: 0b01001010, då att tillämpa en ELLER på detta genom maskering kan ge: 0b01001010 | 0b00000001 = 0b01001011.

Den resulterande skillnaden som man kunde bevittna är endast med pin0, vars bitar har förändrats!

Att komprimera ovanstående uttalande ytterligare via C ++ ger:

DDRB | = 0b00000001

Vi finner dock att det finns ännu mer i det givna programmet. Även om det kan se ganska legitimt och uppenbart ut, borde vi dra nytta av några av uttalandena från io.h-rubrikfilen, särskilt när den i grunden skapas för vår bekvämlighet?

Så om “DDRB | = 1<< PINBO, why it’s like that?

1<< PINBO is implemented for applying the masking effect. The “1” indicates what may be introduced inside the mask, while the < < is simply the left shift functionality. It executes exactly as it’s named, and PINBO is the number of locations that the “1” would sequence across the left hand side. To be precise PINBO may be equivalent of a 0.

Så vi börjar med en 0b00000000 och sätter en '1' för att producera 0b0000001 och sedan överför vi den till vänster 0-positioner, vilket ger en exakt identisk 0b00000001 som ovan.

Om vi ​​antar att det var PINB4 kan uttalandet nu uttryckas som 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Observera att vi använder ett nollindex vilket innebär att det finns fyra nollor efter '1'.

Fortsätter nu till 'while' -slingan som vi noterade över 'oändliga slingan' tidigare. Men kanske nu vill vi att mikrokontrollern ska implementera några av de önskade körningarna. Detta kan bara vara möjligt inom den givna slingan. Det är slingan där den specifika sekvensen upprepas om och om igen.

Om körningen skulle placeras före slingan, skulle den ha genomförts bara en gång.

För att lysdioden ska blinka på obestämd tid krävs dock att PINB0 växlar PÅ / AV växelvis inom slingan. Här hittar vi också de förseningar som införs, utan vilka det skulle vara omöjligt att blinka på lysdioden. Men detta skulle tvinga LED-lampan att blinka i en mycket snabb takt som är svår att känna igen med blotta ögat, den skulle behöva sakta ner lite för att bli identifierbar med våra ögon.

Vi är medvetna om inställningsproceduren för en viss bit i det binära numret, men vi är inte säkra på metoden för att tillämpa en specifik bit '0' om det är '1' än.

Följande program kan ses göra detta men vi kommer också att upptäcka att det kanske inte syns i programmet.

De första två påståendena ändrar biten till “1” (5V, LED-lampor), sedan introduceras en paus i 100 ms.

Nästa par rader förvandlar PINB0-biten till '0' (nollspänning, lysdiod avstängd), men tyvärr kommer OCH-jämförelsen inte att kunna utföra ett '0' från biten, men om vi INTE använder '~' för den binära masken kunde den växla alla 0-tal till 1-tal och tvärtom.

Detta gör att vi endast kan påverka PINB0-biten och vända den till “0”. Parentesen inkluderades för att innehålla maskeringskörningen så att NOT-operationen kunde tillämpas för hela maskerna och inte bara över '1' före vänsterskiftet '<<”.

PORTB | = 1<< PINB0
_fördröja_ms (100)
PORTB & = ~ (1<< PINB0)
_fördröja_ms (100)

För att skapa PÅ AV-förseningar eller perioder av lika varaktighet kan vi korta ned de fyra föregående raderna till två och tillämpa XOR-funktionalitet till vår fördel. Det måste noteras att en XOR utför en tilldelad stift till en 1 om den är 0 och vice versa. Detta utförande skulle bara påverka PINB0. Som ofta kan kommandot tillämpas, skulle det helt enkelt förvandla biten till motsatsen till den befintliga logiken.

PORTB ^ = 1<< PINB0
_fördröja_ms (100)

GJORT! Din lysdiod skulle blinka nu enligt den inställda hastigheten ... Enkelt, eller hur?