| I. Fortsättning från föregående till nästa I den föregående föreläsningen bekantade vi oss med den grundläggande processen för att utveckla CC2430-program i IAR genom ett litet experiment med den enklaste blinkande LED-lampan. Kniven har åtminstone slipats (även om jag inte är särskilt bra på den här slipstenen), och nu är det dags att börja slakta buggar :). Låt oss sedan lära oss några grundläggande CC2430-experiment. Varje litet experiment, indelat i "experimentell introduktion", "programflödesschema", "experimentell källkod och analys" tre delar av beskrivningen. Den här artikeln förklarar det externa avbrottet. För det andra, det externa avbrottet(1) Introduktion till experimentet Avbrott är en mikrokontroller i realtid för att hantera interna eller externa händelser, en intern mekanism. När någon form av intern eller extern händelse inträffar kommer mikrokontrolleravbrottssystemet att tvinga CPU: n att pausa programmet som körs, men för att gå till avbrottshändelsebehandlingen är avbrottsbehandlingen klar och återgår sedan till att avbrytas av programmet, fortsätt att köra. Avbrott är indelade i externa avbrott och interna avbrott, CC2430 innehåller totalt 18 avbrottskällor (specifik avbrottsbeskrivning och avbrottsvektordefinition, du kan hänvisa till " CC2430 Chinese Manual "). Låt oss nu ta en titt på kretsschemat för detta utvecklingskort:
Utvecklingskortet har anslutits till S1-knappen och P0.1, den effekt som detta experiment vill uppnå är att utlösa avbrottet av P0.1 genom att trycka på knappen S1 och sedan styra LED1-lampan / ut i avbrottsservicens subrutin. (2) Experimentell princip och flödesschema Flödesschemat för experimentet är som följer: 
c
(3) Experimentell källkod// header file#include // delay subfunction#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 kristallinitialiseringvoid xtal_init( void ) { SLEEP &=~0x04; &
nbsp; //all ström uppwhile (!
(SLEEP & 0x40 )); //kristalloscillatorn på och stabil CLKCON &=~0x47; &
nbsp; //Välj 32MHz kristalloscillator SLEEP |=0x04; }//LED-initialiseringvoid led_init( void ) { P1SEL =0x00;  
; //P1 är en normal I/O-port P1DIR |=0x0F; //P1.0 P1.1 P1.2 P1.3 Utg ång
led1 = 0; led2 = 0; led3 = 0; led4 = 0; }//initialisering av I/O och externa avbrottvoid io_init( void ) { P0INP &=~0X02;
/ /P0.1 har pull-up och pull-down EA =1; //Total avbrottsaktivering P0IE =1; &
nbsp; //P0 interrupt enable PICTL |=0X09; //P0.1 port interrupt enable, falling edge trigger P0IFG &=~0x02
; //P0.1 interrupt flag clear 0 };//main functionvoid main( void ) { xtal_init(); led_init();
io_init();while ( 1 ); //vänta på avbrott }//underrutin för avbrottsservice#pragma vector = P0INT_VECTOR__interrupt void P0_ISR( void ) { EA =0;
/ / stäng av avbrottet Delay
( 10000 ); Fördröjning(10000 ); Fördröjning(10000 ); Fördröjning(10000); Fördröjning(10000 ); &
nbsp; if ((P0IFG & 0x02 ) >0 ) //nyckelavbrott { P0IFG &=~0x02; &
nbsp; //P0.1 interrupt flag clear 0 led1 = !led1; } P0IF =0; & nbsp; //P0 .1 interrupt flag clear 0 led1 = !led1; } P0IF = 0; & nbsp
nbsp; //P0 avbrottsflagga klar 0 EA =1; &
nbsp; // slå på avbrottet }
Initialisera först enhetsklockan: välj en 32 MHz kristalloscillator. Initialisera sedan lysdioderna: ställ in P1 som I/O-port för allmänt ändamål, ställ in P1.0 ~ P1.3-riktning som utgång och stäng sedan av de 4 lysdioderna. Konfigurera sedan de relevanta SFR-registren för externa avbrott och slå på avbrottsaktiveringen på alla nivåer, vilket involverar 3 SFR: EA, IEN1, PICTL (för detaljerad beskrivning av varje SFR, se " CC2430 Chinese Manual "): EA -- total avbrottsaktivering; IEN1.5 -- aktivering av P0-avbrott; PICTL.3 -- aktivering av P0.1-portavbrott; PICTL.0 -- Ställ in P0.1-portingångens fallande flank för att orsaka avbrottsutlösning. Använd sedan while(1) i huvudfunktionen för att vänta på avbrottet. CC2430 Tips(1) Bittilldelning Syntax Sammanfattning Mycket ofta behöver vi tilldela ett värde (0 eller 1) till en bit i en SFR med en byte för att exakt styra en maskinvaruenhet.
V issa SFR stöder bitadressering, till exempel TCON, P0, etc., för närvarande är tilldelningen av biten mycket enkel, bara fråga ioCC2430.h-huvudfilen i SFR Bit Access-delen av bitdefinitionen kan vara: P0_0 = 0; // P0 den första biten av tilldelningen av värdet 0 P0_0 = 1; / / / P0 den första biten av tilldelningen av värdet 1 Det finns dock SFR som inte stöder bitadressering, som i fallet med den första biten av tilldelningen av värdet på den första biten av den första biten av den första biten av den första biten av den första biten av den första biten av den första biten av den andra biten.
Vissa SFR: er stöder dock inte bitadressering, t.ex. PICTL i detta experiment, och när du vill tilldela ett värde till en av dem är syntaxen följande: PICTL &= ~0x01; //tilldela värdet 0 till den första biten PICTL |= 0x01; //tilldela värdet 1 till den första biten Du kan komma ihåg att & amp;= ~ , |= ~, |= ~, |= ~ , |= P0_0 = 1; //tilldela värdet 1 till den första biten i P0 . amp;= ~, |= dessa två vanliga syntaxer för bittilldelning. (2) Interrupt Enablement Sammanfattning När ett avbrott är inblandat i ett program måste det aktiveras innan avbrottet utlöses.
C 51 avbrottsaktiveringssystem, dess hierarkiska struktur är mycket uppenbar: avbrottschef: EA är chefen, ansvarig för den totala avbrottsaktiveringen: EA = 1; avbrottskapten: nästa är för varje funktionell komponent (t.ex. P0, timer 1, etc.) aktivera kontroll, sådan SFR i allmänhet bitadresserbar, namngivning innehåller vanligtvis IE (avbrottsaktivering) : P0IE = 1; avbrottsteammedlemmarna : avbrott, men på grund av avbrottet i programmet måste avbrottet aktiveras innan avbrottet utlöses.
v arje avbrottslagmedlemmar: lag men eftersom varje funktionell komponent också innehåller flera avbrott, så är den sista nivån för varje av brottsaktiveringskontroll, sådan SFR är i allmänhet inte bitadresserbar, heter i allmänhet IE (Interrupt Enable) eller IM (Interrupt Mask): PICTL | = 0x01; behöver inte memorera avbrotts SFR: erna Det finns inget behov av att memorera avbrotts SFR: erna, så länge du förstår hierarkin och sedan konsulterar manualen eller huvudfilerna när du använder dem. (3) Skriva avbrottsprogram Användningen av avbrott i ett program består i allmänhet av två delar: skrivandet av underrutinen för avbrottsservice och öppnandet av avbrottsaktiveringen.
A vbrottsaktivering har introducerats ovan, följande är en kort introduktion till förberedelsen av avbrottsserviceunderrutin: Först och främst, ange avbrottsvektorn, kan finnas i ioCC2430.h-headerfilen i Interrupt Vectors-delen av frågan, syntaxen är som följer: # pragma vector = Interrupt Vectors och sedan följt av förberedelsen av avbrottshanteraren, strukturen är som följer: ___ interrupt void Function Name (___)
i nterrupt void function name(void) { //on interrupt //interrupt handling //interrupt flag clear 0 //off interrupt }
III. slutsats Denna artikel introducerar en enkel implementeringsmetod för externa avbrott baserat på CC2430, med utgångspunkt från avbrottet, sedan introducerar vi en annan mycket viktig modul - timer. CC2430 har totalt fyra timers, som kan delas in i tre kategorier: timer 1, timer 2, timer 3/4 (3 och 4 av användningen av samma grundläggande). samma).
</n;tt++).
</n;tt++);.
</n;tt++).
</n;tt++); </n;tt++); </n;tt++); </n;tt++); </n;tt++).
</n;tt++).
| 
B 