Megszakítás az Atmel AVR Studio AVR vezérlőjén. Megszakítások - AVR tanulása - Cikkek katalógusa - Mikrokontrollerek - ez egyszerű! Milyen környezetben kell programozni a mikrokontroller megszakításait
A megszakítási rendszerek minden vezérlőrendszer fontos részét képezik.
Az, hogy a mikroprocesszoros rendszer mennyire hatékonyan látja el feladatait, nagyban függ a munkájától. Az MK-51 megszakítási rendszer általános felépítése a 2. ábrán látható. 14.3.
Az MK-51 család mikrovezérlői öt megszakítási forrást támogatnak:
* két külső megszakítás az INT0 és INT1 bemeneteken (P3 portvonalak: P3.2 és P3.3);
* két megszakítás az időzítőktől / T / C0 és T / C1 számlálóktól;
* soros port megszakítás.
A megszakítási kérelmek a mikrokontroller speciális funkcióinak regisztereiben vannak rögzítve: az INT0, INT1, T / C0 és T / C1 megszakítási kérelmek IE0, IE1, TF0, TF1 jelzőjeit a TCON vezérlőregiszter tartalmazza (14.4. táblázat), és az RI és TI megszakítást kérő jelzők a soros portról - a soros port vezérlés SCON regiszterében.
14.4. táblázat. TCON regiszter formátum
0 IT0 A megszakítás típusának beállítása INT0
1 IE0 megszakítási kérelem jelző INT0
2 IT1 A megszakítás típusának beállítása INT1
3 IE1 INT1 megszakítási kérelem jelző
4 TR0 Időzítő/számláló engedélyezése 0
5 TF0 túlcsordulás jelző (megszakításkérés) időzítő/számláló 0
6 TR1 Időzítő/számláló engedélyezése 1
7 TF1 túlcsordulás jelző (megszakítási kérelem) időzítő/számláló 1
A TF0 és TF1 jelzőket hardver állítja be, amikor a megfelelő időzítő/számláló túlcsordul (pontosabban, amikor a T/Cx az "mind egyesek" állapotból a "minden nulla" állapotba vált át.
Az IE0 és IE1 jelzőket hardver állítja be a külső IT0 és IT1 megszakításokból. Külső kérés hatására a jelzőbeállítás akkor is beállítható, ha a megfelelő bemeneten a jel alacsony, vagy amikor ezt a jelet magasról alacsonyra kapcsolják (az MC külső órafrekvenciájának felét meg nem haladó frekvenciával).
A kérés típusát a TCON vezérlőregiszter IT0 és IT1 szoftverbeállítási bitjei konfigurálják. Az ITx = 0 beállítása a megszakítási rendszert úgy konfigurálja, hogy alacsony jelszinten kérjen, ITx = 1 - leeső jel esetén kérjen megszakítást.
A TI és RI jelzőket a soros interfész hardvere állítja be az adás vagy a vétel befejezése után.
Az összes megadott megszakítási kérés jelzője programozottan elérhető a beállításhoz és törléshez. A megszakításkérés jelzőjének szoftverben történő beállítása ugyanazt a mikrokontroller-választ eredményezi, mint a hardverben.
A TF0 és TF1 jelzőket hardver alaphelyzetbe állítja, amikor a vezérlést átadják a megfelelő megszakításkezelőnek.
Az IEx jelzőket a hardver törli a megszakítás kiszolgálása során, ha a megszakítást úgy konfigurálták, hogy érzékelje az INTx jel esését. Ha a megszakítás úgy van konfigurálva, hogy elfogadja a kérésjel szintjét, akkor az IEx jelzőt a megszakítási szolgáltatás rutinjának törölnie kell, befolyásolva a megszakítás forrását a kérés törléséhez.
A TI és RI jelzők csak szoftverrel törölhetők.
Minden megszakítástípus külön-külön engedélyezhető vagy letiltható az IE megszakításengedélyező regiszter megfelelő bitjeinek beállításával vagy törlésével. Ez a regiszter egy általános tiltóbitet is tartalmaz minden megszakításhoz. Az IE regiszter formátumát a táblázat tartalmazza. 14.5.
|
14.5. táblázat. IE regiszterbitek hozzárendelése |
||
|
Pozíció a nyilvántartásban |
Kicsit mnemonikus |
Funkció |
|
Az összes forrásból származó megszakítások letiltása |
||
|
Nem használt |
||
|
Nem használt |
||
|
Megszakítás letiltása innen soros port |
||
|
Időzítő/számláló megszakítása T/C1 letiltása |
||
|
Megszakítás letiltása innen külső forrás INT1 |
||
|
T/C0 időzítő/számláló megszakítás letiltása |
||
|
Az INT0 külső megszakítás letiltása |
||
Mindegyik megszakítástípushoz programozottan hozzárendelhető a két lehetséges prioritás egyike: 0 – a legalacsonyabb vagy 1 – a legmagasabb.
A prioritás beállítása a megfelelő bit beállításával vagy törlésével történik az IP-megszakítási prioritási regiszterben. A regiszter formátumát a táblázat tartalmazza. 14.6.
Ha egyidejűleg érkeznek megszakítási kérelmek különböző prioritású forrásokból, akkor először egy magasabb prioritású forrásból származó kérés kerül feldolgozásra.
Több, azonos prioritású megszakítási kérelem egyidejű vétele esetén azok feldolgozási sorrendjét a mikrokontroller hardvere határozza meg, és szoftverrel nem módosítható. Ez a sorrend megfelel a megszakításkérés zászló lekérdezési sorrendjének, amely a következő:
IT0 -> TF0 -> IT1 -> TF1 -> (RI, TI)
14.6. táblázat. Az IP-regiszterbitek célja
Regisztrálás pozíciója Bitmnemonikus funkció
7 - Nem használt
6 - Nem használt
5 - Nem használt
4 PS Megszakítási prioritás a soros portról
3 PT1 T/C1 időzítő/számláló megszakítási prioritás
2 PX1 Megszakítási prioritás külső forrásból INT1
1 PT0 Időzítő/számláló megszakítási prioritás T/C0
0 PX0 Megszakítási prioritás külső forrásból INT0
A hardverrel megvalósított megszakításkezelő hívás a következőkből áll:
* a programszámláló értékének mentése a verembe;
Az egyes megszakítási források megszakításkezelő belépési pontjai hardverben vannak rögzítve. Értékeiket a táblázat tartalmazza. 14.7.
|
14.7. táblázat. Megszakítás kezelő belépési pontok |
|
|
Forrás megszakítása |
Megszakítás kezelő belépési pontok |
|
külső megszakítás( AZT) |
|
|
Időzítő számláló (TFO) |
|
|
Külső megszakítás (IT1) |
|
|
Időzítő számláló (TF1) |
|
|
Soros port (R1 vagy T1) |
|
A megszakításkezelő első utasítását a megadott címen kell elhelyezni. Általában egy ilyen parancs egy feltétel nélküli ugrás parancs arra a helyre a programban, ahol a kezelő ténylegesen található.
Megszakításkezelőre váltáskor minden olyan megszakítás, amelynek prioritási szintje megegyezik a kiszolgált megszakítás prioritási szintjével, az IE regiszter állapotától függetlenül automatikusan letiltásra kerül - vagyis az azonos prioritási szinttel rendelkező beágyazott megszakítások letiltásra kerülnek. Így egy alacsony prioritású megszakítás (amelynek az IP-regiszter megfelelő bitje "0") megszakítható egy magas prioritású megszakítással (amelynek az IP-regiszter megfelelő bitjében "1" van), de nem alacsony prioritású. A magas prioritású megszakítási szolgáltatást nem szakíthatja meg más forrás.
A megszakításkezelőtől való visszatérés a RETI utasítás segítségével történik, amely visszaállítja a veremből a megszakításkezelő meghívásakor ott tárolt PC-programszámláló értékét és a megszakítási prioritási logikát.
Beszéljünk a megszakításokról. A megszakítás szó önmagáért beszél, bizonyos folyamatok egy ideig leállnak, hogy további műveleteket hajtsanak végre. A megszakítások lehetnek külsőek vagy belsőek. Mondok egy egyszerű példát, amelyet a barátom ajkáról hallottam ...
Mosogatni készült a konyhában, izgatottan fogta fel, feltűrte az ingujját... de az edények zsírosak lettek, és meg kellett állnia, hogy az egyiken találjon mosogatószert a zsíros edények elmosásához. a konyhagarnitúra polcaira, ami után ismét folytatta a foglalkozását. De valamikor megcsörrent a telefon, és ismét félbeszakította a munkáját, felvette a telefont, anyósa felhívott, és azt mondta, hogy eljön látogatóba, ezért el kell mennie a boltba élelmiszert venni neki. érkezés. Elmentem a boltba és csak utána mosogattam.
Ez a példa kétféle megszakítást mutat be, az első a fő munkához kapcsolódik - a zsíros edények eszközének keresése - belső megszakítás, a második - telefon hívás- külső megszakítás.
A mikrokontrollerben külső megszakítások más forrásból érkező jelek, belső megszakítások miatt - magába a mikrokontrollerbe épített eszközök miatt. Miért olyan vonzóak a megszakítások?
Az első az, hogy leállíthatjuk a fő folyamatot valamilyen más funkció végrehajtásához, majd folytathatjuk ezt a folyamatot.
A második, és valószínűleg sok esetben a fő, az összes funkció végrehajtási folyamatának felgyorsítása a belső okok miatt. további eszközök. Térjünk vissza példánkhoz. Mondjuk a barátom akkor kezdett el mosogatni, amikor a felesége már hazajött. A zsíros edényeket látva megkéri, hogy keressen mosogatószert, és amíg elmosogat, már hozza is neki. De aztán megcsörrent a telefon, a feleség felveszi a telefont, beszél az anyjával, és elmegy a boltba. Együtt minden munka nagyon gyorsan elkészül!
És még könnyebb ciklusokban menni – pl. nincs fő program.
Barátnőm a kanapén ül és nem csinál semmit, a házvezetőnő a koszos edényeket látva elmondja neki, és miután megkapta az engedélyt, elmosogatni kezdi magát. Amikor csörög a telefon, azt mondja a feleségének, hogy vegye fel a telefont, a feleség telefonál, és a beszélgetés az élelmiszerboltba megy... Szépség! Ebben az esetben a mikrokontrollerben több I / O eszköz működik egyszerre (a modern mikrokontrollerekben elég sok lehet), és a processzor teljes teljesítménye többszörösére nő, de az eszközmegszakítások feldolgozása egymás után (nem egyidejűleg) történik. , a prioritástól függően ( példánkban a feleség elsőbbséget élvez a házvezetőnővel szemben).
Számos regiszter felelős a megszakítások vezérléséért.
SREG - állapotregiszter(Államok). Megnézzük a bemeneti-kimeneti eszközök táblázatát. A SREG regiszter hetedik bitje az az I (megszakítás) jelző, amelyet globális megszakítás engedélyezési jelzőnek neveznek. Ha a jelzőt kihagyjuk (a hetedik bit nulla), akkor minden megszakítás le van tiltva. Ha a zászló fel van emelve (I-re állítva 1), engedélyezzük a megszakításokat.
Az I zászló beállítása és törlése a következő parancsokkal történik:
SEI - engedélyezze a megszakításokat
CLI - megszakítások letiltása
Hogy melyik megszakítás fog működni, azt a − nevű regiszterekkel lehet beállítani megszakító maszkok.
A megszakítási maszkok a következők:
TIMSK,..,..,.. - időzítők és egyéb beépített eszközök megszakításainak vezérlése.
GIMSK (GIKR a Mega családban) - minden külső megszakítás vezérlése.
A megszakítási maszkok viszont a megszakításjelzőktől függenek:
TIFR és GIFR(nem tévesztendő össze a globális megszakítás engedélyezése jelzővel).
Megszakítási végrehajtási sorrend:
A mikrokontroller bekapcsolásakor az összes megszakítási jelző 0-ra áll vissza. A megszakítások engedélyezéséhez a programnak a SREG regiszter I jelzőjét 1-re kell állítania. Ezt követően regisztrálja a maszk regisztereket a telepített helyi megszakításokkal (megszakítások, amelyekre szükségünk van) .
Amikor megszakítási kérés (jel) érkezik, felemeli a megszakítási jelzőt (még ha a megszakítás le van tiltva is, a beágyazott megszakítások és a különböző megszakítások közötti prioritás megszervezése érdekében). Ha nincs megszakítás tiltás, akkor a vezérlő a megfelelőre kapcsol (Megszakítási vektorok) - megszakítási vektor, az aktuális program szüneteltetése.
Megszakítási vektor egy fix vonal a programterületen, ahová a program ugrik, ha megszakítás történik.
A megszakítási vektorok teljes listáját hívjuk megszakítási vektor táblázat, amely található a kód elején.
Tehát a megszakítási vektor elérésekor a SREG regiszter I jelzője és a megszakítást okozó jelző 0-ra áll vissza, letiltva a többi megszakítást. Ha a megszakítás végrehajtása közben más megszakítási kérelmek is előfordulnak, ezeknek a megszakításoknak a jelzői fel vannak emelve. Amikor az aktuális megszakítás befejeződik, az SREG I jelzője felemelkedik, lehetővé téve a következő megszakítás végrehajtását. Ha több kérés érkezik, és ezek jelzői felemelkednek, akkor először az a megszakítás kerül végrehajtásra, amelynek vektora kisebb, mint a táblázatban szereplő cím, közelebb a memória elejéhez. Következik a második, és így tovább. Ezenkívül a programozó meg tudja szervezni az úgynevezett beágyazott megszakítást, amikor a megszakító program végrehajtása során újabb megszakítás következik be. Ezután az aktuális megszakítás végrehajtása megszakad, és egy újat hajtanak végre, aminek a befejezése után a leállított megszakítás végrehajtása folytatódik.
Példa erre az ATtiny2313 megszakítási vektortáblázata
Az Atmega16 megszakítási vektortáblázata így néz ki:
Összehasonlítva a táblázatok egyáltalán nem egyeznek.
Az ATtiny családban a megszakítási vektor karakterlánc 16 bitet, a Mega családban 32 bitet vesz igénybe (ügyeljen a megszakítási vektorok címére, emlékeztetek arra, hogy a programterület címsorát egy 16-os jelöli. bit szó).
Az ATtiny2313 kódja így nézhet ki:
.cseg .org 0 rjmp Reset rjmp INT_0 rjmp INT_1 rjmp Timer1_capt1 rjmp Timer1_comp1 rjmp Timer1_OVF1 rjmp Timer0_OVF0 rjmp UART_RX rjmp UART_UDRE rjmp UART_TX rjmp_ Time rjmp INT_COMPcomp_ rjmp Timer0_compB rjmp USI_START rjmp USI_OVERFLOW rjmp EE_READY rjmp WDT_OVERFLOW
Mint látható, a megszakítási vektor relatív ugrást hoz létre a megszakító programok címkéihez. Az alábbi táblázat a lehetőségeket mutatja; 1. Amikor nincs fennakadás; 2, 3. külső megszakítással az INT_1 bemeneten.
Ha a címkék „üresek” (nincs program a címke alatt), akkor nem történik semmi, és a többi címkén egymás után „futó” program biztonságosan eléri a parancsot. RETI- Interrupt return – kilépés a megszakításkezelőből a táblázat első oszlopában látható módon.
A megszakító program végrehajtásához, például az INT_1 bemeneten, el kell távolítania az INT_1: címkét a listáról. Ez sematikusan a táblázat második oszlopában látható.
A programozónak azonban kényelmetlen minden megszakítást és külön címkét írni minden alkalommal, különösen a legújabb modellekben, ahol a táblázat elég nagy, könnyebb azonnal beírni a RETI parancsot a megszakítási vektor sorába. ha a megszakítást nem használják. Ekkor a program a táblázat harmadik oszlopában látható módon fog kinézni.
Az AVR vezérlőkben típustól függően 1-8 bemenet lehet külső megszakítások.
Tekintsünk egy külső megszakításvezérlő rendszert. Ehhez a következő I/O regiszterek kombinációi állnak rendelkezésre, modelltől függően (lásd a megfelelő adatlapot):
- GIMSK, EIFR, PCMSK, MCUCR;
- GIKR, GIFR, MCUCR;
- EIMSK, EICR, EIFR;
GIMSK, GIKR, EIMSK - megszakítási maszkok,
EIFR, PCMSK, GIFR, EIFR - megszakítási jelzők
Engedélyezni vagy tiltani külső megszakítások vezérlőregiszterek célja: GIMSK (Általános megszakítási maszk regiszter) (Tiny), GICR (Általános megszakítási vezérlőregiszter) (Mega), MCUCR - (MCU vezérlőregiszter)
EIFR - External Interrupt Flag Register: 1 - engedélyezve, 0 - letiltva. Minden bit (jelző) lehetővé teszi, hogy a megfelelő láb megszakítási forrásként működjön.
GIMSK regiszter vezérlőbitek:
7. bit – INT1: External Interrupt Request 1 Enable - INT1 megszakítás engedélyezési bit: 1 - engedélyezve, 0 - letiltva. Megszakítás akkor is generálódik, ha az INT1 láb kimenetként van konfigurálva. Az INT1 bit megszakításra van beállítva az EIFR jelzőregiszterben. Az INT1 érintkező szinkronizálva van az óragenerátorral.
6. bit - INT0: External Interrupt Request 0 Enable - megszakítás engedélyezése bit INT0: 1 - engedélyezve, 0 - letiltva. Megszakítás akkor is generálódik, ha az INT0 láb kimenetként van konfigurálva. Az INT0 bit megszakításra van beállítva az EIFR jelzőregiszterben. Az INT10 érintkező szinkronizálva van az óragenerátorral.
5. bit - PCIe: Pin Change Interrupt Enable – megszakítás engedélyező bit a PCINT0…7 lábakon: 1 – engedélyezve, 0 – letiltva. A PCINT0...7 lábak bármelyikének módosítása megszakítást generál. A PCINT0…7 lábak külön-külön, a PCMSK jelzőregiszter bitjeivel vannak konfigurálva a megszakításra.
PCMSK- Pin Change Mask Registrer - zászlólajstrom PCMSK: 1 - engedélyezve, 0 - letiltva. Minden bit (jelző) lehetővé teszi, hogy a megfelelő láb megszakítási forrásként működjön. A PCINT0…7 lábak nincsenek szinkronizálva az óragenerátorral, pl. megszakítás történik, ha bármelyik kimenet megváltozik.
Mega8
és a hozzá tartozó zászlóregiszter
7. bit
6. bit - INT0: External Interrupt Request 0 Enable - megszakítás engedélyezése bit INT0: 1 - engedélyezve, 0 - letiltva. Megszakítás akkor is generálódik, ha az INT0 láb kimenetként van konfigurálva. Az INT0 bit megszakításra van beállítva a GIFR flag regiszterében.
GIFR – Általános megszakítási jelzőregiszter: 1 – engedélyezve, 0 – letiltva. Minden bit (jelző) lehetővé teszi, hogy a megfelelő láb megszakítási forrásként működjön.
GICR regiszter vezérlőbitek:
7. bit– : 1. külső megszakítási kérelem engedélyezése – megszakítás engedélyezése bit INT1: 1 - megengedett, 0 - tiltott. Megszakítás akkor is generálódik, ha az INT1 láb kimenetként van konfigurálva. Az INT1 bit megszakításra van beállítva a GIFR jelzőregiszterben.
6. bit - INT0: Külső megszakítási kérelem 0 engedélyezése - megszakítás engedélyezése bit INT0: 1 - megengedett, 0 - tiltott. Megszakítás akkor is generálódik, ha az INT0 láb kimenetként van konfigurálva. Az INT0 bit megszakításra van beállítva a GIFR flag regiszterében.
5. bit – INT2: 2. külső megszakítási kérelem engedélyezése - megszakítás engedélyezése bit INT2: 1 - megengedett, 0 - tiltott. Megszakítás akkor is generálódik, ha az INT2 láb kimenetként van konfigurálva. Az INT2 bit megszakításra van beállítva a GIFR jelzőregiszterben.
Az INT0 és INT1 bemenetek funkcióit minden vezérlőben az MCUCR regiszter alsó bitjei vezérlik.
MCUCR - MCU Control Register
Vezérlő bitek:
1., 0. bitek – ISC01, ISC00 (Megszakításérzékelő vezérlés 0, 1. bit és 0. bit) – ezeknek a biteknek az állapota határozza meg az eseményt az INT0 lábon, amely INT0 megszakítást generál:
ISC01=0, ISC00=0 – logikai nulla szint;
ISC01=0, ISC00=1 – bármilyen logikai állapotváltozás;
ISC01=1, ISC00=0 – lefutó él;
ISC01=1, ISC00=1 – felfutó él.
3., 2. bitek – ISC11, ISC10 (1. megszakításérzékelő vezérlés, 1. bit és 0. bit) – ezeknek a biteknek az állapota határozza meg a jelszintet az INT1 lábon, amelyet az INT1 megszakítás generálására használnak:
ISC11=0, ISC10=0 – logikai nulla szint;
ISC11=0, ISC10=1 – bármilyen logikai állapotváltozás;
ISC11=1, ISC10=0 – lefutó él;
ISC11=1, ISC10=1 – felfutó él.
Nos, úgy tűnik, a minimális külső megszakításokról beszéltünk.
Nyilvánvaló, hogy a megszakítások működéséhez megfelelően elő kell írni őket.
Adjuk hozzá a megszakítás inicializálását az INT1-en, amely a jel felfutó élén indult el apróra:
Ldi r16.0x80 ; írja be az r16-ba a 0b10000000 ldi r17,0x0C számot; írja be az r17-be a 0b00001100 számot az MCUCR,r17-ből; megszakítás a felfutó élen jön létre ISC11=1, ISC10=1 out GIMSK,r16 ; állítsa be a maszkot INT0 sei
Egyébként a tiny2313-on generálhatsz megszakítást bármely PCINT0…7 tűn, a Mega 48-as sorozaton ezek a funkciók nem érhetők el ...
Vannak olyan műveletek, amelyek végrehajtása során a keletkező megszakítások a program összeomlását okozhatják. Ilyenkor a művelet megkezdése előtt CLI-t írunk, utána pedig SEI-t. Ezeket a műveleteket ún atom.
Kívánatos, hogy a megszakítási rutinok tömörek legyenek, és a lehető leggyorsabban fussanak, mivel minden megszakítás célja egy esemény rögzítése. Ha által különböző okok miatt Mivel a program lassan fut, elég az eseményt megörökíteni és kicsit később feldolgozni.
Annak érdekében, hogy a bemutatott anyagot ne zsúfolják el felesleges információkkal, azt javaslom az olvasóknak, hogy használjanak adatlapokat, és ha nem minden világos, akkor gyakrabban kérdezzenek a fórumokon.
Ezután nézzük meg közelebbről a beépített időzítőkön alapuló belső megszakításokat. olvasók. A szavazásban való részvételhez regisztráljon, és felhasználónevével és jelszavával lépjen be az oldalra.
Az ATmega8 mikrokontroller egyik előnye a különböző megszakítások széles választéka.
Megszakítás olyan eseményt jelöl, amelynek bekövetkezésekor a főprogram végrehajtása felfüggesztésre kerül, és egy függvényt hívunk, amely egy bizonyos típusú megszakítást kezel.
A megszakításokat belsőre és külsőre osztják. A belső megszakítási források közé tartoznak a beépített mikrokontroller modulok (időzítők, USART adó-vevő stb.). Külső megszakítások akkor fordulnak elő, ha külső jelek érkeznek a mikrokontroller érintkezőin (például a RESET és INT érintkezőkön). A megszakításhoz vezető jelek jellege a vezérlőregiszterben van beállítva MCUCR, különösen a - ISC00 (0. bit) és ISC01 (1. bit) bitekben az INT 0 bemenethez; ISC10 (bit2) és ISC11 (bit3) az INT1 bemenethez.
Az ATmega8 mikrokontrollerben minden megszakításnak megvan a sajátja megszakítási vektor(a programmemóriaterület elején lévő cím, amely a megadott megszakítási szolgáltatási rutinra ugráshoz szükséges parancsot tárolja). Mega8-ban minden megszakításnak ugyanaz a prioritása. Több megszakítás egyidejű előfordulása esetén először az alacsonyabb vektorszámú megszakítás kerül feldolgozásra.
Megszakítási vektorok az Atmega8-ban
| Cím | Forrás megszakítása | Leírás |
| 0x0000 | VISSZAÁLLÍTÁS | Reset jel |
| 0x0001 | INT0 | Külső megszakítási kérés az INT0 bemeneten |
| 0x0002 | INT1 | Külső megszakítási kérés az INT1 bemeneten |
| 0x0003 | T/C1 | T/C1 Timer Capture |
| 0x0004 | T/C1 | Egyezzen a T/C1 időzítő A összehasonlító regiszterével |
| 0x0005 | T/C1 | Egyezzen a T/C1 időzítő B összehasonlító regiszterével |
| 0x0006 | T/C1 | Számláló túlcsordulás T/C1 |
| 0x0007 | T/C0 | Számláló túlcsordulás T/C0 |
| 0x0008 | SPI | SPI kommunikáció kész |
| 0x0009 | UART | Az UART adó-vevő adatvétele befejeződött |
| 0x000A | UART | Az UART adatregiszter üres |
| 0x000B | UART | Az UART adó-vevő befejezte az adatátvitelt |
| 0x000C | ANA_COMP | Analóg komparátor megszakítás |
Megszakítás vezérlés
4 regiszter felelős a megszakítások kezeléséért az ATmega8-ban:
GIMSK(más néven GICR) - a megszakítások letiltása / engedélyezése az INT0, INT1 bemeneteken
GIFR- minden külső megszakítás kezelése
TIMSK, TIFR- megszakítja a menedzsmentet az időzítőktől/számlálóktól
Regisztráció GIMSK (GICR)
INTFx=1: Megszakítás történt az INTx bemeneten. A megszakítási szolgáltatási rutinba való belépéskor az INTFx automatikusan visszaáll a napló állapotába. 0
Regisztráció TIMSK
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|
| TOIE1 |
OCIE1A |
OCIE1B |
- |
TICIE |
- |
TOIE0 |
- |
TOIE1=1: T/C1 túlcsordulási megszakítás engedélyezve
OCIE1A=1: megszakítás, ha az A összehasonlító regiszter egyezik a T/C1 számláló tartalmával, engedélyezve van
OCIE1B=1: megszakítás, ha a B összehasonlító regiszter egyezik a T/C1 számláló tartalmával
TICIE=1: megszakítható, ha a rögzítési feltétel teljesül
TOIE0=1: T/C0 túlcsordulási megszakítás engedélyezve
Regisztráció TIFR
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|
| TOV1 |
OCF1A |
OCF1B |
- |
ICF1 |
- |
TOV0 |
- |
TOV1=1: T/C1 túlcsordulás történt
OCF1A=1: Az A összehasonlító regiszter megegyezett a T/C1 számláló megengedett tartalmával
OCF1B=1: A B összehasonlító regiszter illesztett T/C1 számlálója megengedett
ICF=1: a rögzítési feltétel teljesült
TOV0=1: T/C0 túlcsordulás történt
A megszakítási szolgáltatási rutinba való belépéskor a TIFR regiszterben a megfelelő megszakításjelző automatikusan naplóállapotba áll vissza. 0
A megszakítások csak akkor működnek, ha az általános megszakítások engedélyezve vannak az SREG állapotregiszterben (7. bit = 1). Ha megszakítás történik, ez a bit automatikusan 0-ra áll vissza, blokkolva a további megszakítások végrehajtását.
Ebben a példában az INT0 láb felhúzható beviteli módban van bekapcsolva. Ha a kimenetet a gombbal földre zárjuk, akkor log.0-t állítunk be rajta (a jelél a tápfeszültségről 0-ra esik le), és a megszakításkezelő aktiválódik, felkapcsolva a B port nulla kimenetére csatlakoztatott lámpát.
üres lámpa BE()
{
PORTB.0=1;
DDRB.0=1;
}
megszakítás void ext_int0_isr(void)
{
lampON();
}
DDRD.2=0;
PORTD.2=1;
SREG|= (1 míg(1) (
A fenti példa azt is bemutatja, hogyan vannak beállítva a megszakítási vektorok a Code Vision AVR-ben (interrupt void ext_int0_isr(void)). A megszakítási vektorok más esetekben is hasonlóan vannak beállítva:
EXT_INT0 2
EXT_INT1 3
TIM2_COMP 4
TIM2_OVF 5
TIM1_CAPT 6
TIM1_COMPA 7
TIM1_COMPB 8
TIM1_OVF 9
TIM0_OVF 10
SPI_STC 11
USART_RXC 12
USART_DRE 13
USART_TXC 14
AD_INT 15
EE_RDY 16
ANA_COMP 17
TWI 18
SPM_READY 19
Rész AVR mikrokontrollerek nagyszámú perifériás eszközt tartalmaz (ADC, Timer / Counters, EXTI, Analog Comparator, EEPROM, USART, SPI, I2C stb.), amelyek mindegyike bizonyos műveleteket hajthat végre adatokon / jeleken és egyéb információkon. Ezek az eszközök a mikrokontrollerbe vannak beépítve, hogy javítsák az alkalmazás hatékonyságát és csökkentsék a költségeket mindenféle AVR mikrokontrolleren alapuló eszköz fejlesztésénél.
A processzor az adatmemóriában található I/O regisztereken keresztül kommunikál/vezérli a perifériás eszközöket, ami lehetővé teszi azok közönséges változóként való használatát. Minden eszköznek saját I/O regisztere van.
Minden bemeneti / kimeneti regiszter (I / O regiszter) három csoportra osztható: adatregiszterek, vezérlőregiszterek és állapotregiszterek.
A vezérlőregiszterek (Control Registers) segítségével a készüléket úgy konfigurálják, hogy bizonyos frekvenciával, pontossággal stb. működjön, és az adatregiszterek (Data Registers) segítségével leolvassák a munka eredményét. ez az eszköz(A/D konverzió, vett adatok, időzítő/számláló érték stb.). Úgy tűnik, nincs itt semmi bonyolult (sőt, itt tényleg nincs semmi bonyolult :)), bekapcsolta a készüléket, jelezte a kívánt üzemmódot, majd csak a kuponok kivágása, az előkészített adatok elolvasása és használja őket a számításokhoz. A teljes kérdés az, hogy pontosan ezeket az adatokat „mikor” kell kiolvasni (hogy az eszköz befejezte-e a munkáját, vagy még folyamatban van az adatfeldolgozás), mert minden periféria a mikrokontroller maggal párhuzamosan, sőt különböző frekvencián működik. Felmerül a megvalósítás kérdése. kommunikáció és szinkronizálás a processzor és perifériaeszköz.
Amint azt valószínűleg sejtette, az eszköz és a processzor közötti kommunikáció és szinkronizálás megvalósításához „Állapotregisztereket” használnak, amelyek tárolják az eszköz aktuális működési állapotát. Minden állapot, amelyben egy eszköz lehet, egy „bitnek” felel meg a regiszter állapota” (zászló), amelynek aktuális értéke „beszél” a jelen eszköz aktuális állapotáról vagy egyedi funkciójáról (befejezett/nem befejezett munka, adatfeldolgozási hiba, a regiszter üres stb.).
A processzor és a periféria közötti kommunikációs mechanizmus az eszköz adott funkcióiért felelős jelzők lekérdezésével valósul meg (flag polling). Egy adott zászló értékétől (eszköz állapotától függően) módosíthatja a program végrehajtásának menetét (elágazás). Például:
Annak ellenőrzése, hogy egy bizonyos zászló be van-e állítva (esemény történt):
if (RegX & (1<<
Flag)
)
// ha a RegX regiszter jelzője be van állítva
{
// csinálj valamit
}
Várakozás egy művelet (esemény) befejezésére:
while(!(RegX & (1< A zászlók lekérdezése meglehetősen erőforrás-igényes feladat, mind a program méretét, mind a program sebességét tekintve. Mivel az AVR mikrokontrollerek összes jelzőszáma meglehetősen nagy (előny), a processzor és az eszköz közötti kommunikáció megvalósítása a zászlók lekérdezésével az Ön által írt program hatékonyságának (kódsebességének / kódméretének) csökkenéséhez vezet, ráadásul a program nagyon zavaróvá válik, ami hozzájárul olyan hibák megjelenéséhez, amelyeket még a kód részletes hibakeresése esetén is nehéz észlelni. Az AVR mikrokontrollerek programjainak hatékonyságának növelése, valamint a programok létrehozásának és hibakeresésének megkönnyítése érdekében a fejlesztők minden perifériás eszközt elláttak „megszakítási forrásokkal” ( Források megszakítása), egyes eszközöknek több megszakítási forrása is lehet. Megszakítási források segítségével valósul meg szinkronizálási mechanizmus, a processzor és a periféria között, azaz a processzor csak akkor kezdi el az adatok fogadását, lekérdezési zászlókat és egyéb műveleteket a perifériás eszközön, ha az eszköz készen áll erre (jelzi az adatfeldolgozás befejeződését, a közben hibát jelez adatkezelés, a nyilvántartás üres, stb.) „megszakítási kérelem” generálásával ( Megszakítási kérés). A szakirodalomban nagyon gyakran az események teljes láncolatát, a „megszakítási kéréstől” (IRQ) a „megszakítási eljárásig” (ISR) megszakításként rövidítik. Megszakítás).
Mi az a megszakítás?
Megszakítás - egy jel, amely tájékoztatja a processzort egy esemény bekövetkezéséről. Ebben az esetben az aktuális parancssorozat végrehajtása felfüggesztésre kerül, és a vezérlés átkerül az ennek az eseménynek megfelelő megszakításkezelési eljárásba, majd a kódvégrehajtás pontosan onnan folytatódik, ahol megszakadt (vezérlő visszatérés). (wiki)
A rutin megszakítása Az (Interrupt Service Routine) nem más, mint egy függvény/szubrutin, amelyet egy bizonyos esemény bekövetkeztekor végre kell hajtani. Az "eljárás" szót fogjuk használni, hogy hangsúlyozzuk a többi funkciótól való különbségét. A fő különbség az eljárás és az egyszerű függvények között az, hogy a szokásos "return from function" (RET assembler utasítás) helyett a "return from interrupt" (RETI assembler utasítás) használatát kell használni. RETurn from Interrupt".
Az AVR megszakítás tulajdonságai: A Reset megszakítás, ellentétben az összes többivel, nem tiltható le. Az ilyen megszakításokat nem maszkolható megszakításoknak is nevezik.
A megszakítási vektortábla, a visszaállítási vektoron kívül, áthelyezhető a Flash memória Boot szakaszának elejére az IVSEL bit beállításával a GICR regiszterben. A visszaállítási vektor a Flash memória Boot szakaszának elejére is áthelyezhető a biztosíték bit - BOOTRST programozásával.
1. ábra ATmega16 megszakítási vektor táblázat Megszakításkezelő prototípus
Ahhoz, hogy egy függvényt megszakításkezelőként deklaráljunk, bizonyos prototípus-szabályozási szabályokat kell követni, hogy a fordító/linker helyesen azonosíthassa és társítsa a kívánt megszakítást a megszakításkezelőhöz. Először is, egy megszakítási rutin nem vehet semmit argumentumnak (void), és nem adhat vissza semmit (void). Ennek az az oka, hogy az AVR-ben minden megszakítás aszinkron, így nem tudható, hogy hol szakad meg a programvégrehajtás, kitől kapjunk és kinek adjunk vissza értéket, valamint hogy minimalizáljuk a be- és kilépési időt. a megszakítás. void isr(void ) Másodszor, a függvény prototípusa előtt jelezni kell, hogy ez egy megszakítási rutin. Mint tudják, a C nyelvben csak a fő függvényben használt kód kerül végrehajtásra. Mivel a megszakításkezelési eljárást sehol nem használjuk a főfüggvényben, hogy a fordító ne „dobja ki” szükségtelenül, az eljárás prototípusa előtt jelezni kell, hogy ez a funkció egy megszakításkezelő eljárás. Megszakításkezelő prototípus az AVR Stúdióban
#beleértve ISR (XXX_vect) Az AVR Stúdióban (AVR GCC) minden megszakítási rutin egy ISR makróval kezdődik, amelyet a következő konstrukció követ zárójelben: XXX_vect ahol "XXX" a megszakítási vektor neve. Egy adott AVR mikrokontroller összes vektorneve megtalálható a mikrokontroller adatlapjának "megszakítási vektortáblázatában" vagy a fejlécfájljában. Például az ATmega16 mikrokontroller „megszakítási vektorok táblázata” az 1. ábrán látható, ahol a Source oszlop tartalmazza a megszakítási vektorok összes nevét. :\Program Files\Atmel\AVR Tools\AVR Toolchain\avr\include\avr\iom16.h), lásd a 2. ábrát. Nincs más dolgunk, mint megkeresni a táblázatban a szükséges vektor nevét, és hozzáadni a " _vect" utótag.
{
}
2. ábra ATmega16 fejlécfájl az AVR Studio számára
Például írjunk egy megszakításkezelési eljárást egy bájt USART-n keresztüli fogadására (USART, Rx Complete):
ISR (USART_RXC_vect)
{
// Megszakításkezelő törzs
}
Mellesleg: mielőtt bármilyen megszakítást használna az AVR Studio-ban, az io.h és interrupt.h fejlécfájlokat bele kell foglalni a projektbe:
#beleértve
#beleértve
Az AVR Studio (AVR GCC) megszakításkezelőiről további információkért lásd: Bevezetés az avr-libc megszakításkezelésébe.
Megszakításkezelő prototípus ImageCraft környezetben
#pragma interrupt_handler
üres<
handler_name>(üres)
{
// Megszakításkezelő törzs
}
Az ImageCraft környezetben a megszakításkezelő prototípusa így néz ki:
üres< handler_name>(üres)
Ahol
#pragma interrupt_handler
Ahol
3. ábra ATmega16 fejlécfájl az ImageCraft IDE-hez
Például a megszakításkezelési eljárás egy bájt USART-n (USART, Rx Complete) keresztül történő fogadásához az ImageCraft környezetben a következőképpen fog kinézni:
#pragma interrupt_handler usart_rxc_isr: iv_USART_RXC
void usart_rxc_isr(void )
{
// Megszakításkezelő törzs
}
Az ImageCraft IDE megszakításkezelési eljárásairól további információkat a fejlesztői környezet Súgó->AVR programozása->Megszakításkezelők menüpontjában talál.
Néha, ha több megszakításkezelőnek ugyanazt a dolgot kell megtennie, akkor a programmemória megtakarítása érdekében több megszakítási vektort irányíthat ugyanahhoz a megszakítási rutinhoz.
Az AVR Stúdióban így néz ki:
ISR (INT0_vect)
{
// Csinálj valamit
}
ISR(INT1_vect, ISR_ALIASOF(INT0_vect) );
Először egy adott vektor megszakítási rutinja következik, ebben az esetben az INT0. Az összes többi eljárás bármely megszakításkezelőre hivatkozhat a konstrukciót használó:
ISR (YYY_vect, ISR_ALIASOF(XXX_vect) ) ;
ahol YYY annak a megszakítási vektornak a neve, amely a XXX vektor korábban deklarált megszakításkezelőjére utal.
ImageCraft környezetben ez így néz ki:
#pragma interrupt_handler
üres<
handler_name>(üres)
{
// Megszakításkezelő törzs
}
#pragma interrupt_handler
#pragma interrupt_handler
üres<
handler_name>(üres)
{
// Megszakításkezelő törzs
}
ahol az XXX és YYY vektorok ugyanarra a megszakításkezelőre utalnak
Hogyan működik a megszakítás az AVR mikrokontrollerekben?
1. Tegyük fel, hogy megtörtént megszakítási kérés” (IRQ).
Apropó: ha egyszerre több megszakítási kérés is előfordul, akkor a legmagasabb prioritású megszakítás kerül feldolgozásra először, az összes többi kérés a magas prioritású megszakítás befejeződésekor.
2. Vizsgálat.
Ha a megszakítás engedélyező bit be van állítva, és a processzorállapot-regiszter (SREG) I-bitje (megszakítás engedélyező bit) be van állítva, a processzor megkezdi a megszakítási rutin előkészítését, míg a megszakítás engedélyező bit (regiszter I-bit) SREG) alaphelyzetbe áll, ezzel letiltva az összes többi megszakítást. Ez azért történik, hogy semmilyen más esemény ne szakítsa meg az aktuális megszakítás feldolgozását.
Apropó: ha a megszakításkezelési eljárásban az I-bitet log állapotra állítja. egység, akkor bármely aktivált megszakítás megszakíthatja az aktuális megszakítás feldolgozását. Az ilyen megszakításokat beágyazott megszakításoknak nevezzük.
3. Készítmény.
A processzor befejezi az aktuális assembler utasítás végrehajtását, majd a következő utasítás címét a verembe tolja (PC->STACK). Ezt követően a processzor ellenőrzi, hogy melyik megszakítási forrás küldött „megszakítási kérelmet” (IRQ), majd ennek a forrásnak (referenciának) a vektortáblájából (amely minden megszakítási forráshoz keményen kódolt) bemegy a a megszakításkezelési eljárás (JMP utasítás). mindent, mindenről a processzor legalább 4 ciklust tölt!(A kérés pillanatától és az aktuális utasítás végrehajtásának időtartamától függően.) Ez nagyon jó válaszidő IRQ, összehasonlítva más gyártók mikrokontrollereivel.
Mellesleg: ha IRQ történik, amikor a mikrokontroller alvó üzemmódban van (alvó üzemmódban), akkor az IRQ válaszideje további négy ciklussal nő, plusz a SUT1 és SUT0 biztosítékbitekbe ágyazott idő (Start-Up Time).
Megszakítás (megszakítás) - olyan esemény, amely azonnali választ igényel a processzortól. A reakció az, hogy a processzor megszakítja az aktuális program feldolgozását ( megszakítandó program) és folytat egy másik program végrehajtását ( program megszakítása) kifejezetten erre az eseményre tervezték. A program befejezése után a processzor visszatér a megszakított program végrehajtásához.
Minden megszakítást igénylő eseményt követ megszakító jel, értesítette erről a számítógépet, és felhívta megszakítási kérés.
A program állapota az összes memóriaelem állapotának halmazát jelenti a megfelelő időpontban (például az utolsó parancs végrehajtása után). Megszakítás esetén a mikrokontroller a programszámláló tartalmát eltárolja a veremben, és betölti abba a megfelelő megszakítási vektor címét. A megszakítási szolgáltatási rutin utolsó utasításának olyan utasításnak kell lennie, amely visszatér a fő programhoz, és visszaállítja a korábban elmentett programszámlálót. A megszakításkezelő végrehajtása során bizonyos információk módosulhatnak. Ezért a megszakításkezelőnek való átadáskor el kell menteni a módosítandó elemeket. Az ilyen elemek halmaza az program állapotvektor. Ebben az esetben a memóriacellák állapotára vonatkozó egyéb információ nem jelentős, vagy szoftveresen visszaállítható.
Vektor kezdeti állapot tartalmazza a program kezdeti elindításához szükséges összes információt. Sok esetben a kezdeti állapotvektor csak egy elemet tartalmaz - a futó program kezdőcímét.
Megszakítási vektor a megszakító program (kezelő) kezdeti állapotvektora, és tartalmazza az összes szükséges információt a kezelőhöz való ugráshoz, beleértve a kezdőcímét is. Minden megszakítástípusnak saját megszakítási vektora van, amely inicializálja a megfelelő kezelő végrehajtását. Általában a megszakítási vektorokat speciálisan lefoglalt fix memóriacellákban tárolják rövid címekkel, amelyek igen megszakítási vektor táblázat. A megfelelő megszakítási programra ugráshoz a processzornak rendelkeznie kell egy megszakítási vektorral és ennek a vektornak a címével. Ezen a címen általában egy feltétel nélküli ugrási parancs található a szolgáltatásmegszakítási rutinhoz.
A tárolási és visszatérési vezérlés általában a megszakításkezelőhöz van hozzárendelve. Ebben az esetben a kezelő három részből áll - előkészítő ( prológ ) és végső ( epilógus ), kapcsolóprogramokat biztosító, és a tényleges megszakító program, amely a kérés által kért műveleteket hajtja végre. A válaszidő a megszakítási kérelem beérkezésének pillanatától a megszakító program végrehajtásának megkezdéséig eltelt idő.
tp a rendszer válaszideje egy megszakításra;
t– a megszakított program állapotának tárolási ideje;
t ppr a tényleges megszakító program ideje;
t be– a megszakított programállapot helyreállítási ideje
Ha több kérési forrás létezik, akkor a bejövő kérések kiszolgálásának egy bizonyos sorrendjét kell felállítani, hívni prioritási arányok vagy szolgálati fegyelem. Az összes lehetséges processzormegszakítási típus halmaza az megszakítási rendszer mikrokontroller. A szolgáltatási fegyelem határozza meg, hogy az egy időben érkező több kérés közül melyiket kell először feldolgozni, és azt adott kérés megszakítani egyik vagy másik megszakításkezelőt.
Ha a megszakítási feldolgozás során magasabb prioritású megszakítási kérés érkezik, a vezérlés a magasabb prioritású megszakításkezelőhöz kerül, miközben az alacsonyabb prioritású megszakításkezelő munkája felfüggesztésre kerül. Felmerül megszakítja a beágyazást. A program meghívja az egymást felfüggeszthető programok maximális számát megszakítási mélység.
Ha a megszakítási kérelmet nem szolgálják ki addig, amíg új kérés érkezik ugyanabból a forrásból (azonos prioritású), akkor megszakítja a rendszer telítettségét. Ebben az esetben a megszakítási kérelmek egy része elvész, ami a normál működés mikrokontroller nem engedélyezett.
Megszakítási rendszer jellemzői vannak:
- a megszakítási kérelmek teljes száma – a megszakításkérés-források száma;
- megszakítási ábrázolás típusa - általában a megszakítási kérelmet egy logikai jelszint képviseli;
- megszakítási prioritás - meghatározza az egyes megszakítási kérelmek feldolgozási sorrendjét, minél magasabb a prioritás, annál kisebb a késleltetés a megszakítási program végrehajtásában;
- reakcióidő - a megszakítási kérelem megjelenése és a megszakítási program végrehajtásának kezdete közötti időintervallum;
- megszakítási késleltetés - a program tárolásának és visszaállításának teljes ideje határozza meg;
- mélység, általában megegyezik a megszakítási rendszer prioritási szintjeinek számával;
- a megszakítási rendszer telítettsége;
- a programok megengedett megszakítási ideje (általában a következő utasítás végrehajtásának vége).
A maszkolás megszakítása arra szolgál, hogy utasítsa a mikrokontrollert, hogy reagáljon minden típusú megszakításra, vagy figyelmen kívül hagyja azokat. A megszakítási maszk egy bináris kódot képvisel, amelynek bitjei a megszakításkérés forrásaihoz vannak leképezve. A bináris kód egyetlen bitje megmondja a mikrokontrollernek, hogy kezelje az ilyen típusú megszakításokat. A nulla bit éppen ellenkezőleg, nem teszi lehetővé a mikrokontroller számára, hogy folytassa a megadott típusú megszakítások feldolgozását.
Általános szabály, hogy a megszakítások maszkolása mellett van egy globális megszakítás engedélyezési bit is, amelynek nulla értéke letiltja az összes megszakításkezelőt (kivéve a hardver visszaállítását és a futtatható program elejére ugrást).
A megszakítási maszk bináris mellett van egy bináris kód is megszakításjelzők, amely lehetővé teszi, hogy a megszakításkezelő beállítsa a megszakítás forrását, ha a mikrokontrollerben több forrás is van a megadott kéréssel.
