Grunnleggende om mikrokontroller utforsket

En ting er flott med mikrokontroller-IC-er, disse er tilgjengelige nesten i alle deler av verden og elektroniske forhandlere.

Introduksjon

Fundamentalt brukes mikrocontroller-enheter populært i applikasjoner som involverer vurderinger av omgivelsene og i lignende elektronikk.

Du kan finne at disse enhetene brukes til å vise en bestemt parameter, i motorstyringsapplikasjoner, LED-belysning, sensorer av forskjellige typer som vippesensor, akselerometer, hastighetsmåler, dataloggere, temperaturregulatorer, tastaturer etc.

Den primære forståelsen av mikrokontrollere kan oppnås ved å referere til AVR Amega32 mikrokontroller som er så avansert at det noen ganger kalles en datamaskin i en chip.

Denne enheten er tildelt til å utføre en rekke kommandoer for å danne et program.

Språket i programmet du ser her er C ++. Du får lære dette språket i større dybder i løpet av kurset her.

Når det gjelder MCUer, får du muligheten til å ha muligheten til å kontrollere og konfigurere alle pinouts.

Hvis du blir litt sliten av dette, bare chill fordi det ikke er noe komplisert i det hele tatt, vil du bli lettet gjennom alle aspektene jevnt og trutt når vi går videre.

I en MCU-brikke kan alle pinner unntatt Vdd og Vss, som er pinnene til brikken, tildeles med eksklusive betegnelser.

Pinout-detaljer

Hvis du ser på brikken fra toppen, vil du finne et lite trekantet hakk som indikerer startpunktet der pinoutene begynner, det teller, det er nummer 1-pinnen på brikken begynner like under dette hakket.

Fra denne pinnen vil du finne 20 pinner opp til bunnen på den siden (venstre), og ytterligere 20 pinner på den andre siden (høyre), fortsetter fra bunnen til toppen på høyre side.

De første 8 pinnene som starter fra hakket er PBO-7 som danner indekspinnene til IC siden alt programmet her begynner med indeksen null.

Ovenstående serie pinouts kalles PORT B, mens det er andre identiske sett med porter tilordnet A til D.

Disse portene kan tildeles for å akseptere og gjenkjenne matede data kalt INPUT, og også for å overføre data i en spesifisert form kalt OUTPUT.

To av pinnene som kommer i den generelle kategorien er (+) / (-) pinnene som også blir referert til som Vdd og GND.

En pinne fra PORT D (PDO-6) kan sees på venstre side av brikken i bunnområdet.

PD7, som er pinne nr. 7 i PORT D, kan spores stående alene og begynner på høyre side av pinouts.

Nå som vi går videre fra høyre side av brikken der PORT D slutter, begynner PORT C tellingen oppover i rekkefølgen.

Disse bidrar til de mange interessante pinnene til MCU, rett fra analoge til digitale.

Disse pinnene er omtalt for å bli sensingangene for å oppdage de mange parametrene gjennom eksternt konfigurerte analoge kretstrinn.

Ovennevnte pinner utgjør PORT A.

Den analoge til digitale konvertering over de ovennevnte pinnene kan forstås ved hjelp av et eksempel der et analogt temperaturnivå oppdaget ved bruk av en vanlig sensor, slik som en termister, påføres en av PORT A-pinnene som lett aksepteres og omformes av MCU. å produsere en digital avlesning fra null til 255 grader F (en 8-biters figur som kan oppgraderes for å oppnå en 10-biters utgang).

En annen funksjon som kan sees i MCUer i tillegg er det tilgjengelige programmeringsområdet eller minnet som bestemmer plassen for variablene og programmet som er spesifisert for mikrokontrolleren.

Videre til dette har MCUene en innebygd klokke tildelt for å telle de relevante parametrene.

Klokkefunksjonene gjør det mulig for MCU å anvende seg for mange forskjellige telleprosesser som kan være raske innen mikrosekunder, avhengig av spesifikasjonen til den spesielle enheten, og som også kan være langsommere i ønsket omfang.

Nå har du kanskje forstått mikrokontrollerkonseptet til en viss grad og angående porter og pinner.

Hvordan lage en SPI-kontakt fra programmereren til mikrokontrolleren

Nå er det på tide å gå litt dypere inn i emnet og undersøke programmeringsverdenen.

Når det er sagt, må vi finne en riktig måte å integrere SPI-kontakten (Serial Peripheral Interface) med MCU før vi hengir oss til en programinnlastingsprosedyre i brikken.

Men selv etter dette kan vi ikke bare skyve SPI inn i MCU pinouts, kan vi? Vi kan heller ikke la de utvidede ledningene fra SPI komme direkte inn i brødbrettet. Dette kan også føre til at feil ledningsinnstilling er koblet til at feil pinner gir dårlige forbindelser.

Derfor, for å gjøre ting helt upåklagelig, gjør vi prosedyrene over et lite veroboard hvor vi får de nødvendige tilkoblingsmetallpinnene, også kalt 'header' loddet. Disse topptekstene kan nå brukes til å koble til SPI-kontakten. Forbindelsene fra denne overskriften kan bli avsluttet til en annen parallell topptekst som kan brukes til brødplateforbindelsene.

Dermed danner ovennevnte montering nå en tettsittende og pålitelig mellomforbindelsesplattform for SPI til MCU.

Opptil nå ser alt bra ut og perfekt, så la oss fortsette å tjene på programmereren som kreves mellom PC-en din og MCU.

Det kan være en rekke selskaper som lager og selger disse programmeringsenhetene, så å skaffe disse bør ikke være et problem for deg, for eksempel Adafruit Industries, USBtinyISP eller Sparkfun etc.

Noen av disse kan se helt annerledes ut enn de konvensjonelle typene, men har i utgangspunktet alt identisk og følger standard programmeringsregler og kan brukes som et grensesnitt mellom PC-en og AVR-mikrokontrolleren.

Men vær sikker på at du tenker, hvis du bruker en annen MCU og ikke en AVR Atmega32, må du kanskje se etter en tilsvarende kompatibel programmerer for den aktuelle MCU-brikken.

Det kan bemerkes at ganske mange av disse programmererne bruker identiske drivere, noe som må tas vare på, og vi vil lære mer om det i de påfølgende kapitlene.

Det er virkelig grunnleggende å koble PC-en din til mikrokontrollerbrikken, og du vil gjerne vite hvor enkel prosessen er nødvendig for dette. Så la oss trykke på knappen med en gangJ

Å lage det ovennevnte forklarte SPI-grensesnittkortet er ikke vanskelig, det handler om å få loddejernet til å fungere gjennom alle tilkoblingene over de viste to toppradene på pinner på et lite generelt bord.

Figuren over viser tilkoblingsdetaljene du må følge når du kobler sammen ledningene mellom topptekstene.

For å gjøre ting enda enklere, la oss gå gjennom følgende tilkoblingsdetaljer for det samme ved å referere til bildet ovenfor:

SPI-pinne starter fra øverst til venstre til 'Master IN, Slave OUT' (MISO)

SPI-pinne fra midten til venstre kobles til klokkepinnen (SCK)

SPI-pin nederst til venstre blir med Reset. (Vi lærer utførlig om denne pinnen i de følgende veiledningene)

SPI relevant nederst til høyre kobles til GND-pinnen på MCU, refererer GND til pinnen som danner nullforsyningslinjen eller den negative (relative) skinnen på forsyningen.

SPI som avsluttes fra midtre høyre header kobles sammen med 'Master Out, Slave IN' (MOSI) -pinnen på MCU.

SPI som kommer ut av toppteksten til høyre er koblet til (+) på MCU, som ganske åpenbart er Vdd eller den positive forsyningspinnen til MCU.

Det er det.

Koble til de to kontaktene som forklart, og SPI-grensesnittkortet er klart for de nødvendige handlingene.

For ytterligere hjelp kan du se figuren som er vist ovenfor, det endelige grensesnittkortet skal se slik ut etter at alle ledningstilkoblingene er riktig utført ved hjelp av diskusjonen ovenfor.

Jeg håper du kanskje allerede har konstruert SPI-grensesnittet som forklart i forrige opplæring, og nå er det på tide å sikre at datamaskinen vår godtar programmereren som vi trenger å integrere mellom PC-en og MCU-en.

Lage en enkel programmeringskode for en MCU

Vi tar en USBTinyISP-enhet tilgjengelig fra Sparkfun, for å koble datamaskinen til mikrokontrolleren.

Vi vet at ethvert datamaskinoperativsystem som Windows vil kreve drivere uten hvilke det ville være ubrukelig å laste noe inn i datamaskinen, og derfor vil programmereren vår trenge drivere for å laste inn i datamaskinen din.

La oss se på prosedyrene som kreves for å installere driverne i datamaskinens operativsystem, her tar vi eksemplet på Windows 7 OS med enten 32-biters eller 64-biters spesifikasjoner.

Åpne sparkfun.com og klikk på “pocket AVR programmerer side”. Koblingen kan lett visualiseres på siden.

Deretter finner du 'Windows-driver' under dokumenter og bare klikker på den.

Dette vil gi deg pocketprog-driver.zip-filen på datamaskinen din.

Gå til datamaskinen din, finn nedlastingsplasseringen og bare pakke den nedlastede filen ut i en mappe.

Hvis datamaskinen din er et 64-biters operativsystem, må du følge noen flere trinn som gitt under, med et 32-biters operativsystem, kan du starte installasjonen direkte fra den utpakkede filen.

For en 64-bit følg disse, for 32-bit bare ignorere:

Google “libusb sourceforge” og klikk på denne lenken siste versjon.

Du vil komme over noen flere filer, men du vil være interessert i å finne bib-filen, det vil si: libusb-win32-bin - #. #. #. #. Zip

Gå nå og finn denne nedlastingsplasseringen på datamaskinen din, pakk den ut og lagre den i en av mappene.

Gå inn i denne mappen, fortsett til amd64-mappen.

Du vil se et par mapper her som: ghcalled libusb0.dll og libusb0.sys.

Du vil endre navn på disse som: libusb0_x64.dll og libusb0_x64.sys.

Nå må du kopiere de ovennevnte filene til pocketprog-driver-mappen, bare skriv filene på den eksisterende versjonen.

For å installere driverne ovenfor, vil følgende metode som er ganske ikke-konvensjonell i sin type interessere deg:

Det er en modus for 'legg til eldre maskinvare'.

Klikk på “Start-menyen”

Fortsett deretter ved å høyreklikke på “datamaskin”

Klikk på 'Administrer', og til slutt klikk på 'Enhetsbehandling'

Deretter velger du “Legg til eldre maskinvare” inne i menyen.

Fortsett med å trykke 'neste', til veiviseren blir satt inn

Følg instruksjonene, og klikk på “Installer maskinvaren som du trenger å velge fra en avansert liste”. Dette vil be radioknappikonet til det aktuelle valget. Det er faktisk en Windows-kontrollknapp som nå ser ut som en liten sirkel med en rundblå arkivering inne.

Nå er det bare å klikke 'Neste'

Dette viser deg 'Vis alle enheter' -menyen som du trenger å klikke på.

Etter dette, fortsett med å klikke på 'Har disk' -ikonet.

Ved hjelp av 'Bla gjennom' -ikonet, fortsett til plasseringen av pocketprog-driver-mappen. Hvis valget ble gjort riktig av deg, vil du visualisere pocketprog.inf-filen som er plassert i den aktuelle mappen.

Dobbeltklikk over denne filen, og du vil absolutt være vitne til at driveren blir installert på PCen.

Over og ut!! La oss fortsette med vår neste veiledning på neste side.

Nå har du kanskje installert den nødvendige programvaren og bygget SPI-grensesnittet.

Hvordan overføre et program til en mikrocontrollerbrikke

Det neste trinnet vil kreve noen få komponenter som et brødbrett, en LED og en beregnet motstand for den tiltenkte applikasjonen.

I denne delen lærer vi testmetoden til programmereren og bekrefter installasjonen av de aktuelle driverne og programvaren.

For å verifisere om driverne og programvaren ble installert riktig, implementerer vi et enkelt program kjent som avrdude.

AVRdude er et program som er tilknyttet den siste WinAVR-installasjonen, uten hvilken den faktiske overføringen av filen til MCU ikke kan være mulig.

Dette programmet er et .hex-filformat som i det vesentlige blir forståelig for MCU for de nødvendige henrettelsene.

Hvis bekreftelsen ikke lykkes, vil programmereren ikke være i stand til å overføre filen.

La oss raskt se hvordan vi kan implementere testprosedyren ved hjelp av følgende instruksjoner:

Åpne DOS (Disk operativsystem) ledetekst ved å klikke “startmeny” og skrive cmd.exe i det gitte søkefeltet.

Nå kan du utføre AVRdude ved å bare skrive avrdude –c usbtiny –p m32 over DOS-ledeteksten. Så snart dette er implementert, vil DOS umiddelbart erkjenne om forbindelsen var en suksess.

I kommandoen ovenfor er “-c” et varslingsflagg som inkluderer “usbtiny” -programmerspesifikasjon, mens “-p” -koden identifiserer mikrokontrollerenheten (“m32 som indikerer Atmega32).

Hvis du har brukt en annen MCU, må du inkludere de relevante prefikset for implementeringen.

Når prosedyren ovenfor er ferdig, kan du skrive 'exit' over DOS-ledeteksten, og det vil føre deg ut av vinduet.

Hvis du seriøst lurer på de faktiske programmeringsdetaljene, vel for det, må vi først lodde og konstruere den eksterne analoge LED-kretsen som programmet kan implementeres over, for med mindre det er et system for å anerkjenne svaret fra MCU, programmeringen og kjøring av mikrokontrolleren ville være ganske meningsløst.

Å lage LED-kortet er veldig enkelt, det handler om å lodde de to ledningene på LED-en over et stykke veroboard og koble motstanden til en av ledningen på LED-en. Rollen til denne lysdioden er bare å begrense strømmen til lysdioden slik at den ikke brenner seg på grunn av overflødig spenningsannonsestrøm fra MCU-utgangen.

Motstandens verdi kan beregnes ved hjelp av følgende enkle formel:

R = (Ub - LEDfwd) / I

Der Ub er forsyningsspenningen, er LEDfwd den optimale driftsspenningen til LED-en som brukes, og jeg er dens optimale forsterkere.

Anta at vi bruker en RØD LED som har en LED fremover spenning = 2,5V og strøm I = 20mA, ligningen ovenfor kan løses som følger:

Siden spenningen fra MCU ville være 5V, kan den uttrykkes som:

R = (5 - 2,5) /. 02 = 125 ohm, ¼ watt, den nærmeste verdien er 120 ohm.

Nå har vi LED, en 120 ohm motstand og en veroboard, bare koble sammen de ovennevnte komponentene som gitt i diagrammet med mikrokontrolleren.

Når dette er gjort, kan MCU programmeres for den tiltenkte responsen på ovenstående LED-oppsett.

Neste gang, programmeringen av MCU.

For å tillate mikrokontrolleren å utføre noen meningsfulle implementeringer, er det viktig å skrive passende instruksjoner i MCU.

Hvordan installere et programmeringsmiljø og undersøke WinAVR

For dette kan vi sannsynligvis bruke vår helt egen “teksteditor” på PC-en vår, selv om noen av oss vil sette pris på bruken av et mer profesjonelt “programmeringsmiljø” i stedet for en vanlig tekstredigerer, enkelt fordi denne tilnærmingen vil tillate deg å glede deg over noe innebygde interessante funksjoner i denne 'programmeringsmiljøet' -pakken.

Det vil støtte opprettelse og redigering av programmer gjennom forskjellige språk, og også kompilere dem i en leveringsmodus som er lett forståelig og akseptert av en mikrokontrollerbrikke.

Til slutt vil dette bli støttet av WinAVR og overført til den aktuelle MCU-brikken.

WinAVR kan også være utstyrt for å utføre mange andre operasjoner, for eksempel feilsøking av programmene og advare oss om mulig syntaks og kompilering av feil og feil. Vi diskuterer disse våre senere veiledninger.

Du vil ha installasjonskurset til WinAVR for å være ekstremt raskt og snappy. La oss dykke ned i detaljene med følgende punkter:

Du må laste ned de nyeste versjonene fra mappen WinAVR source forge files. Du vil komme over nyttig informasjon relatert til denne nedlastingen fra den offisielle nettsiden.

Du vil bli bedt om et sikkerhetsspørsmål, slik at du kan svare hvis du vil at nedlastingen skal finne sted. Dette blir spurt om filen som skal lastes ned er en kjørbar fil.

Last ned filen og start kjøringsprosessen ved å klikke på den. La installasjonen begynne.

Prosessen vil veilede deg med noen svarbare spørsmål, slik at du kanskje kan strømlinjeforme installasjonen i henhold til din komfort. Du vil ignorere mange av disse til standardskjemaene. Det er alt opp til deg å velge de som du synes er best egnet for handlingene.

Inntil nå vil du finne alt ganske normalt og lett å gå, og finne noen få alternativer jeg startmenyen blir kastet på deg. Ingen bekymringer, bare noen av disse bruker faktisk bare en av temene som heter “programmers notepad”.

Når du har klikket på dette ikonet, vil du starte brukergrensesnittet slik at du kanskje kan bruke skrivingen av programmene (for eksempel å lage og redigere). Du vil også være vitne til programmet som består av menykommandoer for å hjelpe deg med å kompilere kodene og legge dem inn i mikrokontrolleren.

Den grunnleggende jobben til den ovennevnte programmeringsnotisblokken er å transformere en menneskelig lesbar kode som du vil skrive til en serie instruksjoner som bare er forståelige for MCU.

Den neste opplæringen vil dekke testingen av ovennevnte programmerer, slik at vi kan være sikre på kompatibiliteten med Windows og om den perfekt 'håndhilser' med mikrokontrolleren din.

Hvordan programmere en MCU for å slå på en LED

Når dette er bekreftet, fortsetter vi med å lage en liten 'gjør ingenting' -kode, bare for å sikre at prosedyren for kodeoverføring ikke støter på feil.

Selvfølgelig er vi nå klare til å implementere vårt første program inne i MCU, men før det ville det være interessant å oppsummere raskt hva vi gjorde i løpet av våre tidligere veiledninger:

Vi anskaffet AVR Atmel-mikrokontrolleren i henhold til den nødvendige spesifikasjonen her, vi har brukt ATMega32 til illustrasjonene. Deretter lærte vi om det grunnleggende om mikrokontroller og programmeringsenheten som er ansvarlig for å overføre et program til MCU-brikken.

Videre bygde vi SP-grensesnittkontakten som er viktig, slik at datamaskinen din kan kobles til mikrokontrolleren for programmeringshandlingene.

Etter dette bekreftet vi om driverne ble installert riktig i datamaskinen for et 32-bit så vel som et 64-men operativsystem.

Deretter installerte vi programmeringsmiljøet kalt Win AVR for å legge til rette for enkel skrivingoverføring av kodene til mikrokontrolleren, etterfulgt av implementeringen av avrdude for å verifisere programmereren med PC-en din og mikrokontrolleren sammenkoblet.

Til slutt i forrige kapittel ferdigbygget vi LED / motstandskretsen og koblet den til de relevante MCU-utgangene.

Det er mye arbeid, men det er på tide å gå med en gang i noen virkelige programmerings ting!

Til å begynne med vil vi dele mikrokontrolleren i tre kategorier, dette vil forenkle vår forståelse mye:

Kontroll, oppdagelse og kommunikasjon

Det ville være interessant å vite at funksjonene ovenfor kan programmeres på mange forskjellige måter.

I vårt første program ville vi prøve å beordre mikrokontrolleren til å 'kontrollere' en ekstern parameter, ja du har rett, det ville være LED-en som vi nylig bygde.

For å være presis, vil vi be MCU om å slå PÅ den tilkoblede LED-en, ja jeg vet at dette ser ganske primitivt ut, men startfasen må alltid være enkel.

Å gå videre med den nåværende jobben, og få MCU til å styre LED er faktisk ganske enkelt:

For dette instruerer vi pin # 0 på PORT B ​​om å produsere den nødvendige 5V for LED.

Husk fra forrige opplæring, vi koblet anoden til LED-en til den ovennevnte stiften til MCU.

Det er to viktige ting som må adresseres til denne stiften på MCU: 1) utgang og 2) 5 volt

Vi lærer en måte vi kan instruere den spesifikke pinnen til å bli utdata fra MCU.

Når den er satt til å være utgangen fra brikken, kan vi be den om å være “høy” (5V) eller “lav” (0V) etter ønske for en applikasjon.

Siden hvilken som helst logikkrets som MCU, kan pinnene visne en utgang eller en inngang og kunne konfigureres til å produsere enten en logisk høy eller logisk lav, trenger pinnene bare å tildeles enten for å være en logisk høy eller en logisk lav. , det er ikke noen mellomliggende eller udefinerte stater annet enn disse par statene for mikrokontrollere eller for noen digital IC for den saks skyld. Det samme gjelder også for hver pin i MCU.

Når det gjelder inngangs- og utgangstildelingene, vil inngangene være posisjonert for å akseptere signaler fra eksterne analoge trinn, mens utgangene vil være ansvarlige for å tolke disse til de angitte logiske tilstandene, eller en frekvens.

Selv om oppgavene ovenfor kunne gjøres på mange forskjellige måter, ville vi diskutere en av dem for enkelhets skyld. Imidlertid må det bemerkes at selv om den som presenteres akkurat nå ser enkel og interessant ut, er den ikke så levedyktig og ikke en anbefalt type for alle MCU-applikasjoner, av samme grunn vil du bli introdusert for mer populære programmeringsmetoder senere i løpet av kurset. . Disse programmene tillater at bare de ønskede pinnene tildeles i henhold til spesifikasjonene uten å påvirke de andre tilstøtende som muligens allerede er tilordnet for å utføre noen andre funksjoner.

Men akkurat nå vil vi ikke bry oss om de andre pinnene så mye og vil bare bruke de relevante pinnene av interesse, og i noen grad unngå komplikasjoner.

For å tilordne en pin som en utgang, må vi bruke Data Direction Register (DDR). Hvis du lurer på hva register her betyr, er det ganske enkelt et mellomrom i MCU som gjør det mulig for mikrokontrolleren å svare på en spesifikk måte.

Ved hjelp av DDR kan vi stille inn pinnen til å enten sende data som er som en 'output', eller godta data som er i form av en 'input'.

Men du kan være forvirret når det gjelder ordet, hva innebærer dette? En data tilfører en tredje dimensjon til pinnene som kan tildeles kontinuerlig ved logisk null (0V) eller logisk høy (5V), men hva med signalene som kan variere raskt, for eksempel frekvensen av pulser. En frekvens vil være ledsaget av høy og lav logikk (5V og 0V) som pendler med noen spesifiserte intervaller eller perioder, og dermed blir den tidsorientert og kan justeres med hensyn til tid, det er derfor vi identifiserer som 'data' som betyr en parameter som indikerer en funksjon i forhold til en annen funksjon (logiske tilstander og tid).

En metode for å tildele pin0 som utgang er å skrive følgende kode:

DDRB = 0b00000001

I det ovennevnte programmet, betyr DDRB Data Direction Register for PORT B ​​0b instruerer kompilatoren angående følgende binære uttrykk for et tall mens '1' på slutten av uttrykket indikerer posisjonen til pin0, det vil si plasseringen i skjemaet av den første pinnen i PORT B.

Hvis du husker, lærte vi at PORT B ​​knytter 8 pinner til den (fra 0 til pin7), og hvis du merker at ovennevnte kode også har 8 sifre i seg, noe som betyr at hvert siffer betyr disse 8 pinnene i PORT B.

Nå vil neste prosedyre være å tilordne 5V til denne pinnen (pin0). Igjen er driftsprinsippet identisk med DDR som ovenfor uttrykt gjennom følgende binære kode:

PORTB = 0b00000001

Som det kan sees, er den eneste forskjellen mellom ovennevnte og den tidligere at i denne koden har vi brukt PORT-registeret. Dette registeret håndterer spesifikt pin-tildelingen til den aktuelle porten som den er plassert for inne i MCU. Dermed gjør det oss i stand til å tilordne den virkelige datalogikken (0 eller 1) for disse pinouts.

Nå kan vi være interessert i å diskutere noen om de omtrentlige detaljene i programmet vårt. Som vi vet at alle programmer krever en spesiell plass for å starte utførelsen, kan dette sammenlignes med en kokk som kjenner alle ingrediensene angående en bestemt oppskrift, men ikke blir instruert fra hvor du skal begynne.

Den “viktigste” funksjonen her er stedet der hvert av C / C ++ programmene starter utførelsen. Derfor kan det viktigste opprettes som:

int main (ugyldig)
{
}

For å gjøre det mulig for programmet å tolke DDR- og PORT-registerdetaljene og deres funksjon inne i MCU-brikken, må det imidlertid inkluderes en ekstra uttalelse som kan bestå av alle data angående AVR MCU. Kanskje vi vil legge til denne inkluderingen i alle programmene våre.

#inkludere
int main (ugyldig)
{
}

Så snart kompileringen starter, fokuserer forprosessor-delen av kompilatoren på AVR-katalogen for å identifisere “io.h” -filen. Utvidelsen '.h' her indikerer at den er en headerfil, og at denne koden i filen ville bli introdusert i begynnelsen (hodet) av kildefilen som blir opprettet, derav navnet 'header'.

Her på kan vi introdusere DDR- og PORT-setningene i koden vår, fordi tillegg av io.h-headerfilen ville ha ledet kompilatoren angående dem.

#inkludere

int main (ugyldig)

{

DDRB = 0b00000001 // Data Direction Register innstilling pin0 til utgang og de resterende pinnene som inngang

PORTB = 0b00000001 // Still pin0 til 5 volt

}

Ovenstående fikser retningen til pin0 som utgangen, med en styrke på 5V. Imidlertid er det fremdeles ett problem som ikke er bestemt for denne pinnen, det vil si at denne pinnen ennå ikke skal instrueres om å bli slått PÅ på ubestemt tid så lenge MCU er slått på. Denne uendelige tilbakemeldingssløyfen vil sikre at denne pinnen fra MCU ikke slås AV, men fortsetter med 5V-utgangen på ubestemt tid.

Selv om det er mange forskjellige metoder for å bruke en loopinstruksjon for en pin, vil vi prøve å bruke 'while' -sløyfen her. Som navnet antyder, forteller 'while' -sløyfen mikrokontrolleren at 'mens' strømmen er tilgjengelig, må du være aktivert med den tildelte 5V for den tildelte pinouten.

#inkludere

int main (ugyldig)

{

DDRB = 0b00000001 // Data Direction Register innstilling pin0 til utgang og de resterende pinnene som inngang

PORTB = 0b00000001 // Still pin0 til 5 volt

mens (1)

{

// Kode ville være her hvis det trengte å utføre om og om og om igjen ... uendelig

}

}

Det kan være lurt å merke seg at her har vi brukt '1' i form av et argument for 'while' -sløyfen, siden alt bortsett fra '0' kan betraktes som en logisk 'sann'.

Det antyder at 'while' loop-betraktningen aldri vil være ansvarlig for noe annet enn en logisk 'true', noe som betyr at den spesifikke pinnen vil henges fast med den angitte tilstanden på ubestemt tid.

LED-en kan være vitne til å være PÅ over den tildelte pinnen permanent så lenge MCU mottok strøm over Vdd og Vss.

Det er det, nå har vi resultatet som vi ønsket å få, og til slutt kan vi se det skje etter så mye hardt arbeid, men likevel å se det søte resultatet av vårt harde arbeid er så tilfredsstillende.

I løpet av de neste veiledningene lærer vi hvordan du legger til en 'tids' -dimensjon i LED-en ovenfor, det er hvordan du får den til å blinke med en bestemt spesifisert hastighet.

I den ovennevnte implementeringen blinker faktisk LED, men sløyfehastigheten er så rask at den nesten er som en permanent bryter PÅ over LED-belysningen.

Vi får se hvordan denne sløyfen kan legges til med en forsinkelse som ønsket for å få LED-lampen til å blinke med den forsinkede hastigheten.

Hvordan få en LED til å blinke ved hjelp av AVR-mikrokontroller

I den siste diskusjonen lærte vi hvordan vi skulle få en LED til å slå PÅ gjennom en mikrokontroller, det var enestående, ikke sant? Kan ikke være så mye!

Her vil vi lære hvordan du kan krydre LED-belysningen ovenfor ved å tildele toveis funksjonalitet, det vil si at vi prøver å få den til å blinke eller blinke med en spesifisert frekvens eller frekvens. Vi ser også hvordan denne hastigheten kan økes eller reduseres etter ønske av brukeren.

La oss ta en titt på dette:

#inkludere

#inkludere

int main (ugyldig)

{

DDRB | = 1<< PINB0

mens (1)

{

PORTB ^ = 1<< PINB0

_forsink_ms (100)

}

}

Hvis du føler deg forvirret av de merkelige symbolene (&, ^, | etc) som brukes i ovennevnte uttrykk (& er ikke der, men kan brukes i andre lignende koder), er det relatert informasjon du vil være interessert i å vite om disse :

Den inkluderer mange standard logiske algoritmer som AND, OR, NOT og XOR som vanligvis brukes med ovennevnte kode.

Denne logiske funksjonaliteten sammenligner spesifikt de to bitene '1' og '0' i henhold til deres tildelte sannhetstabeller.

Vi får en ide ved å analysere følgende bitarrangement:

01001011 &
10001101
er lik
00001001

I ovennevnte refererer koden & til AND som brukt i C-programmering.

Når du leser radene vertikalt, antyder det at 0 og 1 er lik 0, 1 og 0 også er lik 0, 0 og 0 er lik 0, 1 og 1 er lik 1. Å lese det er så enkelt som det. Dette er i henhold til sannhetstabellen til en AND-operatør.

Hvis vi vurderer følgende tabell, indikerer det symbolet “|” som betegner bruken av 'ELLER' -funksjonalitet, '|' kan du finne rett til venstre for 'backspace' på tastaturet:

01001011 |
10001101
er lik
11001111

Identisk indikerer denne sannhetstabellen for en ELLER-logikkfunksjon at bitene 0 eller 1 er lik 1, 1 eller 0 også er lik 1, 0 eller 0 er lik 0, mens 1 eller 1 er lik 1.

Følgende bitkombinasjon er for XOR-logikkoperatør betegnet med ^ og kan studeres akkurat som vi gjorde med AND-, ELLER sannhetstabellene:

01001011 ^
10001101
er lik
11000110

La oss nå fortsette med det første programmet og lære hva følgende linje i det betyr:

#inkludere

Gjennom våre tidligere veiledninger vet vi hvordan uttrykket fungerer, så vi vil ikke gjenta det, men det ser ut til å være et nytt 'inkludere' uttrykt av #include som må undersøkes.

I dette 'inkluderer' delay.h gir oss noen enkle metoder for implementering.

Som navnet antyder, gjør forsinkelsen.h oss i stand til å indusere en forsinkelse i det aktuelle programmet.

Neste uttrykk int main (void) kan utelates fra den pågående diskusjonen siden vi allerede har dekket dette i våre tidligere innlegg.

Deretter kommer den endrede DDRB.

Følgende viser den tidligere formen, som ikke er en bedre måte å tilordne pinnene på, siden alle pinnene fra 0 til 7 ble byttet for å danne inngangene. Men forestill deg hva som ville være situasjonen hvis vi ønsket å lage et lengre program som krever disse pinnene for annen funksjonalitet? For eksempel kan pin2 være nødvendig for å bruke et eksternt bytte av et apparat. I så fall vil vi ikke sette pris på å tildele det samme som en innspill bare gjennom prøving og feiling. Det kan bety feil respons fra fjernsenderen til apparatmottakeren.

DDRB = 0b00000001

Vi vil heller bare påvirke en bit, hatt pin0 bit, og se på 'ELLER' -funksjonaliteten, dette kan utføres gjennom en binær maskering.

DDRB = DDRB | 0b00000001

Her er den tilslørt med en 'ELLER' -maske: 0b00000001, selv om det ganske ser ut til å være et autentisk binært tall, hvis den tidligere DDRB for eksempel: 0b01001010, og å bruke en ELLER på dette gjennom maskering kan gi: 0b01001010 | 0b00000001 = 0b01001011.

Den resulterende forskjellen som kunne sees, er bare med pin0, hvis biter har endret seg!

Å komprimere uttalelsen ovenfor ytterligere via C ++ gir:

DDRB | = 0b00000001

Vi finner imidlertid at det er enda mer i det gitte programmet. Selv om det kan se ganske legitimt og åpenbart ut, bør vi dra nytte av noen av uttalelsene fra io.h-headerfilen, spesielt når den er opprettet for vår bekvemmelighet?

Så hvis “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 begynner med en 0b00000000, og setter en '1' for å produsere 0b0000001, og deretter overfører vi den til venstre 0-posisjoner, noe som gir en nøyaktig identisk 0b00000001 som ovenfor.

Hvis vi antar at det var PINB4, kan uttalelsen nå uttrykkes som 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Vær oppmerksom på at vi bruker en nullindeks som betyr at det er fire nuller etter '1'.

Fortsetter nå til 'mens' -sløyfen vi hadde notert over den 'uendelige sløyfen' tidligere. Men kanskje nå vil vi at mikrokontrolleren skal implementere noen av de ønskede henrettelsene. Dette kan bare være mulig innenfor den gitte sløyfen. Det er løkken der den bestemte sekvensen gjentas igjen og igjen.

I tilfelle henrettelsen ble plassert før løkken, ville den ha implementert bare en gang.

For å få LED-lampen til å blinke på ubestemt tid, vil det imidlertid være nødvendig å slå PINB0 vekselvis PÅ / AV innen sløyfen. Her finner vi også forsinkelsene som blir introdusert, uten at det vil være umulig å blinke på LED-lampen. Men dette vil tvinge LED-lampen til å blinke i en veldig rask hastighet som er vanskelig å gjenkjenne med det blotte øye, og det vil trenge å bremse litt for å bli identifiserbar med øynene våre.

Vi er klar over konfigureringsprosedyren for en bestemt bit i det binære tallet, men er ikke sikker på metoden for å bruke en spesifikk bit '0' i tilfelle det er '1' ennå.

Følgende program kan sees når du gjør dette, men vi vil også finne ut at det kanskje ikke er synlig i programmet.

De to første setningene endrer biten til “1” (5V, LED-lys), og deretter innføres en pause i 100 ms.

De neste par linjene gjør PINB0-biten til '0' (nullspenning, LED slått av), men beklager at AND-sammenligningen ikke vil kunne utføre en '0' fra biten, men hvis vi IKKE bruker '~' for den binære masken kunne den bytte alle 0s til 1s og omvendt.

Dette vil gjøre det mulig for oss å påvirke bare PINB0-biten og snu den til “0”. Parentesen ble inkludert for å inneholde maskeringskjøringen slik at NOT-operasjonen kunne brukes på hele masker og ikke bare over '1' før venstre skift '<<”.

PORTB | = 1<< PINB0
_forsink_ms (100)
PORTB & = ~ (1<< PINB0)
_forsink_ms (100)

For å skape PÅ AV forsinkelser eller perioder med like varighet, kan vi forkorte de foregående fire linjene til to og bruke XOR-funksjonalitet i vår fordel. Det må bemerkes at en XOR-utførelse en tildelt pin til en 1 i tilfelle den er 0 og omvendt. Denne utførelsen ville bare påvirke PINB0. Som ofte kan kommandoen brukes, vil den ganske enkelt gjøre biten til det motsatte av den eksisterende logikken.

PORTB ^ = 1<< PINB0
_forsink_ms (100)

FERDIG! LED-lampen din vil blinke nå i henhold til den innstilte hastigheten ... Enkel, ikke sant?