| I. Az előzőről a következőre továbblépve Az előző előadásban a CC2430-as programok IAR-ban történő fejlesztésének alapvető folyamatával ismerkedtünk meg egy kis kísérleten keresztül a legegyszerűbb LED villogtatásával. A kés legalább meg lett élezve (bár nem vagyok túl jó ebben az élező kőben), és most már ideje elkezdeni a bogarak lemészárlását :). Ezután tanuljunk meg néhány alapvető CC2430-as kísérletet. Minden kis kísérlet, osztva "kísérleti bevezetés", "program folyamatábrája", "kísérleti forráskód és elemzés" három részre a leírás. Ez a cikk elmagyarázza a külső megszakítást. Másodszor, a külső megszakítás(1) Bevezetés a kísérletbe A megszakítás egy valós idejű mikrokontroller a belső vagy külső események kezelésére, egy belső mechanizmus. Amikor valamilyen belső vagy külső esemény történik, a mikrokontroller megszakítási rendszere arra kényszeríti a CPU-t, hogy szüneteltesse a végrehajtott programot, de a megszakítási esemény feldolgozásához menjen, a megszakítási feldolgozás befejeződik, majd visszatér a program megszakításához, folytassa a végrehajtást. A megszakítások külső megszakításokra és belső megszakításokra oszlanak, a CC2430 összesen 18 megszakítási forrást tartalmaz (a konkrét megszakítási leírás és a megszakítási vektor meghatározása a " CC2430 kínai kézikönyv " című dokumentumban található). Most nézzük meg ennek a fejlesztési lapnak az áramköri diagramját: 
A fejlesztési lapot az S1 gombhoz és a P0.1-hez csatlakoztattuk, a hatás, amit ez a kísérlet el akar érni, az, hogy az S1 gomb megnyomásával kiváltja a P0.1 megszakítását, majd a megszakítás kiszolgáló alprogramban vezérli a LED1 fényét / kialvását. (2) Kísérleti elv és folyamatábra A kísérlet folyamatábrája a következő:
c
(3) Kísérleti forráskód// fejlécfájl#include // delay alfunkció#define led1 P1_0#define led2 P1_1#define led3 P1_2#define led4 P1_3void Delay( unsigned n) { && &
nbsp; unsigned tt;for (tt = 0;tt<n;tt++);for (tt = 0;tt<n;tt++);for (tt = 0;tt<n;tt++); &
nbsp; for (tt = 0;tt<n;tt++);for (tt = 0;tt<n;tt++); }//32M kristály inicializálásavoid xtal_init( void ) { SLEEP &=~0x04; &
nbsp; //minden bekapcsoláswhile (!
(SLEEP & 0x40 )); //kristályos oszcillátor bekapcsolva és stabil CLKCON &=~0x47; &
nbsp; //Select 32MHz-es kristályoszcillátor SLEEP |=0x04; }//LED inicializálásvoid led_init( void ) { P1SEL =0x00;  
; //P1 egy normál I/O port P1DIR |=0x0F; //P1.0 P1.1 P1.2 P1.3 Ki menet
led1 = 0; led2 = 0; led3 = 0; led4 = 0; }//io és külső megszakítás inicializálásvoid io_init( void ) { P0INP &=~0X02;
/ /P0.1 pull-up és pull-down EA =1; //Teljes megszakítás engedélyezése P0IE =1; &
nbsp; //P0 megszakítás engedélyezése PICTL |=0X09; //P0.1 port megszakítás engedélyezése, csökkenő élű trigger P0IFG &=~0x02
; //P0.1 interrupt flag clear 0 };//main functionvoid main( void ) { xtal_init(); led_init();
io_init();while ( 1 ); //megszakításra várni }//megszakítás kiszolgáló alprogram#pragma vector = P0INT_VECTOR__interrupt void P0_ISR( void ) { EA =0;
/ / megszakítás kikapcsolása Delay
( 10000 ); Delay(10000 ); Delay(10000 ); Delay(10000); Delay(10000 ); Delay(10000 ); &
nbsp; if ((P0IFG & 0x02 ) >0 ) //billentyű megszakítás { P0IFG &=~0x02; &
nbsp; //P0.1 megszakítási jelző törlése 0 led1 = !led1; } P0IF =0; &
nbsp; //P0 megszakítási jelző törlése 0 EA =1; &
nbsp; // megszakítás bekapcsolása }
Először inicializáljuk az Unity Clockot: válasszunk egy 32MHz-es kristály oszcillátort. Ezután inicializáljuk a LED-eket: állítsuk be a P1-et általános célú I/O portként, állítsuk be a P1.0 ~ P1.3 irányt kimenetként, majd kapcsoljuk ki a 4 LED-et. Ezután konfigurálja a megfelelő SFR regisztereket a külső megszakításokhoz, és kapcsolja be a megszakítás engedélyezését minden szinten, 3 SFR-t érintve: EA, IEN1, PICTL (az egyes SFR-ek részletes leírását lásd a " CC2430 kínai kézikönyv " című dokumentumban): EA -- teljes megszakításengedélyezés; IEN1.5 -- P0 megszakítás engedélyezése; PICTL.3 -- P0.1 port megszakítás engedélyezése; PICTL.0 -- a P0.1 port bemenetének csökkenő élét állítja be a megszakítás kiváltására. Ezután a while(1)-t használjuk a főfüggvényben a megszakításra való várakozáshoz. CC2430 tippek(1) Bit hozzárendelés szintaxis összefoglaló Nagyon gyakran kell egy értéket (0 vagy 1) hozzárendelni egy bithez egy egybájtos SFR-ben egy hardvereszköz pontos vezérléséhez.
N éhány SFR támogatja a bitcímzést, mint például a TCON, P0 stb., Ebben az időben a bit hozzárendelése nagyon egyszerű, csak kérdezze le az ioCC2430.h fejlécfájlt az SFR Bit Access részében a bit definíciója lehet: P0_0 = 0; // P0 az első bit a hozzárendelés értékének 0 P0_0 = 1; / / / / P0 az első bit a hozzárendelés értékének 1 Azonban vannak SFR-ek, amelyek nem támogatják a bitcímzést, mint például az első bit a hozzárendelés értékének első bitje a második bit első bitjének első bitje esetében.
Vannak azonban olyan SFR-ek, amelyek nem támogatják a bitcímzést, mint például a PICTL ebben a kísérletben, amikor értéket akarunk rendelni az egyikhez, a szintaxis a következő: PICTL &= ~0x01; // 0 értéket rendelünk az első bithez PICTL |= 0x01; // 1 értéket rendelünk az első bithez Emlékezhetünk, hogy & amp;= ~, |= ~, |= ~, |= ~, |= P0_0 = 1; // 1 értéket rendelünk a P0 első bitjéhez . amp;= ~, |= ez a két gyakori bit hozzárendelési szintaxis. (2) A megszakítás engedélyezésének összefoglalása Ha egy megszakítás részt vesz egy programban, akkor a megszakítás kiváltása előtt engedélyezni kell.
C 51 megszakítás engedélyezési rendszer, hierarchikus felépítése nagyon nyilvánvaló: megszakítás főnök: EA a főnök, felelős a teljes megszakítás engedélyezése: EA = 1; megszakítás leválasztás kapitány: a következő az egyes funkcionális komponensek (például P0, időzítő 1, stb.) engedélyezése vezérlés, mint SFR általában bitcímezhető, elnevezése általában tartalmaz IE (Interrupt Enable): P0IE = 1; a megszakítás csapat tagjai: leválasztás, de a programmegszakítása miatt a megszakítást engedélyezni kell a megszakítás kiváltása előtt.
m inden megszakítási csapattag: csapat, de mivel minden funkcionális komponens több megszakítást is tartalmaz, így az utolsó szint minden megszakítás engedélyezésének vezérlésére szolgál, az ilyen SFR általában nem bitcímezhető, elnevezése általában IE (Interrupt Enable) vagy IM (Interrupt Mask): PICTL | = 0x01; nem kell megjegyezni a megszakítási SFR-eket. A megszakítási SFR-eket nem szükséges megjegyezni, amennyiben megérti a hierarchiát, majd használatukkor konzultál a kézikönyvvel vagy a fejlécfájlokkal. (3) Megszakítási programok írása A megszakítások használata egy programban általában két részből áll: a megszakítást kiszolgáló szubrutin megírása és a megszakítás engedélyezésének megnyitása.
A megszakítás engedélyezése fentebb bemutatásra került, a következőkben röviden bemutatjuk a megszakítás-kiszolgáló szubrutin elkészítését: Először is, adja meg a megszakítási vektort, lehet az ioCC2430.h fejlécfájlban a megszakítási vektorok résznél a lekérdezés, a szintaxis a következő: # pragma vector = megszakítási vektorok , majd ezt követi a megszakításkezelő elkészítése, a szerkezet a következő: ___ megszakítás void Function Name (___)
i nterrupt void függvénynév(void) { //on interrupt //interrupt kezelés //interrupt flag clear 0 //off interrupt }
III. Következtetés Ez a cikk egy egyszerű külső megszakítás megvalósítási módszert mutat be a CC2430 alapján, a megszakítás alapján, majd bemutatunk egy másik nagyon fontos modult - az időzítőt. A CC2430 összesen négy időzítővel rendelkezik, amelyek három kategóriába sorolhatók: időzítő 1, időzítő 2, időzítő 3/4 (3 és 4 a használat ugyanaz az alap). ugyanazt).
</n;tt++).
</n;tt++);.
</n;tt++).
</n;tt++); </n;tt++); </n;tt++); </n;tt++); </n;tt++).
</n;tt++).
| 
发表于 2014-10-30 23:16:46
K 