| I. Doorgaan van de vorige naar de volgende In de vorige lezing hebben we onszelf vertrouwd gemaakt met het basisproces van het ontwikkelen van CC2430-programma's in IAR door middel van een klein experiment met het eenvoudigste LED-knipperen. Het mes is in ieder geval geslepen (hoewel ik niet erg goed ben in deze slijpsteen), en nu is het tijd om bugs te gaan slachten :). Laten we nu een paar basis CC2430 experimenten leren. Elke kleine experimenten, verdeeld in "experimentele inleiding", "programma stroomdiagram", "experimentele broncode en analyse" drie delen van de beschrijving. Dit artikel legt de externe interrupt. Ten tweede, de externe interrupt(1) Inleiding tot het experiment Interrupt is een real-time microcontroller om te gaan met interne of externe gebeurtenissen, een intern mechanisme. Wanneer een soort van interne of externe gebeurtenis zich voordoet, zal de microcontroller te onderbreken systeem dwingt de CPU om het programma pauze wordt uitgevoerd, maar om naar de interrupt event verwerking, interrupt verwerking is voltooid, en vervolgens terug te keren naar worden onderbroken door het programma, blijven uitvoeren. Interrupts zijn onderverdeeld in externe interrupts en interne interrupts, CC2430 bevat een totaal van 18 interrupt bronnen (specifieke interrupt beschrijving en interrupt vector definitie, kunt u verwijzen naar de " CC2430 Chinese handleiding "). Laten we nu eens kijken naar het schakelschema van deze ontwikkelprintplaat:
Het ontwikkelbord is aangesloten op de S1-toets en P0.1, het effect dat dit experiment wil bereiken is het triggeren van de interrupt van P0.1 door op de toets S1 te drukken, en vervolgens het aansturen van LED1 licht/uit in de interruptservice-subroutine. (2) Experimenteel principe en stroomschema Het stroomschema van het experiment ziet er als volgt uit: 
c
(3) Experimentele broncode// headerbestand#include // delay subfunctie#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 kristal initialisatievoid xtal_init( void ) { SLEEP &=~0x04; &
nbsp; //all power upwhile (!
(SLEEP & 0x40 )); //kristaloscillator aan en stabiel CLKCON &=~0x47; &
nbsp; //Selecteer 32MHz kristaloscillator SLEEP |=0x04; }//LED initialisatievoid led_init( void ) { P1SEL =0x00;  
/ /P1 is een normale I/O poort P1DIR |=0x0F; //P1.0 P1.1 P1.2 P1.3 Uitg ang
led1 = 0; led2 = 0; led3 = 0; led4 = 0;//io en externe interrupt initialisatievoid io_init( void ) { P0INP &=~0X02;
/ /P0.1 heeft pull-up en pull-down EA =1; //Total interrupt enable 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 functievoid main( void ) { xtal_init(); led_init();
io_init();while ( 1 ); //wacht op interrupt }//interrupt service subroutine#pragma vector = P0INT_VECTOR__interrupt void P0_ISR( void ) { EA =0;
/ / schakel interrupt uit Vertraging
( 10000 ); Vertraging(10000 ); Vertraging(10000 ); Vertraging(10000 ); Vertraging(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; // zet interrupt aan }
Initialiseer eerst de Unity Clock: kies een 32MHz kristaloscillator. Initialiseer vervolgens de LED's: stel P1 in als de algemene I/O-poort, stel P1.0 ~ P1.3 in als de uitgang en schakel vervolgens de 4 LED's uit. Configureer vervolgens de relevante SFR-registers voor externe interrupts en schakel de interruptvrijgave op alle niveaus in, waarbij 3 SFR's betrokken zijn: EA, IEN1, PICTL (raadpleeg " CC2430 Chinese handleiding " voor een gedetailleerde beschrijving van elke SFR): EA -- totale interruptvrijgave; IEN1.5 -- P0 interrupt vrijgave; PICTL.3 -- P0.1 port interrupt enable; PICTL.0 -- stel P0.1 port input dalende flank in om interrupt trigger te veroorzaken. Gebruik vervolgens while(1) in de hoofdfunctie om op de interrupt te wachten. CC2430 Tips(1) Syntaxis voor bittoewijzing Samenvatting Heel vaak moeten we een waarde (0 of 1) toewijzen aan een bit in een SFR van één byte om een hardwareapparaat nauwkeurig te besturen.
S ommige SFR's ondersteunen bit-adressering, zoals TCON, P0, enz., op dit moment, de toewijzing van het bit is zeer eenvoudig, gewoon een query van de ioCC2430.h header-bestand in de SFR Bit Access deel van de bit-definitie kan worden: P0_0 = 0; // P0 het eerste bit van de toewijzing van de waarde van 0 P0_0 = 1; / / P0 het eerste bit van de toewijzing van de waarde van 1 Er zijn echter SFR's ondersteunen geen bit-adressering, zoals in het geval van het eerste bit van de toewijzing van de waarde van het eerste bit van het eerste bit van het eerste bit van het tweede bit .
Sommige SFR's ondersteunen echter geen bitadressering, zoals de PICTL in dit experiment. Als je een waarde wilt toewijzen aan een van deze SFR' s, is de syntaxis als volgt: PICTL &= ~0x01; //wijst een waarde van 0 toe aan het eerste bit PICTL |= 0x01; //wijst een waarde van 1 toe aan het eerste bit Je kunt onthouden dat & amp;= ~, |= ~, |= ~, |= P0_0 = 1; //wijst een waarde van 1 toe aan het eerste bit van P0 . amp;= ~, |= deze twee gebruikelijke syntaxis voor bittoewijzing. (2) Interrupt Enablement Summary Wanneer een interrupt betrokken is bij een programma, moet deze worden ingeschakeld voordat de interrupt wordt getriggerd.
C 51 interrupt enable systeem, de hiërarchische structuur is zeer duidelijk: interrupt baas: EA is de baas, verantwoordelijk voor de totale interrupt enable: EA = 1; interrupt detachment kapitein: volgende is voor elke functionele component (zoals P0, timer 1, enz.) in staat stellen controle, zoals SFR over het algemeen bit adresseerbare, naamgeving bevat over het algemeen IE (Interrupt Enable): P0IE = 1; de interrupt teamleden : detachment, maar als gevolg van de onderbreking van het programma , moet de interrupt worden ingeschakeld voordat de interrupt wordt geactiveerd.
e lke interrupt teamleden: team, maar omdat elke functionele component bevat ook meerdere interrupts, dus het laatste niveau is voor elke interrupt enable control, dergelijke SFR is over het algemeen niet bit adresseerbaar, genaamd bevatten over het algemeen IE (Interrupt Enable) of IM (Interrupt Mask): PICTL | = 0x01; niet nodig om de interrupt SFR's onthouden Het is niet nodig om de SFR's voor interrupts uit het hoofd te leren, zolang je de hiërarchie begrijpt en de handleiding of headerbestanden raadpleegt wanneer je ze gebruikt. (3) Interruptprogramma's schrijven Het gebruik van interrupts in een programma bestaat over het algemeen uit twee delen: het schrijven van de interruptservice-subroutine en het openen van de interruptvrijgave.
I nterrupt enable is hierboven geïntroduceerd, het volgende is een korte inleiding tot de voorbereiding van interrupt service subroutine: Allereerst, geef de interrupt vector, kan in de ioCC2430.h header-bestand in de Interrupt Vectors deel van de query, de syntaxis is als volgt: # pragma vector = Interrupt Vectors en vervolgens gevolgd door de voorbereiding van de interrupt handler, de structuur is als volgt: ___ interrupt void Functie Naam (___)
i nterrupt void function name(void) { //op interrupt //interrupt afhandeling //interrupt flag clear 0 //off interrupt }
III. Conclusie Dit artikel introduceert een eenvoudige externe interrupt implementatie methode op basis van CC2430, met de basis van de interrupt, dan introduceren we een andere zeer belangrijke module - timer. CC2430 heeft een totaal van vier timers, die kunnen worden onderverdeeld in drie categorieën: timer 1, timer 2, timer 3/4 (3 en 4 van het gebruik van dezelfde basis). hetzelfde).
</n;tt++).
</n;tt++);.
</n;tt++).
</n;tt++); </n;tt++); </n;tt++); </n;tt++).
</n;tt++).
| 
发表于 2014-10-30 23:16:46
B 