|
1. Collegamento tra i livelli superiori e inferiori Nella lezione precedente, ci siamo familiarizzati con il processo base di sviluppo del programma CC2430 tramite un semplice esperimento di lampeggiamento a LED. Il coltello è stato affilato comunque (anche se la mia pietra per affilare non è buona), e ora inizierò a macellare insetti :). Poi, impariamo alcuni esperimenti di base di CC2430. Ogni piccolo esperimento è diviso in tre parti: "Introduzione all'esperimento", "Diagramma di flusso del programma" e "Codice sorgente sperimentale e analisi". Questo articolo spiega le interruzioni esterne. 2. Interruzione esterna(1) Introduzione all'esperimentoGli interrupt sono un meccanismo interno che permette ai microcontrollori di elaborare eventi interni o esterni in tempo reale. Quando si verifica un evento interno o esterno, il sistema di interruzione del microcontrollore costringe la CPU a mettere in pausa il programma in esecuzione e a processare invece l'evento di interruzione. Gli interrupt sono suddivisi in interruzioni esterne e interne, e CC2430 contiene un totale di 18 sorgenti di interruzione (per descrizioni specifiche degli interrupt e definizioni di vettori di interruzione, si prega di fare riferimento a "Manuale cinese CC2430》）。 Ora diamo un'occhiata allo schema elettrico di questa scheda di sviluppo:
Il pulsante S1 è stato collegato a P0.1 sulla scheda di sviluppo, e l'effetto di questo esperimento è quello di attivare l'interruzione di P0.1 tramite il pulsante S1, per poi controllare l'accensione/spegnimento di LED1 nel sottoprogramma di servizio interrupt. (2) Principio sperimentale e diagramma di flussoIl diagramma di flusso sperimentale è il seguente:
(3) Codice sorgente sperimentale//头文件
#include
//延时子函数
#defineLed1 P1_0
#defineled2 P1_1
#defineled3 P1_2
#defineled4 P1_3
VoidRitardo (senza firmaturan)
{
senza firmaturatt;
per(tt =0; tt<n; tt++);
per(tt =0; tt<n; tt++);
per(tt =0; tt<n; tt++);
per(tt =0; tt<n; tt++);
per(tt =0; tt<n; tt++);
}
//32M晶振初始化
Voidxtal_init(Void)
{
SONNO &= ~0x04; //都上电
mentre(! (SONNO &0x40)); //晶体振荡器开启且稳定
CLKCON &= ~0x47; //Scegli un oscillatore a cristallo a 32MHz
SONNO |=0x04;
}
//LED灯初始化
Voidled_init(Void)
{
P1SEL =0x00; P1 è la normale porta I/O
P1DIR |=0x0F; Uscita P1.0 P1.1 P1.2 P1.3
condotta 1 = 0;
condotta 2 = 0;
condotta 3 = 0;
condotta 4 = 0;
}
//io及外部中断初始化
Voidio_init(Void)
{
P0INP &= ~0X02; //P0.1有上拉、下拉
EA =1; //总中断使能
P0IE =1; //P0中断使能
PICTL |= 0X09; //P0.1口中断使能，下降沿触发
P0IFG &= ~0x02; //P0.1中断标志清0
};
//主函数
Voidmain(Void)
{
xtal_init();
led_init();
io_init();
mentre(1); //等待中断
}
//中断服务子程序
#pragma vettore = P0INT_VECTOR
__interrupt VoidP0_ISR(Void)
{
EA =0; Il cancello viene interrotto
Ritardo (10000);
Ritardo (10000);
Ritardo (10000);
Ritardo (10000);
Ritardo (10000);
se((P0IFG &0x02) >0) //按键中断
{
P0IFG &= ~0x02; //P0.1中断标志清0
led1 = !led1;
}
P0IF =0; //P0中断标志清0
EA =1; //开中断
}
Per prima cosa, inizializza il clock di sistema: seleziona un oscillatore a cristallo a 32MHz. Poi inizializza i LED: imposta P1 come porta I/O generale, imposta la direzione P1.0 ~ P1.3 come uscita e poi spegni le 4 luci LED. Successivamente, configura i registri SFR rilevanti per interruzioni esterne per abilitare interruzioni a tutti i livelli, coinvolgendo 3 SFR:EA、IEN1、PICTL(Per i dettagli di ogni SFR, si prega di consultare ilManuale cinese CC2430》）： EA- Attivazione totale dell'interruzione; IEN1.5- Attivazione dell'interrupt P0; PICTL.3—— Opzione di interruzione della porta P0.1 abilitata; PICTL.0—— Imposta il bordo di caduta della porta P0.1 per causare l'attivazione dell'interrupt. Poi usa while(1) nella funzione principale e attendi l'interrupt. Consigli CC2430(1) Riassunto della sintassi di assegnazione dei bit Molte volte, dobbiamo assegnare un bit (0 o 1) a un singolo byte di SFR per controllare con precisione il dispositivo hardware. C'è SFRIndirizzamento dei bit di supportoAd esempio, TCON, P0, ecc., al momento l'assegnazione dei contropunti è molto semplice, basta interrogare la definizione dei bit nella sezione SFR Bit Access del file di intestazione ioCC2430.h: P0_0 = 0; // assegnare 0 alla prima cifra di P0 P0_0 = 1; // assegnare un valore di 1 alla prima cifra di P0
Ma alcuni SFR non ci sonoL'indirizzamento bit non è supportato, come in questo esperimentoPICTL, in questo momento, vuoi assegnare un valore a uno di essi, la sintassi è la seguente: PICTL &= ~0x01; Assegnare un valore di 0 alla prima cifra PICTL |= 0x01; Assegnare un valore di 1 alla prima cifra
Te lo ricordi&= ~，|=Questi due sono comunemente usati nella sintassi di assegnazione dei bit. (2) Sommario dell'abilitazione dell'interruzione Quando un interrupt è coinvolto nel programma, deve essere abilitato prima che venga attivato l'interrupt. La gerarchia del sistema di abilitazione degli interrupt C51 è molto evidente: Boss Interrupt: EAè il capo, responsabileGeneraleAbilitazione dell'interruzione: EA = 1;
Ogni capo squadra interrotto: Il prossimo è per ciascunoParti funzionali(come P0, timer 1, ecc.), tali SFR sono generalmente indirizzabili per bit, e il nome contiene generalmente IE (Interrupt Enable): P0IE = 1;
Ogni membro della squadra veniva interrotto: Squadra Ma poiché ogni caratteristica contiene anche più interruzioni al suo interno, l'ultimo livello è per questoOgni interruzioneQuesto tipo di SFR è generalmente senza bit e non indirizzabile, e di solito contiene IE (Interrupt Enable) o IM (Interrupt Mask) nel nome: PICTL |=0x01;
Non c'è bisogno di interrompere SFR per rotazione, basta comprendere la sua gerarchia e poi prendersi il tempo di consultare il manuale o il file di intestazione (header file). (3) Interrompere la scrittura dei programmi L'uso degli interrupt in un programma generalmente include due parti: la scrittura del sottoprogramma del servizio di interruzione e l'apertura dell'attivazione dell'interrupt. La funzione di interruzione è stata introdotta sopra, e di seguito è riportata una breve introduzione alla scrittura del sottoprogramma di servizio interrupt: Specifica primaVettore di interruzione, che può essere interrogata nella sezione Interrupt Vectors del file di intestazione ioCC2430.h, con la seguente sintassi: #pragma vettore = vettore di interruzione
Successivamente scrivi immediatamente il gestore di interrupt, strutturato come segue: __interrupt nome della funzione void (void) { //开中断 //中断处理 //中断标志清0 //关中断 }
3. ConclusioneQuesto articolo introduce il metodo di implementazione delle semplici interruzioni esterne basate su CC2430 e, dopo la base degli interrupt, introdurremo un altro modulo molto importante: i timer. CC2430 ha un totale di 4 timer, che possono essere suddivisi in tre categorie: timer 1, timer 2, timer 3/4 (3 e 4 sono praticamente lo stesso utilizzo).
</n; tt++);
</n; tt++);
</n; tt++);
</n; tt++);
</n; tt++);
| 
Pubblicato su 30/10/2014 23:16:46
|
|
|
|
