Atmega8 mikrokontrollerid. Atmega8 programmeerimine algajatele

Mikrokontrolleritega meisterdamine on küsimus, mis on aktuaalsem ja huvitavam kui kunagi varem. Elame ju 21. sajandil, uute tehnoloogiate, robotite ja masinate ajastul. Tänapäeval oskab juba noorest peale iga teine inimene kasutada internetti ja erinevaid vidinaid, ilma milleta on vahel igapäevaelus raske hakkama saada.

Seetõttu käsitleme selles artiklis eelkõige mikrokontrollerite kasutamise küsimusi, aga ka nende otsest kasutamist, et hõlbustada meid kõiki iga päev silmitsi seisvate missioonidega. Mõelgem välja, mis on selle seadme väärtus ja kui lihtne on seda praktikas kasutada.

Mikrokontroller on kiip, mille eesmärk on juhtida elektriseadmeid. Klassikaline kontroller ühendab ühes kiibis nii protsessori kui kaugseadmete töö ning sisaldab muutmäluseadet. Üldiselt on see ühe kiibiga personaalarvuti, mis suudab täita suhteliselt tavalisi ülesandeid.

Mikroprotsessori ja mikrokontrolleri erinevus seisneb protsessori kiibi sisseehitatud käivitus-stopp-seadmete, taimerite ja muude kaugstruktuuride olemasolus. Ühe komplekti asemel üsna võimsa, laialdaste võimalustega, monoahelale ehitatud arvutusaparaadi kasutamine praeguses kontrolleris vähendab oluliselt selle baasil loodud seadmete ulatust, tarbimist ja hinda.

Sellest järeldub, et sellist seadet saab kasutada arvutustehnikas, nagu kalkulaator, emaplaat, CD-kontrollerid. Neid kasutatakse ka elektrilistes kodumasinates - mikrolaineahjudes, pesumasinates ja paljudes teistes. Mikrokontrollereid kasutatakse laialdaselt ka tööstusmehaanikas, alates mikroreleedest kuni tööpinkide juhtimistehnikateni.

AVR mikrokontrollerid

Tutvume nüüdisaegses tehnikamaailmas levinuma ja väljakujunenud kontrolleriga nagu AVR. See koosneb kiirest RISC-mikroprotsessorist, kahte tüüpi energiat tarbivast mälust (Flash-projekti vahemälu ja EEPROM-i teabe vahemälu), RAM-tüüpi töövahemälust, I/O-portidest ja mitmesugustest kaugliidese struktuuridest.

töötemperatuur on vahemikus -55 kuni +125 kraadi Celsiuse järgi;
säilitustemperatuur on -60 kuni +150 kraadi;
kõrgeim pinge RESET viigul vastavalt GND-le: maksimaalselt 13 V;
maksimaalne toitepinge: 6,0 V;
sisend/väljundliini maksimaalne elektrivool: 40 mA;
Maksimaalne vool toiteliinil VCC ja GND: 200 mA.

AVR mikrokontrolleri võimalused

Absoluutselt kõigil eranditeta Mega tüüpi mikrokontrolleritel on sõltumatu kodeerimise omadus, võimalus muuta oma draiveri mälu komponente ilma välise abita. See eripära võimaldab nende abil moodustada väga paindlikke kontseptsioone ning nende töömeetodit muudab mikrokontroller isiklikult seoses konkreetse pildiga, mille määravad sündmused väljast või seest.

Teise põlvkonna AVR mikrokontrollerite lubatud vahemälu loenduspöörete arv on 11 tuhat pööret, kui standardne pöörete arv on 100 tuhat.

AVR-i sisend- ja väljundportide struktuuri konfiguratsioon on järgmine: füsioloogilise väljundi eesmärk on reguleerida kolm bitti, mitte kaks, nagu tuntud bitikontrollerites (Intel, Microchip, Motorola jne. ). See omadus välistab vajaduse omada kaitse eesmärgil mälus dubleerivat pordikomponenti ning kiirendab ka mikrokontrolleri energiatõhusust koos välisseadmetega, nimelt sellega seotud elektriprobleemide korral väljaspool.

Kõigil AVR-i mikrokontrolleritel on mitmetasandiline summutustehnoloogia. Tundub, et see katkestab venestaja standardvoolu, et saavutada prioriteetne ja teatud sündmuste poolt määratud eesmärk. Konkreetse juhtumi jaoks on peatamistaotluse teisendamiseks rutiin ja see asub projekti mälus.

Kui ilmneb probleem, mis käivitab seiskamise, salvestab mikrokontroller komponentide reguleerimise loendurid, peatab üldprotsessoril selle programmi täitmise ja alustab sulgemisprotsessi täitmist. Täitmise lõpus jätkatakse peatamisprogrammi patrooni all varem salvestatud programmiloendurit ja protsessor jätkab lõpetamata projekti täitmist.

AVR-i mikrokontrolleri baasil valmistatud käsitöö

AVR-i mikrokontrollereid kasutav meisterdamine muutub oma lihtsuse ja madalate energiakulude tõttu populaarsemaks. Mis need on ja kuidas neid oma käte ja mõistusega valmistada, vt allpool.

"direktor"

Selline seade oli mõeldud väikeseks abiliseks nii neile, kes eelistavad metsas jalutada, kui ka looduseuurijatele. Vaatamata sellele, et enamus telefone on navigaatoriga, vajavad need töötamiseks internetiühendust ning linnast eraldatud kohtades on see probleemiks, samuti pole lahendatud probleem metsas laadimisega. Sel juhul oleks üsna soovitav selline seade kaasas olla. Seadme olemus seisneb selles, et see määrab, millises suunas liikuda ja millise kauguse soovitud asukohani.

Ahel on ehitatud AVR-i mikrokontrolleri baasil, mille taktsagedus on 11,0598 MHz välisest kvartsresonaatorist. GPS-iga töötamise eest vastutab U-bloxi NEO-6M. See, kuigi aegunud, on tuntud ja eelarve moodul, millel on üsna selge asukoha määramise võimalus. Teave on keskendunud Nokia 5670 ekraanile. Mudel sisaldab ka HMC5883L magnetlainemõõtjat ja ADXL335 kiirendusmõõturit.

Juhtmevaba liikumisanduriga signalisatsioon

Kasulik seade, mis sisaldab liikumisseadet ja võimalust anda raadiokanali järgi märku, et see on käivitatud. Disain on teisaldatav ja laetakse aku või akude abil. Selle valmistamiseks peab teil olema mitu HC-12 raadiomoodulit, samuti HC-SR501 liikumisandur.

Liikumisseade HC-SR501 töötab toitepingega 4,5 kuni 20 volti. Ja LI-Ion aku optimaalseks tööks peaksite minema ümber toitesisendi ohutus LED-i ja sulgema lineaarse stabilisaatori 7133 juurdepääsu ja väljundi (2. ja 3. jalg). Pärast nende protseduuride lõpetamist alustab seade pidevat tööd pingega 3 kuni 6 volti.

Tähelepanu: raadiomooduliga HC-12 töötades käivitus andur mõnikord valesti. Selle vältimiseks on vaja saatja võimsust 2 korda vähendada (käsk AT+P4). Andur töötab õliga ning üks laetud aku mahutavusega 700 mAh peab vastu üle aasta.

Miniterminal

Seade osutus suurepäraseks abiliseks. Seadme valmistamise aluseks on vaja AVR-i mikrokontrolleriga plaati. Kuna ekraan on otse kontrolleriga ühendatud, ei tohiks toiteallikas olla üle 3,3 volti, kuna suuremad numbrid võivad seadmega probleeme tekitada.

Peaksite võtma muunduri mooduli, mis põhineb LM2577-l ja aluseks võib olla 2500 mAh mahutav Li-Ion aku. Saadaval on kasulik pakett, mis tagab pideva 3,3 volti kogu tööpinge vahemikus. Laadimisel kasutage TP4056 kiibil põhinevat moodulit, mida peetakse eelarvesõbralikuks ja üsna kvaliteetseks. Selleks, et saaksite miniterminali ühendada 5-voldiste mehhanismidega ilma ekraani põletamise ohuta, peate kasutama UART-porte.

AVR-i mikrokontrolleri programmeerimise põhiaspektid

Mikrokontrolleri kodeerimine toimub sageli assembler- või SI-stiilis, kuid võite kasutada ka teisi Forthi või BASIC-keeli. Seega, et alustada kontrolleri programmeerimise uurimist, peaksite olema varustatud järgmise materjalikomplektiga, sealhulgas: mikrokontroller, kolmes tükis - ATmega8A-PU, ATtiny2313A-PU ja ATtiny13A-PU peetakse väga populaarseks. ja tõhus.

Programmi mikrokontrollerisse juurutamiseks vajate programmeerijat: parimaks peetakse programmeerijat USBASP, mis annab 5-voldise pinge, mida kasutatakse tulevikus. Projekti tulemuste visuaalseks hindamiseks ja järelduste tegemiseks on vaja andmete kajastamise ressursse - need on LED-id, LED-induktiivpool ja ekraan.

Mikrokontrolleri sideprotseduuride uurimiseks teiste seadmetega on vaja DS18B20 digitaalset temperatuuriseadet ja DS1307 kella, mis näitab õiget aega. Samuti on olulised transistorid, takistid, kvartsresonaatorid, kondensaatorid, nupud.

Süsteemide paigaldamiseks vajate kinnitusplaadi näidist. Mikrokontrollerile kujunduse ehitamiseks peaksite kasutama ilma jootmiseta kokkupanemiseks mõeldud leivatahvlit ja selle jaoks mõeldud džemprite komplekti: näidisplaati MB102 ja mitut tüüpi džemprid - elastsed ja jäigad, aga ka U-kujulised. Mikrokontrollerid kodeeritakse USBASP programmeerija abil.

Lihtsaim seade, mis põhineb AVR-i mikrokontrolleril. Näide

Niisiis, olles tutvunud AVR-i mikrokontrollerite ja nende programmeerimissüsteemiga, vaatleme kõige lihtsamat seadet, mille aluseks see kontroller on. Toome näite madalpinge elektrimootorite draiverist. See seade võimaldab juhtida kahte nõrga pideva vooluga elektrimootorit korraga.

Maksimaalne võimalik elektrivool, millega programmi saab laadida, on 2 A kanali kohta ja mootorite maksimaalne võimsus on 20 W. Plaadil on paar kaheklemmilist plokki elektrimootorite ühendamiseks ja kolme klemmiplokk võimendatud pinge andmiseks.

Seade näeb välja nagu trükkplaat mõõtmetega 43 x 43 mm ning sellele on ehitatud radiaatori miniahel, mille kõrgus on 24 millimeetrit ja kaal 25 grammi. Koormustega manipuleerimiseks sisaldab juhiplaat umbes kuut sisendit.

Järeldus

Kokkuvõtteks võib öelda, et AVR-i mikrokontroller on kasulik ja väärtuslik tööriist, eriti nokitsejatele. Ja kasutades neid õigesti, järgides programmeerimise reegleid ja soovitusi, saate hõlpsalt omandada kasuliku asja mitte ainult igapäevaelus, vaid ka kutsetegevuses ja lihtsalt igapäevaelus.

Mikrokontrolleri ahelad, artiklid ja kirjeldused koos püsivara ja auto fotodega.

Lihtne tahhomeeter ATmega8 mikrokontrolleril

Tahhomeetrit kasutatakse autodes mis tahes pöörlemisvõimeliste osade pöörlemiskiiruse mõõtmiseks. Selliste seadmete jaoks on palju võimalusi, pakun võimalust AVR-i mikrokontrolleril ATmega8. Minu valikul sa ka...

Lugege täielikult

Värvimuusika autos Attiny45 mikrokontrolleril

Seda värvilist muusikat, millel on väike suurus ja 12 V toiteallikas, saab alternatiivselt kasutada autos mis tahes ürituste jaoks. Selle diagrammi esmane allikas on raadio nr 5, 2013 A. LAPTEV, Zyryanovsk, Kasahstan. Skeem…

Lugege täielikult

Soojendusega peegel ja tagaklaasi kontroller

Võimaldab juhtida tagaklaasi ja peegleid eraldi ühe nupuga, lisaks on iga kanali jaoks kohandatav kuni poolteist tundi kestev väljalülitustaimer. Ahel on üles ehitatud ATtiny13A mikrokontrollerile. Töö kirjeldus:

Lugege täielikult

Autolambi dimmer

Peaaegu kõikidel autodel on sisevalgustuse juhtimine, mis toimub pardaarvuti või eraldi pardasüsteemi abil. Tuli süttib sujuvalt ja kustub ka teatud viivitusega (...

Lugege täielikult

GSM signalisatsioon koos märguandega mobiiltelefonis

Tutvustan väga populaarset autosignalisatsiooni ahelat, mis põhineb mikrokontrolleril ATmega8. Selline häire annab hoiatuse administraatori mobiiltelefonile kõnede või SMS-ide kujul. Seade integreerub mobiiltelefoniga, kasutades...

Lugege täielikult

Vilkuv stopak mikrokontrolleril

Tegin vilkuvast stopakist uue versiooni. Tööalgoritm ja juhtimisahel on erinevad, suurus ja ühendus on samad. Võimalik on reguleerida vilkumise sagedust, kestust enne pidevale helendusele lülitumist ja töötsüklit...

Lugege täielikult

DRL pluss strobid

See käsitöö võimaldab teil LED DRL-e strobeerida. Käsitöö on väikese suurusega, seda juhitakse vaid ühe nupuga ja sellel on laiad kohandamisvõimalused. Tahvli suurus on 30 x 19 millimeetrit. Tagaküljel on klemmiplokk...

Lugege täielikult

Valmistame ja ühendame ukse lähemale signalisatsiooniga

Automaatakendega autode arv kasvab pidevalt ja isegi kui autol seda pole, teevad paljud inimesed selle ise. Minu eesmärk oli selline seade kokku panna ja ühendada...

Lugege täielikult

LEDid süttivad kiiruse järgi

See osutus "kõrvaltooteks": 5x7 maatriksil käikude kuvamise projekti jaoks oli vaja katsetada kiirusanduri töörežiimi, selleks panin kokku väikese vooluringi. Ahel võib LED-id sisse lülitada sõltuvalt ...

Lugege täielikult

Digitaalne tahhomeeter AVR-i mikrokontrolleril (ATtiny2313)

Tahhomeeter mõõdab auto osade, mehhanismide ja muude komponentide pöörlemiskiirust. Tahhomeeter koosneb 2 põhiosast - andurist, mis mõõdab pöörlemiskiirust ja ekraanist, kus...

Lugege täielikult

Lihtne digitaalne spidomeeter ATmega8 mikrokontrolleril

Spidomeeter on mõõteseade auto kiiruse määramiseks. Mõõtmismeetodi järgi on spidomeetrid mitut tüüpi: tsentrifugaal-, kronomeetrilised, vibratsiooni-, induktsioon-, elektromagnetilised, elektroonilised ja lõpuks GPS-spidomeetrid.

Lugege täielikult

Korra sujuv süütamine mikrokontrolleril

Sellel versioonil on veidi erinev paigutus: lisatud on teine seadistusnupp ja eemaldatud on süütekiiruse potentsiomeeter. Omadused: kaks eraldi sõltumatut kanalit. Iga kanali jaoks on kolm reguleeritavate parameetrite rühma: viivitusaeg enne käivitamist...

Projektid saidil ATMega8.

Lihtsad projektid ühe lihtsaima ja populaarseima mikrokontrolleri uurimiseks.

Töötamiseks vajate vähemalt CodeVision AVR2.04.4a ja Proteus 7.2 SP6. Kui soovite töötada riistvaraga, on teil vaja ka programmeerijat. Soovitan seda - seda on lihtne kokku panna ja see töötab hästi. Ainus probleem on algse ATMega8 püsivaraga, seda saab teha kas LPT-pordi kaudu - 5-provodov-avr või osta juhtmega mikrokontrolleri, ma võtsin selle.

Valgusfoor nr 1.

Lihtsaim foor ühes suunas ei nõua loomiseks palju pingutusi ja oskusi. Ahel pannakse kokku mõne minutiga. Takistid valitakse kasutatavate LED-ide põhjal (470 oomi reiting on näidatud "Nõukogude" AL307 jaoks), tuleb märkida, et diagrammil on AVCC tihvt ühendatud toiteallikaga, kui see pole ühendatud tõelise mikrokontrolleriga, olenemata sisseehitatud ADC (analoog-digitaalmuunduri) kasutamisest, siis võid kahjustada mikrolülitust (tõsi kõikide Mega seeria kontrollerite puhul)!!!

Lähtekood on nii lihtne, et esitan selle siin. Leidsin selle C koodi Internetist ja parandasin seda veidi, kuid iga programmeerija ütleb teile, et see kood on rumal (hiljem kirjeldan täpselt, kuidas selliseid programme kirjutada), kuid see on lihtne, visuaalne ja töötav.

Kiibi tüüp: ATmega8
Programmi tüüp: rakendus

Mälu mudel: väike
Andmepaki suurus: 256

#kaasa

#kaasa

tühine põhi(tühine)
{
// Pordi B lähtestamine
PORTB=0x00;
DDRB=0x00;

// Porti C lähtestamine
PORTC=0x00;
DDRC=0x00;

// Porti D lähtestamine
PORTD=0x00;
DDRD=0x07;

// Välise katkestuse(te) lähtestamine
// INT0: Väljas
// INT1: Väljas
MCUCR=0x00;

// Analoogkomparaator: väljas

ACSR=0x80;
SFIOR=0x00;

samas (1) (

PORTD.2=1; //roheline põleb
viivitus_ms(8000); //põleb 8 sekundit

viivitus_ms(500); //Oota pool sekundit

PORTD.2=0; //Lülita roheline välja

PORTD.2=1; //Lülita roheline sisse

/*delay_ms(500);//Oodake pool sekundit
PORTD.2=0; //Lülita roheline välja
viivitus_ms(500); //Oota pool sekundit
PORTD.2=1; //Lülita roheline sisse
viivitus_ms(500); //Oota pool sekundit*/

PORTD.1=1; //Lülita kollane sisse
PORTD.2=0; //Lülita roheline välja
viivitus_ms(3000); //Oodake 3 sekundit

PORTD.0=1; //Lülita punane sisse
PORTD.1=0; //kollase välja lülitamine
viivitus_ms(9000); //9 sekundiks

PORTD.1=1; //muutuda kollaseks punaseks
viivitus_ms(3000); //oota 3 sekundit
PORTD.0=0; //Lülita punane välja
PORTD.1=0; //ja kollane
};
}

Koodi saab veel veidi lühendada, kui arvestada, et vaikimisi on peaaegu kõik ATMega8 pordid ja registrid lähtestatud 0-ks. Nüüd algajatele mõned selgitused:

#kaasa

Need on nn päisefailid, mis on nendes kirjas, mida rakendame teistest failidest. Näiteks protseduur delay_ms(X), mis määrab viivituse millisekundites, on kirjutatud teise inimese poolt ja see sisaldub failis delay.c (tegelikult ei pruugi kõik täpselt nii olla või üldse mitte - protseduur võib sisaldada objekti faili tüübiga * obj, *.asm) ja selle kasutamise reeglid on kirjeldatud failis delay.h, mille me kaasame.

PORTB=0x00;
DDRB=0x00;

Reserveeritud nimed, mis tähistavad kontrolleri pordiregistreid (selle kontaktid on rühmitatud baitide kaupa – igaüks 8, iga pordiregistri bitt vastab oma viigule) ja pordivahetuse suunaregistreid (0-sisend, 1-väljund)

Näiteks DDRB.5=1 kirjutamine tähendab, et kontrolleri PB5 viik on seadistatud väljundiks ja PORTB.5=0 või =1 kirjutamisel saame sellel viigul 0 (0...0,8 volti) või 1 (4...5 volti). Muidugi saab pordile kohe kogu väärtuse määrata: PORTB=0xFF, st. kõik PB-pordi kontaktid on 1.

while(1) (avaldis);

tähistab lõpmatut tsüklit, kuna 1=TRUE.

Valgusfoor nr 2.

Foori saamiseks kahes suunas peate muutma fooriskeemi nr 1:

ja foori kood nr 1:

DDRD=0b00111111; //0b(b7)(b6)(b5)(b4)(b3)(b2)(b1)(b0)

Paremal on biti (kahend) esitus numbrist, mille kõige olulisem number on vasakul, võib selle kirjutada ka kümnendsüsteemis (DDRD=63;) või kuueteistkümnendsüsteemis (DDRD=0x3F;).

tühine põhi(tühine)

Main on põhiprotseduur, sellega algab programmi täitmine, void tähendab sõna otseses mõttes mitte midagi (nulltüüp), void asemel saab asendada (allkirjastatud või allkirjastamata) int, long; float, double ja nii edasi (ja isegi osuti teisele muutujale, millest tuleb juttu hiljem). Veelgi enam, tühimiku asendamine mõne tüübiga esimeses positsioonis tähendab, et see konstruktsioon on funktsioon, mitte protseduur ja võib tagastada väärtuse, st. seda tuleb sees sõnaga täiendada tagasi.

int fun (tühjus) (
int a=10;
tagastama(a);
}

Kõik muudatused tehti vastavalt tööskeemile:

Vilkuva rohelise signaaliga foori kahesuunalise toimimise skeem. Ka see skeem on internetist võetud ja minu meelest: vilkuvaid rohelisi signaale peaks rohkem olema.

Valgusfoor nr 3.

Näited nr 1 ja nr 2 tõid välja mõneti „lihtne” koodikasutus, mis on küll vastuvõetav väikeste programmide puhul, kuid mida ei saa kasutada ressursside raiskamise tõttu suurtes rakendustes.
Koodi lihtsustamiseks ja lühendamiseks tehnoloogilistes rakendustes kasutavad programmeerijad tavaliselt automaate. Automaat on protsessi lihtsustatud ja piisav mudel. Näiteks võib kogu foori töö jagada teatud piiratud arvuks olekuteks, mis teatud perioodiga korduvad. Automaadi esindamiseks vajate tarkvaralist olekuloendurit ja olekudekoodrit. Foori nr 3, mis koosneb transpordifoorist 4 suunas, 4 jalakäijate foorist, 1 raudteeülesõidufoorist, 1 vilkuvast jalakäijate valgusfoorist, oleks problemaatiline luua ilma automaatseadmeta.

Allpool on näidatud kood ilma jalakäijate ja raudtee foore töötlemata. On lihtne mõista, et protseduurid meeldivad
void SetRedT1(void) //Transpordifoor1 lülitage punane D3 sisse
{
ptc|=0x01;
}
seadke või tühjendage üksikud bitid.

Põhitsüklis suureneb loenduri i väärtus pidevalt, kuni see jõuab 48-ni.
i++;
Sel juhul nullitakse loendur.
kui (i==48) (i=0;); // 24c=0,5*48

Tingis võrreldakse loenduri väärtust pidevalt konstantidega ja tööd tehakse portidega. Kuigi see kood on kahest eelmisest arenenum, sobib see ka rohkem selguse kui töö jaoks. Spetsialistid ei kasuta enamasti üksikute võrdlustoimingute komplekte, vaid kasutavad lülitusoperaatoreid või isegi kirjutavad eelnevalt arvutatud andmed massiividesse - kasutage valmis tabelit:

flash unsigned char sw[N]=(
//G1Y1R1G2Y2R2 XX
0b10000100, //1 X perioodid roheline1 ja punane2 põlevad
0b10000100, //2
...
0b00000100, // X perioodi roheline1 vilgub,

0b10000100, //
...
0b01001100, //K-1 Roheline1 kustub, Kollane1 ja Kollane2 süttivad
0b00110000, //K Punane1 süttib, roheline1 süttib, kollane2 ja punane2 kustuvad

...
0b01101000 //N
};

samal ajal (1)
{
i++;

PORTC=(sw[i]>>x) | mask;
PORTD=(sw[i]>>x) | mask;
viivitus_ms(500);
};
}

Muidugi avaldised (sw[i]>>x) | maski kirjeldatakse tinglikult, kõik sõltub signaalide teabe asukohast sw konstandis.

/*****************************************************
Kiibi tüüp: ATmega8
Programmi tüüp: rakendus
AVR-i põhitakti sagedus: 1,000000 MHz
Mälu mudel: väike
Välise RAM-i suurus: 0
Andmepaki suurus: 256
*****************************************************/

#kaasa
#kaasa

unsigned char ptb=0;
unsigned char ptc=0;
unsigned char ptd=0;

void SetRedT1() //Transpordifoor1 lülitab punase D3 sisse
{
ptc|=0x01;
}

void ResetRedT1() //Transpordifoor1 lülitage punane D3 välja
{
ptc&=~0x01;
}

void SetYelT1() //Transpordifoor1 lülitage kollane D2 sisse
{
ptc|=0x02;
}

void ResetYelT1() //Transpordifoor1 lülitage kollane D2 välja
{
ptc&=~0x02;
}

tühine SetGrnT1() //Transpordifoor1 muutub roheliseks D1
{
ptc|=0x04;
}

void ResetGrnT1() //Transpordi foor1 lülitage roheline D1 välja
{
ptc&=~0x04;
}

void SetRedT2() //Transpordifoor2 lülitab punase sisse D6
{
ptc|=0x08;
}

void ResetRedT2() //Transpordifoor2 lülita punane D6 välja
{
ptc&=~0x08;
}

void SetYelT2() //Transpordifoor2 lülitage kollane D5 sisse
{
ptc|=0x10;
}

void ResetYelT2() //Transpordifoor2 lülitage kollane D5 välja
{
ptc&=~0x10;
}

void SetGrnT2() //Transpordifoor2 muutub roheliseks D4
{
ptc|=0x20;
}

void ResetGrnT2() //Transpordi foor2 lülitage roheline D4 välja
{
ptc&=~0x20;
}

void SetRedT3() //Transpordifoor3 lülitab punase sisse D9
{
ptd|=0x01;
}

void ResetRedT3() //Transpordifoor3 lülita punane D9 välja
{
ptd&=~0x01;
}

void SetYelT3() //Transpordifoor3 lülitage kollane D8 sisse
{
ptd|=0x02;
}

void ResetYelT3() //Transpordifoor3 lülita kollane D8 välja
{
ptd&=~0x02;
}

void SetGrnT3() //Transpordifoor3 muutub roheliseks D7
{
ptd|=0x04;
}

void ResetGrnT3() //Transpordi foor3 lülitage roheline D7 välja
{
ptd&=~0x04;
}

void SetRedT4() //Transpordifoor2 lülitab punase sisse D12
{
ptd|=0x08;
}

void ResetRedT4() //Transpordifoor2 lülita punane D12 välja
{
ptd&=~0x08;
}

void SetYelT4() //Transpordifoor2 lülitage kollane D11 sisse
{
ptd|=0x10;
}

void ResetYelT4() //Transpordifoor2 lülita kollane D11 välja
{
ptd&=~0x10;
}

tühine SetGrnT4() //Transpordifoor2 muutub roheliseks D10
{
ptd|=0x20;
}

void ResetGrnT4() //Transpordifoor2 lülitage roheline D10 välja
{
ptd&=~0x20;
}

// Deklareerige siin oma globaalsed muutujad

tühine põhi(tühine)
{
märgita char i=0;

PORTB=0x00;
DDRB=0xFF;
PORTC=0x00;
DDRC=0xFF;
PORTD=0x00;
DDRD=0xFF;
ACSR=0x80;

samal ajal (1)
{
if (i==0) (ResetYelT1();ResetRedT1();SetGrnT1();
ResetYelT2();SetRedT2();
ResetYelT3();ResetRedT3();SetGrnT3();
ResetYelT4();SetRedT4();

); //0s
if (i==16) (LähtestaGrnT1();
LähtestaGrnT3();

); //8s
if (i==17) (SetGrnT1();
SetGrnT3();

};
if (i==18) (LähtestaGrnT1();
LähtestaGrnT3();

};
if (i==19) (SetGrnT1();
SetGrnT3();

};
if (i==20) (ResetGrnT1();SetYelT1();
SetYelT2();
LähtestaGrnT3();SetYelT3();
SetYelT4();

); //10s
if (i==24) (ResetYelT1();SetRedT1();
ResetYelT2();ResetRedT2();SetGrnT2();
ResetYelT3();SetRedT3();
ResetYelT4();ResetRedT4();SetGrnT4();

); //12s
if (i==40) (LähtestaGrnT2();
LähtestaGrnT4();

); //20s
if (i==41) (SetGrnT2();
SetGrnT4();

};
if (i==42) (LähtestaGrnT2();
LähtestaGrnT4();

); //21s
if (i==43) (SetGrnT2();
SetGrnT4();

};
if (i==44) (SetYelT1();
LähtestaGrnT2();SetYelT2();
SetYelT3();
LähtestaGrnT4();SetYelT4();

); //22s
i++;
kui (i==48) (i=0;); // 24c=0,5*48 - tsükkel

//PORTB=ptb;
PORTC=ptc;
PORTD=ptd;
viivitus_ms(500);
};
}

Veeru indikaator.

Kui eelmistes näidetes kasutati mikrokontrolleri digitaalseid ressursse, siis selles näites kasutatakse analoogseid - ADC-sid. Analoog-digitaalmuundur on ette nähtud analoogsignaali diskreetseks teisendamiseks teatud diskreetimissagedusega digitaalkoodiks. Algajatele ütlen vaid, et maksimaalne digiteerimiskiirus on piiratud.

Ribaindikaator kuvab sisendpinget helendavate segmentide (või lihtsalt üksikute emitterite) veeru kujul, mis on väga kasulik igasuguste indikaatorite jaoks, mille näideteks on veerulised salvestustaseme indikaatorid (RLI).

Sisendpinge ei tohiks ületada toitepinget ja etalonpingena kasutatakse mikrokontrolleri 5-voldist toiteallikat ning filtrina kasutatakse AREF-i kontakti välist kondensaatorit.

Programmi kood on toodud allpool:

/*****************************************************
Kiibi tüüp: ATmega8
Programmi tüüp: rakendus
AVR-i põhitakti sagedus: 4,000000 MHz
Mälu mudel: väike
Välise RAM-i suurus: 0
Andmepaki suurus: 256
*****************************************************/

#kaasa
#kaasa

#define ADC_VREF_TYPE 0x40 //5V Vcc + C 4,7uF AREF

//PD0 LED1
//PD1 LED2
//PD2 LED3
//PD3 LED4
//PD4 LED5
//PD5 LED6
//PD6 LED7
//PD7 LED8
//PB0 LED9
//PB1 LED10
//PB2 LED11
//PB3 LED12
//PB4 LED13
//PB5 LED14

//PC4 LED15
//PC5 LED16

konst
unsigned char PD=
{
0b00000000, //0
0b00000001, //1
0b00000011, //2
0b00000111, //3
0b00001111, //4
0b00011111, //5
0b00111111, //6
0b01111111, //7
0b11111111, //8
//_____________
0b11111111, //9
0b11111111, //10
0b11111111, //11
0b11111111, //12
0b11111111, //13
0b11111111, //14
0b11111111, //15
0b11111111 //16
};
märgita täht PB=
{
0b00000000, //0
0b00000000, //1
0b00000000, //2
0b00000000, //3
0b00000000, //4
0b00000000, //5
0b00000000, //6
0b00000000, //7
0b00000000, //8
//_____________
0b00000001, //9
0b00000011, //10
0b00000111, //11
0b00001111, //12
0b00011111, //13
0b00111111, //14
//_____________
0b00111111, //15
0b00111111 //16
};

// Lugege AD teisendustulemust
unsigned int read_adc(signed char adc_input)
{
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
// ADC sisendpinge stabiliseerimiseks vajalik viivitus
delay_us(10);
// Käivitage AD teisendamine
ADCSRA|=0x40;
// Oodake, kuni AD teisendamine on lõpule viidud
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
tagastada ADCW;
}

void ADC_init()
{
//ADC lähtestamine
//ADC Kellasagedus: 125 000 kHz
// ADC pinge viide: Vcc, kork. AREF-il
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x85;
}

tühine dekodeerimine (int signaal)
{
PORTD=PD;
PORTB=PB;

if (signaal==15) (PORTC |= 0b00010000;PORTC &= 0b11011111;)
muidu kui (signaal==16) (PORTC |= 0b00110000;)
muu (PORTC &= 0b11001111;)
}

tühine SetupIO()
{
// Sisend-/väljundportide lähtestamine
PORTB=0b00000000;
DDRB= 0b00111111;

PORTC=0b00001100;
DDRC= 0b00110000; //PC0,PC1 = ADC0,ADC1, PC2,PC3 seadistusviigud koos PUP-iga

PORTD=0x00;
DDRD=0xFF;
}

tühine põhi(tühine)
{
// Analoogkomparaatori lähtestamine
// Analoogkomparaator: väljas
// Analoogkomparaatori sisendi hõivamine taimeri/loenduriga 1: väljas
ACSR=0x80;
SFIOR=0x00;

SetupIO();
ADC_init();

samal ajal (1)
{
Decode(read_adc(0)*0,049*0,32);
viivitus_ms(100);
};
}

Peaaegu kõiki selles koodis kasutatud tehnikaid käsitleti eespool. Ainus, mida tahaksin märkida, on laiendatud konstruktsioon if-lausega:
kui () () //kui (tingimus on täidetud), siis ( )
else if () () //muidu kui (tingimus on täidetud) siis ( )
muidu () //muidu ( )

Ja väljendus read_adc(0)*0,049*0,32
tõsiasi on see, et ADC loob oma väärtused skaalal 0-1023 (2^10), mis vastab skaalal 0-5 volti (kuna võrdluspinge on 5 volti) ja me peame kõigepealt saama volti ja seejärel teisendada need kogusesegmentideks. 1024*0,049*0,32=16 st. Kogu ADC skaala koosneb 16 segmendist.
Arv 0,049 võetakse 5 volti / 1024 loendi kordsena = 0,0048828 (~ 10 ADC loendit) ja korrutatakse seejärel katseliselt 0,32-ga, et saada viimase segmendi süttimine soovitud sisendpingel.

Jadaport.

Ja nüüd teen ettepaneku sukelduda liideste maailma. Lihtsaim ja kõige laialdasemalt kasutatav jadaprotokoll RS232 on kuni viimase ajani, kuigi seda peeti aegunuks, endiselt kaasaegsete mikrokontrollerite tootmisse - ja mitte ainult üks, reeglina on neid praegu vähemalt 4. Samuti kasutavad paljud seadmed endiselt seda liidest (näiteks mõned NoritakeItron VFD ekraanid, aeglase tootmise seadmed jne). See näide võimaldab teil hinnata, kui lihtne on RS232 (USART) konfigureerimine ja kasutamine mikrokontrollerites.

Allpool on kood, mis edastab tähemärgi 0.

Tere, Datagorians!
Pärast oma esimese artikli avaldamist valdasid mind küsimused mikrokontrollerite kohta, kuidas, mida, kus, miks...
Et saaksite aru, kuidas see must kast töötab, räägin teile mikrokontrollerist (edaspidi MK) ATmega8. Põhimõtteliselt toodab Atmel tervet seeriat AVR-i perekonna MK-sid - need on alamperekonnad Tiny ja Mega. Ma ei kirjelda teatud MK eeliseid, see on teie otsustada, mis teile kõige paremini sobib. Mõned laiendatud perekonna esindajad:
Niisiis, ATmega8, kõigi ATmega lihtsaim MK:
Alustame sisemiste osade uurimist lihtsustatud struktuuriskeemi abil:
See on kõigi ATmega üldistatud diagramm.
Kõik AVR mikrokontrollerid on ehitatud nn Harvardi arhitektuuri järgi ehk siis kasutatakse programmimälu ja andmemälu eraldi adresseerimist. Selle arhitektuuri eelised on suurenenud kiirus, näiteks ATmega täidab ühe käsu taktimpulsi kohta, see tähendab, et sagedusel 16 MHz teeb MK 16 miljonit toimingut sekundis.
Ja nüüd järjekorra kohta tripi kohta.
1. Kella generaator sünkroniseerib kõik siseseadmed.
2. ROM on kirjutuskaitstud mäluseade, mida kasutatakse programmide ja muutumatute andmete (konstantide) salvestamiseks.
3. Käskude dekooder - tema on siin kõige tähtsam, tema juhib kõike, mis kätte jõuab.
4. ALU on aritmeetika-loogiline seade, mis sooritab arvudega aritmeetilisi (liitmine, lahutamine jne) ja loogilisi (AND, OR, NOT, XOR) tehteid.
5. RON – üldotstarbelised registrid, nendega opereerib ALU, mida kasutatakse ka ajutiseks andmete salvestamiseks. RON-registreid saab kombineerida registripaarideks:
r26: r27 – X;
r28: r29 – Y;
r30: r31 – Z.
Registripaare kasutatakse RAM-is olevate andmete kaudseks adresseerimiseks.
6. RAM on muutmäluseade, mida kasutatakse andmete, massiivide ja virnade salvestamiseks.
7. PORTA-PORTn – suhtlemine välismaailmaga, sisend/väljundpordid, no selge, miks...
8. Eriline UVV-d on spetsiaalsed sisend/väljundseadmed, erinevate välisseadmete kontrollerid, näiteks USART (tuntud ka kui COM-port), mõnikord USB, ADC, DAC, I2C, ühesõnaga, mis seal on...
Jah, jah, see kõik on teooria, kuid te ei jõua ära oodata, et midagi kokku panna, proovida ja toimima panna! Seejärel loetleme, mida vajame:
1. Programmeerija vastava tarkvaraga, sellest kirjutasin viimases artiklis;
2. C-keele kompilaatoril Code Vision AVR on head tööriistad MK jaoks mõeldud programmide arendamiseks;
Enne C-keeles programmeerimise alustamist oleks tore tutvuda selle keele kirjandusega, näiteks on Kernighani ja Ritchie suurepärane raamat “The C Language”.
Olgu, alustame...
Testimisahel.
Paneme selle diagrammi kokku:
Sellest saab baasmudel. Muide, parem on vooluahel kokku panna leivaplaadile ja panna MK pistikupessa. Kuid selline skeem on mõttetu. Lisame näiteks LED-i ja ärge unustage voolu piiravat takistit. Ühendame selle pordi B nullviiguga.
Diagramm näeb välja selline:
Lülitame voolu sisse... NULL!!! Mida sa ilma programmita tahtsid?
Tähendab…
Kirjutame programmi!
Nii et olete CVAVR-i käivitanud, mis on esimene asi, mida peaksite tegema? Käivitage Code Wizard AVR, klõpsates tööriistaribal hammasratta nuppu, kuvatakse viisardi aken:
Siin valime MK tüübi ja taktsageduse. Järgmisena minge vahekaardile Pordid:
Ja me konfigureerime, millise pordi bitt sisendiks või väljundiks konfigureeritakse, pordi B bitt 0 väljastab signaali ja ülejäänud saavad vastu.
Seadete salvestamiseks valige menüü File / Generate Save and Exit, sisestage kõigi järgnevate päringute failinimed, soovitavalt, et need oleksid samad, näiteks "prj". See on kõik, oleme loonud programmi lähteteksti viisardis määratud sätetega.
Vaatame, mis meil on. Esimesed 22 rida on kommentaar, see tähendab, et see ei mõjuta programmi toiminguid, seega kõik, mis jääb “/*” ja “*/” vahele, on kommentaar ja kompilaator ignoreerib kogu seda asja. 24. terminisse lisame päisefaili, see kirjeldab, milliseid registreid kutsutakse ja mis aadressil need asuvad. C-programmeerimise jaoks pole üksikasjad siin vajalikud.
28. realt alustame põhiprogrammi funktsiooni definitsiooniga peamine (),
Kerime allpool. Pöörake tähelepanu ridadele 36 ja 37, siin määratakse pordile B väärtus ja valitakse edastussuund. Üldiselt näeb see välja selline:
See tähendab, et kui üks on kirjutatud DDRB registri mis tahes bitti, töötab pordi B vastav bitt väljundina. Meie puhul on see bitt 0.
Muide, ATmega pordidel on üks tore omadus: isegi kui port on sisendiks seadistatud ja PORTx-i register on kirjutatud, ühendatakse sisemised tõmbetakistid toiteallika positiivsega, mis välistab kasutamise. välistest ripptakistitest. See on mugav mis tahes andurite ja nuppude ühendamisel.
Kompileerime programmi selleks klõpsake nuppu Tee projekt või menüüst Projekt / Make. Vigu ei tohiks esineda, kui te midagi ei muutnud.
Avame kausta C:\cvavr\bin\, leiame sealt prj.hex faili. See on programm, mille me MK jaoks koostasime. Ühendame programmeerija arvuti ja MK-ga. Käivitame programmi Pony Prog ja lohistame faili prj.hex selle aknasse. Lülitage MK-le toide sisse ja laadige sinna meie programm... Jälle mitte midagi? Kuid probleem on selles, et me ei väljastanud midagi pordi B nullbitile või pigem väljastasime selle, ainult et see on null. Ja selleks, et meie LED süttiks, peame selle väljastama. Teeme just seda, asendame real 36 "PORTB=0x00;". "PORTB=0x01;". Paneme programmi uuesti kokku. Ja Pony Prog programmis laadime faili uuesti, kasutades kiirklahvi Ctrl+L või menüüd Fail / Laadi failid uuesti. Kustutame MK ja laadime püsivara selle uuesti üles. HURRA!!! SEE TÖÖTAB!!!
Muide, Pony Prog toetab skripte ja selleks, et ei peaks muretsema taaskäivitamise, kustutamise ja kirjutamise pärast, saab lihtsalt kirjutada skripti laiendiga .e2s ja nimetada seda näiteks prog.e2s. Seda saate teha märkmiku abil. Selle sisu saab olema järgmine:
VALI SEADME ATMEGA8
SELGITUSPUHVER
LAADI KÕIK prj.hex
KUSTUTA-KÕIK
KIRJUTA-KÕIK
Asetage skript hex-failiga samasse kausta ja käivitage see topeltklõpsuga. Sõltuvalt sellest, kui mugav see on, saate oma töölauale paigutada otsetee...
Jätkub…

Üldine informatsioon
See Arduino kontrolleri versioon, kui mitte kõige lihtsam, on isetootmiseks kindlasti kõige taskukohasem. See põhineb juba klassikalisel Arduino vooluringil ATMega8 kontrolleril.
Kokku on välja töötatud kaks võimalust:
Modulaarne
Üks laud

Modulaarne valik
See kontrolleri versioon koosneb kolmest plaadist:
Ühe laua võimalus
Kõik on sama, ainult ühel tahvlil:
Plaat on valmistatud ühepoolsest foolium PCB-st ja seda saab kodus paljundada, kasutades näiteks LUT tehnoloogiat. Tahvli mõõdud: 95x62
Mikrokontrolleri programmeerimine

Pärast plaadi kokkupanemist peate kontrollerit vilkuma, laadima sellesse alglaaduri. Selleks vajate programmeerijat. Võtame puhta ATMega8 tüüpi kontrolleri, paigaldame selle programmeerijasse ja ühendame arvutiga. Kasutasin AVR ISP mkII programmeerijat koos ATMega8-48-88-168 adapteriga. Programmeerime Arduino IDE abil, see seab automaatselt vajalikud kaitsmebitid. Järjestus on järgmine:
1. Valige programmeerija (Teenus > Programmeerija > AVRISP mkII). Kui seda programmeerijat kasutatakse esimest korda, peate installima draiveri AVRISP-MKII-libusb-drv.zip. Kui kasutate mõnda muud programmeerijat peale AVRISP mkII, peate loendist valima vajaliku.
2. Mikrokontrolleri plaadi valimine (Tööriistad > Tahvel > Arduino NG või vanem koos ATmega8-ga). Kui kasutate mõnda muud mikrokontrollerit peale ATmega8, peate valima sellele sobiva plaadi.
3. Kirje alglaadur (Tööriistad > Record bootloader).
4. Paigaldage kontroller tahvlile ja ongi kõik, Arduino on töövalmis.