For å overføre fra en datamaskin til en mikrokontroller trenger vi USBasp og AVRDUDE-programmet.I dag er det et bredt utvalg av programmerere designet for programmering AVR mikrokontrollere. Blant dem kan du finne mange hjemmelagde, som knapt engang kan kalles programmerere, siden de er direkte koblet til COM-porten med bare noen få motstander. derimot moderne datamaskiner og bærbare datamaskiner er praktisk talt ikke lenger utstyrt med COM-porter, så et av hovedkriteriene når du velger en programmerer er muligheten til å koble den til USB-port. Den billigste, enkleste og vanligste er USBasp-programmereren. Den kan kjøpes i nesten hvilken som helst radiobutikk på rimelig pris. Dens kostnad er Kinesisk internett Butikken varierer fra $1,5 til $3.

Programmerer USBasp

Datamaskinen kommuniserer med mikrokontrolleren ved hjelp av USBasp-programmereren via USB-porten, og data overføres via grensesnittet SPI – S erial P erifert Jeg grensesnitt(seriell perifert grensesnitt). For å kommunisere MK med programmereren, brukes spesielle pinner: MOSI, MISO, SCK, RESET, VCC, GND. Selv om SPI forutsetter bruk av kun tre pinner MOSI, MISO og SCK, men vi vil bruke alle seks pinner.

Ved utveksling av data via grensesnitt SPI Mikrokontrolleren kan samtidig enten motta (MISO pin) eller overføre data (MOSI pin). Innstilling av modus for mottak eller overføring av data utføres ved å påføre en viss puls til SCK-pinnen.

Programmeringskontakten har som regel 10 pinner og er koblet til mikrokontrolleren ved hjelp av en 10-leder kabel. Det er imidlertid mer praktisk å bruke kabler som har en 6-pinners adapter, siden i dette tilfellet er alle pinner okkupert. For en ti-pinners kontakt forblir en pinne ledig, og fire pinner er koblet til den felles ledningen (GND).

For at datamaskinen skal oppdage programmereren, må du installere USBasp-driveren.

Et bilde av programmereren koblet til ATmega8-mikrokontrolleren er vist nedenfor.

Den eneste ulempen eller, mer korrekt, mindre ulempe med denne programmereren er at den ikke støttes (uten forskjellige triks) av Atmel Studio, så du må bruke tredjepartsprogram. Den mest velprøvde er AVRDUDE.

Innstillinger

Nå må vi bare fullføre det siste trinnet. Start AVRDUDE-programmet. Som standard åpnes Program-fanen. Nederst i vinduet i Innstillinger-menyen, velg type programmerer usbasp. Neste i kategorien Mikrokontroller velg vår ATmega8 mikrokontroller. Nedenfor i kategorien Blits klikk på ellipseikonet og i menyen som åpnes, spesifiser banen til den kompilerte filen med utvidelsen hex. Banen til filen og selve filen vil være den samme som vi tidligere har spesifisert i .

For å sikre at programmereren blir oppdaget av operativsystemet (programmeringsdriveren er riktig installert) og er riktig koblet til mikrokontrolleren, klikk på knappen Lesning. Hvis det ikke er noen feil, vises et vindu med oppføringen " Generatorkalibreringscellene er lest!" Og det heksadesimale tallet vil vises i det øverste vinduet. Hver MK har sitt eget nummer.

Før du tar opp nytt program Det anbefales å tømme mikrokontrollerminnet. Dette kan gjøres ved å klikke på knappen Slett alt. Som et resultat vil et vindu vises som indikerer at krystallen er ren.

Klikk nå på Program-knappen i kategorien Blits. Når programmet er vellykket tatt opp i MK, vises et vindu med oppføringen nedenfor.

Resultatet av det innspilte, eller, som de også sier, fastvareprogrammet er en tent LED koblet til PC0-pinnen på mikrokontrolleren vår.

God dag. La oss fortsette. Etter at vi ble kjent med prosessen med å feilsøke programmet skrev vi i "atmel studio" og praktisk talt satt sammen en krets med en LED i "proteus", var det på tide å sette sammen kretsen i maskinvare og flashe mikrokontrolleren.

For å programmere en prototype ( atmega 8) vil vi bruke USBASP-programmereren. Det ser slik ut:

En kabel vil bli koblet til kontakten, som hoppere er koblet til, som igjen vil bli koblet til kontaktene på brødbrettet som mikrokontrolleren er installert på:

Den første pinnen er merket på kontakten med en pil.

Etter at vi fant ut programmereren. La oss gå videre til å sette sammen kretsen i maskinvare. Vi monterer mikrokontrolleren på et brødbrett. La meg minne deg på at den første etappen er merket på MK med en liten sirkel.

Oppgaven er å koble programmeringspinnene til "steinpinnene".

Vi kobler jumpere til 10-pins kontakten. Vi bruker følgende pinner MOSI, RST, SCK, MISO, VTG (VCC), GND.

Jeg håper du allerede har lastet ned dataarket på atmega8. Hvis ikke, kan du laste den ned. Vi ser på pinouten til mikrokontrollerpinnene.

Vi kobler jumpere til følgende pinner:

• VCC til pinne 7 på MK;
• SCK til pinne 19 på MK;
• MISO til pinne 18 på MK;
• MOSI til pinne 17 på MK;
• GND (programmeringspinne 10) til pinne 8 på MK;
• RST til 1 pin av MK;

For videre vellykket drift vil operativsystemet, når du starter shaitan-maskinen (programmereren) for første gang, tilby å installere driverne som er nødvendige for at enheten skal fungere.

Det skal ikke være noen problemer når du jobber med ekspeditøren. Nedlasting. Lag en mappe der vi pakker det nedlastede arkivet ut. I veiviseren for maskinvareinstallasjon angir vi deretter banen til mappen med den utpakkede driveren.

Hvis du kjører Windows 7 eller nyere, kan du oppleve noen mindre problemer. Driverne for programmereren er ganske gamle, så de har de ikke digital signatur. Når du prøver å installere en slik driver, vil operativsystemet vise noe slikt *

"Den digitale signaturen til sjåfører kreves for av denne enheten. På siste endring utstyr eller programvare en feil signert eller skadet fil eller skadevare ukjent opprinnelse. (Kode 52)."

For å rette opp situasjonen må du deaktivere verifisering av driverens digitale signatur. Jeg vil ikke beskrive hvordan du deaktiverer det (alle har sitt eget operativsystem), de kan bli funnet på Internett.

Etter at du har deaktivert signaturverifisering, angir du banen til mappen med den utpakkede driveren i veiviseren for maskinvareinstallasjon.

Jeg håper alt ordnet seg for deg og at programmereren er klar til å jobbe.

La oss gå videre til å sette sammen kretsen med LED.

For å flashe mikrokontrollerens fastvare vil vi bruke programmet "avrdudeprog". Den ligger i det generelle arkivet.

Velg atmega8 fra listen over mikrokontrollere. Etter at du har valgt MK, vises et vindu som informerer deg om at sikrings- og låsebitene er satt som standard.

Åpne deretter kategorien Sikringer. Med enkle ord Sikringer er MK-konfigurasjonsinnstillinger som det er best å ikke leke med. For tilfellet når du kjøpte samme kontroller som meg og du ikke har en ekstern kvartsresonator (du bruker en intern oscillator klokkefrekvens), merk av nøyaktig de samme boksene som vist på bildet. Det må være en hake ved siden av elementet "omvendt".

De konfigurerte innstillingene "kommanderer" Atmega8A til å utføre arbeidet sitt underlagt klokke fra den interne oscillatoren (klokkefrekvens 8 MHz). For at innstillingene skal tre i kraft, må du klikke på "Programmering" -knappen. Men før du trykker, dobbeltsjekk at alt er riktig innstilt.

Gå tilbake til "Program"-siden.

Etter at vi allerede har fortalt programmet hvilken mikrokontroller vi skal blinke, velger vi fastvarefilen som vi skrev i forrige leksjon. Den har en HEX-forlengelse. Ligger i "Debug"-mappen

Før du blinker "småsteinen", klikk på "Slett alt" -knappen. Dette vil beskytte deg mot uforståelige feil (hva om steinen allerede er sydd):

Vi nyter resultatet av arbeidet vårt :) Fortsetter...

Jeg har sagt mer enn en eller to ganger at å studere MK bør begynne med assembler. Et helt kurs på nettsiden ble viet til dette (selv om det ikke er særlig konsekvent, men etter hvert kjemmer jeg det til et adekvat utseende). Ja, det er vanskelig, resultatet vil ikke være den første dagen, men du vil lære å forstå hva som skjer i kontrolleren din. Du vil vite hvordan det fungerer, og ikke kopiere andres kilder som en ape og prøve å forstå hvorfor det plutselig sluttet å fungere. I tillegg er det mye lettere for C å lage redneck-kode som vil komme ut med en høygaffel på det mest uleilige tidspunktet.

Dessverre ønsker alle resultater umiddelbart. Så jeg bestemte meg for å gå den andre veien - lage en tutorial på C, men med å vise undertøyet hans. En god embedder-programmerer holder alltid maskinvaren tett ved bolten, og lar den ikke ta et eneste skritt uten tillatelse. Så først vil det være C-koden, deretter hva kompilatoren produserte og hvordan det hele faktisk fungerer :)

På den annen side, Xi sterke poeng Dette er kodeportabilitet. Hvis du selvfølgelig skriver alt riktig. Separering av arbeidsalgoritmene og deres maskinvareimplementeringer i ulike deler av prosjektet. Deretter, for å overføre algoritmen til en annen mikrokontroller, vil det være nok å bare skrive om grensesnittlaget, der alle anrop til maskinvaren skrives, og la all arbeidskoden være som den er. Og selvfølgelig lesbarhet. C-kildekoden er lettere å forstå ved første øyekast (selv om ... for eksempel, jeg bryr meg ikke om hva jeg skal peke på - det være seg C eller ASM :)), men igjen, hvis alt er skrevet riktig. Jeg vil også ta hensyn til disse punktene.

Brorparten av alle eksemplene vil være min som prøvestykket som brorparten av alle eksemplene skal installeres på. utviklingsstyret.

Det første C-programmet for AVR

Velge en kompilator og sette opp miljøet
Det er mange forskjellige C-kompilatorer for AVR:
Først av alt dette IAR AVR C- er nesten definitivt anerkjent som den beste kompilatoren for AVR, fordi selve kontrolleren ble laget i nært samarbeid mellom Atmel og spesialister fra IAR. Men du må betale for alt. Og denne kompilatoren er ikke bare en dyr kommersiell programvare, men har også så massevis av innstillinger at det krever mye innsats å ganske enkelt kompilere den i den. Jeg utviklet virkelig ikke et vennskap med ham; prosjektet råtnet på grunn av merkelige feil på koblingsstadiet (senere fant jeg ut at det var en skjev sprekk).

Andre kommer WinAVR GCC- en kraftig optimaliserende kompilator. Helt åpen kildekode, på tvers av plattformer, generelt, alle livets gleder. Den integreres også perfekt i AVR Studio slik at du kan feilsøke akkurat der, noe som er veldig praktisk. Generelt valgte jeg det.

Det er også CodeVision AVR C er en veldig populær kompilator. Den ble populær på grunn av sin enkelhet. Arbeidsprogram Du kan få det på bare noen få minutter - startkodeveiviseren hjelper veldig med dette, og stempler standarder for initialisering av alle slags uarts. For å være ærlig, er jeg litt mistenksom overfor det - når jeg først måtte demontere et program skrevet av denne kompilatoren, viste det seg å være en slags rot og ikke kode. En forferdelig mengde unødvendige bevegelser og operasjoner, som resulterte i en betydelig mengde kode og treg ytelse. Imidlertid var det kanskje en feil i DNA-et til personen som skrev den originale fastvaren. I tillegg vil han ha penger. Ikke så mye som IAR, men merkbart. Og i demomodus lar den deg ikke skrive mer enn 2kb kode.
Selvfølgelig er det en sprekk, men hvis du skal stjele, er det en million, i IAR-forstand :)

Det er også Image Craft AVR C Og MicroC fra mikroelektronikk. Jeg trengte ikke å bruke noen av dem, men S.W.G. veldig rosende MicroPascal, sier de, et fryktelig praktisk programmeringsmiljø og biblioteker. Jeg tror MicroC ikke vil være verre, men det er også betalt.

Som sagt, jeg valgte WinAVR av tre grunner: det er gratis, det integreres i AVR Studio og det er skrevet for det. klar kode for alle anledninger.

Så last ned WinAVR-installasjonen med AVR Studio. Deretter installeres studioet først, deretter rulles WinAVR oppå og festes til studioet i form av en plugin. Jeg anbefaler på det sterkeste å installere WinAVR på en kort bane, noe som C:\WinAVR, på denne måten vil du unngå mange problemer med stier.

Opprette et prosjekt
Så, studioet er installert, C er skrudd inn, det er på tide å prøve å programmere noe. La oss starte med det enkle, det enkleste. Start et studio, velg der nytt prosjekt, som AVR GCC-kompilatoren og skriv inn navnet på prosjektet.

Et arbeidsfelt åpnes med en tom *.c-fil.

Nå vil det ikke skade å konfigurere visningen av stier i studiobokmerkene. For å gjøre dette, gå til:
Meny Verktøy - Alternativer - Generelt - Filfaner og velg "Kun filnavn" fra rullegardinlisten. Ellers vil det være umulig å jobbe - fanen vil inneholde hele banen til filen, og det vil ikke være mer enn to eller tre faner på skjermen.

Prosjektoppsett
Generelt anses det som klassisk å lage en make-fil der alle avhengigheter er beskrevet. Og det er nok riktig. Men for meg, som vokste opp med fullt integrerte IDE-er som uVision eller AVR Studio denne tilnærmingen er dypt fremmed. Derfor vil jeg gjøre det på min måte, alt med studiomidler.

Stikk på knappen med giret.

Dette er innstillingene for prosjektet ditt, eller snarere innstillingene for automatisk generering av en make-fil. På den første siden trenger du bare å angi frekvensen som din MK skal operere med. Dette avhenger av sikringsbitene, så vi antar at frekvensen vår er 8000000Hz.
Vær også oppmerksom på optimaliseringslinjen. Nå er det -Os - dette er størrelsesoptimalisering. La det være som det er for nå, så kan du prøve å leke med denne parameteren. -O0 er ingen optimalisering i det hele tatt.

Det neste trinnet er å konfigurere banene. Først av alt, legg til prosjektkatalogen din der - du vil legge til tredjepartsbiblioteker der. Banen ".\" vil vises i listen.

Make-filen er generert, du kan se på den i standardmappen i prosjektet ditt, bare ta en titt og se hva som er der.

Det er alt for nå. Klikk OK overalt og gå til kilden.

Formulering av problemet
Et blankt ark er fristende å implementere en utspekulert idé, siden den banale blinkingen av en diode ikke lenger fungerer. La oss umiddelbart ta oksen ved hornene og implementere forbindelsen med datamaskinen - dette er det første jeg gjør.

Det vil fungere slik:
Når en ener (kode 0x31) kommer gjennom COM-porten, vil vi slå på dioden, og når en null kommer (kode 0x30) slås den av. Dessuten vil alt bli gjort på avbrudd, og bakgrunnsoppgaven vil være blinking av en annen diode. Enkelt og meningsfylt.

Montering av kretsen
Vi må koble USB-USART-omformermodulen til USART-pinnene på mikrokontrolleren. For å gjøre dette, ta en jumper fra to ledninger og plasser den på pinnene på kryss og tvers. Det vil si at vi kobler Rx-en til kontrolleren til Tx-en til omformeren, og Tx-en til omformeren til Rx-en til kontrolleren.

Til slutt er dette diagrammet:

Jeg vurderer ikke å koble til de gjenværende pinnene, strøm eller tilbakestilling, det er standard.

Skrive kode

La meg ta en reservasjon med en gang at jeg ikke skal fordype meg spesifikt i beskrivelsen av selve C-språket. Det er rett og slett en kolossal mengde materiale for dette, alt fra det klassiske "C Programming Language" fra K&R til forskjellige manualer.

Jeg fant en slik metode i oppbevaringen min; jeg brukte den en gang for å studere dette språket. Alt der er kort, klart og saklig. Jeg setter det gradvis sammen og drar det inn på nettstedet mitt.

Det er sant at ikke alle kapitlene er overført ennå, men jeg tror det ikke blir så lenge til.

Det er usannsynlig at jeg kan beskrive det bedre, så fra treningskurs, i stedet for en detaljert forklaring av finessene, vil jeg ganske enkelt gi direkte lenker til individuelle sider i denne håndboken.

Legger til biblioteker.
Først av alt legger vi til de nødvendige bibliotekene og overskriftene med definisjoner. Tross alt er C et universelt språk, og vi må forklare ham at vi jobber spesifikt med AVR, så skriv linjen i kildekoden:

1	#inkludere

#inkludere

Denne filen ligger i mappen WinAVR og den inneholder en beskrivelse av alle registre og porter til kontrolleren. Dessuten er alt der utspekulert, med binding til en spesifikk kontroller, som overføres av kompilatoren via gjøre fil i parameter MCU og basert på denne variabelen kobles en header-fil til prosjektet ditt med en beskrivelse av adressene til alle porter og registre for denne spesifikke kontrolleren. Wow! Uten det er det også mulig, men da vil du ikke kunne bruke symbolske registernavn som SREG eller UDR, og du må huske adressen til hver som "0xC1", som vil være en hodepine.

Selve laget #inkludere<имя файла> lar deg legge til innhold av alle slag til prosjektet ditt tekstfil, for eksempel en fil med en beskrivelse av funksjoner eller et stykke annen kode. Og for at direktivet kunne finne denne filen, spesifiserte vi banen til prosjektet vårt (WinAVR-katalogen er allerede registrert der som standard).

Hovedfunksjon.
Et C-program består utelukkende av funksjoner. De kan nestes og kalles fra hverandre i hvilken som helst rekkefølge og forskjellige måter. Hver funksjon har tre nødvendige parametere:

• Returverdien er f.eks. synd(x) returnerer verdien av sinusen til x. Som i matematikk, kort sagt.
• De overførte parameterne er de samme X.
• Funksjonskropp.

Alle verdier som sendes og returneres må være av en eller annen type, avhengig av dataene.

Ethvert C-program må inneholde en funksjon hoved- som et inngangspunkt til hovedprogrammet, ellers er det ikke C i det hele tatt :). Ved tilstedeværelsen av main i andres kildekode fra en million filer, kan du forstå at dette er hoveddelen av programmet, der alt begynner. Så la oss spørre:

1 2 3 4 5

int main(void) ( return 0 ; )

int main(void) ( return 0; )

Det er det, først enkleste programmet skrevet, det spiller ingen rolle at det ikke gjør noe, vi har nettopp startet.

La oss finne ut hva vi gjorde.
int Dette er datatypen som hovedfunksjonen returnerer.

Selvfølgelig i en mikrokontroller hoved- i prinsippet kan ingenting returneres, og i teorien burde det være det void main(void), men GCC ble opprinnelig designet for PC og der kan programmet returnere verdien operativsystem ved ferdigstillelse. Derfor GCC på void main(void) sverger til advarsel.

Dette er ikke en feil, det vil fungere, men jeg liker ikke advarsler.

tomrom dette er typen data vi sender til funksjonen, i dette tilfellet hoved- kan heller ikke akseptere noe utenfra, derfor tomrom- en dummy. En stubbe brukes når det ikke er behov for å sende eller returnere noe.

Her er de { } krøllete klammeparenteser er en programblokk, i dette tilfellet kroppen til en funksjon hoved-, vil koden være plassert der.

komme tilbake- dette er returverdien som hovedfunksjonen vil returnere ved fullføring, siden vi har en int, altså et tall, så må vi returnere et tall. Selv om dette fortsatt ikke gir mening, fordi... på mikrokontrolleren kan vi bare gå ingensteds fra main. Jeg returnerer null. For det spiller ingen rolle. Men kompilatoren er vanligvis smart og genererer ikke kode for denne saken.
Selv om, hvis pervertert, så fra hoved- Du kan gå til MK - for eksempel fall inn i bootloader-seksjonen og utføre den, men dette vil kreve triksing på lavt nivå med fastvaren for å korrigere overgangsadressene. Nedenfor vil du se selv og forstå hvordan du gjør det. For hva? Dette er et annet spørsmål, i 99,999% av tilfellene er dette ikke nødvendig :)

Vi gjorde det og gikk videre. La oss legge til en variabel, vi trenger den egentlig ikke og det er ingen vits i å introdusere variabler uten den, men vi lærer. Hvis variabler legges til inne i kroppen til en funksjon, er de lokale og eksisterer bare i denne funksjonen. Når du avslutter funksjonen, slettes disse variablene, og RAM-minnet tildeles for viktigere behov. .

1 2 3 4 5 6

int main(void) (usignert char i; return 0;)

int main(void) ( usignert char i; return 0; )

usignert betyr usignert. Faktum er at i den binære representasjonen er den mest signifikante biten allokert til tegnet, noe som betyr at tallet +127/-128 passer inn i en byte (char), men hvis tegnet forkastes vil det passe fra 0 til 255. Vanligvis er skiltet ikke nødvendig. Så usignert.
Jeg er bare et variabelnavn. Ikke mer.

Nå må vi initialisere portene og UART. Selvfølgelig kan du ta og koble til biblioteket og ringe en slags UartInit(9600); men da vet du ikke hva som egentlig skjedde.

Vi gjør dette:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int main(void) (usignert char i; #define XTAL 8000000L #define baudrate 9600L #define bauddivider (XTAL/(16*baudrate)-1)#define HI(x) ((x)>>8) #define LO(x) ((x)& 0xFF) UBRRL = LO(bauddivider) ; UBRRH = HI(bauddivider) ; UCSRA = 0; UCSRB = 1<< RXEN| 1 << TXEN| 1 << RXCIE| 0 << TXCIE; UCSRC = 1 << URSEL| 1 << UCSZ0| 1 << UCSZ1; }

int main(void) ( usignert char i; #define XTAL 8000000L #define baudrate 9600L #define bauddivider (XTAL/(16*baudrate)-1) #define HI(x) ((x)>>8) #define LO( x) ((x)& 0xFF) UBRRL = LO(bauddivider); UBRRH = HI(bauddivider); UCSRA = 0; UCSRB = 1<

Skummelt? Faktisk er det bare fem siste linjer med ekte kode. Alt, det #definere det er et forprosessor makrospråk. Nesten det samme som i Assembly, men syntaksen er litt annerledes.

De vil lette rutineoperasjonene dine med å beregne de nødvendige koeffisientene. I første linje sier vi det i stedet XTAL du kan trygt erstatte 8000000, og L- indikasjon på typen, sier lang er klokkefrekvensen til prosessoren. Det samme baudrate— frekvens for dataoverføring via UART.

bauddivider allerede mer komplisert, i stedet for det vil uttrykket beregnet ved hjelp av formelen fra de to foregående erstattes.
Vel og L.O. Og HI de lave og høye bytene vil bli tatt fra dette resultatet, fordi Det kan åpenbart ikke passe inn i én byte. I HI X (makroinndataparameteren) forskyves åtte ganger til høyre, noe som resulterer i at bare den mest signifikante byten gjenstår. Og i L.O. vi gjør en bitvis OG med tallet 00FF, som et resultat vil bare den lave byten forbli.

Så alt som er gjort er som #definere du kan trygt kaste det, og beregne de nødvendige tallene på en kalkulator og umiddelbart legge dem inn på linjene UBBRL = …. og UBBRH = …..

Kan. Men! Gjør dette HELT UMULIG!

Det vil fungere slik eller slik, men du vil ha såkalte magiske tall- verdier hentet fra ingensteds og av ukjente årsaker, og hvis du åpner et slikt prosjekt om et par år, vil det være vanskelig å forstå hva disse verdiene er. Selv nå, hvis du vil endre hastigheten eller endre kvartsfrekvensen, må alt beregnes på nytt, men du endret et par tall i koden, og det er det. Generelt, hvis du ikke ønsker å bli merket som en koder, så lag koden din slik at den er lett å lese, forståelig og enkel å endre.

Da er alt enkelt:
Alle disse "UBRRL og Co" er konfigurasjonsregistre for UART-senderen ved hjelp av hvilke vi vil kommunisere med verden. Og nå har vi tildelt dem de nødvendige verdiene, satt dem til ønsket hastighet og modus.

Opptakstype 1< Betyr følgende: ta 1 og sett den på plass RXEN i byte. RXEN dette er den fjerde biten i registeret UCSRB, Så 1< danner det binære tallet 00010000, TXEN- dette er den tredje biten, og 1< vil gi 00001000. Singel "|" det er bitvis ELLER, altså 00010000 | 00001000 = 00011000. På samme måte settes de gjenværende nødvendige konfigurasjonsbitene og legges til den generelle heapen. Som et resultat blir det innsamlede nummeret registrert i UCSRB. Flere detaljer er beskrevet i dataarket om MK i USART-delen. Så la oss ikke la oss distrahere av tekniske detaljer.

Ferdig, på tide å se hva som skjedde. Klikk på kompilering og start emulering (Ctrl+F7).

Feilsøking
Alle slags fremdriftslinjer løp gjennom, studioet endret seg og en gul pil dukket opp nær inngangen til hovedfunksjonen. Det er her prosessoren kjører og simuleringen er satt på pause.

Faktum er at det i utgangspunktet faktisk var på linjen UBRRL = LO(bauddivider); Tross alt, det vi har i definere er ikke kode, men bare foreløpige beregninger, som er grunnen til at simulatoren er litt kjedelig. Men nå skjønte han at den første instruksjonen er fullført og om du klatrer opp i treet I/O-visning, til USART-delen og se på UBBRL-byten der, vil du se at verdien allerede er der! 0x33.

Ta det ett skritt videre. Se hvordan innholdet i det andre registeret endres. Så gå gjennom dem alle, vær oppmerksom på det faktum at alle de angitte bitene er satt som jeg fortalte deg, og de settes samtidig for hele byten. Det går ikke lenger enn til Return – programmet er over.

Åpning
Tilbakestill simuleringen til null. Klikk der Tilbakestill (Shift+F5). Åpne den demonterte oppføringen, nå vil du se hva som faktisk skjer i kontrolleren. Vis -> Demonter. Og ikke YYAAAAAA!!! Monter!!! SKREKK!!! OG DET ER NØDVENDIG. Slik at du senere, når noe går galt, ikke er dum i koden og ikke stiller dumme spørsmål på forumene, men umiddelbart gå inn i magen og se hvor du sitter fast. Det er ikke noe skummelt der.

Først blir det topper fra serien:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

+00000000: 940C002A JMP 0x0000002A Hopp +00000002: 940C0034 JMP 0x00000034 Hopp +00000004: 940C0034 JMP 0x000000 +6000000 +6000000 +4C 0x00000034 Hopp +00000008: 940C0034 JMP 0x00000034 Hopp +0000000A: 940C0034 JMP 0x00000034 Hopp +0000000C: 34 J0C00x04 Hopp 0000000E: 940C0034 JMP 0x00000034 Hopp +00000010: 940C0034 JMP 0x00000034 Hopp +00000012: 940C0034 JMP 0x00000 +4C0000 +4C0000 +40000 0x00000034 Hopp +00000016: 940C0034 JMP 0x00000034 Hopp +00000018: 940C0034 JMP 0x00000034 Hopp +0000001A: 940 J0C000x34 J0C000x4 : 940C0034 JMP 0x00000034 Hopp +0000001E: 940C0034 JMP 0x00000034 Hopp +00000020: 940C0034 JMP 0x00000030 9 JMP 020000034 JMP 020000034 0200000034 0200000309 JMP 020000034 34 Hopp +00000024: 940C0034 JMP 0x00000034 Hopp +00000026: 940C0034 JMP 0x00000034 Hopp +00000028: 940C0030 Hopp 00x04

00000000: 940C002A JMP 0x0000002A Hopp +00000002: 940C0034 JMP 0x00000034 Hopp +00000004: 940C0034 JMP 0x00000 JMP 0x00000 +600000 0x00000034 Hopp +00000008: 940C0034 JMP 0x00000034 Hopp +0000000A: 940C0034 JMP 0x00000034 Hopp +0000000C: 940 J0C000000E4 : 940C0034 JMP 0x00000034 Hopp +00000010: 940C0034 JMP 0x00000034 Hopp +00000012: 940C0034 JMP 0x00000030 9 JMP 040000034 Hopp +000000034 JMP 0400000034 34 Hopp +00000016: 940C0034 JMP 0x00000034 Hopp +00000018: 940C0034 JMP 0x00000034 Hopp +0000001A: 940C0034 Hopp +00004 JMP 000004 JMP 00000 : 940C0034 JMP 0x00000034 Hopp +0000001E: 940C0034 JMP 0x00000034 Hopp +00000020: 940C0034 JMP 0x00000030 9 JMP 020000034 JMP 020000034 0200000034 0200000309 JMP 020000034 34 Hopp +00000024: 940C0034 JMP 0x00000034 Hopp +00000026: 940C0034 JMP 0x00000034 Hopp +00000028: 940C0030 Hopp 00x04

Dette er avbruddsvektortabellen. Vi kommer tilbake til det senere, men foreløpig er det bare å se og huske at det eksisterer. Den første kolonnen er adressen til flashcellen der kommandoen ligger, den andre er kommandokoden, den tredje er kommandoen mnemonic, den samme monteringsinstruksjonen, den tredje er operandene til kommandoen. Vel, automatisk kommentar.
Så hvis du ser, er det kontinuerlige overganger. Og JMP-kommandokoden er fire byte, den inneholder hoppadressen skrevet bakover - den lave byten på den lave adressen og hoppkommandokoden 940C

0000002B: BE1F UT 0x3F,R1 Ut til I/O plassering

Registrerer denne nullen på adressen 0x3F. Hvis du ser på I/O-visningskolonnen, vil du se at adressen 0x3F er adressen til SREG-registeret - flaggregisteret til kontrolleren. De. vi tilbakestiller SREG for å kjøre programmet på null betingelser.

1 2 3 4

+0000002C: E5CF LDI R28,0x5F Last umiddelbart +0000002D: E0D4 LDI R29,0x04 Last umiddelbart +0000002E: BFDE OUT 0x3E,R29 Ut til I/O plassering +0000002F:/8 Ut til I/O plassering +00000002F:/8

0000002C: E5CF LDI R28,0x5F Last umiddelbart +0000002D: E0D4 LDI R29,0x04 Last umiddelbart +0000002E: BFDE OUT 0x3E,R29 Ut til I/O plassering +00000002F:/8 Ut til I/O plassering +0000002F:

Dette laster stabelpekeren. Du kan ikke laste direkte inn i I/O-registre, kun gjennom et mellomregister. Derfor, først LDI til mellomliggende, og deretter derfra OUT til I/O. Jeg vil også fortelle deg mer om stabelen senere. For nå, vet at dette er et dynamisk minneområde som henger på slutten av RAM og lagrer adresser og mellomliggende variabler. Nå har vi indikert hvor stabelen vår skal starte fra.

00000032: 940C0041 JMP 0x00000041 Hopp

Hopp helt til slutten av programmet, og der har vi forbud mot avbrudd og looping tett på seg selv:

1 2	+00000041: 94F8 CLI Global Interrupt Disable +00000042: CFFF RJMP PC-0x0000 Relativt hopp

00000041: 94F8 CLI Global Interrupt Disable +00000042: CFFF RJMP PC-0x0000 Relativt hopp

Dette er i tilfelle uforutsette omstendigheter, som for eksempel å avslutte hovedfunksjonen. Kontrolleren kan bringes ut av en slik sløyfe enten ved en tilbakestilling av maskinvare, eller, mer sannsynlig, ved en tilbakestilling fra en vakthund. Vel, eller, som jeg sa ovenfor, korriger dette i hex-editoren og galopper bort dit hjertet måtte ønske. Vær også oppmerksom på at det er to typer overganger: JMP og RJMP; den første er en direkte overgang til en adresse. Den opptar fire byte og kan hoppe direkte gjennom hele minneområdet. Den andre typen overgang er RJMP - relativ. Kommandoen hans tar to byte, men han beveger seg fra gjeldende posisjon (adresse) 1024 skritt fremover eller bakover. Og parameterne indikerer forskyvningen fra det nåværende punktet. Det brukes oftere pga tar halve plassen i en spyling, og lange overganger er sjelden nødvendig.

1	+00000034: 940C0000 JMP 0x00000000 Hopp

00000034: 940C0000 JMP 0x00000000 Hopp

Og dette er et hopp helt til begynnelsen av koden. En slags omstart. Du kan sjekke at alle vektorene hopper her. Konklusjonen fra dette er at hvis du nå aktiverer avbrudd (de er deaktivert som standard) og avbruddet ditt oppstår, men det er ingen behandler, vil det bli en tilbakestilling av programvaren - programmet vil bli kastet tilbake til begynnelsen.

Hovedfunksjon. Alt er likt, du trenger ikke engang å beskrive det. Bare se på det allerede beregnede antallet som føres inn i registrene. Kompilator-forprosessoren rocker!!! Så ingen "magiske" tall!

1 2 3 4 5 6 7 8 9 10 11 12

<

00000036: E383 LDI R24,0x33 Last umiddelbart +00000037: B989 OUT 0x09,R24 Ut til I/O plassering 15: UBRRH = HI(bauddivider); +00000038: BC10 UT 0x20,R1 Ut til I/O plassering 16: UCSRA = 0; +00000039: B81B UT 0x0B,R1 Ut til I/O plassering 17: UCSRB = 1<

Og her er feilen:

1 2 3

+0000003E: E080 LDI R24.0x00 Last umiddelbart +0000003F: E090 LDI R25.0x00 Last umiddelbart +00000040: 9508 RET Subrutine retur

0000003E: E080 LDI R24.0x00 Last umiddelbart +0000003F: E090 LDI R25.0x00 Last umiddelbart +00000040: 9508 RET Subrutine retur

Spørsmålet er hvorfor kompilatoren legger til slike topper? Og dette er ikke noe mer enn Return 0, vi definerte funksjonen som int main(void) og så kastet vi bort ytterligere fire byte for ingenting :) Og hvis du gjør void main(void) vil bare RET forbli, men en advarsel vises , at vår hovedfunksjon ikke returnerer noe. Generelt, gjør som du vil :)

Vanskelig? Tydeligvis ikke. Klikk trinn-for-trinn-utførelse i disassembler-modus og se hvordan prosessoren utfører individuelle instruksjoner, hva som skjer med registrene. Hvordan skjer bevegelse gjennom kommandoer og siste looping?

Fortsettelse om et par dager...

Offtop:
Alexei78 Jeg opprettet en plugin for Firefox som gjør det enklere å navigere på nettstedet og forumet mitt.
Diskusjon og nedlasting,

Oppgave: La oss utvikle et program for å kontrollere én LED. Når knappen trykkes inn, lyser LED-en og når den slippes, slukker den.

Først, la oss utvikle et skjematisk diagram av enheten. I/O-porter brukes til å koble eksterne enheter til mikrokontrolleren. Hver av portene er i stand til å fungere som både inngang og utgang. La oss koble LED-en til en av portene og knappen til den andre. For dette eksperimentet vil vi bruke en kontroller Atmega8. Denne brikken inneholder 3 I/O-porter, har 2 åtte-biters og 1 seksten-biters timer/teller. Også om bord er det en 3-kanals PWM, 6-kanals 10-bit analog-til-digital-omformer og mye mer. Etter min mening er en mikrokontroller flott for å lære det grunnleggende om programmering.

For å koble til lysdioden vil vi bruke linje PB0, og for å lese informasjon fra knappen bruker vi linje PD0. Diagrammet er vist i fig. 1.

Ris. 1

Gjennom motstand R2 tilføres pluss forsyningsspenning til inngang PD0, som tilsvarer et logisk ett-signal. Når knappen lukkes, synker spenningen til null, som tilsvarer en logisk null. I fremtiden kan R2 ekskluderes fra kretsen, erstatte den med en intern lastmotstand, angi de nødvendige innstillingene i programmet. Lysdioden er koblet til utgangen til port PB0 gjennom strømbegrensende motstand R3. For å tenne LED-en, må du bruke et logisk ett-signal til PB0-linjen. Vi vil bruke en intern masterklokkegenerator på 4 MHz, siden enheten ikke har høye krav til frekvensstabilitet.

Nå skriver vi programmet. Jeg bruker programmeringsmiljøet til å skrive programmer AVR Studio Og WinAvr.Åpne AVR Studio, et velkomstvindu dukker opp, klikk på "Opprett et nytt prosjekt"-knappen, velg deretter prosjekttype - AVR GCC, skriv prosjektnavnet for eksempel "cod1", sjekk både "Opprett prosjektmappe" og "Opprett" initialiseringsfil" avmerkingsbokser, klikk på "Neste"-knappen, velg "AVR Simulator" i venstre vindu, og "Atmega8" mikrokontroller skriv inn i høyre vindu, klikk på "Fullfør"-knappen, redigeringsprogrammet og prosjektkategoritreet åpnes - innledende innstillinger er fullført.

Først, la oss legge til standard beskrivelsestekst for Atmega8 ved å bruke operatøren for å legge ved eksterne filer: #inkludere

direktivsyntaks #inkludere

#inkludere<имя_файла.h>
#inkluder "filnavn.h"

Vinkelbraketter< и >angi for kompilatoren at inkluderte filer først må letes etter i standard WinAvr-mappen kalt include. De doble anførselstegnene " og " forteller kompilatoren å begynne å søke i katalogen der prosjektet er lagret.

Hver type mikrokontroller har sin egen header-fil. For ATMega8 kalles denne filen iom8.h, for ATtiny2313 - iotn2313.h. I begynnelsen av hvert program må vi inkludere header-filen til mikrokontrolleren vi bruker. Men det er også en felles header-fil io.h. Forbehandleren behandler denne filen og inkluderer, avhengig av prosjektinnstillingene, den nødvendige overskriftsfilen i programmet vårt.

For oss vil den første linjen i programmet se slik ut:

#inkludere

Ethvert C-program må inneholde én hovedfunksjon. Den heter hoved. Programutførelse begynner alltid med utførelse av hovedfunksjonen. Funksjonen har en header - int main(void) og en body - den er avgrenset med krøllete klammeparenteser ().

int main(void)
{
funksjon kroppen
}

Vi vil legge til koden vår til funksjonens kropp. Returtypen er angitt før funksjonsnavnet. Hvis funksjonen ikke returnerer en verdi, brukes nøkkelen tomrom.

int- dette er et 2-byte heltall, verdiområdet er fra - 32768 til 32767

Etter funksjonsnavnet er parameterne som sendes til funksjonen når den kalles, angitt i parentes (). Hvis funksjonen ikke har noen parametere, brukes nøkkelordet tomrom. Funksjon hoved- inneholder et sett med kommandoer, systeminnstillinger og hovedprogramløkken.

Deretter konfigurerer vi porten D ved inngangen. Portens driftsmodus bestemmes av innholdet i registeret DDRD(informasjonsoverføringsretningsregister). Vi skriver tallet "0x00" (0b0000000 - i binær form) i dette registeret; ingenting er koblet til denne porten bortsett fra knappen, så vi konfigurerer hele porten D som en inngang. Du kan konfigurere porten bit for bit ved å skrive tallene 0 eller 1 inn i hver bit av registeret (0-inngang, 1-utgang), for eksempel DDRD = 0x81 (0b10000001) - den første og siste linjen i port D fungerer som utgang, resten som input. Den interne belastningsmotstanden må også kobles til. PORTx-registeret kontrollerer om de interne motstandene er slått på eller av når porten er i inngangsmodus. La oss skrive enheter der.

Sette opp porten B til utgangen. Portens driftsmodus bestemmes av innholdet i registeret DDRB. Ingenting annet enn en LED til porten B ikke tilkoblet, så hele porten kan konfigureres som utgang. Dette gjøres ved å skrive til registeret DDRB tallene "0xFF". For å forhindre at LED-en lyser når du slår den på første gang, skriv til porten B logiske nuller. Dette gjøres ved opptak PORTB= 0x00;

For å tildele verdier brukes "="-symbolet og kalles tilordningsoperatøren, ikke å forveksle med "lik"-tegnet.

Portkonfigurasjonen vil se slik ut:

DDRD = 0x00;
PORTD = 0xFF;
DDRB = 0xFF;
PORTB = 0x00;

Vi skriver hovedsløyfen til programmet. samtidig som("mens" fra engelsk) - denne kommandoen organiserer en løkke, og gjentar selve løkken mange ganger til betingelsen er oppfylt, det vil si mens uttrykket i parentes er sant. I C anses et uttrykk for å være sant hvis det ikke er lik null, og usant hvis det er det.

Kommandoen ser slik ut:

mens (tilstand)
{
løkkekropp
}

I vårt tilfelle vil hovedsløyfen kun bestå av én kommando. Denne kommandoen tildeler register PORTB registerverdien som skal inverteres PORTD.

PORTB = ~PIND; //ta verdien fra port D, inverter den og tilordne den til PORTB (skriv til PORTB)

// C-uttrykk leses fra høyre til venstre

PIND informasjonsinndataregister. For å lese informasjon fra den eksterne utgangen til kontrolleren, må du først bytte ønsket bit av porten til inngangsmodus. Det vil si, skriv til den tilsvarende biten i registeret DDRx null. Først etter dette kan et digitalt signal fra en ekstern enhet leveres til denne pinnen. Deretter vil mikrokontrolleren lese byten fra registeret PINx. Innholdet i den tilsvarende biten tilsvarer signalet på den eksterne pinnen til porten. Programmet vårt er klart og ser slik ut:

#inkludere int main (void) ( DDRD = 0x00; //port D - inngang PORTD = 0xFF; //koble belastningsmotstanden DDRB = 0xFF; //port B - utgang PORTB = 0x00; //sett utgangen til 0 while(1 ) ( PORTB = ~PIND; //~ bitvis inversjonstegn ) )

Kommentarer er mye brukt i C-språket. Det er to måter å skrive på.

/*En kommentar*/
//En kommentar

I dette tilfellet vil ikke kompilatoren ta hensyn til hva som er skrevet i kommentaren.

Hvis du bruker det samme programmet og kobler 8 knapper og 8 lysdioder til mikrokontrolleren, som vist i figur 2, vil det være klart at hver bit av porten D samsvarer med portbiten B. Ved å trykke på SB1-knappen lyser HL1, ved å trykke på SB2-knappen lyser HL2 osv.

Figur 2

Artikkelen brukte materialer fra boken av A.V. Belov. "Opplæring for utviklere av AVR-enheter"

Atmega8 mikrokontrollere er de mest populære representantene for familien deres. På mange måter skylder de dette på den ene siden enkel betjening og forståelig struktur, og på den andre ganske bred funksjonalitet. Denne artikkelen vil dekke Atmega8-programmering for nybegynnere.

generell informasjon

Mikrokontrollere er overalt. De finnes i kjøleskap, vaskemaskiner, telefoner, fabrikkmaskiner og en lang rekke andre tekniske apparater. Mikrokontrollere varierer fra enkle til ekstremt komplekse. Sistnevnte tilbyr betydelig flere funksjoner og funksjonalitet. Men du vil ikke kunne forstå kompleks teknologi med en gang. I utgangspunktet må du mestre noe enkelt. Og Atmega8 vil bli tatt som prøve. Programmering på den er ikke vanskelig takket være dens kompetente arkitektur og vennlige grensesnitt. I tillegg har den tilstrekkelig ytelse til å brukes i de fleste, og de brukes også i industrien. Når det gjelder Atmega8, krever programmering kunnskap om språk som AVR (C/Assembler). Hvor skal jeg starte? Å mestre denne teknologien er mulig på tre måter. Og alle velger selv hvor de skal begynne å jobbe med Atmega8:

1. Programmering via Arduino.
2. Kjøp av en ferdig enhet.
3. Selvmontering av en mikrokontroller.

Vi vil vurdere det første og tredje punktet.

Arduino

Dette er en praktisk plattform designet i en form som er egnet for raskt å lage ulike enheter. Brettet har allerede alt du trenger i form av selve mikrokontrolleren, dens sele og programmerer. Ved å følge denne veien vil en person motta følgende fordeler:

1. Lavterskelkrav. Du trenger ikke ha spesielle ferdigheter for å utvikle tekniske enheter.
2. Et bredt spekter av elementer vil være tilgjengelig for tilkobling uten ekstra forberedelse.
3. Rask start på utvikling. Med Arduino kan du hoppe rett inn i å lage enheter.
4. Tilgjengelighet av et stort antall opplæringsmateriell og eksempler på implementeringer av ulike design.

Men det er også visse ulemper. Dermed lar Arduino-programmering Atmega8 deg ikke stupe dypere inn i mikrokontrollerens verden og forstå mange nyttige aspekter. I tillegg må du lære et programmeringsspråk, som er forskjellig fra de som brukes av AVR (C/Assembler). Og en ting til: Arduino har et ganske smalt utvalg av modeller. Derfor vil det før eller senere være behov for å bruke en mikrokontroller, som ikke brukes i tavler. Men generelt sett er dette et godt alternativ for å jobbe med Atmega8. Programmering via Arduino vil gi deg en trygg start på elektronikkens verden. Og det er usannsynlig at en person gir opp på grunn av feil og problemer.

Selvmontering

Takket være det vennlige designet kan du lage dem selv. Dette krever tross alt billige, rimelige og enkle komponenter. Dette vil tillate deg å studere designen til Atmega8-mikrokontrolleren grundig, hvis programmering etter montering vil virke enklere. Også, om nødvendig, kan du uavhengig velge andre komponenter for en spesifikk oppgave. Riktignok er det en viss ulempe her - kompleksitet. Det er ikke lett å sette sammen en mikrokontroller på egenhånd når du ikke har den nødvendige kunnskapen og ferdighetene. Vi vil vurdere dette alternativet.

Hva trengs for montering?

Først må du skaffe deg selve Atmega8. Å programmere en mikrokontroller uten den, vet du, er umulig. Det vil koste flere hundre rubler - samtidig som det gir anstendig funksjonalitet. Det er også spørsmålet om hvordan Atmega8 vil bli programmert. USBAsp er en ganske god enhet som har vist seg å være veldig bra. Men du kan bruke en annen programmerer. Eller sett den sammen selv. Men i dette tilfellet er det en risiko for at hvis den lages dårlig, vil den gjøre mikrokontrolleren til et ikke-funksjonelt stykke plast og jern. Det ville heller ikke skade å ha et brødbrett og gensere. De er ikke nødvendige, men vil spare deg for nerver og tid. Og til slutt trenger du en 5V strømforsyning.

Atmega8-programmering for nybegynnere ved å bruke et eksempel

La oss se på hvordan, generelt sett, en enhet er opprettet. Så la oss si at vi har en mikrokontroller, en LED, en motstand, en programmerer, tilkoblingsledninger og en strømforsyning. Det første trinnet er å skrive fastvaren. Det forstås som et sett med kommandoer for mikrokontrolleren, som presenteres som en endelig fil i et spesielt format. Det er nødvendig å spesifisere forbindelsen til alle elementer, samt interaksjon med dem. Etter dette kan du begynne å sette sammen kretsen. VCC-pinnen skal ha strøm. Til enhver annen, designet for å fungere med enheter og elementer, kobles først en motstand, og deretter en LED. I dette tilfellet avhenger kraften til den første av kraftkravene til den andre. Du kan bruke følgende formel: R=(Up-Ups)/Is. Her er p kraften og s er LED. La oss forestille oss at vi har en LED som forbruker 2V og krever en forsyningsstrøm på 10 mA, konverter den til en form som er mer praktisk for matematiske operasjoner og få 0,01A. Da vil formelen se slik ut: R=(5V-2V)/0,01A=3V/0,01A=300 Ohm. Men i praksis er det ofte umulig å velge det ideelle elementet. Derfor tas den mest passende. Men du må bruke en motstand med en motstand høyere enn verdien oppnådd matematisk. Takket være denne tilnærmingen vil vi forlenge levetiden.

Hva blir det neste?

Så vi har et lite diagram. Nå gjenstår det bare å koble programmereren til mikrokontrolleren og skrive fastvaren som ble opprettet inn i minnet. Det er ett poeng her! Når du bygger en krets, er det nødvendig å lage den på en slik måte at mikrokontrolleren kan blinke uten avlodding. Dette vil spare tid, nerver og forlenge levetiden til elementene. Inkludert Atmega8. In-circuit programmering, det skal bemerkes, krever kunnskap og ferdigheter. Men det lar deg også lage mer avanserte design. Tross alt skjer det ofte at elementer blir skadet under avlodding. Etter dette er diagrammet klart. Spenning kan påføres.

Viktige poeng

Jeg vil gjerne gi nybegynnere nyttige tips om Atmega8-programmering. Ikke endre innebygde variabler og funksjoner! Det anbefales å blinke enheten med det opprettede programmet etter å ha sjekket det for fravær av "evige løkker", som vil blokkere all annen forstyrrelse, og bruke en god sender. Hvis du bruker et hjemmelaget produkt til disse formålene, bør du være mentalt forberedt på at mikrokontrolleren svikter. Når du flasher en enhet ved hjelp av en programmerer, bør du koble til de tilsvarende utgangene VCC, GND, SCK, MOSI, RESET, MISO. Og ikke bryt sikkerhetsreglene! Hvis de tekniske spesifikasjonene bestemmer at strømforsyningen skal være 5V, må du følge nøyaktig denne spenningen. Selv bruk av 6V-elementer kan påvirke ytelsen til mikrokontrolleren negativt og forkorte levetiden. Selvfølgelig har 5V-batterier visse forskjeller, men som regel er alt innenfor rimelige grenser. For eksempel vil maksimal spenning holdes på 5,3V.

Opplæring og forbedring av ferdigheter

Heldigvis er Atmega8 en veldig populær mikrokontroller. Derfor vil det ikke være vanskelig å finne likesinnede eller rett og slett kunnskapsrike og dyktige mennesker. Hvis du ikke vil finne opp hjulet på nytt, men bare vil løse et visst problem, kan du søke etter det nødvendige opplegget på det store verdensveven. Forresten, et lite hint: selv om robotikk er ganske populær i det russisktalende segmentet, hvis det ikke er noe svar, bør du se etter det i det engelsktalende segmentet - det inneholder en størrelsesorden mer informasjon. Hvis det er visse tvil om kvaliteten på de eksisterende anbefalingene, kan du se etter bøker som diskuterer Atmega8. Heldigvis tar produksjonsselskapet hensyn til populariteten til utviklingen og forsyner dem med spesialisert litteratur, der erfarne folk forteller hva og hvordan, og gir også eksempler på hvordan enheten fungerer.

Er det vanskelig å begynne å lage noe eget?

Det er nok å ha 500-2000 rubler og noen få gratis kvelder. Denne gangen er mer enn nok til å bli kjent med Atmega8-arkitekturen. Etter litt trening kan du enkelt lage dine egne prosjekter som utfører spesifikke oppgaver. For eksempel en robotarm. Atmega8 alene burde være mer enn nok til å formidle de grunnleggende motoriske funksjonene til fingrene og hånden. Selvfølgelig er dette en ganske vanskelig oppgave, men det er ganske gjennomførbart. I fremtiden vil det være mulig å lage komplekse ting som vil kreve dusinvis av mikrokontrollere. Men dette er alt fremover, før det må du få en god praksisskole på noe enkelt.