Pēc "Zigbee Journey (9)" rakstīšanas 3. martā autors sākotnēji plānoja nekavējoties sākt rakstīt nelielu eksperimentu par "temperatūras uzraudzības sistēmu" kā kopsavilkumu par virkni izkliedētu zināšanu punktu iepriekš. Tomēr es arī sapratu, ka, lai gan katrs no iepriekšējiem mazajiem eksperimentiem tika detalizēti aprakstīts, tā koda normatīvais un strukturālais raksturs varētu teikt par nepanesamu. Tā kā tas ir kopsavilkums, mums vajadzētu progresēt uz sākotnējā pamata, nevis mehāniski salikt kopā iepriekšējos mazos zināšanu punktus. Tāpēc es apturēju savu sākotnējo plānu, veltīju laiku, lai apgūtu vispārējās iegultās attīstības metodes, un uzrakstīju divas esejasIegulta C51 programmēšanas specifikācija" un "Iegultā projekta koda struktūras hierarhija》。 Šis žurnāls ir ne tikai Zigbee pirmā ceļojuma kopsavilkums, bet arī ietver autora mācību pieredzi pēdējās dienās, cerot, ka tas būs noderīgs Zigbee iesācējiem.
Pilns teksts ir sakārtots atbilstoši programmatūras izstrādes pamatprocesam: prasību analīze, kontūras dizains, detalizēts dizains, kodēšanas ieviešana un testēšana.
1. Pieprasījuma analīzePēc diskusijas starp "klientu" un "izstrādātāju" tika noteikts šāds sistēmas funkcijas apraksts:
… Pašreizējo istabas temperatūru apkopo CC2430 bāzes mezgli, un tās temperatūras vērtības var kontrolēt, izmantojot datoru
… Pašam CC2430 mezglam jābūt noteiktai stabilitātes pakāpei, un tas var automātiski atgriezties normālā stāvoklī
… Paraugu ņemšanas intervālu un mezgla jaudas pārvaldību var kontrolēt ar datoru
2. Kontūras dizainsSaskaņā ar iepriekš minēto prasību analīzi mēs varam sadalīt sistēmu divos moduļos:CC2430 mezglsunDators。
[CC2430 mezgls]
… Ārējos parametrus var regulāri savākt un nosūtīt uz datoru
… Automātiska atiestatīšana, kad ierīce ir izslēgta
… Komandas no datora var saņemt un apstrādāt attiecīgi: mainiet parauga intervālu/enerģijas pārvaldību
[Dators]
… C mašīna saņem un parāda datus, izmantojot seriālā porta rīku
… Instrukcijas var nosūtīt mikrokontrollerim, izmantojot seriālā porta rīku, lai kontrolētu tā paraugu ņemšanas ātrumu un jaudas pārvaldību
3. Detalizēts projekts(1) Koda struktūra
Šīs sistēmas koda struktūras slāņošana faktiski ir aprakstīta esejā "Iegultā projekta koda struktūras hierarhija", un kopija ir šāda:
(1) Aparatūras abstrakcijas slānis
[ioCC2430.h] (iekļauta sistēma)：Ir definēti visi CC2430 SFR un pārtraukuma vektori
[hal.h] Ietver kopīgas tipu definīcijas, kopīgus piešķiršanas makro un kopēju CC2430 mikroshēmas resursu konfigurāciju (I/O, seriālā saziņa, ADC, taimeris, enerģijas pārvaldība utt.)
(2) Funkcionālais moduļa slānis
[modulis.h] definē mikroshēmas resursus (taimeri, I/O), ārpus mikroshēmas paplašināšanas moduļus (LED) un saistīto funkciju deklarācijas
[modulis.cIeviesiet katra moduļa (LED) inicializāciju.
(3) Lietojumprogrammas slānis
[main.cSkatiet hal.h, ioCC2430.h un module.h, lai izpildītu īpašas lietojumprogrammas prasības, piemēram, temperatūras uztveršanu, saziņu ar datoru, kā arī izslēgšanu un atiestatīšanu
(2) Katra moduļa ieviešanas metodes
Saskaņā ar moduļiem, kas sadalīti saskaņā ar kontūras dizainu, iekšējo sistēmu var iedalīt divos galvenajos moduļos:CC2430 mezglsunDators。
Tā kā datorā ir seriālā porta sakaru rīki, tā funkcijas var atbilst prasībām, tāpēc mums nav jādara šī datora daļa, un nav nepieciešams to analizēt. Parunāsim par CC2430 sadaļu zemāk
Katras punkta apakšfunkcijas īstenošanas metode:
… Izmantojiet taimera skaita pārplūdes pārtraukumu, lai aktivizētu laika paraugu ņemšanu
… UART0 režīms ar seriālo pieslēgvietu pārraida temperatūras datus uz datoru
… CC2430 iebūvētā sargsuņa ķēde tiek izmantota, lai realizētu sistēmas automātiskās atiestatīšanas funkciju
… Seriālais ports tiek izmantots, lai saņemtu pārtraukumus, lai uztvertu un reaģētu uz vadības komandām no datora
1) Ja saņemts@Rakstzīme ir paraugu ņemšanas intervāla vadības komanda, kurai seko skaitlis, kas norāda paraugu ņemšanas intervālu: 0-0,5 s, 1-1, 2-2s
如：@0，表示每隔0.5秒采样一次。
2) Ja saņemts$ Rakstzīme ir miega režīma vadības komanda, kurai seko skaitlis, kas norāda barošanas režīmu
Piemēram: $3, kas nozīmē, ka sistēma jāieslēdz 3. barošanas režīmā.
(3) Programmas plūsmas diagramma
- Programmas plūsmas diagrammas apgūšana
- Taimeris 1 pārplūdes pārtraukuma programmas plūsmas diagramma
- Seriālā porta saņemšanas pārtraukuma procedūras plūsmas diagramma
4. Kodēšanas ieviešana(1) Aparatūras abstrakcijas slānis
Aparatūras abstrakcijas slānis ietver ioCC2430.h un hal.h. Tā kā iepriekšējā sistēma nāk kopā ar to, tā netiks uzskaitīta.
Šis ir saraksts ar visu hal.h saturu (jo šis fails ir pārāk garš un izskatās neērti, es to parādīšu moduļos):
- galva
- I/O pieslēgvietas
- Pārtraukts
- Seriālais ports
- Jaudas un pulksteņa pārvaldība
- Taimeris
- Sargsuns
- ADC
[url =]
[/url]
/***********************************************************
*Faila nosaukums: hal.h
*Autors: hustlzp
*Datums: 2011. gada 8. marts
*Izdevums: 1.1
* Funkcijas apraksts: Aparatūras abstrakcijas slānis
*Modificētie ieraksti:
***********************************************************/
#ifndef HAL_H
#defineHAL_H
#include
/***********************************************************
Izplatītākās tipu definīcijas
***********************************************************/
typedef bez parakstaogles BAITS;
typedef bez parakstaint VĀRDS;
typedef bez parakstagarš DWORD;
/***********************************************************
Bieži izmantotās makro definīcijas
***********************************************************/
//8 vietas augstākas
#defineHIGH_BYTE(a) ((BAITS) (((VĀRDS)(a)) >> 8))
//8 vietas zemāk
#defineLOW_BYTE(a) ((BAITS) ((VĀRDS)(a)))
//Nodošana
#defineSET_WORD(regH,regL,vārds)
darīt{
(regH) = HIGH_BYTE (vārds);
(regL) = LOW_BYTE (vārds);
}kamēr(0)
[url =] [/url]
[url =] [/url]
/***********************************************************
I/O pieslēgvietas
***********************************************************/
/*Konfigurējiet I/O porta virzienu
-----------------------------------------*/
#defineIO_DIR_PORT_PIN(port, pin, dir)
darīt{
ja(dir == IO_OUT)
P##port##DIR |= (0x01<<(pin));
citādi
P##port##DIR &= ~(0x01<<(pin));
}kamēr(0)
//Parametra dir vērtība ir:
#defineIO_IN 0
#defineIO_OUT 1
/*Konfigurējiet I/O porta ievades režīmu
-----------------------------------------*/
#defineIO_IMODE_PORT_PIN(ports, pin, imode)
darīt{
ja(imode == IO_IMODE_TRI)
P##port##INP |= (0x01<<(pin));
citādi
P##port##INP &= ~(0x01<<(pin));
}kamēr (0)
#define IO_PUD_PORT(port, pud)
darīt {
if (pud == IO_PULLDOWN)
P2INP |= (0x01 << (port+5));
citādi
P2INP &= ~(0x01 << (port+5));
}, kamēr (0)
Parametra PUD vērtība ir:
#define IO_PULLUP 0 // Pull up
#define IO_PULLDOWN 1 // Pavelciet uz leju
/*配置I/O口的功能
-----------------------------------------*/
#define IO_FUNC_PORT_PIN(port, pin, func)
darīt {
if((ports == 2) && (pin == 3)){
if (func) {
P2SEL |= 0x02;
} citādi {
P2SEL &= ~0x02;
}
}
else if((port == 2) && (pin == 4)){
if (func) {
P2SEL |= 0x04;
} citādi {
P2SEL &= ~0x04;
}
}
citādi{
if (func) {
P##port##SEL |= (0x01<<(pin));
} citādi {
P##port##SEL &= ~(0x01<<(pin));
}
}
}, kamēr (0)
Parametra func vērtība ir:
#define IO_FUNC_GIO 0 // Vispārīgais I/O
#define IO_FUNC_PERIPH 1 // Perifērijas I/O
Konfigurējiet perifērijas I/O atrašanās vietu
#define IO_PER_LOC_TIMER1_AT_PORT0_PIN234() do { PERCFG = (PERCFG&~0x40)|0x00; }, kamēr (0)
#define IO_PER_LOC_TIMER1_AT_PORT1_PIN012() do { PERCFG = (PERCFG&~0x40)|0x40; }, kamēr (0)
#define IO_PER_LOC_TIMER3_AT_PORT1_PIN34() do { PERCFG = (PERCFG&~0x20)|0x00; }, kamēr (0)
#define IO_PER_LOC_TIMER3_AT_PORT1_PIN67() do { PERCFG = (PERCFG&~0x20)|0x20; }, kamēr (0)
#define IO_PER_LOC_TIMER4_AT_PORT1_PIN01() do { PERCFG = (PERCFG&~0x10)|0x00; }, kamēr (0)
#define IO_PER_LOC_TIMER4_AT_PORT2_PIN03() do { PERCFG = (PERCFG&~0x10)|0x10; }, kamēr (0)
#define IO_PER_LOC_SPI1_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x08)|0x00; }, kamēr (0)
#define IO_PER_LOC_SPI1_AT_PORT1_PIN4567() do { PERCFG = (PERCFG&~0x08)|0x08; }, kamēr (0)
#define IO_PER_LOC_SPI0_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x04)|0x00; }, kamēr (0)
#define IO_PER_LOC_SPI0_AT_PORT1_PIN2345() do { PERCFG = (PERCFG&~0x04)|0x04; }, kamēr (0)
#define IO_PER_LOC_UART1_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x02)|0x00; }, kamēr (0)
#define IO_PER_LOC_UART1_AT_PORT1_PIN4567() do { PERCFG = (PERCFG&~0x02)|0x02; }, kamēr (0)
#define IO_PER_LOC_UART0_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x01)|0x00; }, kamēr (0)
#define IO_PER_LOC_UART0_AT_PORT1_PIN2345() do { PERCFG = (PERCFG&~0x01)|0x01; }, kamēr (0)
//Parametra imode vērtība ir:
#defineIO_IMODE_PUD 0 //Pavelciet uz augšu/velciet uz leju
#defineIO_IMODE_TRI 1 //Trīs valstis[url =] [/url]
[url =] [/url]
/***********************************************************
Pārtraukts
***********************************************************/
//Ieslēgšanas/izslēgšanas pārtraukumiem
#defineINT_ON 1
#defineINT_OFF 0
//Izmanto, lai ievietotu/notīrītu pārtraukuma karodziņus
#defineINT_SET 1
#defineINT_CLR 0
//Globālie pārtraukuma iestatījumi
#defineINT_GLOBAL_ENABLE(ieslēgts) EA=(!! ieslēgts)
//Pārtraukuma definēšana
#defineINUM_RFERR 0
#defineINUM_ADC 1
#defineINUM_URX0 2
#defineINUM_URX1 3
#defineINUM_ENC 4
#defineINUM_ST 5
#defineINUM_P2INT 6
#defineINUM_UTX0 7
#defineINUM_DMA 8
#defineINUM_T1 9
#defineINUM_T2 10
#defineINUM_T3 11
#defineINUM_T4 12
#defineINUM_P0INT 13
#defineINUM_UTX1 14
#defineINUM_P1INT 15
#defineINUM_RF 16
#defineINUM_WDT 17
/*Atļautie pārtraukumi
-----------------------------------------*/
#defineINT_ENABLE(inum, ieslēgts)
darīt{
ja (inum==INUM_RFERR) { RFERRIE = ieslēgts; }
citādi ja(inum==INUM_ADC) { ADCIE = ieslēgts; }
citādi ja(inum==INUM_URX0) { URX0IE = ieslēgts; }
citādi ja(inum==INUM_URX1) { URX1IE = ieslēgts; }
citādi ja(inum==INUM_ENC) { ENCIE = ieslēgts; }
citādi ja(inum==INUM_ST) { STIE = ieslēgts; }
citādi ja(inum==INUM_P2INT) { (ieslēgts) ? (IEN2 |=0x02) : (IEN2 &= ~0x02); }
citādi ja(inum==INUM_UTX0) { (ieslēgts) ? (IEN2 |=0x04) : (IEN2 &= ~0x04); }
citādi ja(inum==INUM_DMA) { DMAIE = ieslēgts; }
citādi ja(inum==INUM_T1) { T1IE = ieslēgts; }
citādi ja(inum==INUM_T2) { T2IE = ieslēgts; }
citādi ja(inum==INUM_T3) { T3IE = ieslēgts; }
citādi ja(inum==INUM_T4) { T4IE = ieslēgts; }
citādi ja(inum==INUM_P0INT) { P0IE = ieslēgts; }
citādi ja(inum==INUM_UTX1) { (ieslēgts) ? (IEN2 |=0x08) : (IEN2 &= ~0x08); }
citādi ja(inum==INUM_P1INT) { (ieslēgts) ? (IEN2 |=0x10) : (IEN2 &= ~0x10); }
citādi ja(inum==INUM_RF) { (ieslēgts) ? (IEN2 |=0x01) : (IEN2 &= ~0x01); }
citādi ja(inum==INUM_WDT) { (ieslēgts) ? (IEN2 |=0x20) : (IEN2 &= ~0x20); }
}kamēr (0)
/*Pārtraukuma prioritātes iestatīšana
-----------------------------------------*/
#defineINT_PRIORITY(grupa, PRI)
darīt{
ja(pri ==0) { IP0 &= ~grupa; IP1 &= ~grupa; }
ja(pri ==1) { IP0 |= grupa; IP1 &= ~grupa; }
ja(pri ==2) { IP0 &= ~grupa; IP1 |= grupa; }
ja(pri ==3) { IP0 |= grupa; IP1 |= grupa; }
}kamēr (0)
//Parametra pri vērtība ir: 0/1/2/3 (augstākā prioritāte)
//Parametru grupas vērtība ir:
#defineRFERR_RF_DMA 0x01//IP0 grupa
#defineADC_P2INT_T1 0x02//IP1 grupa
#defineURX0_UTX0_T2 0x04//IP2 grupa
#defineURX1_UTX1_T3 0x08//IP3 grupa
#defineENC_P1INT_T4 0x10//IP4 grupa
#defineST_WDT_P0INT 0x20//IP5 grupa
/*Pārtraukuma karodziņa iegūšana
-----------------------------------------*/
#defineINT_GETFLAG(inum) (
(inum==INUM_RFERR) ? RFERRIF :
(inum==INUM_ADC) ? ADCIF :
(inum==INUM_URX0) ? URX0JA :
(inum==INUM_URX1) ? URX1IF :
(inum==INUM_ENC) ? ENCIF_0 :
(inum==INUM_ST) ? STIF :
(inum==INUM_P2INT) ? P2JA:
(inum==INUM_UTX0) ? UTX0JA :
(inum==INUM_DMA) ? DMAIF :
(inum==INUM_T1) ? T1JA:
(inum==INUM_T2) ? T2IF:
(inum==INUM_T3) ? T3IF:
(inum==INUM_T4) ? T4JA:
(inum==INUM_P0INT) ? P0JA:
(inum==INUM_UTX1) ? UTX1JA :
(inum==INUM_P1INT) ? P1JA:
(inum==INUM_RF) ? S1CON &= ~0x03 :
(inum==INUM_WDT) ? WDTIF :
0
)
/*Pārtraukuma karodziņa iestatīšana
-----------------------------------------*/
#defineINT_SETFLAG(inum, f)
darīt{
ja (inum==INUM_RFERR) { RFERRIF= f; }
citādi ja(inum==INUM_ADC) { ADCIF = f; }
citādi ja(inum==INUM_URX0) { URX0IF = f; }
citādi ja(inum==INUM_URX1) { URX1IF = f; }
citādi ja(inum==INUM_ENC) { ENCIF_1 = ENCIF_0 = f; }
citādi ja(inum==INUM_ST) { STIF = f; }
citādi ja(inum==INUM_P2INT) { P2IF = f; }
citādi ja(inum==INUM_UTX0) { UTX0IF= f; }
citādi ja(inum==INUM_DMA) { DMAIF = f; }
citādi ja(inum==INUM_T1) { T1IF = f; }
citādi ja(inum==INUM_T2) { T2IF = f; }
citādi ja(inum==INUM_T3) { T3IF = f; }
citādi ja(inum==INUM_T4) { T4IF = f; }
citādi ja(inum==INUM_P0INT) { P0IF = f; }
citādi ja(inum==INUM_UTX1) { UTX1IF= f; }
citādi ja(inum==INUM_P1INT) { P1IF = f; }
citādi ja(inum==INUM_RF) { (f) ? (S1CON |=0x03) : (S1CON &= ~0x03); }
citādi ja(inum==INUM_WDT) { WDTIF = f; }
}kamēr (0)
[url =] [/url]
[url =] [/url]
/***********************************************************
Seriālais ports
***********************************************************/
//BAUD_E vērtība, kas atbilst dažādiem pārraides ātrumiem
#defineBAUD_E(baud, clkDivPow) (
(bauds==2400) ? 6 +clkDivPow :
(bauds==4800) ? 7 +clkDivPow :
(bauds==9600) ? 8 +clkDivPow :
(bauds==14400) ? 8 +clkDivPow :
(bauds==19200) ? 9 +clkDivPow :
(bauds==28800) ? 9 +clkDivPow :
(bauds==38400) ? 10+clkDivPow :
(bauds==57600) ? 10+clkDivPow :
(bauds==76800) ? 11+clkDivPow :
(bauds==115200) ? 11+clkDivPow :
(bauds==153600) ? 12+clkDivPow :
(bauds==230400) ? 12+clkDivPow :
(bauds==307200) ? 13+clkDivPow :
0 )
//BAUD_M vērtība, kas atbilst dažādiem pārraides ātrumiem
#defineBAUD_M(baud) (
(bauds==2400) ? 59 :
(bauds==4800) ? 59 :
(bauds==9600) ? 59 :
(bauds==14400) ? 216 :
(bauds==19200) ? 59 :
(bauds==28800) ? 216 :
(bauds==38400) ? 59 :
(bauds==57600) ? 216 :
(bauds==76800) ? 59 :
(bauds==115200) ? 216 :
(bauds==153600) ? 59 :
(bauds==230400) ? 216 :
(bauds==307200) ? 59 :
0)
/*Seriālā porta konfigurācija UART režīmā
-----------------------------------------*/
#defineUART_SETUP(uart, receiveEnable, baudRate, options)
darīt{
ja((uart) ==0){
ja(PERCFG &0x01){
P1SEL |=0x30;
}citādi{
P0SEL |=0x0C;
}
}
citādi{
ja(PERCFG &0x02){
P1SEL |=0xC0;
}citādi{
P0SEL |=0x30;
}
}
U##uart##GCR = BAUD_E((baudRate),CLKSPD);
U##uart##BAUD = BAUD_M(baudu ātrums);
U##uart##CSR |=0x80;
U##uart##CSR |= receiveEnable;
U##uart##UCR |= ((opcijas) |0x80);
}kamēr(0)
//Parametra vērtība receiveEnable:
#defineUART_RECEIVE_ENABLE 0x40 //Atļaujas saņemšana
#defineUART_RECEIVE_DISABLE 0x00
//Parametru opciju vērtība:
#defineFLOW_CONTROL_ENABLE 0x40 //Plūsmas kontrole
#defineFLOW_CONTROL_DISABLE 0x00
#defineEVEN_PARITY 0x20 //Neregulāra pārbaude
#defineODD_PARITY 0x00 //Dīvaina pārbaude
#defineNINE_BIT_TRANSFER 0x10 //9 baitu pārsūtīšana
#defineEIGHT_BIT_TRANSFER 0x00 //8 baitu pārsūtīšana
#definePARITY_ENABLE 0x08 //Paritātes pārbaudes iespējošana
#definePARITY_DISABLE 0x00
#defineTWO_STOP_BITS 0x04 //2 pozīciju apstāšanās pozīcija
#defineONE_STOP_BITS 0x00 //1 pieturas pozīcija
#defineHIGH_STOP 0x02 //Apstāšanās līmenis ir augsts
#defineLOW_STOP 0x00 //Apturēšanas pozīcija ir zema
#defineHIGH_START 0x01 //Sākuma bitu līmenis ir augsts
#defineLOW_START 0x00 //Sākuma bitu līmenis ir zems
//Seriālais ports sūta rakstzīmes
#defineUART_SEND(uart,dati)
darīt{
kamēr(U##uart##CSR &0x01);
U##uart##DBUF = dati;
}kamēr (0)
#defineUART0_SEND(dati) UART_SEND(0,dati)
#defineUART1_SEND(dati) UART_SEND(1,dati)
//Seriālais ports saņem rakstzīmes
#defineUART_RECEIVE(uart,dati)
darīt{
kamēr(! (U##uart##CSR&0x04));
data=U##uart##DBUF;
}kamēr(0)
#defineUART0_RECEIVE(dati) UART_RECEIVE(0,dati)
#defineUART1_RECEIVE(dati) UART_RECEIVE(1,dati)
[url =] [/url]
[url =] [/url]
/***********************************************************
Jaudas un pulksteņa pārvaldība
***********************************************************/
//Iegūstiet pulksteņa krosoveru
#defineCLKSPD (CLKCON & 0x07)
//Barošanas režīma iestatīšana
#defineSET_POWER_MODE(režīms)
darīt{
ja(režīms ==0) { MIEGS &= ~0x03; }
citādi ja(režīms ==3) { MIEGS |=0x03; }
citādi{ MIEGS &= ~0x03; MIEGA režīms |= režīms; }
PCON |=0x01;
asm("NĒ");
}kamēr (0)
//Parametru režīms ir iestatīts uz šādām vērtībām:
#definePOWER_MODE_0 0x00
#definePOWER_MODE_1 0x01
#definePOWER_MODE_2 0x02
#definePOWER_MODE_3 0x03
//Izmanto, lai noteiktu augstfrekvences RC oscilatoru stabilitāti
#defineHIGH_FREQUENCY_RC_OSC_STABLE (MIEGA & 0x20)
//Izmanto, lai noteiktu kristāla oscilatora stabilu stāvokli
#defineXOSC_STABLE (MIEGS & 0x40)
//Iegūstiet taimera ķeksīša frekvences vērtību
#defineTICKSPD ((CLKCON & 0x38) >> 3)
//Iestatiet galveno pulksteņa frekvenci
#defineSET_MAIN_CLOCK_SOURCE(avots)
darīt{
ja(avots) {
CLKCON |=0x40;
kamēr(! HIGH_FREQUENCY_RC_OSC_STABLE);
ja(TICKSPD ==0){
CLKCON |=0x08;
}
MIEGS |=0x04;
}
citādi{
MIEGS &= ~0x04;
kamēr(! XOSC_STABLE);
asm("NĒ");
CLKCON &= ~0x47;
MIEGS |=0x04;
}
}kamēr (0)
//Parametra avota vērtība ir:
#defineKRISTĀLA 0x00 //Kristāla oscilators
#defineRC 0x01 //RC oscilators
[url =] [/url]
[url =] [/url]
/***********************************************************
Taimeris 1
***********************************************************/
//Taimeris 1 ļauj pārtraukt skaitīšanas pārplūdi
#defineTIMER1_ENABLE_OVERFLOW_INT(val)
(TIMIF = (val) ? TIMIF |0x40: TIMIF & ~0x40)
//Pārplūdes pārtraukuma karodziņa iestatīšana taimeri 1
#defineTIMER1_OVERFLOW_INT_SETFLAG(f) (T1CTL= ((T1CTL & (~0x10)) | f))
//Sākas 1. taimeris
#defineTIMER1_RUN(vērtība) (T1CTL = (vērtība) ? T1CTL|0x02 : T1CTL&~0x03)
//Taimera pulksteņa dalījuma iestatīšana
#defineSET_TIMER_TICK(vērtība) do{ CLKCON = ((CLKCON & (~0x38)) | vērtība); } kamēr (0)
//Vērtības vērtība ir:
#defineTIMER1_TICK_32M 0x00 //32MHz
#defineTIMER1_TICK_16M 0x08 //16 MHz, sistēmas atiestatīšanas noklusējuma vērtība
#defineTIMER1_TICK_8M 0x10 //8 MHz
#defineTIMER1_TICK_4M 0x18 //4MHz
#defineTIMER1_TICK_2M 0x20 //2MHz
#defineTIMER1_TICK_1M 0x28 //1MHz
#defineTIMER1_TICK_500k 0x30 //500 kHz
#defineTIMER1_TICK_250k 0x38 //250 kHz
//Iestatiet TICK krustojumu taimeri 1
#defineSET_TIMER1_TICKDIV(vērtība)
darīt{
T1CTL &= ~0x0c;
T1CTL |= vērtība;
}kamēr (0)
//kur vērtība ir:
#defineTIMER1_TICKDIV_1 0x00 //1 nodaļa
#defineTIMER1_TICKDIV_8 0x04 //8 ceļu frekvence
#defineTIMER1_TICKDIV_32 0x08
#defineTIMER1_TICKDIV_128 0x0c
//Taimera pārpildes perioda iestatīšana
#defineSET_TIMER1_PERIOD(vērtība)
darīt{
T1CC0H = HIGH_BYTE(vērtība);
T1CC0L = LOW_BYTE(vērtība);
}kamēr (0)
//Iestatiet 1. taimera darbības režīmu
#defineSET_TIMER1_MODE(režīms)
darīt{
T1CTL = ((T1CTL & (~0x03)) | režīms);
}kamēr (0)
//Režīma vērtība ir:
#defineTIMER1_MODE_STOP 0x00
#defineTIMER1_MODE_FREE 0x01
#defineTIMER1_MODE_MODULE 0x02
#defineTIMER1_MODE_UPDOWN 0x03
[url =] [/url]
[url =] [/url]
/***********************************************************
Sargsuns
***********************************************************/
//Sargsuņa taimeri pārpildes perioda iestatīšana
#defineWDT_SET_TIMEOUT_PERIOD(taimauts)
darīt{ WDCTL &= ~0x03; WDCTL |= taimauts; }kamēr (0)
//Parametra taimauta vērtība ir:
#defineSEC_1 0x00 //pēc 1 sekundes
#defineM_SEC_250 0x01 //pēc 250 ms
#defineM_SEC_15 0x02 //pēc 15 ms
#defineM_SEC_2 0x03 //pēc 2 ms
//Suņu barošanas procedūras
#defineWDT_RESET() do {
WDCTL = (WDCTL & ~0xF0) |0xA0;
WDCTL = (WDCTL & ~0xF0) |0x50;
} kamēr (0)
//Iedarbināt/apturēt sargsuņa taimeri
#defineWDT_ENABLE() WDCTL |= 0x08
#defineWDT_DISABLE() WDCTL &= ~0x08
[url =] [/url]
[url =] [/url]
/***********************************************************
ADC
***********************************************************/
//Viena ADC konfigurēšana
#defineADC_SINGLE_CONVERSION(iestatījumi)
darīt{ ADCCON3 = iestatījumi; }kamēr(0)
//Parametru iestatījums sastāv no šādām kombinācijām:
//Atskaites spriegums
#defineADC_REF_1_25_V 0x00 //Iekšējais 1.25 V atsauces spriegums
#defineADC_REF_P0_7 0x40 //Ārējais atsauces spriegums uz AIN7 tapas
#defineADC_REF_AVDD 0x80 //AVDD_SOC piespraudes
#defineADC_REF_P0_6_P0_7 0xC0 //AIN6-AIN7 Ārējais atsauces spriegums diferenciālajām ieejām
//Paraugu ņemšanas ātrums
#defineADC_8_BIT 0x00 //8. vieta
#defineADC_10_BIT 0x10 //10. vieta
#defineADC_12_BIT 0x20 //12. vieta
#defineADC_14_BIT 0x30 //14. vieta
//Ievadiet kanālu
#defineADC_AIN0 0x00 //P0_0
#defineADC_AIN1 0x01 //P0_1
#defineADC_AIN2 0x02 //P0_2
#defineADC_AIN3 0x03 //P0_3
#defineADC_AIN4 0x04 //P0_4
#defineADC_AIN5 0x05 //P0_5
#defineADC_AIN6 0x06 //P0_6
#defineADC_AIN7 0x07 //P0_7
#defineADC_GND 0x0C //Zeme
#defineADC_TEMP_SENS 0x0E //Mikroshēmas temperatūras sensors
#defineADC_VDD_3 0x0F //VDD/3
ADC konvertēšana ir pabeigta
#define ADC_SAMPLE_READY() (ADCCON1 & 0x80)
#endif
//启动ADC转化
#define ADC_START()
do { ADCCON1 |= 0x40; }, kamēr (0)//Izvēlieties ADC trigera režīmu kā manuālu (t.i., ADC_SAMPLE_READY)
#defineADC_STOP()
darīt{ ADCCON1 |=0x30; }kamēr (0)[url =] [/url]
(2) Funkcionālais moduļa slānis
[url =] [/url]
/***********************************************************
*Faila nosaukums: module.h
*Autors: hustlzp
*Datums: 2011. gada 6. marts
*Versija: 1.0
*Funkcijas apraksts: Funkcionālā moduļa slāņa galvenes fails
*Funkciju saraksts: void led_init()
anulēt timer1_init()
spēkā neesošs uart0_init (spēkā neesošs);
void Uart0SendString(neparakstīts char *s);
pludiņš adc_start(tukšs)
void get_temperature(neparakstīts char *output,float temp);
spēkā neesošs watchdog_init (spēkā neesošs);
*Modificētie ieraksti:
***********************************************************/
#ifndef MODULE_H
#defineMODULE_H
#include"hal.h"
/***********************************************************
Gaismas diode
***********************************************************/
//Definējiet LED tapas
#defineLED1 P1_0
#defineLED2 P1_1
#defineLED3 P1_2
#defineLED4 P1_3
//LED gaisma un izslēgta
#defineLED_OFF 1
#defineLED_ON 0
//LED inicializācija
Tukšumsled_init (Tukšums);
/***********************************************************
taimeris1
***********************************************************/
//Izmanto, lai iestatītu taimeri pārplūdes perioda vērtību
#defineTIMER1_OVF_2SEC 0xF424 //2s
#defineTIMER1_OVF_1SEC 0x7A12 //1s
#defineTIMER1_OVF_dot5SEC 0x3D09 //0,5 sekundes
//Taimeris 1 tiek inicializēts
Tukšums timer1_init (Tukšums);
/***********************************************************
UART0
***********************************************************/
//UART0 inicializācija
Tukšums uart0_init (Tukšums);
//Seriālā porta pārraides virkne
Tukšums Uart0SendString(bez parakstaogles*s);
/***********************************************************
ADC-14
***********************************************************/
//Izmanto, lai ADC iegūtos datus pārvērstu Celsija temperatūrā
#defineADC_TO_CELSIUS (temp) (temp * 0.06229 - 311.43)
//ADC konvertēšanas uzsākšana
pludiņšadc_start (Tukšums);
//Pārveidošana
Tukšums get_temperature(bez parakstaogles*izeja,pludiņštemp);
/***********************************************************
Sargsuns
***********************************************************/
//Skatīties suņa inicializāciju
Tukšums watchdog_init (Tukšums);
#endif
[url =] [/url]
[url =] [/url]
/***********************************************************
*Faila nosaukums: module.c
*Autors: hustlzp
*Datums: 2011/3/11
*Versija: 1.0
*Funkcijas apraksts: Funkcionālā moduļa slāņa avota fails
*Funkciju saraksts: (izlaists)
*Modificētie ieraksti:
***********************************************************/
#include"modulis.h"
/***********************************************************
*Funkcijas nosaukums: led_init
* Funkcijas funkcija: LED inicializācija
*Ieejas parametri: Nav
*Eksporta parametri: Nav
***********************************************************/
Tukšumsled_init (Tukšums)
{
//Konfigurējiet P1.0, P1.1, P1.2 un P1.3 kā vispārīgus I/O portus
IO_FUNC_PORT_PIN (1, 0, IO_FUNC_GIO);
IO_FUNC_PORT_PIN (1, 1, IO_FUNC_GIO);
IO_FUNC_PORT_PIN (1, 2, IO_FUNC_GIO);
IO_FUNC_PORT_PIN (1, 3, IO_FUNC_GIO);
//P1.0, P1.1, P1.2 un P1.3 konfigurēšana kā izvades
IO_DIR_PORT_PIN (1, 0, IO_OUT);
IO_DIR_PORT_PIN (1, 1, IO_OUT);
IO_DIR_PORT_PIN (1, 2, IO_OUT);
IO_DIR_PORT_PIN (1, 3, IO_OUT);
led1 = LED_ON;
led2 = LED_OFF;
led3 = LED_OFF;
led4 = LED_OFF;
}
/***********************************************************
*Funkcijas nosaukums: timer1_init
* Funkcijas funkcija: Taimeris 1 inicializācija
*Ieejas parametri: Nav
*Eksporta parametri: Nav
***********************************************************/
Tukšumstimer1_init (Tukšums)
{
INT_GLOBAL_ENABLE INT_ON. punkts; //Globālā pārtraukuma atvēršana
INT_ENABLE INUM_T1, INT_ON. punkts); //Atvērt T1 pārtraukumu
TIMER1_ENABLE_OVERFLOW_INT INT_ON. punkts; //Atvērt T1 skaita pārplūdes pārtraukumu
SET_TIMER_TICK TIMER1_TICK_4M. punkts; //Iestatiet taimeri TICK uz 4MHz
SET_TIMER1_PERIOD TIMER1_OVF_2SEC. punkts; //Iestatiet skaitīšanas periodu T1 līdz 2s
SET_TIMER1_TICKDIV TIMER1_TICKDIV_128. punkts; //Iestatiet pulksteņa krustojumu T1 uz 128
SET_TIMER1_MODE TIMER1_MODE_MODULE. punkts; //Iestatiet T1 darbības režīmu uz moduli
}
/***********************************************************
*Funkcijas nosaukums: uart0_init
* Funkcijas funkcija: Seriālā porta UART0 inicializācija
*Ieejas parametri: Nav
*Eksporta parametri: Nav
***********************************************************/
Tukšumsuart0_init (Tukšums)
{
//Atlasiet UART atrašanās vietu
IO_PER_LOC_UART0_AT_PORT0_PIN2345 ();
//UART konfigurēšana: saņemšana atļauta, 115200 bps, viena bita apturēšanas bits, bez paritātes
UART_SETUP (0, UART_RECEIVE_ENABLE,115200, ONE_STOP_BITS | PARITY_DISABLE);
//Atvērt kopējo pārtraukumu
INT_GLOBAL_ENABLE INT_ON. punkts;
//Atveriet seriālo portu 0, lai saņemtu pārtraukumus
INT_ENABLE(INUM_URX0, INT_ON);
}
/***********************************************************
*Funkcijas nosaukums: Uart0SendString
* Funkcijas funkcija: Taimeris 1 inicializācija
*Ievades parametrs: neparakstīts burts *s
Sūtāmā virkne
*Eksporta parametri: Nav
***********************************************************/
TukšumsUart0SendString(bez parakstaogles*s)
{
kamēr(*s !=0)
UART0_SEND(*s++);
}
/***********************************************************
*Funkcijas nosaukums: adc_start
* Funkcijas funkcija: sākt ADC konvertēšanu
*Ieejas parametri: Nav
*Eksporta parametrs: peldošs
Temperatūras vērtība tabletē
***********************************************************/
pludiņšadc_start (Tukšums)
{
bez parakstainttemperatūra;
//Atsauces spriegums ir 1,25 V, paraugu ņemšanas precizitāte ir 14 biti, un pārveidošanas mērķis ir mikroshēmas temperatūras sensors
ADC_SINGLE_CONVERSION(ADC_REF_1_25_V | ADC_14_BIT | ADC_TEMP_SENS);
ADC_STOP (); //ADC konvertēšanas aktivizēšanas metodes iestatīšana uz manuālu
ADC_START (); //ADC konvertēšanas uzsākšana
kamēr(! ADC_SAMPLE_READY()); //Pagaidiet, līdz konvertēšana tiks pabeigta
temp = ADCL >>2; //Konvertēšanas rezultātu saglabāšana temp
temp |= (((bez parakstaint) ADCH) <<6);
AtgriešanāsADC_TO_CELSIUS (temp); //Atgriež faktisko temperatūras vērtību pēc konvertēšanas
}
/***********************************************************
*Funkcijas nosaukums: get_temperature
* Funkcijas funkcija: apstrādājiet temperatūras vērtību un saglabājiet to rakstzīmju masīvā sērijveida izvadei
*Ievades parametrs: neparakstīts char * izeja
Izmanto, lai saglabātu konvertēto temperatūras vērtību
pludiņa temperatūra
Celsija temperatūras vērtība
*Eksporta parametri: Nav
***********************************************************/
Tukšumsget_temperature(bez parakstaogles*izeja,pludiņštemp)
{
Rezultāts[0] = (bez parakstaogles)(temp) /10 + 48; //Desmit vietas
Rezultāts[1] = (bez parakstaogles)(temp) %10 + 48; //viens cipars
Rezultāts[2] ='.'; //Decimālzīme
Rezultāts[3] = (bez parakstaogles)(temp*10) %10 + 48; //Desmitais
Rezultāts[4] = (bez parakstaogles)(temp*100) %10 + 48; //Procentile
Rezultāts[5] =''; //Stīgu endifikatori
}
/***********************************************************
*Funkcijas nosaukums: watchdog_init
* Funkcijas funkcija: Watch dog inicializācija
*Ieejas parametri: Nav
*Eksporta parametri: Nav
***********************************************************/
Tukšumswatchdog_init (Tukšums)
{
WDT_SET_TIMEOUT_PERIOD (SEC_1); //Taimauta laika iestatīšana uz 1 s
WDT_ENABLE (); //Sāciet sargsuni
}
[url =] [/url]
(3) Lietojumprogrammas slānis
[url =] [/url]
/*******************************************************************
Faila nosaukums: main.c
Autors: hustlzp
Datums: 2011/3/11
Versija: 1.0
Funkcijas apraksts: Programmas pamatfails
Funkciju saraksts: (izlaists)
Izmaiņu ieraksts:
*******************************************************************/
#include
/********************************************************************
Pakalpojuma pārtraukšanas procedūras
********************************************************************/
/* 定时器1溢出中断子程序
-------------------------------------------------------*/
#pragma vektors=T1_VECTOR
__interrupt spēkā neesošs T1_ISR(spēkā neesošs)
{
EA = 0; Vārti tiek pārtraukti
led2 = LED_ON;
get_temperature(izlaide,adc_start()); Temperatūras vērtības konvertēšana par izvadāmo rakstzīmju masīvu
Uart0SendString(izvade); Izejas temperatūras vērtība
Uart0SendString("°C");
LED2
/* 串口接收中断子程序
-------------------------------------------------------*/
#pragma vektors=URX0_VECTOR
__interrupt spēkā neesošs RE_ISR(spēkā neesošs)
{
EA = 0;
led3 = LED_ON;
saņemt = U0DBUF;
if(type==1) // type=1, kas norāda, ka saņemtā rakstzīme tiek izmantota, lai iestatītu taimera pārplūdes periodu
{
tips = 0;
pārslēgt (saņemt)
{
gadījums '0': // Taimera pārplūdes periods ir 0.5s
{
SET_TIMER1_PERIOD TIMER1_OVF_dot5SEC. punkts;
pārtraukums;
}
gadījums '1': // Taimera pārplūdes periods ir 1s
{
SET_TIMER1_PERIOD TIMER1_OVF_1SEC. punkts;
pārtraukums;
}
gadījums "2": // Taimera pārplūdes periods ir 2s
{
SET_TIMER1_PERIOD TIMER1_OVF_2SEC. punkts;
pārtraukums;
}
}
}
else if(type==2) // type=2, norādot, ka saņemtās rakstzīmes tiek izmantotas miega režīma kontrolei
{
tips = 0;
led1 = LED_OFF;
led2 = LED_OFF;
led3 = LED_OFF;
pārslēgt (saņemt)
{
gadījums '1': // Ieiet barošanas režīmā PM1
{
SET_POWER_MODE 1. punkts;
pārtraukums;
}
gadījums '2': // Ieiet barošanas režīmā PM2
{
SET_POWER_MODE 2. punkts;
pārtraukums;
}
gadījums "3": //Ieiet barošanas režīmā PM3
{
SET_POWER_MODE panta 3. punkts;
pārtraukums;
}
}
}
else if(type==0) // type=0, kas norāda, ka saņemtā rakstzīme ir vadības komandas tips: @ vai $
{
if(receive=='@')
{
tips=1; "@" tiek saņemts, lai norādītu, ka nākamā rakstzīme tiek izmantota, lai iestatītu pārplūdes periodu
}
else if(receive=='$')
{
tips = 2; Tiek saņemts '$', kas norāda, ka nākamā rakstzīme tiek izmantota sistēmas miega režīma vadībai
}
}
led3 = LED_OFF;
EA = 1;
}
=LED_OFF;
TIMER1_OVERFLOW_INT_SETFLAG INT_CLR. punkts; Notīriet pārtraukuma zīmi
EA = 1; Atvērts pārtraukums
}
/* 主函数
-------------------------------------------------------*/
void main(void)
{
SET_MAIN_CLOCK_SOURCE (KRISTĀLS); Iestatiet sistēmas pulksteni uz 32 MHz kristāla oscilatoru
led_init (); LED inicializācija
uart0_init (); Seriālā porta UART0 inicializācija
timer1_init (); Taimeris 1 tiek inicializēts
watchdog_init (); Skatīties suņa inicializāciju
kamēr (1)
{
WDT_RESET (); Barojiet suni pastāvīgi
}
}/********************************************************************
Galvenā programma
********************************************************************/
/* 全局变量
-------------------------------------------------------*/
neparakstīta char izvade[6]={0}; Temperatūras dati tiek saglabāti ērtai sērijveida izvadei
neparakstīta char saņemšana; Saņemto rakstzīmju glabāšana
neparakstīts rakstzīmes tips=0; Saņemtās rakstzīmes tipa karodziņš ir iestatīts uz 0/1/2"modulis.h"[url =] [/url]
5. TestēšanaAk ~ Kods beidzot ir ielīmēts, tas ir patiešām nogurdinoši, pārbaudīsim šo mazo sistēmu:
(1) Paraugu ņemšana laikā
Atveriet seriālo portu un sāciet IAR atkļūdošanu, un konstatējiet, ka led1 ir ieslēgts, un seriālā porta rīka temperatūras vērtība tiek pastāvīgi ģenerēta, un paraugu ņemšanas intervāls tiek noteikts kā 2s:
(2) Paraugu ņemšanas intervāla kontrole
Ievadiet "@1" seriālā porta rīkā un pēc tam pārbaudiet paraugu ņemšanas intervālu un konstatējiet, ka tas ir kļuvis par 1s; Ievadiet "@0", un paraugu ņemšanas intervāls ir mainījies uz 0,5 s.
(3) Miega režīma kontrole
Ievadiet "$1" seriālā porta rīkā un konstatējiet, ka visas gaismas diodes ir izslēgtas un temperatūras paraugu ņemšana ir apstājusies:
Pēc testēšanas sistēma darbojas normāli un stabili, un būtībā atbilst prasībām.
Studenti, kuriem nepieciešams pirmkodsNoklikšķiniet šeit, lai lejupielādētu
6. SecinājumsŠajā rakstā kā piemērs tiek izmantots nedaudz visaptverošs eksperiments, lai parādītu, kā integrēt CC2430 mikroshēmas resursus, lai uzrakstītu salīdzinoši standartizētu mazu sistēmu. Pēc dažām dienām es veltīšu laiku, lai uzrakstītu vienkāršu hal.h lietotāja rokasgrāmatu, lai es un visi varētu viegli darbināt CC2430.
Tālāk es pabeigšu pētījumus par CC2430 mikroshēmu resursiem un veltīšu sevi TI Z-Stack protokola kaudzes apguvei ~
Emuāra ieraksts, kas rakstīts šajā sērijā, pagaidām ir beidzies, bet Zigbee ceļojums turpināsies. Priekšā esošā ainava nav zināma, bet es ticu, ka autors pārvarēs šķēršļus ar visiem un izbaudīs kāpumus un kritumus, un būs ieguvumi.
Sekojiet līdzi: "Pievienojieties TI Z-Stack" emuāra ierakstiem!
Publicēts 30.10.2014 23:47:44
|
|
|
|
Publicēts 31.10.2014 08:04:14
Piedodiet, ka neko nesaprotu