| I. Fortsættelse fra det foregående til det næste I den forrige forelæsning gjorde vi os bekendt med den grundlæggende proces med at udvikle CC2430-programmer i IAR gennem et lille eksperiment med den simpleste LED, der blinker. Kniven er i det mindste blevet slebet (selvom jeg ikke er særlig god til denne slibesten), og nu er det tid til at begynde at slagte bugs :). Lad os nu lære et par grundlæggende CC2430-eksperimenter. Hvert lille eksperiment er opdelt i "eksperimentel introduktion", "programflowdiagram", "eksperimentel kildekode og analyse" tre dele af beskrivelsen. Denne artikel forklarer den eksterne afbrydelse. For det andet den eksterne afbrydelse(1) Introduktion til eksperimentet Interrupt er en realtidsmikrocontroller til at håndtere interne eller eksterne begivenheder, en intern mekanisme. Når der opstår en slags intern eller ekstern begivenhed, vil mikrocontrollerens afbrydelsessystem tvinge CPU'en til at sætte det program, der udføres, på pause, men at gå til afbrydelseshændelsesbehandlingen, afbrydelsesbehandlingen er afsluttet og derefter vende tilbage til at blive afbrudt af programmet, fortsæt med at udføre. Afbrydelser er opdelt i eksterne afbrydelser og interne afbrydelser, CC2430 indeholder i alt 18 afbrydelseskilder (specifik afbrydelsesbeskrivelse og afbrydelsesvektordefinition, du kan henvise til " CC2430 Chinese Manual "). Lad os nu se på kredsløbsdiagrammet for dette udviklingskort:
Udviklingskortet er forbundet med S1-knappen og P0.1, og den effekt, som dette eksperiment ønsker at opnå, er at udløse afbrydelsen af P0.1 ved at trykke på tasten S1 og derefter styre LED1-lyset/ud i afbrydelsesserviceunderrutinen. (2) Eksperimentelt princip og flowdiagram Flowdiagrammet for eksperimentet er som følger: 
c
(3) Eksperimentel kildekode// 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 krystalinitialiseringvoid xtal_init( void ) { SLEEP &=~0x04; &
nbsp; //al power upwhile (!
(SLEEP & 0x40 )); //krystaloscillator tændt og stabil CLKCON &=~0x47; &
nbsp; //Vælg 32MHz krystaloscillator SLEEP |=0x04; }//LED-initialiseringvoid led_init( void ) { P1SEL =0x00;  
; //P1 er en normal I/O-port P1DIR |=0x0F; //P1.0 P1.1 P1.2 P1.3 Output
led1 = 0; led2 = 0; led3 = 0; led4 = 0; }//io og ekstern interrupt-initialiseringvoid io_init( void ) { P0INP &=~0X02;
/ /P0.1 har pull-up og pull-down EA =1; //Total afbrydelsesaktivering 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 ); //vent på interrupt } //interrupt service subroutine#pragma vector = P0INT_VECTOR__interrupt void P0_ISR( void ) { EA =0;
/ / slå afbrydelse fra Delay
( 10000 ); Delay(10000 ); Delay(10000 ); Delay(10000 ); Delay(10000 ); &
nbsp; if ((P0IFG & 0x02 ) >0 ) //key interrupt { P0IFG &=~0x02; &
nbsp; //P0.1 interrupt flag clear 0 led1 = !led1; } P0IF =0; &
nbsp; //P0 interrupt flag clear 0 EA =1; &
nbsp; // slå interrupt til }
Initialiser først Unity Clock: vælg en 32 MHz krystaloscillator. Initialiser derefter LED'erne: Indstil P1 som den generelle I/O-port, indstil P1.0 ~ P1.3-retningen som output, og sluk derefter de 4 LED'er. Konfigurer derefter de relevante SFR-registre til eksterne afbrydelser, og tænd for afbrydelsesaktiveringen på alle niveauer, hvilket involverer 3 SFR'er: EA, IEN1, PICTL (for en detaljeret beskrivelse af hver SFR henvises til " CC2430 Chinese Manual "): EA -- total interrupt enable; IEN1.5 -- aktivering af P0-interrupt; PICTL.3 -- aktivering af P0.1-portinterrupt; PICTL.0 -- sæt P0.1 port input falling edge til at forårsage interrupt trigger. Brug derefter while(1) i hovedfunktionen til at vente på afbrydelsen. CC2430 Tips(1) Bit Assignment Syntax Summary Meget ofte er vi nødt til at tildele en værdi (0 eller 1) til en bit i en single-byte SFR for præcist at styre en hardwareenhed.
N ogle SFR'er understøtter bitadressering, såsom TCON, P0 osv., på dette tidspunkt er tildelingen af biten meget enkel, bare spørg ioCC2430.h-headerfilen i SFR Bit Access-delen af bitdefinitionen kan være: P0_0 = 0; // P0 den første bit af tildelingen af værdien af 0 P0_0 = 1; / / / P0 den første bit af tildelingen af værdien af 1 Der er dog SFR'er, der ikke understøtter bitadressering, som i tilfældet med den første bit af tildelingen af værdien af den første bit af den første bit af den første bit af den første bit af den første bit af den anden bit .
Men nogle SFR' er understøtter ikke bitadressering, f.eks. PICTL i dette eksperiment, og når du vil tildele en værdi til en af dem, er syntaksen som følger: PICTL &= ~0x01; //tildel en værdi på 0 til den første bit PICTL |= 0x01; //tildel en værdi på 1 til den første bit Du kan huske, at & amp;= ~, |= ~, |= ~, |= P0_0 = 1; //tildel en værdi på 1 til den første bit af P0 . amp;= ~, |= disse to almindelige bittildelingssyntakser. (2) Interrupt Enablement Summary Når et interrupt er involveret i et program, skal det aktiveres, før interruptet udløses.
C 51 interrupt enable system, dets hierarkiske struktur er meget indlysende: interrupt boss: EA er chefen, ansvarlig for den samlede interrupt enable: EA = 1; interrupt detachment captain: næste er for hver funktionel komponent (såsom P0, timer 1 osv.) Aktiver kontrol, sådan SFR generelt bit adresserbar, navngivning indeholder generelt IE (Interrupt Enable) : P0IE = 1; interrupt teammedlemmer : frigørelse, men på grund af afbrydelse af programmet skal afbrydelsen aktiveres, før afbrydelsen udløses.
h vert interrupt-holdmedlem: hold, men fordi hver funktionel komponent også indeholder flere afbrydelser, så er det sidste niveau for hver inter rupt-aktiveringskontrol, sådan SFR er generelt ikke bitadresserbar, navngivet indeholder generelt IE (Interrupt Enable) eller IM (Interrupt Mask): PICTL | = 0x01; behøver ikke at huske interrupt SFR'erne Det er ikke nødvendigt at huske interrupt-SFR'erne, så længe du forstår hierarkiet og derefter konsulterer manualen eller headerfilerne, når du bruger dem. (3) Skrivning af interrupt-programmer Brugen af interrupts i et program består generelt af to dele: skrivning af interrupt service subroutinen og åbning af interrupt enable.
I nterrupt enable er blevet introduceret ovenfor, følgende er en kort introduktion til forberedelsen af interrupt service subroutine: Først og fremmest skal du angive interruptvektoren, kan være i ioCC2430.h headerfilen i Interrupt Vectors-delen af forespørgslen, syntaksen er som følger: # pragma vector = Interrupt Vectors og derefter efterfulgt af forberedelsen af interrupt handler, strukturen er som følger: ___ interrupt void Function Name (___)
i nterrupt void function name(void) { //on interrupt //interrupt handling //interrupt flag clear 0 //off interrupt }
III. konklusion Denne artikel introducerer en simpel ekstern interrupt-implementeringsmetode baseret på CC2430, med udgangspunkt i interruptet, så introducerer vi et andet meget vigtigt modul - timer. CC2430 har i alt fire timere, som kan opdeles i tre kategorier: timer 1, timer 2, timer 3/4 (3 og 4 af brugen af det samme grundlæggende). det samme).
</n;tt++).
</n;tt++);.
</n;tt++).
</n;tt++); </n;tt++); </n;tt++); </n;tt++).
</n;tt++).
| 
2014-10-30 23:16:46
B 