Artikel ini adalah artikel cermin dari terjemahan mesin, silakan klik di sini untuk melompat ke artikel aslinya.

Jaringan Pertanian Architect_Programmer_Code»Arsitek › Pemrograman › Pemrograman lainnya › Perjalanan Zigbee (10): Eksperimen Komprehensif - Berdasarkan Suhu CC2430...
Melihat: 10835|Jawab: 1

Zigbee Journey (10): Eksperimen Komprehensif - Sistem Pemantauan Suhu Berdasarkan CC2430

[Salin tautan]
Diposting pada 30/10/2014 23.47.44 | | | |
Setelah menulis "Zigbee Journey (9)" pada tanggal 3 Maret, penulis awalnya berencana untuk segera mulai menulis eksperimen kecil tentang "sistem pemantauan suhu" sebagai ringkasan dari serangkaian poin pengetahuan yang tersebar sebelumnya. Namun, saya juga menyadari bahwa meskipun masing-masing eksperimen kecil sebelumnya dijelaskan secara rinci, sifat normatif dan struktural dari kodenya dapat dikatakan tak tertahankan. Karena ini adalah ringkasan, kita harus membuat kemajuan berdasarkan dasar, daripada secara mekanis menyatukan poin-poin pengetahuan kecil sebelumnya. Oleh karena itu, saya menunda rencana awal saya, meluangkan waktu untuk mempelajari teknik umum pengembangan tertanam, dan menulis dua esaiSpesifikasi pemrograman C51 tertanam" dan "Hierarki struktur kode proyek tertanam》。 Log ini bukan hanya ringkasan perjalanan pertama Zigbee, tetapi juga menggabungkan pengalaman belajar penulis dalam beberapa hari terakhir, berharap dapat membantu pemula Zigbee.
Teks lengkap diatur sesuai dengan proses dasar pengembangan perangkat lunak: analisis persyaratan, desain garis besar, desain terperinci, implementasi pengkodean, dan pengujian.
1. Analisis permintaan
Setelah diskusi antara "pelanggan" dan "pengembang", deskripsi fungsi sistem berikut ditentukan:
… Suhu ruangan saat ini dikumpulkan oleh node berbasis CC2430, dan nilai suhunya dapat dipantau melalui PC
… Node CC2430 itu sendiri harus memiliki tingkat stabilitas tertentu dan dapat secara otomatis kembali ke keadaan normal
… Interval pengambilan sampel dan manajemen daya node dapat dikontrol oleh PC
2. Desain garis besar
Menurut analisis persyaratan di atas, kita dapat membagi sistem menjadi dua modul:Simpul CC2430danPC。
　　[Node CC2430]　　
… Parameter eksternal dapat dikumpulkan secara teratur dan dikirim ke PC
… Reset otomatis saat mesin dimatikan
… Perintah dari PC dapat diterima dan diproses sesuai dengan itu: ubah interval sampel/manajemen daya
　　[PC]　　
… Mesin C menerima dan menampilkan data melalui alat port serial
… Instruksi dapat dikirim ke mikrokontroler melalui alat port serial untuk mengontrol kecepatan pengambilan sampel dan manajemen dayanya
3. Desain terperinci
(1) Struktur kode
Pelapisan struktur kode sistem ini sebenarnya telah dijelaskan dalam esai "Hierarki struktur kode proyek tertanam", dan salinannya adalah sebagai berikut:
(1) Lapisan abstraksi perangkat keras
　　　　　　[ioCC2430.h] (Termasuk Sistem)：Semua vektor SFR dan interupsi CC2430 didefinisikan
　　　　　　[hal.h] Termasuk definisi tipe umum, makro penugasan umum, dan konfigurasi umum sumber daya on-chip CC2430 (I/O, komunikasi serial, ADC, timer, manajemen daya, dll.)
　　(2) Lapisan modul fungsional
　　　　　　[modul.h] mendefinisikan sumber daya on-chip (timer, I/O), modul ekspansi off-chip (LED), dan deklarasi fungsi terkait
　　　　　　[modul.cTerapkan inisialisasi setiap modul (LED).
　　(3) Lapisan aplikasi
　　　　　　[main.cLihat hal.h, ioCC2430.h, dan module.h untuk mencapai persyaratan aplikasi khusus seperti akuisisi suhu, interkomunikasi dengan PC, serta shutdown dan reset
(2) Metode implementasi setiap modul
Menurut modul yang dibagi sesuai dengan desain garis besar, sistem intrinsik dapat dibagi menjadi dua modul utama:Simpul CC2430danPC。
Karena ada alat komunikasi port serial pada PC, fungsinya dapat memenuhi persyaratan, jadi kita tidak perlu melakukan bagian PC ini, dan tidak perlu menganalisisnya. Mari kita bicara tentang bagian CC2430 di bawah ini
Metode implementasi setiap sub-fungsi titik:
… Gunakan interupsi luapan hitungan pengatur waktu untuk memicu pengambilan sampel berjangka waktu
… Mode UART0 dengan port serial mentransmisikan data suhu ke PC
… Sirkuit pengawas bawaan CC2430 digunakan untuk mewujudkan fungsi reset otomatis sistem
… Port serial digunakan untuk menerima interupsi untuk menangkap dan merespons perintah kontrol dari PC
1) Jika diterima@Karakternya adalah perintah kontrol interval pengambilan sampel, diikuti dengan angka yang menunjukkan interval pengambilan sampel: 0-0,5 detik, 1-1 detik, 2-2 detik
如：@0，表示每隔0.5秒采样一次。
2) Jika diterima$  Karakter adalah perintah kontrol tidur, diikuti dengan angka yang menunjukkan mode daya
Misalnya: $3, yang berarti menempatkan sistem ke mode daya 3.
(3) Bagan alur program
  • Bagan alur program master
  • Timer 1 Bagan Alir Program Overflow Interrupt
  • Bagan alir prosedur interupsi penerima port serial




4. Implementasi pengkodean
(1) Lapisan abstraksi perangkat keras
Lapisan abstraksi perangkat keras mencakup ioCC2430.h dan hal.h. Karena sistem sebelumnya menyertainya, itu tidak akan terdaftar.
Berikut ini adalah daftar semua isi hal.h (karena file ini terlalu panjang dan terlihat tidak nyaman, saya akan menunjukkannya dalam modul):
  • kepala
  • Port I/O
  • Terputus
  • Port serial
  • Manajemen daya dan jam
  • Pengatur waktu
  • Anjing pengawas
  • ADC
[url =] [/url]
/***********************************************************
*Nama file: hal.h
*Penulis: hustlzp
*Tanggal: 8 Maret 2011
*Edisi: 1.1
* Deskripsi fungsi: Lapisan abstraksi perangkat keras
*Catatan yang dimodifikasi:
***********************************************************/


#ifndef HAL_H
#defineHAL_H


#include


/***********************************************************
                       Definisi jenis umum
***********************************************************/
typedef tidak ditandatanganiarang   BIT;
typedef tidak ditandatanganiint    KATA;
typedef tidak ditandatanganipanjang   DWORD;



/***********************************************************
                       Definisi makro yang umum digunakan
***********************************************************/

//8 tempat lebih tinggi
#defineHIGH_BYTE(a) ((BYTE) (((WORD)(a)) >> 8))


//8 tempat lebih rendah
#defineLOW_BYTE(a) ((BYTE) ((WORD)(a)))


//Penugasan
#defineSET_WORD(regH,regL,kata)  
   melakukan{                           
      (regH)=HIGH_BYTE(kata);     
      (regL)=LOW_BYTE(kata);      
   }sementara(0)
[url =] [/url]

[url =] [/url]
/***********************************************************
                       Port I/O
***********************************************************/
/*Konfigurasikan arah port I/O
-----------------------------------------*/
#defineIO_DIR_PORT_PIN(port, pin, dir)  
   melakukan{                                 
      jika(dir == IO_OUT)                 
         P##port##DIR |= (0x01<<(pin));  
      yang lain                              
         P##port##DIR &= ~(0x01<<(pin));
   }sementara(0)



//Nilai parameter dir adalah:
#defineIO_IN 0
#defineIO_OUT 1


/*Konfigurasikan mode input port I/O
-----------------------------------------*/
#defineIO_IMODE_PORT_PIN(port, pin, imode)
   melakukan{                                    
      jika(imode == IO_IMODE_TRI)            
         P##port##INP |= (0x01<<(pin));     
      yang lain                                 
         P##port##INP &= ~(0x01<<(pin));   
   }sementara (0)



#define IO_PUD_PORT (pelabuhan, pud)        
   lakukan {                              
      if (pud == IO_PULLDOWN)         
         P2INP |= (0x01 << (port + 5));
      yang lain                           
         P2INP &= ~(0x01 << (port + 5));
   } sementara (0)


Nilai parameter PUD adalah:
#define IO_PULLUP 0 // Tarik ke atas
#define IO_PULLDOWN 1 // Tarik ke bawah


/*配置I/O口的功能
-----------------------------------------*/

#define IO_FUNC_PORT_PIN(port, pin, func)  
   lakukan {                                    
      if((port == 2) && (pin == 3)){      
         if (func) {                       
            P2SEL |= 0x02;                 
         } else {                          
            P2SEL &= ~0x02;               
         }                                 
      }                                    
      else if((port == 2) && (pin == 4)){  
         if (func) {                       
            P2SEL |= 0x04;                 
         } else {                          
            P2SEL &= ~0x04;               
         }                                 
      }                                    
      lain{                                
         if (func) {                       
            P##port##SEL |= (0x01<<(pin));
         } else {                          
            P##port##SEL &= ~(0x01<<(pin));
        }                                 
      }                                    
   } sementara (0)


Nilai fungsi parameter adalah:
#define IO_FUNC_GIO 0 // I/O Umum
#define IO_FUNC_PERIPH 1 // I/O Periferal


Mengonfigurasi lokasi I/O periferal
#define IO_PER_LOC_TIMER1_AT_PORT0_PIN234() do { PERCFG = (PERCFG&~0x40)|0x00; } sementara (0)
#define IO_PER_LOC_TIMER1_AT_PORT1_PIN012() do { PERCFG = (PERCFG&~0x40)|0x40; } sementara (0)

#define IO_PER_LOC_TIMER3_AT_PORT1_PIN34() do { PERCFG = (PERCFG&~0x20)|0x00; } sementara (0)
#define IO_PER_LOC_TIMER3_AT_PORT1_PIN67() do { PERCFG = (PERCFG&~0x20)|0x20; } sementara (0)

#define IO_PER_LOC_TIMER4_AT_PORT1_PIN01() do { PERCFG = (PERCFG&~0x10)|0x00; } sementara (0)
#define IO_PER_LOC_TIMER4_AT_PORT2_PIN03() do { PERCFG = (PERCFG&~0x10)|0x10; } sementara (0)

#define IO_PER_LOC_SPI1_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x08)|0x00; } sementara (0)
#define IO_PER_LOC_SPI1_AT_PORT1_PIN4567() do { PERCFG = (PERCFG&~0x08)|0x08; } sementara (0)

#define IO_PER_LOC_SPI0_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x04)|0x00; } sementara (0)
#define IO_PER_LOC_SPI0_AT_PORT1_PIN2345() do { PERCFG = (PERCFG&~0x04)|0x04; } sementara (0)

#define IO_PER_LOC_UART1_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x02)|0x00; } sementara (0)
#define IO_PER_LOC_UART1_AT_PORT1_PIN4567() do { PERCFG = (PERCFG&~0x02)|0x02; } sementara (0)

#define IO_PER_LOC_UART0_AT_PORT0_PIN2345() do { PERCFG = (PERCFG&~0x01)|0x00; } sementara (0)
#define IO_PER_LOC_UART0_AT_PORT1_PIN2345() do { PERCFG = (PERCFG&~0x01)|0x01; } sementara (0)

//Nilai parameter imode adalah:
#defineIO_IMODE_PUD 0   //Tarik ke atas/tarik ke bawah
#defineIO_IMODE_TRI 1   //Tiga negara bagian[url =] [/url]

[url =] [/url]
/***********************************************************
                       Terputus
***********************************************************/
//Untuk interupsi on/off
#defineINT_ON 1
#defineINT_OFF 0


//Digunakan untuk menempatkan/menghapus bendera interupsi
#defineINT_SET 1
#defineINT_CLR 0


//Pengaturan interupsi global
#defineINT_GLOBAL_ENABLE(pada) EA=(!! aktif)


//Tentukan jeda
#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


/*Interupsi yang diizinkan
-----------------------------------------*/
#defineINT_ENABLE(inum, pada)                        
   melakukan{                                             
      jika      (inum==INUM_RFERR) { RFERRIE = aktif; }  
      yang lain jika(inum==INUM_ADC)   { ADCIE = aktif; }  
      yang lain jika(inum==INUM_URX0)  { URX0IE = aktif; }  
      yang lain jika(inum==INUM_URX1)  { URX1IE = aktif; }  
      yang lain jika(inum==INUM_ENC)   { ENCIE = aktif; }  
      yang lain jika(inum==INUM_ST)    { STIE = aktif; }  
      yang lain jika(inum==INUM_P2INT) { (aktif) ? (IEN2 |=0x02) : (IEN2 &= ~0x02); }
      yang lain jika(inum==INUM_UTX0)  { (aktif) ? (IEN2 |=0x04) : (IEN2 &= ~0x04); }
      yang lain jika(inum==INUM_DMA)   { DMAIE = aktif; }  
      yang lain jika(inum==INUM_T1)    { T1IE = aktif; }  
      yang lain jika(inum==INUM_T2)    { T2IE = aktif; }  
      yang lain jika(inum==INUM_T3)    { T3IE = aktif; }  
      yang lain jika(inum==INUM_T4)    { T4IE = aktif; }  
      yang lain jika(inum==INUM_P0INT) { P0IE = aktif; }  
      yang lain jika(inum==INUM_UTX1)  { (aktif) ? (IEN2 |=0x08) : (IEN2 &= ~0x08); }
      yang lain jika(inum==INUM_P1INT) { (aktif) ? (IEN2 |=0x10) : (IEN2 &= ~0x10); }
      yang lain jika(inum==INUM_RF)    { (aktif) ? (IEN2 |=0x01) : (IEN2 &= ~0x01); }
      yang lain jika(inum==INUM_WDT)   { (aktif) ? (IEN2 |=0x20) : (IEN2 &= ~0x20); }
   }sementara (0)


/*Menetapkan prioritas pemadaman
-----------------------------------------*/
#defineINT_PRIORITY(grup, pri)                     
   melakukan{                                               
      jika(pri ==0) { IP0 &= ~grup; IP1 &= ~kelompok; }
      jika(pri ==1) { IP0 |= grup; IP1 &= ~kelompok; }
      jika(pri ==2) { IP0 &= ~grup; IP1 |= kelompok; }
      jika(pri ==3) { IP0 |= grup; IP1 |= kelompok; }
   }sementara (0)

//Nilai parameter pri adalah: 0/1/2/3 (prioritas tertinggi)


//Nilai grup parameter adalah:
#defineRFERR_RF_DMA 0x01//Grup IP0
#defineADC_P2INT_T1 0x02//Grup IP1
#defineURX0_UTX0_T2 0x04//Grup IP2
#defineURX1_UTX1_T3 0x08//Grup IP3
#defineENC_P1INT_T4 0x10//Grup IP4
#defineST_WDT_P0INT 0x20//Grup IP5


/*Dapatkan bendera interupsi
-----------------------------------------*/
#defineINT_GETFLAG(inum) (                       
   (inum==INUM_RFERR) ? RFERRIF :
   (inum==INUM_ADC) ? ADCIF :
   (inum==INUM_URX0) ? URX0JIKA :
   (inum==INUM_URX1) ? URX1JIKA :
   (inum==INUM_ENC) ? ENCIF_0 :
   (inum==INUM_ST) ? STIF :
   (inum==INUM_P2INT) ? P2JIKA :
   (inum==INUM_UTX0) ? UTX0JIKA :
   (inum==INUM_DMA) ? DMAIF :
   (inum==INUM_T1) ? T1JIKA :
   (inum==INUM_T2) ? T2JIKA :
   (inum==INUM_T3) ? T3JIKA :
   (inum==INUM_T4) ? T4JIKA :
   (inum==INUM_P0INT) ? P0JIKA :
   (inum==INUM_UTX1) ? UTX1JIKA :
   (inum==INUM_P1INT) ? P1JIKA :
   (inum==INUM_RF) ? S1CON &= ~0x03    :
   (inum==INUM_WDT) ? WDTIF :
   0                                             
)


/*Atur bendera interupsi
-----------------------------------------*/
#defineINT_SETFLAG(inum, f)                     
   melakukan{                                          
      jika      (inum==INUM_RFERR) { RFERRIF= f; }
      yang lain jika(inum==INUM_ADC)   { ADCIF = f; }
      yang lain jika(inum==INUM_URX0)  { URX0IF = f; }
      yang lain jika(inum==INUM_URX1)  { URX1IF = f; }
      yang lain jika(inum==INUM_ENC)   { ENCIF_1 = ENCIF_0 = f; }
      yang lain jika(inum==INUM_ST)    { STIF = f;  }
      yang lain jika(inum==INUM_P2INT) { P2IF = f;  }
      yang lain jika(inum==INUM_UTX0)  { UTX0IF= f;  }
      yang lain jika(inum==INUM_DMA)   { DMAIF = f;  }
      yang lain jika(inum==INUM_T1)    { T1JIKA = f;  }
      yang lain jika(inum==INUM_T2)    { T2IF = f;  }
      yang lain jika(inum==INUM_T3)    { T3IF = f;  }
      yang lain jika(inum==INUM_T4)    { T4IF = f;  }
      yang lain jika(inum==INUM_P0INT) { P0IF = f;  }
      yang lain jika(inum==INUM_UTX1)  { UTX1IF= f;  }
      yang lain jika(inum==INUM_P1INT) { P1JIKA = f;  }
      yang lain jika(inum==INUM_RF)    { (f) ? (S1CON |=0x03) : (S1CON &= ~0x03); }
      yang lain jika(inum==INUM_WDT)   { WDTIF = f;  }
   }sementara (0)
[url =] [/url]

[url =] [/url]
/***********************************************************
                       Port serial
***********************************************************/
//Nilai BAUD_E sesuai dengan baud rate yang berbeda
#defineBAUD_E(baud, clkDivPow) (     
    (baud==2400)   ?  6  +clkDivPow :
    (baud==4800)   ?  7  +clkDivPow :
    (baud==9600)   ?  8  +clkDivPow :
    (baud==14400)  ?  8  +clkDivPow :
    (baud==19200)  ?  9  +clkDivPow :
    (baud==28800)  ?  9  +clkDivPow :
    (baud==38400)  ?  10+clkDivPow :
    (baud==57600)  ?  10+clkDivPow :
    (baud==76800)  ?  11+clkDivPow :
    (baud==115200) ?  11+clkDivPow :
    (baud==153600) ?  12+clkDivPow :
    (baud==230400) ?  12+clkDivPow :
    (baud==307200) ?  13+clkDivPow :
    0  )


//Nilai BAUD_M sesuai dengan baud rate yang berbeda
#defineBAUD_M(baud) (      
    (baud==2400)   ?  59  :
    (baud==4800)   ?  59  :
    (baud==9600)   ?  59  :
    (baud==14400)  ?  216 :
    (baud==19200)  ?  59  :
    (baud==28800)  ?  216 :
    (baud==38400)  ?  59  :
    (baud==57600)  ?  216 :
    (baud==76800)  ?  59  :
    (baud==115200) ?  216 :
    (baud==153600) ?  59  :
    (baud==230400) ?  216 :
    (baud==307200) ?  59  :
  0)


/*Konfigurasi port serial dalam mode UART
-----------------------------------------*/
#defineUART_SETUP(uart, receiveEnable, baudRate, opsi)      
   melakukan{                                                         
      jika((uart) ==0){                                          
         jika(PERCFG &0x01){                                    
            P1SEL |=0x30;                                      
         }yang lain{                                               
            P0SEL |=0x0C;                                      
         }                                                      
      }                                                         
      yang lain{                                                   
         jika(PERCFG &0x02){                                    
            P1SEL |=0xC0;                                      
         }yang lain{                                               
            P0SEL |=0x30;                                      
         }                                                      
      }                                                         
                                                               
      U##uart##GCR = BAUD_E((baudRate),CLKSPD);                 
      U##uart##BAUD = BAUD_M(baudRate);                        
                                                               
      U##uart##CSR |=0x80;                                    
                                                               
      U##uart##CSR |= menerimaAktifkan;                           
                                                               
      U##uart##UCR |= ((opsi) |0x80);                       
   }sementara(0)
     
//Nilai parameter receiveEnable:
#defineUART_RECEIVE_ENABLE 0x40   //Menerima izin
#defineUART_RECEIVE_DISABLE 0x00   
     
//Nilai opsi parameter:
#defineFLOW_CONTROL_ENABLE 0x40   //Kontrol aliran
#defineFLOW_CONTROL_DISABLE 0x00


#defineEVEN_PARITY 0x20   //Verifikasi sesekali
#defineODD_PARITY 0x00   //Verifikasi aneh


#defineNINE_BIT_TRANSFER 0x10   //Transfer 9 byte
#defineEIGHT_BIT_TRANSFER 0x00   //Transfer 8 byte


#definePARITY_ENABLE 0x08   //Pemberdayaan pemeriksaan paritas
#definePARITY_DISABLE 0x00

#defineTWO_STOP_BITS 0x04   //Posisi berhenti 2 posisi
#defineONE_STOP_BITS 0x00   //1 posisi berhenti


#defineHIGH_STOP 0x02   //Level berhenti tinggi
#defineLOW_STOP 0x00   //Posisi berhenti rendah
     
#defineHIGH_START 0x01   //Level bit awal tinggi
#defineLOW_START 0x00   //Level bit awal rendah


//Port serial mengirim karakter
#defineUART_SEND(uart, data)            
   melakukan{                                 
     sementara(U##uart##CSR &0x01);        
       U##uart##DBUF = data;            
   }sementara (0)
#defineUART0_SEND(data) UART_SEND(0,data)
#defineUART1_SEND(data) UART_SEND(1,data)


//Port serial menerima karakter
#defineUART_RECEIVE(uart, data)         
   melakukan{                                 
     sementara(! (U##uart##CSR&0x04));      
       data=U##uart##DBUF;              
   }sementara(0)
#defineUART0_RECEIVE(data) UART_RECEIVE(0,data)
#defineUART1_RECEIVE(data) UART_RECEIVE(1,data)
[url =] [/url]

[url =] [/url]
/***********************************************************
                       Manajemen daya dan jam
***********************************************************/
//Dapatkan crossover jam
#defineCLKSPD (CLKCON & 0x07)


//Atur mode daya
#defineSET_POWER_MODE(mode)                  
   melakukan{                                       
      jika(mode ==0) { TIDUR &= ~0x03; }
      yang lain jika(mode ==3) { TIDUR |=0x03;  }
      yang lain{ TIDUR &= ~0x03; TIDUR |= mode;  }
      PCON |=0x01;                           
      asm("NOP");                              
   }sementara (0)


//Mode parameter diatur ke nilai berikut:
#definePOWER_MODE_0 0x00  
#definePOWER_MODE_1 0x01
#definePOWER_MODE_2 0x02
#definePOWER_MODE_3 0x03


//Digunakan untuk mendeteksi stabilitas osilator RC frekuensi tinggi
#defineHIGH_FREQUENCY_RC_OSC_STABLE (TIDUR & 0x20)


//Digunakan untuk mendeteksi kondisi stabil osilator kristal
#defineXOSC_STABLE (TIDUR & 0x40)


//Dapatkan nilai frekuensi tick timer
#defineTICKSPD ((CLKCON & 0x38) >> 3)


//Atur frekuensi jam master
#defineSET_MAIN_CLOCK_SOURCE(sumber)
   melakukan{                              
      jika(sumber) {                    
        CLKCON |=0x40;               
        sementara(! HIGH_FREQUENCY_RC_OSC_STABLE);
        jika(TICKSPD ==0){            
          CLKCON |=0x08;            
        }                             
        TIDUR |=0x04;               
      }                              
      yang lain{                          
        TIDUR &= ~0x04;               
        sementara(! XOSC_STABLE);         
        asm("NOP");                  
        CLKCON &= ~0x47;              
        TIDUR |=0x04;               
      }                              
   }sementara (0)


//Nilai sumber parameter adalah:
#defineKRISTAL 0x00   //Osilator kristal
#defineRC 0x01   //Osilator RC
[url =] [/url]

[url =] [/url]
/***********************************************************
                       Pengatur waktu 1
***********************************************************/
//Pengatur waktu 1 memungkinkan hitungan luapan terganggu
#defineTIMER1_ENABLE_OVERFLOW_INT(val)
   (TIMIF = (val) ? TIMIF |0x40: TIMIF & ~0x40)


//Atur bendera interupsi luapan untuk timer 1
#defineTIMER1_OVERFLOW_INT_SETFLAG(f) (T1CTL= ((T1CTL & (~0x10)) | f))


//Pengatur waktu 1 dimulai
#defineTIMER1_RUN(nilai) (T1CTL = (nilai) ? T1CTL|0x02 : T1CTL&~0x03)


//Atur pembagian jam untuk pengatur waktu
#defineSET_TIMER_TICK(nilai) do{ CLKCON = ((CLKCON & (~0x38)) | nilai); } sementara(0)


//Nilai nilainya adalah:
#defineTIMER1_TICK_32M 0x00  //32MHz
#defineTIMER1_TICK_16M 0x08  //16MHz, nilai default untuk reset sistem
#defineTIMER1_TICK_8M 0x10  //8MHz
#defineTIMER1_TICK_4M 0x18  //4MHz
#defineTIMER1_TICK_2M 0x20  //2MHz
#defineTIMER1_TICK_1M 0x28  //1MHz
#defineTIMER1_TICK_500k 0x30  //500kHz
#defineTIMER1_TICK_250k 0x38  //250kHz

//Atur crossover TICK untuk timer 1
#defineSET_TIMER1_TICKDIV(nilai)  
   melakukan{                             
     T1CTL &= ~0x0c;               
     T1CTL |= nilai;               
   }sementara (0)
      
//di mana nilainya adalah:      
#defineTIMER1_TICKDIV_1 0x00   //1 divisi
#defineTIMER1_TICKDIV_8 0x04   //Frekuensi 8 arah
#defineTIMER1_TICKDIV_32 0x08
#defineTIMER1_TICKDIV_128 0x0c


//Mengatur periode luapan pengatur waktu
#defineSET_TIMER1_PERIOD(nilai)
   melakukan{                           
     T1CC0H = HIGH_BYTE(nilai);  
     T1CC0L = LOW_BYTE(nilai);   
   }sementara (0)
     
//Atur mode pengoperasian Timer 1
#defineSET_TIMER1_MODE(mode)  
   melakukan{                        
     T1CTL = ((T1CTL & (~0x03)) | mode);           
   }sementara (0)


//Nilai mode adalah:
#defineTIMER1_MODE_STOP 0x00
#defineTIMER1_MODE_FREE 0x01
#defineTIMER1_MODE_MODULE 0x02
#defineTIMER1_MODE_UPDOWN 0x03
[url =] [/url]

[url =] [/url]
/***********************************************************
                       Anjing pengawas
***********************************************************/
//Atur periode luapan untuk pengatur waktu pengawas
#defineWDT_SET_TIMEOUT_PERIOD(batas waktu)
   melakukan{ WDCTL &= ~0x03; WDCTL |= batas waktu; }sementara (0)


//Nilai batas waktu parameter adalah:
#defineSEC_1 0x00     //setelah 1 detik
#defineM_SEC_250 0x01     //setelah 250 ms
#defineM_SEC_15 0x02     //setelah 15 ms
#defineM_SEC_2 0x03     //setelah 2 ms


//Prosedur pemberian makan anjing
#defineWDT_RESET() melakukan {           
   WDCTL = (WDCTL & ~0xF0) |0xA0;
   WDCTL = (WDCTL & ~0xF0) |0x50;
} sementara (0)


//Mulai/hentikan pengatur waktu pengawas
#defineWDT_ENABLE() WDCTL |= 0x08
#defineWDT_DISABLE() WDCTL &= ~0x08
[url =] [/url]

[url =] [/url]
/***********************************************************
                       ADC
***********************************************************/
//Mengonfigurasi satu ADC
#defineADC_SINGLE_CONVERSION(pengaturan)
   melakukan{ ADCCON3 = pengaturan; }sementara(0)

//Pengaturan parameter terdiri dari kombinasi berikut:
//Referensitage
#defineADC_REF_1_25_V 0x00     //Tegangan Referensi Internal 1.25V
#defineADC_REF_P0_7 0x40     //Referensi eksternaltage pada pin AIN7
#defineADC_REF_AVDD 0x80     //AVDD_SOC Pin
#defineADC_REF_P0_6_P0_7 0xC0     //AIN6-AIN7 Tegangan referensi eksternal untuk input diferensial


//Laju pengambilan sampel
#defineADC_8_BIT 0x00     //Tempat ke-8
#defineADC_10_BIT 0x10     //Juara 10
#defineADC_12_BIT 0x20     //Tempat ke-12
#defineADC_14_BIT 0x30     //Tempat ke-14


//Masuk ke saluran
#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     //Tanah
#defineADC_TEMP_SENS 0x0E     //Sensor suhu dalam chip
#defineADC_VDD_3 0x0F     //vdd/3




Konversi ADC selesai
#define ADC_SAMPLE_READY() (ADCCON1 & 0x80)

#endif
//启动ADC转化
#define ADC_START()
  do { ADCCON1 |= 0x40; } sementara (0)//Pilih mode pemicu ADC sebagai manual (yaitu, ADC_SAMPLE_READY)
#defineADC_STOP()  
  melakukan{ ADCCON1 |=0x30; }sementara (0)[url =] [/url]


(2) Lapisan modul fungsional
  • modul.h
  • modul.c
[url =] [/url]
/***********************************************************
*Nama file: module.h
*Penulis: hustlzp
*Tanggal: 6 Maret 2011
*Versi: 1.0
*Deskripsi fungsi: File header lapisan modul fungsional
*Daftar fungsi: void led_init()
            Void timer1_init()
            batal uart0_init(batal);
            void Uart0SendString(char *s yang tidak ditandatangani);
            mengapung adc_start(kosong)
            void get_temperature(char tidak ditandatangani * output, float temp);
            batal watchdog_init(batal);
*Catatan yang dimodifikasi:
***********************************************************/

#ifndef MODULE_H
#defineMODULE_H


#include"hal.h"


/***********************************************************
                        LED
***********************************************************/
//Tentukan pin LED
#defineLED1 P1_0         
#defineLED2 P1_1         
#defineLED3 P1_2         
#defineLED4 P1_3   

//Lampu LED dan mati
#defineLED_OFF 1
#defineLED_ON 0

//Inisialisasi LED
kosongled_init(kosong);




/***********************************************************
                        pengatur waktu1
***********************************************************/
//Digunakan untuk mengatur nilai periode luapan untuk pengatur waktu
#defineTIMER1_OVF_2SEC 0xF424   //2 detik
#defineTIMER1_OVF_1SEC 0x7A12   //1 detik
#defineTIMER1_OVF_dot5SEC 0x3D09   //0,5 detik   

//Pengatur waktu 1 menginisialisasi
kosong  timer1_init(kosong);
                  

/***********************************************************
                        UART0
***********************************************************/
//Inisialisasi UART0
kosong  uart0_init(kosong);                    

//String transmisi port serial
kosong  Uart0SendString(tidak ditandatanganiarang*dtk);
   

/***********************************************************
                        ADC-14
***********************************************************/
//Digunakan untuk mengubah data yang diperoleh oleh ADC ke suhu Celcius
#defineADC_TO_CELSIUS(suhu) (suhu * 0,06229 - 311,43)

//Memulai konversi ADC
mengapungadc_start(kosong);

//Konversi
kosong  get_temperature(tidak ditandatanganiarang* keluaran,mengapungsuhu);


/***********************************************************
                        Anjing Penjaga
***********************************************************/
//Inisialisasi pengawas
kosong  watchdog_init(kosong);                 

#endif
[url =] [/url]

[url =] [/url]
/***********************************************************
*Nama file: module.c
*Penulis: hustlzp
*Tanggal: 2011/3/11
*Versi: 1.0
* Deskripsi Fungsi: File sumber lapisan modul fungsional
*Daftar fungsi: (dihilangkan)
*Catatan yang dimodifikasi:
***********************************************************/


#include"modul.h"


/***********************************************************
*Nama Fungsi: led_init
* Fungsi fungsi: inisialisasi LED
*Parameter masuk: Tidak ada
*Parameter ekspor: Tidak ada
***********************************************************/
kosongled_init(kosong)
{
  //Konfigurasikan P1.0, P1.1, P1.2, dan P1.3 sebagai port I/O umum
  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);
  
  //Konfigurasikan P1.0, P1.1, P1.2, dan P1.3 sebagai output
  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;
}


/***********************************************************
* Nama Fungsi: timer1_init
* Fungsi fungsi: Inisialisasi Timer 1
*Parameter masuk: Tidak ada
*Parameter ekspor: Tidak ada
***********************************************************/
kosongtimer1_init(kosong)
{
  INT_GLOBAL_ENABLE(INT_ON);                 //Buka interupsi global
  
  INT_ENABLE(INUM_T1, INT_ON);               //Buka interupsi T1

  TIMER1_ENABLE_OVERFLOW_INT(INT_ON);        //Buka interupsi luapan hitungan T1
  
  SET_TIMER_TICK(TIMER1_TICK_4M);            //Atur timer TICK ke 4MHz
  
  SET_TIMER1_PERIOD(TIMER1_OVF_2SEC);        //Atur periode penghitungan untuk T1 hingga 2 detik
  
  SET_TIMER1_TICKDIV(TIMER1_TICKDIV_128);   //Atur crossover jam untuk T1 ke 128
  
  SET_TIMER1_MODE(TIMER1_MODE_MODULE);      //Atur mode berjalan T1 ke modul
}


/***********************************************************
* Nama Fungsi: uart0_init
* Fungsi fungsi: Inisialisasi UART0 port serial
*Parameter masuk: Tidak ada
*Parameter ekspor: Tidak ada
***********************************************************/
kosonguart0_init(kosong)
{
  //Pilih lokasi UART
  IO_PER_LOC_UART0_AT_PORT0_PIN2345();
  
  //Konfigurasikan UART: Terima diizinkan, 115200bps, bit stop satu bit, tanpa paritas
  UART_SETUP(0, UART_RECEIVE_ENABLE,115200, ONE_STOP_BITS | PARITY_DISABLE);

  //Buka interupsi total
  INT_GLOBAL_ENABLE(INT_ON);      

  //Buka port serial 0 untuk menerima interupsi
  INT_ENABLE(INUM_URX0, INT_ON);   
}


/***********************************************************
*Nama fungsi: Uart0SendString
* Fungsi fungsi: Inisialisasi Timer 1
*Parameter entri: char tanpa tanda tangan *s
            String yang ingin Anda kirim
*Parameter ekspor: Tidak ada
***********************************************************/
kosongUart0SendString(tidak ditandatanganiarang*dt)
{
  sementara(*s !=0)         
    UART0_SEND(*s++);
}


/***********************************************************
*Nama Fungsi: adc_start
*Fungsi fungsi: Mulai konversi ADC
*Parameter masuk: Tidak ada
*Parameter ekspor: mengambang
            Nilai suhu di tablet
***********************************************************/
mengapungadc_start(kosong)
{
  tidak ditandatanganiintsuhu;
  
  //Tegangan referensi adalah 1.25V, akurasi pengambilan sampel adalah 14 bit, dan target konversi adalah sensor suhu on-chip
  ADC_SINGLE_CONVERSION(ADC_REF_1_25_V | ADC_14_BIT | ADC_TEMP_SENS);
  
  ADC_STOP();                           //Tetapkan metode pemicu untuk konversi ADC ke manual
  
  ADC_START();                           //Memulai konversi ADC
  
  sementara(! ADC_SAMPLE_READY());            //Tunggu hingga konversi selesai
  
  temp = ADCL >>2;                     //Menyimpan hasil konversi dalam sementara
  temp |= (((tidak ditandatanganiint) ADCH) <<6);
  
  KembaliADC_TO_CELSIUS(suhu);           //Mengembalikan nilai suhu aktual setelah konversi
}


/***********************************************************
*Nama fungsi: get_temperature
* Fungsi fungsi: Memproses nilai suhu dan menyimpannya dalam array karakter untuk output serial
*Parameter entri: char tidak ditandatangani *output
            Digunakan untuk menyimpan nilai suhu yang dikonversi
            Suhu mengambang
            Nilai suhu Celcius
*Parameter ekspor: Tidak ada
***********************************************************/
kosongget_temperature(tidak ditandatanganiarang* keluaran,mengapungsuhu)
{
  keluaran[0] = (tidak ditandatanganiarang(suhu) /10 + 48;         //Sepuluh tempat
  keluaran[1] = (tidak ditandatanganiarang(suhu) %10 + 48;         //satu digit
  keluaran[2] ='.';                                      //Titik desimal
  keluaran[3] = (tidak ditandatanganiarang(suhu*10) %10 + 48;      //Kesepuluh
  keluaran[4] = (tidak ditandatanganiarang(suhu*100) %10 + 48;      //Persentil
  keluaran[5] ='';                                    //Ujung ujung string
}


/***********************************************************
* Nama Fungsi: watchdog_init
* Fungsi fungsi: Inisialisasi anjing pengawas
*Parameter masuk: Tidak ada
*Parameter ekspor: Tidak ada
***********************************************************/
kosongwatchdog_init(kosong)
{
  WDT_SET_TIMEOUT_PERIOD(SEC_1);   //Atur waktu tunggu ke 1 detik
  WDT_ENABLE();                    //Mulai pengawas
}
[url =] [/url]


(3) Lapisan aplikasi
  • main.c
[url =] [/url]
/*******************************************************************
Nama file: main.c
Penulis: hustlzp
Tanggal: 2011/3/11
Versi: 1.0
Deskripsi fungsi: File program master
Daftar Fungsi: (dihilangkan)
Catatan Modifikasi:
*******************************************************************/


#include




/********************************************************************
                             Prosedur layanan interupsi
********************************************************************/
/* 定时器1溢出中断子程序
-------------------------------------------------------*/
#pragma vektor = T1_VECTOR
__interrupt void T1_ISR(void)
{
  EA = 0;                                   Gerbang terputus
  
  led2 = LED_ON;                          
  
  get_temperature(keluaran,adc_start());    Ubah nilai suhu menjadi array karakter yang akan dikeluarkan
   
  Uart0SendString(keluaran);                Nilai suhu keluaran
  Uart0SendString("°C");  


  dipimpin 2


/* 串口接收中断子程序
-------------------------------------------------------*/
#pragma vektor = URX0_VECTOR
__interrupt void RE_ISR(void)
{
  EA = 0;
  
  led3 = LED_ON;

  menerima = U0DBUF;   
  
  if(type==1) // type=1, yang menunjukkan bahwa karakter yang diterima digunakan untuk mengatur periode luapan timer
  {
    jenis=0;
    beralih (menerima)
    {
      kasus '0': // Periode luapan pengatur waktu adalah 0,5 detik
      {
        SET_TIMER1_PERIOD(TIMER1_OVF_dot5SEC);
        istirahat;
      }
      kasus '1': // Periode luapan pengatur waktu adalah 1 detik
      {
        SET_TIMER1_PERIOD(TIMER1_OVF_1SEC);
        istirahat;
      }
      kasus '2': // Periode luapan pengatur waktu adalah 2 detik
      {
        SET_TIMER1_PERIOD(TIMER1_OVF_2SEC);
        istirahat;         
      }
    }
  }
  else if(type==2) // type=2, menunjukkan bahwa karakter yang diterima digunakan untuk kontrol tidur
  {
    jenis=0;
    led1 = LED_OFF;
    led2 = LED_OFF;
    led3 = LED_OFF;
    beralih (menerima)
    {
      kasus '1': // Masuk ke mode daya PM1
      {
        SET_POWER_MODE(1);  
        istirahat;
      }
      kasus '2': // Masuk ke mode daya PM2
      {
        SET_POWER_MODE(2);  
        istirahat;
      }
      kasus '3': //Masuk ke mode daya PM3
      {
        SET_POWER_MODE(3);  
        istirahat;
      }
    }
  }
  else if(type==0) // type=0, yang menunjukkan bahwa karakter yang diterima adalah jenis perintah kontrol: @ atau $
  {
    if(receive=='@')  
    {
      tipe = 1;     '@' diterima untuk menunjukkan bahwa karakter berikutnya digunakan untuk mengatur periode luapan
    }
    else if(receive=='$')
    {
      tipe = 2;     '$' diterima, menunjukkan bahwa karakter berikutnya digunakan untuk kontrol tidur sistem
    }
  }
  
  led3 = LED_OFF;
   
  EA = 1;
}
=LED_OFF;
  
  TIMER1_OVERFLOW_INT_SETFLAG(INT_CLR);   Menghapus tanda interupsi
  
  EA = 1;                                   Interupsi terbuka  
}
/* 主函数
-------------------------------------------------------*/
void main(void)
{
  SET_MAIN_CLOCK_SOURCE(KRISTAL);  Atur jam sistem ke osilator kristal 32MHz
  
  led_init();                      Inisialisasi LED
  
  uart0_init();                    Inisialisasi UART0 port serial
  
  timer1_init();                   Pengatur waktu 1 menginisialisasi
  
  watchdog_init();                 Inisialisasi pengawas
  
  sementara(1)
  {
    WDT_RESET();                   Beri makan anjing terus-menerus
  }
}/********************************************************************
                            Program utama   
********************************************************************/
/* 全局变量
-------------------------------------------------------*/
keluaran char yang tidak ditandatangani[6]={0};       Data suhu disimpan untuk output serial yang mudah
tidak ditandatangani menerima;             Simpan karakter yang diterima
tipe char yang tidak ditandatangani = 0;              Bendera jenis karakter yang diterima diatur ke 0/1/2"modul.h"[url =] [/url]


5. Pengujian
Oh ~ Kodenya akhirnya ditempelkan, benar-benar melelahkan, mari kita uji sistem kecil ini:
(1) Pengambilan sampel berjangka waktu
Buka port serial, dan mulai debugging IAR, dan temukan bahwa led1 menyala, dan nilai suhu pada alat port serial terus-menerus dihasilkan, dan interval pengambilan sampel ditentukan menjadi 2 detik:
(2) Kontrol interval pengambilan sampel
Masukkan "@1" di alat port serial, lalu uji interval pengambilan sampel, dan temukan bahwa itu telah menjadi 1; Masukkan "@0" dan interval pengambilan sampel telah berubah menjadi 0,5 detik.
(3) Kontrol tidur
Masukkan "$1" di alat port serial dan temukan bahwa semua LED mati dan pengambilan sampel suhu telah berhenti:
Setelah pengujian, sistem bekerja secara normal dan stabil, dan pada dasarnya memenuhi persyaratan.
Siswa yang membutuhkan kode sumberKlik di sini untuk mengunduh
6. Kesimpulan
Makalah ini mengambil eksperimen yang sedikit komprehensif sebagai contoh untuk menunjukkan cara mengintegrasikan sumber daya CC2430 on-chip untuk menulis sistem kecil yang relatif standar. Dalam beberapa hari, saya akan meluangkan waktu untuk menulis panduan pengguna sederhana untuk hal.h sehingga saya dan semua orang dapat dengan mudah mengoperasikan CC2430.
Selanjutnya, saya akan menyelesaikan penelitian saya tentang sumber daya on-chip CC2430 dan mengabdikan diri untuk mempelajari tumpukan protokol TI Z-Stack~
Posting blog yang ditulis dalam seri ini telah berakhir untuk saat ini, tetapi perjalanan Zigbee akan berlanjut. Pemandangan di depan tidak diketahui, tetapi saya percaya bahwa penulis akan mengatasi rintangan dengan semua orang dan merasakan pasang surut, dan akan ada keuntungan.
Nantikan: Posting blog "Bergabunglah dengan TI Z-Stack"!















Mantan:Perjalanan Zigbee (9): Beberapa eksperimen dasar CC2430 yang penting - tidur sistematis dan terjaga yang terganggu
Depan:Hari ini adalah Halloween, bagaimana Anda akan menghibur?

Pos terkait
Diposting pada 31/10/2014 08.04.14 |
Maafkan aku karena tidak mengerti apa pun
Sanggahan:
Semua perangkat lunak, materi pemrograman, atau artikel yang diterbitkan oleh Code Farmer Network hanya untuk tujuan pembelajaran dan penelitian; Konten di atas tidak boleh digunakan untuk tujuan komersial atau ilegal, jika tidak, pengguna akan menanggung semua konsekuensi. Informasi di situs ini berasal dari Internet, dan sengketa hak cipta tidak ada hubungannya dengan situs ini. Anda harus sepenuhnya menghapus konten di atas dari komputer Anda dalam waktu 24 jam setelah pengunduhan. Jika Anda menyukai program ini, harap dukung perangkat lunak asli, pembelian pendaftaran, dan dapatkan layanan asli yang lebih baik. Jika ada pelanggaran, silakan hubungi kami melalui email.
Mail To:help@itsvse.com