Atmega8 programmering. Programmering av AVR-mikrokontroller. MK-gränssnitt i programmeringsläge
För att överföra från en dator till en mikrokontroller behöver vi USBasp och programmet AVRDUDE.Idag finns det ett brett urval av programmerare designade för programmering AVR mikrokontroller. Bland dem kan du hitta många hemmagjorda, som knappast ens kan kallas programmerare, eftersom de är direkt anslutna till COM-porten med bara några motstånd. dock moderna datorer och bärbara datorer är praktiskt taget inte längre utrustade med COM-portar, så ett av huvudkriterierna när du väljer en programmerare är möjligheten att ansluta den till USB uttag. Den billigaste, enklaste och vanligaste är USBasp-programmeraren. Den kan köpas i nästan vilken radiobutik som helst överkomligt pris. Dess kostnad är kinesiskt internet Butiken sträcker sig från $1,5 till $3.
Programmerare USBasp
Datorn kommunicerar med mikrokontrollern med hjälp av USBasp-programmeraren via USB-porten, och data överförs via gränssnittet SPI – S erial P erifert jag gränssnitt(seriellt perifert gränssnitt). För att kommunicera MK med programmeraren används speciella stift: MOSI, MISO, SCK, RESET, VCC, GND. Fastän SPI förutsätter användning av endast tre stift MOSI, MISO och SCK, men vi kommer att använda alla sex stift.
Vid utbyte av data via gränssnitt SPI Mikrokontrollern kan samtidigt antingen ta emot (MISO-stift) eller sända data (MOSI-stift). Inställning av läget för att ta emot eller sända data utförs genom att en viss puls appliceras på SCK-stiftet.
Programmeringskontakten har som regel 10 stift och är ansluten till mikrokontrollern med en 10-trådskabel. Det är dock bekvämare att använda kablar som har en 6-stiftsadapter, eftersom i det här fallet är alla stift upptagna. För en tiopolig kontakt förblir ett stift ledigt och fyra stift är anslutna till den gemensamma ledningen (GND).
För att datorn ska kunna upptäcka programmeraren måste du installera USBasp-drivrutinen.
Ett foto av programmeraren som är ansluten till ATmega8-mikrokontrollern visas nedan.
Den enda nackdelen eller, mer korrekt, mindre besvär med denna programmerare är att den inte stöds (utan olika tricks) av Atmel Studio, så du måste använda tredje partsprogram. Den mest beprövade är AVRDUDE.
inställningar
Nu måste vi bara slutföra det sista steget. Starta programmet AVRDUDE. Som standard öppnas fliken Program. Längst ned i fönstret i menyn Inställningar väljer du typ av programmerare usbasp. Nästa i kategorin Mikrokontroller välj vår ATmega8 mikrokontroller. Nedan i kategorin Blixt klicka på ellipsikonen och i menyn som öppnas, ange sökvägen till den kompilerade filen med tillägget hex. Sökvägen till filen och själva filen kommer att vara desamma som vi tidigare angett i .
För att säkerställa att programmeraren upptäcks av operativsystemet (programmeringsdrivrutinen är korrekt installerad) och är korrekt ansluten till mikrokontrollern, klicka på knappen Läsning. Om det inte finns några fel visas ett fönster med posten " Generatorns kalibreringsceller har lästs!” Och det hexadecimala talet kommer att visas i det övre fönstret. Varje MK har sitt eget nummer.
Innan du spelar in nytt program Det rekommenderas att rensa mikrokontrollerns minne. Detta kan göras genom att klicka på knappen Radera allt. Som ett resultat kommer ett fönster att visas som indikerar att kristallen är ren.
Klicka nu på knappen Program i kategorin Blixt. När programmet har spelats in i MK, visas ett fönster med posten nedan.
Resultatet av det inspelade, eller, som de också säger, firmware-programmet är en tänd LED ansluten till PC0-stiftet på vår mikrokontroller.
God dag. Låt oss fortsätta. Efter att vi bekantat oss med processen att felsöka programmet skrev vi i "atmel studio" och praktiskt taget monterade en krets med en lysdiod i "proteus", var det dags att montera kretsen i hårdvara och flasha mikrokontrollern.
För att programmera en prototyp ( atmega 8) kommer vi att använda USBASP-programmeraren. Det ser ut så här:
En kabel kommer att anslutas till kontakten, till vilken byglar är anslutna, som i sin tur kommer att anslutas till uttagen på brödbrädet som mikrokontrollern är installerad på:
Det första stiftet är markerat på kontakten med en pil.
Efter att vi listat ut programmeraren. Låt oss gå vidare till att montera kretsen i hårdvara. Vi monterar mikrokontrollern på en brödbräda. Låt mig påminna dig om att det första benet är markerat på MK med en liten cirkel.
Uppgiften är att ansluta programmeringsstiften till "sten"-stiften.
Vi ansluter byglar till 10-stiftskontakten. Vi använder följande stift MOSI, RST, SCK, MISO, VTG (VCC), GND.
Jag hoppas att du redan har laddat ner databladet på atmega8. Om inte kan du ladda ner den. Vi tittar på pinouten på mikrokontrollerns stift.
Vi ansluter byglar till följande stift:
- VCC till stift 7 på MK;
- SCK till stift 19 på MK;
- MISO till stift 18 på MK;
- MOSI till stift 17 på MK;
- GND (programmeringsstift 10) till stift 8 på MK;
- RST till 1 stift av MK;
För ytterligare framgångsrik drift kommer operativsystemet, när shaitan-maskinen (programmeraren) startas för första gången, att erbjuda att installera de drivrutiner som krävs för att enheten ska fungera.
Det borde inte vara några problem när du arbetar med expeditern. Ladda ner. Skapa en mapp där vi packar upp det nedladdade arkivet. Sedan i Hardware Installation Wizard anger vi sökvägen till mappen med den uppackade drivrutinen.
Om du kör Windows 7 eller senare kan du uppleva några mindre problem. Drivrutinerna för programmeraren är ganska gamla, så de har de inte digital signatur. När du försöker installera en sådan drivrutin kommer operativsystemet att visa något så här *
"Den digitala signaturen av förare som krävs för av denna enhet. På sista ändring utrustning eller programvara en felaktigt undertecknad eller skadad fil eller skadlig programvara okänt ursprung. (Kod 52)."
För att rätta till situationen måste du inaktivera verifiering av digital signatur för drivrutinen. Jag kommer inte att beskriva hur man inaktiverar det (alla har sitt eget operativsystem), de kan hittas på Internet.
När du har inaktiverat signaturverifiering anger du sökvägen till mappen med den uppackade drivrutinen i installationsguiden för maskinvara.
Jag hoppas att allt löste sig för dig och att programmeraren är redo att arbeta.
Låt oss gå vidare till att montera kretsen med lysdioden.
För att flasha mikrokontrollerns firmware kommer vi att använda programmet "avrdudeprog". Det finns i det allmänna arkivet.
Välj atmega8 från listan över mikrokontroller. När du har valt MK kommer ett fönster att visas som informerar dig om att säkrings- och låsbitarna är inställda som standard.
Öppna sedan fliken Säkringar. Med enkla ord Säkringar är MK-konfigurationsinställningar som det är bäst att inte spela med. För fallet när du köpte samma kontroller som jag och du inte har en extern kvartsresonator (du använder en intern oscillator klockfrekvens), markera exakt samma rutor som visas på bilden. Det måste finnas en bock bredvid den "omvända" posten.
De konfigurerade inställningarna "kommander" Atmega8A att utföra sitt arbete med förbehåll för klockning från den interna oscillatorn (klockningsfrekvens 8 MHz). För att inställningarna ska träda i kraft måste du klicka på knappen "Programmering". Men innan du trycker, dubbelkolla att allt är korrekt inställt.
Återgå till sidan "Program".
Efter att vi redan har berättat för programmet vilken mikrokontroller vi kommer att blinka, väljer vi firmwarefilen som vi skrev i förra lektionen. Den har en HEX-förlängning. Finns i mappen "Debug".
Innan du blinkar "stenen", klicka på knappen "Radera allt". Detta kommer att skydda dig från obegripliga misstag (tänk om stenen redan har sytts):
Vi njuter av resultatet av vårt arbete :) Fortsättning följer...
Jag har sagt mer än en eller två gånger att studera MK ska börja med assembler. En hel kurs på webbplatsen ägnades åt detta (även om det inte är särskilt konsekvent, men efter hand kammar jag det till ett adekvat utseende). Ja, det är svårt, resultatet kommer inte att vara den första dagen, men du kommer att lära dig att förstå vad som händer i din kontroller. Du kommer att veta hur det fungerar, och inte kopiera andras källor som en apa och försöka förstå varför det plötsligt slutade fungera. Dessutom är det mycket lättare för C att skapa redneck-kod som kommer ut med en höggaffel vid det mest olämpliga ögonblicket.
Tyvärr vill alla ha resultat direkt. Så jag bestämde mig för att gå åt andra hållet - göra en tutorial på C, men med att visa hans underkläder. En bra inbäddningsprogrammerare håller alltid sin hårdvara hårt vid bulten, så att den inte kan ta ett enda steg utan tillstånd. Så först blir det C-koden, sedan vad kompilatorn producerade och hur det hela faktiskt fungerar :)
Å andra sidan, Xi starka sida Detta är kodportabilitet. Om du förstås skriver allt rätt. Separera arbetsalgoritmerna och deras hårdvaruimplementationer i olika delar av projektet. Sedan, för att överföra algoritmen till en annan mikrokontroller, räcker det att endast skriva om gränssnittslagret, där alla anrop till hårdvaran skrivs, och lämna all arbetskod som den är. Och förstås läsbarhet. C-källkoden är lättare att förstå vid första anblicken (även om ... till exempel, jag bryr mig inte om vad jag ska peka på - vare sig det är C eller ASM :)), men återigen, om allt är skrivet korrekt. Jag kommer också att uppmärksamma dessa punkter.
Lejonparten av alla exempel kommer att vara min som provbiten på vilken lejonparten av alla exempel kommer att installeras. utvecklingsstyrelsen.
Det första C-programmet för AVR
Att välja en kompilator och ställa in miljön
Det finns många olika C-kompilatorer för AVR:
Först av allt detta IAR AVR C- är nästan definitivt erkänd som den bästa kompilatorn för AVR, eftersom själva styrenheten skapades i nära samarbete mellan Atmel och specialister från IAR. Men du måste betala för allt. Och den här kompilatorn är inte bara en dyr kommersiell programvara, utan har också så många inställningar att det tar mycket ansträngning att helt enkelt kompilera den i den. Jag utvecklade verkligen ingen vänskap med honom; projektet ruttnade på grund av konstiga fel vid länkningsstadiet (senare fick jag reda på att det var en sned spricka).
Andra kommer WinAVR GCC- en kraftfull optimeringskompilator. Helt öppen källkod, plattformsoberoende, i allmänhet, alla glädjeämnen i livet. Den integreras också perfekt i AVR Studio så att du kan felsöka precis där, vilket är jävligt bekvämt. I allmänhet valde jag det.
Det finns också CodeVision AVR Cär en mycket populär kompilator. Det blev populärt på grund av sin enkelhet. Arbetsprogram Du kan få det på bara några minuter - startkodsguiden hjälper till mycket med detta, stämplar standarder för initiering av alla typer av uarts. För att vara ärlig är jag lite misstänksam mot det - när jag väl var tvungen att demontera ett program skrivet av den här kompilatorn visade det sig vara någon form av röra och inte kod. En fruktansvärd mängd onödiga rörelser och operationer, vilket resulterade i en ansenlig mängd kod och långsam prestanda. Men det kanske fanns ett fel i DNA:t hos personen som skrev den ursprungliga firmwaren. Plus att han vill ha pengar. Inte lika mycket som IAR, men märkbart. Och i demoläge låter den dig inte skriva mer än 2kb kod.
Naturligtvis finns det en spricka, men om du ska stjäla är det en miljon, i IAR-bemärkelse :)
Det finns också Image Craft AVR C Och MicroC från mikroelektronik. Jag behövde inte använda någondera, men S.W.G. mycket berömmande MicroPascal, säger de, en fruktansvärt bekväm programmeringsmiljö och bibliotek. Jag tror att MicroC inte kommer att vara sämre, men det är också betalt.
Jag valde som sagt WinAVR av tre anledningar: det är gratis, det integreras i AVR Studio och det är skrivet för det. redo kod för alla tillfällen.
Så ladda ner WinAVR-installationen med AVR Studio. Därefter installeras studion först, sedan rullas WinAVR ovanpå och kopplas till studion i form av en plugin. Jag rekommenderar starkt att du installerar WinAVR på en kort väg, ungefär som C:\WinAVR, på så sätt slipper du många problem med sökvägar.
Skapa ett projekt
Så, studion är installerad, C är fastskruvad, det är dags att försöka programmera något. Låt oss börja med det enkla, det enklaste. Starta en studio, välj där nytt projekt, som AVR GCC-kompilator och ange namnet på projektet.
Ett arbetsfält öppnas med en tom *.c-fil.
Nu kommer det inte att skada att konfigurera visningen av vägar i studiobokmärkena. För att göra detta, gå till:
Meny Verktyg - Alternativ - Allmänt - Filflikar och välj "Endast filnamn" från rullgardinsmenyn. Annars kommer det att vara omöjligt att fungera - fliken kommer att innehålla hela sökvägen till filen och det kommer inte att finnas mer än två eller tre flikar på skärmen.
Projektuppsättning
I allmänhet anses det vara klassiskt att skapa en make-fil där alla beroenden beskrivs. Och det är nog rätt. Men för mig, som växte upp med helt integrerade IDE som uVision eller AVR Studio detta tillvägagångssätt är djupt främmande. Därför kommer jag att göra det på mitt sätt, allt med hjälp av studiomedel.
Peka på knappen med kugghjulet.
 |
Det här är inställningarna för ditt projekt, eller snarare inställningarna för automatisk generering av en make-fil. På den första sidan behöver du bara ange den frekvens med vilken din MK kommer att fungera. Detta beror på säkringsbitarna, så vi antar att vår frekvens är 8000000Hz.
Var också uppmärksam på optimeringslinjen. Nu finns det -Os - detta är storleksoptimering. Lämna det som det är nu, så kan du försöka spela med den här parametern. -O0 är ingen optimering alls.
Nästa steg är att konfigurera sökvägarna. Först av allt, lägg till din projektkatalog där - du kommer att lägga till tredjepartsbibliotek där. Sökvägen ".\" visas i listan.
Make-filen har skapats, du kan titta på den i standardmappen i ditt projekt, ta bara en titt och se vad som finns där.
 |
Det var allt tills vidare. Klicka på OK överallt och gå till källan.
Formulering av problemet
Ett tomt pappersark är frestande att implementera någon listig idé, eftersom det banala blinkandet av en diod inte längre fungerar. Låt oss omedelbart ta tjuren vid hornen och implementera kopplingen till datorn - det här är det första jag gör.
Det kommer att fungera så här:
När en etta (kod 0x31) kommer till COM-porten slår vi på dioden, och när en nolla kommer (kod 0x30) stängs den av. Dessutom kommer allt att göras på avbrott, och bakgrundsuppgiften kommer att blinka en annan diod. Enkelt och meningsfullt.
Montering av kretsen
Vi måste ansluta USB-USART-omvandlarmodulen till USART-stiften på mikrokontrollern. För att göra detta, ta en bygel från två ledningar och placera den på stiften korsvis. Det vill säga, vi ansluter styrenhetens Rx till omvandlarens Tx och omvandlarens Tx till styrenhetens Rx.
I slutändan är detta diagrammet:
 |
Jag överväger inte att ansluta de återstående stiften, ström eller återställa, det är standard.
Skriver kod
Låt mig genast göra en reservation för att jag inte kommer att fördjupa mig specifikt i beskrivningen av själva C-språket. Det finns helt enkelt en kolossal mängd material för detta, allt från det klassiska "C Programming Language" från K&R till olika manualer.
Jag hittade en sådan metod i mitt förråd, jag använde den en gång för att studera detta språk. Allt där är kort, tydligt och rakt på sak. Jag sätter gradvis ihop det och drar det till min hemsida.
Det är sant att inte alla kapitel har överförts än, men jag tror att det inte kommer att dröja länge.
Det är osannolikt att jag kan beskriva det bättre, så från träningskurs, istället för en detaljerad förklaring av subtiliteterna, kommer jag helt enkelt att tillhandahålla direktlänkar till enskilda sidor i denna manual.
Lägger till bibliotek.
Först och främst lägger vi till de nödvändiga biblioteken och rubrikerna med definitioner. När allt kommer omkring är C ett universellt språk och vi måste förklara för honom att vi arbetar specifikt med AVR, så skriv raden i källkoden:
| 1 | #omfatta |
#omfatta
Denna fil finns i mappen WinAVR och den innehåller en beskrivning av alla register och portar på styrenheten. Dessutom är allt där listigt, med bindning till en specifik styrenhet, som överförs av kompilatorn via göra fil i parameter MCU och baserat på denna variabel kopplas en header-fil till ditt projekt med en beskrivning av adresserna till alla portar och register för just denna styrenhet. Wow! Utan det är det också möjligt, men då kommer du inte att kunna använda symboliska registernamn som SREG eller UDR och du måste komma ihåg adressen till var och en som "0xC1", vilket kommer att vara en huvudvärk.
Själva laget #omfatta<имя файла> låter dig lägga till innehåll av alla slag till ditt projekt textfil, till exempel en fil med en beskrivning av funktioner eller en bit annan kod. Och för att direktivet skulle kunna hitta den här filen angav vi sökvägen till vårt projekt (WinAVR-katalogen är redan registrerad där som standard).
Huvudfunktion.
Ett C-program består helt av funktioner. De kan kapslas och anropas från varandra i valfri ordning och olika sätt. Varje funktion har tre nödvändiga parametrar:
- Returvärdet är t.ex. sin(x) returnerar värdet på sinus av x. Som i matematik, kort och gott.
- De överförda parametrarna är samma X.
- Funktionskropp.
Alla värden som överförs och returneras måste vara av någon typ, beroende på data.
Alla C-program måste innehålla en funktion huvud som en ingång till huvudprogrammet, annars är det inte alls C :). Genom närvaron av main i någon annans källkod från en miljon filer kan du förstå att detta är huvuddelen av programmet, där allt börjar. Så låt oss fråga:
| 1 2 3 4 5 | int main(void) (retur 0;) |
int main(void) ( return 0; )
Det var allt, först enklaste programmet skrivet, det spelar ingen roll att det inte gör någonting, vi har precis börjat.
Låt oss ta reda på vad vi gjorde.
int Detta är den datatyp som huvudfunktionen returnerar.
Naturligtvis i en mikrokontroller huvud i princip ingenting kan returneras och i teorin borde det vara det void main(void), men GCC designades ursprungligen för PC och där kan programmet returnera värdet operativ system vid färdigställande. Därför GCC på void main(void) svär vid varning.
Detta är inte ett fel, det kommer att fungera, men jag gillar inte varningar.
tomhet detta är den typ av data som vi skickar till funktionen, i det här fallet huvud kan därför inte heller acceptera något utifrån tomhet- en dummy. En stubb används när det inte finns något behov av att sända eller returnera något.
Här är de { } lockiga hängslen är ett programblock, i detta fall kroppen av en funktion huvud, kommer koden att finnas där.
lämna tillbaka- det här är returvärdet som huvudfunktionen kommer att returnera vid slutförandet, eftersom vi har en int, det vill säga ett tal, då måste vi returnera ett tal. Även om detta fortfarande inte är meningsfullt, eftersom... på mikrokontrollern kan vi bara gå ingenstans från main. Jag returnerar null. För det spelar ingen roll. Men kompilatorn är vanligtvis smart och genererar inte kod för det här fallet.
Även om, om pervers, då från huvud Du kan gå till MK - till exempel falla in i bootloader-sektionen och köra den, men detta kommer att kräva att du manipulerar på låg nivå med firmwaren för att korrigera övergångsadresserna. Nedan ser du själv och förstår hur du gör. För vad? Detta är en annan fråga, i 99,999% av fallen är detta inte nödvändigt :)
Vi gjorde det och gick vidare. Låt oss lägga till en variabel, vi behöver den egentligen inte och det är ingen idé att introducera variabler utan den, men vi lär oss. Om variabler läggs till inuti kroppen av en funktion, är de lokala och existerar endast i den här funktionen. När du avslutar funktionen raderas dessa variabler och RAM-minnet allokeras för viktigare behov. .
| 1 2 3 4 5 6 | int main(void) (osignerad char i; return 0;) |
int main(void) (osignerad char i; return 0;)
osignerad betyder osignerad. Faktum är att i den binära representationen allokeras den mest signifikanta biten till tecknet, vilket innebär att talet +127/-128 passar in i en byte (char), men om tecknet kasseras kommer det att passa från 0 till 255. Vanligtvis behövs inte skylten. Så osignerad.
iär bara ett variabelnamn. Inte mer.
Nu måste vi initiera portarna och UART. Naturligtvis kan du ta och ansluta biblioteket och anropa någon form av UartInit(9600); men då vet du inte vad som egentligen hände.
Vi gör så här:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | int main(void) (osignerad 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) (osignerad char i; #define XTAL 8000000L #define baudrate 9600L #define baudvider (XTAL/(16*baudrate)-1) #define HI(x) ((x)>>8) #define LO( x) ((x)& 0xFF) UBRRL = LO(bauddivider); UBRRH = HI(bauddivider); UCSRA = 0; UCSRB = 1< Skrämmande? Faktum är att det bara finns fem sista raderna med riktig kod. Allt som #definiera Det är ett förbehandlare makrospråk. Nästan samma saker som i Assembly, men syntaxen är något annorlunda. De kommer att underlätta dina rutinoperationer för att beräkna de nödvändiga koefficienterna. I första raden säger vi det istället XTAL du kan säkert ersätta 8000000, och L- indikering av typen, som säger att lång är processorns klockfrekvens. Det samma baudrate— Frekvens för dataöverföring via UART. bauddivider redan mer komplicerat, istället för det kommer uttrycket som beräknats med formeln från de två föregående att ersättas. Så allt som är gjort är som #definiera du kan säkert slänga det och beräkna de nödvändiga siffrorna på en miniräknare och omedelbart skriva in dem på raderna UBBRL = …. och UBBRH = ….. Burk. Men! Gör det här ABSOLUT OMÖJLIGT! Det kommer att fungera så eller så, men du kommer att ha sk magiska siffror- värderingar hämtade från ingenstans och av okända anledningar, och om man öppnar ett sådant projekt om ett par år så blir det jävligt svårt att förstå vad dessa värderingar är. Även nu, om du vill ändra hastigheten eller ändra kvartsfrekvensen, måste allt räknas om igen, men du ändrade ett par siffror i koden och det är allt. I allmänhet, om du inte vill bli stämplad som en kodare, gör sedan din kod så att den är lätt att läsa, förståelig och lätt att ändra. Då är allt enkelt: Inspelningstyp 1< Klart, dags att se vad som hände. Klicka på kompilering och starta emulering (Ctrl+F7). Felsökning Faktum är att det från början faktiskt var på raden UBRRL = LO(bauddivider); Det vi har i definition är trots allt inte kod, utan bara preliminära beräkningar, varför simulatorn är lite tråkig. Men nu insåg han, den första instruktionen är klar och om du klättrar upp i trädet I/O-vy, till USART-sektionen och titta på UBBRL-byten där, kommer du att se att värdet redan finns där! 0x33. Ta det ett steg längre. Se hur innehållet i det andra registret förändras. Så gå igenom dem alla, var uppmärksam på att alla angivna bitar är inställda som jag sa till dig, och de är inställda samtidigt för hela byten. Det går inte längre än till Return – programmet är över. Öppning Först kommer toppar från serien: 00000000: 940C002A JMP 0x0000002A Hopp +00000002: 940C0034 JMP 0x00000034 Hopp +00000004: 940C0034 JMP 0x00000 +4C34 JMP 0x00000 +40000 0x00000034 Hopp +00000008: 940C0034 JMP 0x00000034 Hopp +0000000A: 940C0034 JMP 0x00000034 Hopp +0000000C: 940 J0C0000000000E440 : 940C0034 JMP 0x00000034 Hopp +00000010: 940C0034 JMP 0x00000034 Hopp +00000012: 940C0034 JMP 0x00000030 9 JMP 000000034 Hopp +000000012: 940C0034 JMP 0x00000030 9 JMP 000000030 0400000034 JMP 010000034 0400000034 JMP 010000034 34 Hopp +00000016: 940C0034 JMP 0x00000034 Hopp +00000018: 940C0034 JMP 0x00000034 Hopp +0000001A: 940C0034 JMP +000040 JMP 00004 : 940C0034 JMP 0x00000034 Hopp +0000001E: 940C0034 JMP 0x00000034 Hopp +000000020: 940C0034 JMP 0x00000030 9 JMP 020000034 0200000034 0200000034 JMP 020000034 JMP 020000034 0200000030 34 Hopp +00000024: 940C0034 JMP 0x00000034 Hopp +00000026: 940C0034 JMP 0x00000034 Hopp +00000028: 940C0030 Hopp 00304 JMP 00304 Detta är avbrottsvektortabellen. Vi återkommer till det senare, men för nu är det bara att titta och komma ihåg att det finns. Den första kolumnen är adressen till flashcellen i vilken kommandot ligger, den andra är kommandokoden, den tredje är kommandot mnemonic, samma monteringsinstruktion, den tredje är kommandots operander. Tja, automatisk kommentar. 0000002B: BE1F OUT 0x3F,R1 Ut till I/O-plats Spelar in denna nolla på adress 0x3F. Om du tittar på I/O-vykolumnen kommer du att se att adress 0x3F är adressen till SREG-registret - kontrollenhetens flaggregister. De där. vi återställer SREG för att köra programmet på nollvillkor. 0000002C: E5CF LDI R28,0x5F Ladda omedelbart +0000002D: E0D4 LDI R29,0x04 Ladda omedelbart +0000002E: BFDE OUT 0x3E,R29 Ut till I/O plats +0000002F:/8 Ut till I/O plats +00000002F:/8 Ut till I/O plats Detta laddar stackpekaren. Du kan inte ladda direkt i I/O-register, endast genom ett mellanregister. Därför först LDI till mellanliggande, och sedan därifrån OUT till I/O. Jag kommer också att berätta mer om stacken senare. För nu, vet att detta är ett dynamiskt minnesområde som hänger i slutet av RAM och lagrar adresser och mellanliggande variabler. Nu har vi angett var vår stack ska börja från. 00000032: 940C0041 JMP 0x00000041 Hopp Hoppa till slutet av programmet, och där har vi ett förbud mot avbrott och looping tätt på sig själv: 00000041: 94F8 CLI Global Interrupt Disable +00000042: CFFF RJMP PC-0x0000 Relativt hopp Detta är vid oförutsedda omständigheter, som att avsluta huvudfunktionen. Styrenheten kan tas ut ur en sådan slinga antingen genom en hårdvaruåterställning eller, mer troligt, genom en återställning från en vakthund. Tja, eller, som jag sa ovan, korrigera detta i hex-editorn och galoppera iväg dit vårt hjärta vill. Observera också att det finns två typer av övergångar: JMP och RJMP; den första är en direkt övergång till en adress. Den upptar fyra byte och kan direkt hoppa genom hela minnesområdet. Den andra typen av övergång är RJMP - relativ. Hans kommando tar två byte, men han flyttar sig från den aktuella positionen (adressen) 1024 steg framåt eller bakåt. Och dess parametrar indikerar offset från den aktuella punkten. Det används oftare pga tar upp halva utrymmet i en spolning, och långa övergångar behövs sällan. 00000034: 940C0000 JMP 0x00000000 Jump Och detta är ett hopp till början av koden. En sorts omstart. Du kan kontrollera att alla vektorer hoppar här. Slutsatsen från detta är att om du nu aktiverar avbrott (de är inaktiverade som standard) och ditt avbrott inträffar men det finns ingen hanterare, så kommer det att ske en mjukvaruåterställning - programmet kommer att kastas tillbaka till början. Funktion huvud. Allt är likt, du behöver inte ens beskriva det. Se bara på det redan beräknade antalet som förs in i registren. Kompilatorns förprocessor rockar!!! Så inga "magiska" siffror! 00000036: E383 LDI R24,0x33 Ladda omedelbart +00000037: B989 OUT 0x09,R24 Ut till I/O plats 15: UBRRH = HI(bauddivider); +00000038: BC10 UT 0x20,R1 Ut till I/O-plats 16: UCSRA = 0; +00000039: B81B UT 0x0B,R1 Ut till I/O-plats 17: UCSRB = 1< Och här är buggen: 0000003E: E080 LDI R24.0x00 Ladda omedelbart +0000003F: E090 LDI R25.0x00 Ladda omedelbart +00000040: 9508 RET Subrutin retur Frågan är varför kompilatorn lägger till sådana toppar? Och det här är inget annat än Return 0, vi definierade funktionen som int main(void) och så slösade vi ytterligare fyra byte för ingenting :) Och om du gör void main(void) kommer bara RET att finnas kvar, men en varning kommer att visas , att vår huvudfunktion inte returnerar något. I allmänhet, gör som du vill :) Svår? Uppenbarligen inte. Klicka steg-för-steg-exekvering i disassembler-läge och se hur processorn utför individuella instruktioner, vad som händer med registren. Hur sker rörelse genom kommandon och slutlig looping? Fortsättning om ett par dagar... Offtop: Uppgift: Låt oss utveckla ett program för att styra en lysdiod. När knappen trycks in tänds lysdioden och när den släpps slocknar den. Låt oss först utveckla ett schematiskt diagram av enheten. I/O-portar används för att ansluta externa enheter till mikrokontrollern. Var och en av portarna kan fungera som både ingång och utgång. Låt oss ansluta lysdioden till en av portarna och knappen till den andra. För detta experiment kommer vi att använda en styrenhet Atmega8. Detta chip innehåller 3 I/O-portar, har 2 åtta-bitars och 1 sexton-bitars timer/räknare. Även ombord finns en 3-kanals PWM, 6-kanals 10-bitars analog-till-digital-omvandlare och mycket mer. Enligt min mening är en mikrokontroller bra för att lära sig grunderna i programmering. För att ansluta lysdioden kommer vi att använda linje PB0, och för att läsa information från knappen använder vi linje PD0. Diagrammet visas i fig. 1. Ris. 1 Genom motstånd R2 tillförs plus matningsspänning till ingången PD0, vilket motsvarar en logisk ettasignal. När knappen stängs sjunker spänningen till noll, vilket motsvarar en logisk noll. I framtiden kan R2 uteslutas från kretsen, ersätta den med ett internt belastningsmotstånd, ange de nödvändiga inställningarna i programmet. Lysdioden är ansluten till utgången på port PB0 genom strömbegränsande motstånd R3. För att tända lysdioden måste du lägga på en logisk ettsignal på PB0-linjen. Vi kommer att använda en intern masterklockgenerator på 4 MHz, eftersom enheten inte har höga krav på frekvensstabilitet. Nu skriver vi programmet. Jag använder programmeringsmiljön för att skriva program AVR Studio Och WinAvr.Öppna AVR Studio, ett välkomstfönster dyker upp, klicka på knappen "Skapa ett nytt projekt", välj sedan projekttyp - AVR GCC, skriv projektnamnet till exempel "cod1", kontrollera både "Skapa projektmapp" och "Skapa" initialiseringsfil" kryssrutor, klicka på knappen "Nästa", välj "AVR Simulator" i det vänstra fönstret och "Atmega8" mikrokontroller skriv i det högra fönstret, klicka på knappen "Slutför", redigeraren och projektkategoriträdet öppnas - initiala inställningar är klara. Låt oss först lägga till standardbeskrivningstext för Atmega8 med operatören för att bifoga externa filer: #omfatta direktivsyntax #omfatta #omfatta<имя_файла.h> Vinkelfästen< и >ange för kompilatorn att inkluderade filer först måste letas efter i WinAvr standardmappen med namnet include. Dubbla citattecken " och " talar om för kompilatorn att börja söka i katalogen där projektet är lagrat. Varje typ av mikrokontroller har sin egen rubrikfil. För ATMega8 kallas denna fil iom8.h, för ATtiny2313 - iotn2313.h. I början av varje program måste vi inkludera rubrikfilen för mikrokontrollern vi använder. Men det finns också en vanlig rubrikfil io.h. Förprocessorn bearbetar denna fil och inkluderar, beroende på projektinställningarna, den erforderliga huvudfilen i vårt program. För oss kommer den första raden i programmet att se ut så här: #omfatta Alla C-program måste innehålla en huvudfunktion. Den heter main. Programexekveringen börjar alltid med exekveringen av huvudfunktionen. Funktionen har en header - int main(void) och en body - den är avgränsad av hängslen (). int main(void) Vi kommer att lägga till vår kod i funktionens kropp. Returtypen anges före funktionsnamnet. Om funktionen inte returnerar ett värde, används nyckeln tomhet. int- detta är ett 2-byte heltal, värdeintervallet är från - 32768 till 32767 Efter funktionsnamnet anges parametrarna som skickas till funktionen när den anropas inom parentes (). Om funktionen inte har några parametrar används nyckelordet tomhet. Fungera huvud innehåller en uppsättning kommandon, systeminställningar och huvudprogramslingan. Därefter konfigurerar vi porten D vid ingången. Portens driftläge bestäms av innehållet i registret DDRD(informationsöverföringsriktningsregister). Vi skriver numret "0x00" (0b0000000 - i binär form) i detta register; ingenting är anslutet till denna port förutom knappen, så vi konfigurerar hela port D som en ingång. Du kan konfigurera porten bit för bit genom att skriva siffrorna 0 eller 1 i varje bit i registret (0-ingång, 1-utgång), till exempel DDRD = 0x81 (0b10000001) - den första och sista raden i port D fungerar som output, resten som input. Det interna belastningsmotståndet måste också anslutas. PORTx-registret styr om de interna motstånden slås på eller av när porten är i ingångsläge. Låt oss skriva enheter där. Konfigurera porten B till utgången. Portens driftläge bestäms av innehållet i registret DDRB. Inget annat än en LED till porten B inte ansluten, så hela porten kan konfigureras som utgång. Detta görs genom att skriva till registret DDRB siffrorna "0xFF". För att förhindra att lysdioden tänds när du slår på den första gången, skriv till porten B logiska nollor. Detta görs genom att spela in PORTB= 0x00; För att tilldela värden används symbolen "=" och kallas för tilldelningsoperatorn, inte att förväxla med tecknet "lika". Portkonfigurationen kommer att se ut så här: DDRD = 0x00; Vi skriver programmets huvudslinga. medan("while" från engelska) - detta kommando organiserar en loop, upprepar slingans kropp många gånger tills villkoret är uppfyllt, det vill säga medan uttrycket inom parentes är sant. I C anses ett uttryck vara sant om det inte är lika med noll, och falskt om det är det. Kommandot ser ut så här: medan (skick) I vårt fall kommer huvudslingan att bestå av endast ett kommando. Detta kommando tilldelar register PORTB registervärdet som ska inverteras PORTD. PORTB = ~PIND; //ta värdet från port D, invertera det och tilldela det till PORTB (skriv till PORTB) // C-uttryck läses från höger till vänster PIND informationsinmatningsregister. För att kunna läsa information från styrenhetens externa utgång måste du först växla önskad bit av porten till ingångsläge. Det vill säga skriv till motsvarande bit i registret DDRx noll. Först efter detta kan en digital signal från en extern enhet matas till detta stift. Därefter kommer mikrokontrollern att läsa byten från registret PINx. Innehållet i motsvarande bit motsvarar signalen på portens externa stift. Vårt program är klart och ser ut så här: #omfatta Kommentarer används ofta i C-språket. Det finns två sätt att skriva. /*En kommentar*/ I det här fallet kommer kompilatorn inte att uppmärksamma vad som skrivs i kommentaren. Om du använder samma program och ansluter 8 knappar och 8 lysdioder till mikrokontrollern, som visas i figur 2, kommer det att vara tydligt att varje bit av porten D matchar dess portbit B. Genom att trycka på SB1-knappen tänds HL1, genom att trycka på SB2-knappen tänds HL2 osv. figur 2 Artikeln använde material från boken av A.V. Belov. "Handledning för AVR-enhetsutvecklare" Atmega8 mikrokontroller är de mest populära representanterna för sin familj. På många sätt beror de på å ena sidan enkelhet i drift och begriplig struktur och å andra sidan ganska bred funktionalitet. Den här artikeln kommer att täcka Atmega8-programmering för nybörjare. Mikrokontroller finns överallt. De finns i kylskåp, tvättmaskiner, telefoner, fabriksmaskiner och ett stort antal andra tekniska apparater. Mikrokontroller sträcker sig från enkla till extremt komplexa. De senare erbjuder betydligt fler funktioner och funktionalitet. Men du kommer inte att kunna förstå komplex teknik direkt. Till en början måste du behärska något enkelt. Och Atmega8 kommer att tas som ett prov. Att programmera på den är inte svårt tack vare dess kompetenta arkitektur och vänliga gränssnitt. Dessutom har den tillräcklig prestanda för att användas i de flesta.Dessutom används de även inom industrin. När det gäller Atmega8 kräver programmering kunskaper i språk som AVR (C/Assembler). Var ska man börja? Att bemästra denna teknik är möjligt på tre sätt. Och alla väljer själva var de ska börja arbeta med Atmega8: Vi kommer att överväga den första och tredje punkten. Detta är en bekväm plattform designad i en form som är lämplig för att snabbt skapa olika enheter. Kortet har redan allt du behöver i form av själva mikrokontrollern, dess sele och programmerare. Genom att följa denna väg kommer en person att få följande förmåner: Men det finns också vissa nackdelar. Således tillåter Arduino-programmering Atmega8 dig inte att kasta dig djupare in i mikrokontrollerns värld och förstå många användbara aspekter. Dessutom måste du lära dig ett programmeringsspråk, som skiljer sig från de som används av AVR (C/Assembler). Och en sak till: Arduino har ett ganska smalt utbud av modeller. Därför kommer det förr eller senare att finnas ett behov av att använda en mikrokontroller, som inte används i kort. Men generellt sett är detta ett bra alternativ för att arbeta med Atmega8. Programmering via Arduino ger dig en trygg start i elektronikens värld. Och en person kommer sannolikt inte att ge upp på grund av misslyckanden och problem. Tack vare den vänliga designen kan du göra dem själv. Detta kräver trots allt billiga, prisvärda och enkla komponenter. Detta gör att du kan studera designen av Atmega8-mikrokontrollern, vars programmering efter montering kommer att verka lättare. Vid behov kan du också självständigt välja andra komponenter för en specifik uppgift. Det är sant att det finns en viss nackdel här - komplexitet. Det är inte lätt att montera en mikrokontroller på egen hand när du inte har nödvändiga kunskaper och färdigheter. Vi kommer att överväga detta alternativ. Först måste du skaffa Atmega8 själv. Att programmera en mikrokontroller utan den, du vet, är omöjligt. Det kommer att kosta flera hundra rubel - samtidigt som det ger anständig funktionalitet. Det är också frågan om hur Atmega8 kommer att programmeras. USBAsp är en ganska bra enhet som har visat sig vara väldigt bra. Men du kan använda någon annan programmerare. Eller montera den själv. Men i det här fallet finns det en risk att om den skapas dåligt kommer den att förvandla mikrokontrollern till en icke-funktionell bit av plast och järn. Det skulle inte heller skada att ha en brödbräda och byglar. De är inte nödvändiga, men kommer att spara nerver och tid. Och slutligen behöver du en 5V strömkälla. Låt oss titta på hur, generellt sett, en enhet skapas. Så låt oss säga att vi har en mikrokontroller, en lysdiod, ett motstånd, en programmerare, anslutningskablar och en strömförsörjning. Det första steget är att skriva firmware. Det förstås som en uppsättning kommandon för mikrokontrollern, som presenteras som en slutlig fil i ett speciellt format. Det är nödvändigt att specificera anslutningen av alla element, såväl som interaktion med dem. Efter detta kan du börja montera kretsen. VCC-stiftet ska vara strömsatt. Till alla andra, designade för att fungera med enheter och element, ansluts först ett motstånd och sedan en lysdiod. I det här fallet beror kraften hos den första på effektkraven för den andra. Du kan använda följande formel: R=(Up-Ups)/Is. Här är p strömmen och s är lysdioden. Låt oss föreställa oss att vi har en lysdiod som förbrukar 2V och kräver en matningsström på 10 mA, konvertera den till en form som är mer bekväm för matematiska operationer och få 0,01A. Då kommer formeln att se ut så här: R=(5V-2V)/0.01A=3V/0.01A=300 Ohm. Men i praktiken är det ofta omöjligt att välja det ideala elementet. Därför tas den mest lämpliga. Men du måste använda ett motstånd med ett motstånd som är högre än det matematiskt erhållna värdet. Tack vare detta tillvägagångssätt förlänger vi dess livslängd. Så vi har ett litet diagram. Nu återstår bara att ansluta programmeraren till mikrokontrollern och skriva in den fasta programvaran som skapades i dess minne. Det finns en poäng här! När du bygger en krets är det nödvändigt att skapa den på ett sådant sätt att mikrokontrollern kan blinka utan avlödning. Detta kommer att spara tid, nerver och förlänga livslängden på elementen. Inklusive Atmega8. In-circuit programmering, det bör noteras, kräver kunskaper och färdigheter. Men det låter dig också skapa mer avancerade mönster. När allt kommer omkring händer det ofta att element skadas under avlödning. Efter detta är diagrammet klart. Spänning kan appliceras. Jag skulle vilja ge nybörjare användbara tips om Atmega8-programmering. Ändra inte inbyggda variabler och funktioner! Det är lämpligt att flasha enheten med det skapade programmet efter att ha kontrollerat det för frånvaron av "eviga loopar", som kommer att blockera alla andra störningar och använda en bra sändare. Om du använder en hemmagjord produkt för dessa ändamål bör du vara mentalt förberedd på att mikrokontrollern misslyckas. När du flashar en enhet med hjälp av en programmerare bör du ansluta motsvarande utgångar VCC, GND, SCK, MOSI, RESET, MISO. Och bryt inte mot säkerhetsföreskrifterna! Om de tekniska specifikationerna föreskriver att strömförsörjningen ska vara 5V, måste du följa exakt denna spänning. Även användningen av 6V-element kan påverka mikrokontrollerns prestanda negativt och förkorta dess livslängd. Naturligtvis har 5V-batterier vissa skillnader, men som regel är allt inom rimliga gränser. Till exempel kommer den maximala spänningen att hållas vid 5,3V. Lyckligtvis är Atmega8 en mycket populär mikrokontroller. Därför kommer det inte att vara svårt att hitta likasinnade eller helt enkelt kunniga och skickliga personer. Om du inte vill uppfinna hjulet på nytt, utan bara vill lösa ett visst problem, kan du söka efter det nödvändiga schemat på den stora webben. Förresten, en liten ledtråd: även om robotteknik är ganska populär i det rysktalande segmentet, om det inte finns något svar, bör du leta efter det i det engelsktalande segmentet - det innehåller en storleksordning mer information. Om det finns vissa tvivel om kvaliteten på de befintliga rekommendationerna, kan du leta efter böcker som diskuterar Atmega8. Lyckligtvis tar tillverkningsföretaget hänsyn till populariteten för sin utveckling och förser dem med specialiserad litteratur, där erfarna personer berättar vad och hur, och även ger exempel på hur enheten fungerar. Det räcker att ha 500-2000 rubel och några lediga kvällar. Den här tiden är mer än tillräckligt för att bekanta dig med Atmega8-arkitekturen. Efter lite övning kan du enkelt skapa dina egna projekt som utför specifika uppgifter. Till exempel en robotarm. Enbart Atmega8 borde vara mer än tillräckligt för att förmedla de grundläggande motoriska funktionerna i fingrarna och handen. Naturligtvis är detta en ganska svår uppgift, men det är ganska genomförbart. I framtiden kommer det att vara möjligt att skapa komplexa saker som kommer att kräva dussintals mikrokontroller. Men allt detta ligger framför dig, innan dess måste du få en bra övningsskola på något enkelt.
Bra och L.O. Och HEJ de låga och höga byten kommer att tas från detta resultat, eftersom Det kanske uppenbarligen inte passar in i en byte. I HEJ X (makroingångsparametern) förskjuts åtta gånger åt höger, vilket resulterar i att endast den mest signifikanta byten återstår. Och i L.O. vi gör bitvis OCH med siffran 00FF, som ett resultat kommer bara den låga byten att finnas kvar.
Alla dessa "UBRRL och Co" är konfigurationsregister för UART-sändaren med hjälp av vilka vi kommer att kommunicera med världen. Och nu har vi tilldelat dem de nödvändiga värdena, ställt in dem till önskad hastighet och läge.
Alla möjliga förloppsstaplar sprang igenom, studion ändrades och en gul pil dök upp nära ingången till huvudfunktionen. Det är här processorn körs för närvarande och simuleringen är pausad.
Återställ nu simuleringen till noll. Klicka där Återställ (Skift+F5). Öppna den demonterade listan, nu kommer du att se vad som faktiskt händer i kontrollern. Visa -> Demonterare. Och inte YYAAAAAA!!! Assemblerare!!! SKRÄCK!!! OCH DET ÄR NÖDVÄNDIGT. Så att du senare, när något går fel, inte är dum i koden och inte ställer lata frågor på forumen, utan omedelbart sätter dig i magen och ser var du har fastnat. Det finns inget läskigt där. 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 Hoppa +00000002: 940C0034 JMP 0x00000034 Hoppa +00000004: 940C0034 JMP 0x00000 +4C000000 +4C34 JMP 0x00000 +4C 0x00000034 Hopp +00000008: 940C0034 JMP 0x00000034 Hopp +0000000A: 940C0034 JMP 0x00000034 Hopp +0000000C: 34 J0C000x04 J0C0004 0000000E: 940C0034 JMP 0x00000034 Hopp +00000010: 940C0034 JMP 0x00000034 Hopp +00000012: 940C0034 JMP 0x00000 +400000 +4000 JMP 940C0000 0x00000034 Hopp +00000016: 940C0034 JMP 0x00000034 Hopp +00000018: 940C0034 JMP 0x00000034 Hopp +0000001A: 940 J0C000x4 : 940C0034 JMP 0x00000034 Hopp +0000001E: 940C0034 JMP 0x00000034 Hopp +000000020: 940C0034 JMP 0x00000030 9 JMP 020000034 0200000034 0200000034 JMP 020000034 JMP 020000034 0200000030 34 Hopp +00000024: 940C0034 JMP 0x00000034 Hopp +00000026: 940C0034 JMP 0x00000034 Hopp +00000028: 940C0030 Hopp 00304 JMP 00304
Så, om du tittar, finns det kontinuerliga övergångar. Och JMP-kommandokoden är fyra byte, den innehåller hoppadressen skriven bakåt - den låga byten vid den låga adressen och hoppkommandokoden 940C 1
2
3
4
+0000002C: E5CF LDI R28,0x5F Ladda omedelbart +0000002D: E0D4 LDI R29,0x04 Ladda omedelbart +0000002E: BFDE OUT 0x3E,R29 Ut till I/O plats +0000002F:/8 Ut till I/O plats +00000002F:/8000002F
1
2
+00000041: 94F8 CLI Global Interrupt Disable +00000042: CFFF RJMP PC-0x0000 Relativt hopp
1
+00000034: 940C0000 JMP 0x00000000 Hopp
1
2
3
4
5
6
7
8
9
10
11
12
< 1
2
3
+0000003E: E080 LDI R24.0x00 Ladda omedelbart +0000003F: E090 LDI R25.0x00 Ladda omedelbart +00000040: 9508 RET Subrutin retur
Alexei78 Jag skapade ett plugin för Firefox som gör det lättare att navigera på min webbplats och mitt forum.
Diskussion och nedladdning,
#inkludera "filnamn.h"
{
funktionskropp
}
PORTD = 0xFF;
DDRB = 0xFF;
PORTB = 0x00;
{
öglekropp
}
//En kommentar
allmän information
Arduino
Självmontering
Vad behövs för montering?
Atmega8-programmering för nybörjare med hjälp av ett exempel
Vad kommer härnäst?
Viktiga punkter
Utbildning och kompetensförbättring
Är det svårt att börja skapa något eget?
