发送代码

  1. #include <iocc2530.h>
  2. #include "hal_mcu.h"
  3. #include "hal_assert.h"
  4. #include "hal_board.h"
  6. #include "hal_rf.h"
  7. #include "basic_rf.h"
  8. #include <stdio.h>
  10. #include "usb.h"
  11. #include "12864.h"
  12. #include "oled.h"
  14. //#define RX
  15. uchar Recdata[10];
  16. uchar RXTXflag=1;
  17. uchar str[20] = "RF_text";
  18. uchar temp;
  19. uint  datanumber = 0;
  20. unsigned char buf[10];
  21. unsigned char len=0;
  22. unsigned char i;
  23. uint stringlen = 0;
  25. /**********************************
  26. 初始化串口函数
  27. **********************************/
  28. void initUART0(void)
  29. {
  30.     CLKCONCMD &= ~0x40; //设置系统时钟源为32MHZ晶振
  31.     while (CLKCONSTA & 0x40)
  32.         ;               //等待晶振稳定
  33.     CLKCONCMD &= ~0x47; //设置系统主时钟频率为32MHZ
  34.     SLEEPCMD |= 0x04;   //关闭其它无用频率信号
  35.     PERCFG = 0x00;                   //位置1P0口
  36.     P0SEL |= (1 << 3) | (1 << 2);    // P0设置为串口
  37.     P2DIR &= ~((1 << 7) | (1 << 6)); // P0优先作为UART0
  38.     U0CSR |= (1 << 7);
  39.     U0GCR |= 9;   //指数值，波特率设为9600
  40.     U0BAUD |= 59; //小数部分59
  41.     UTX0IF = 1;        // usart 0 tx中断
  42.     U0CSR |= (1 << 6); //接收器使能
  43.     IEN0 |= (1 << 7) | (1 << 2);
  44. }
  46. /*******************
  47. 初始化系统时钟
  48. *******************/
  49. void InitClock(void)
  50. {
  51.     CLKCONCMD &= ~0x40; //设置系统时钟源为32MHZ晶振
  52.     while (CLKCONSTA & 0x40)
  53.         ;               //等待晶振稳定
  54.     CLKCONCMD &= ~0x47; //设置系统主时钟频率为32MHZ
  55.     SLEEPCMD |= 0x04;   //关闭其它无用频率信号
  56. }
  58. /*******************
  59. 延时
  60. *******************/
  61. void Delay(unsigned int n)
  62. {
  63.     unsigned int tt;
  64.     for (tt = 0; tt < n; tt++)
  65.         ;
  66.     for (tt = 0; tt < n; tt++)
  67.         ;
  68.     for (tt = 0; tt < n; tt++)
  69.         ;
  70.     for (tt = 0; tt < n; tt++)
  71.         ;
  72.     for (tt = 0; tt < n; tt++)
  73.         ;
  74. }
  76. /****************************************************************
  77. 串口接收一个字符:一旦有数据从串口传至CC2530,则进入中断，将接收到的数据赋值给变量temp.
  78. ****************************************************************/
  79. #pragma vector = URX0_VECTOR
  80.  __interrupt void UART0_ISR(void)
  81.  {
  82.     URX0IF = 0;//清中断标志
  83.     //Recdata[datanumber++] = U0DBUF;//U0DBUF:USART 0 接收/发送数据缓存
  84.     temp= U0DBUF;
  85.  }
  87. //RF中断初始化
  88. void rf_init()
  89. {
  90.     //(1 << 6)硬件产生一个CRC-16（ITU-T）并附加到发送帧。不需要写最后2 个字节到TXBUF。
  91.     //硬件检查一个CRC-16，并以一个16 位状态字代替RX FIFO，包括一个CRC OK 位。状态字可通过APPEND_DATA_MODE 控制。
  92.     //(1 << 5)定义无线电是否自动发送确认帧。当autoack 使能，所有经过地址过滤接受的帧都设置确认请求标志，在接收之后自动确认一个有效的CRC12 符号周期。
  93.     FRMCTRL0 |= (1 << 5) | (1 << 6); //(0x20 | 0x40);//硬件CRC以及AUTO_ACK使能   FRMCTRL0:帧处理
  94.     TXFILTCFG = 0x09; //0000 1001 设置TX抗混叠过滤器以获得合适的带宽 
  95.     AGCCTRL1 = 0x15;  //调整AGC目标值  
  96.     FSCAL1 = 0x00;    //获得最佳的EVM
  97.     RFIRQM0 |= (1 << 6); // RXPKTDONE 中断位使能
  98.     IEN2 |= (1 << 0); //  RF 中断使能
  99.     EA = 1; //开中断
  100.     FREQCTRL = 0x0a;    //信道选择，选择11信道
  101.     SHORT_ADDR0 = 0x05; // 0x0005//目标地址过滤期间使用的短地址
  102.     SHORT_ADDR1 = 0x00;
  103.     PAN_ID0 = 0x23; // 选择两个设备进行无线通信时的个域网ID: PANID  0x0022//目标地址过滤期间使用的PANID
  104.     PAN_ID1 = 0x00;
  105.     RFST = 0xed; //清除RXFIFO缓冲区并复位解调器
  106.     RFST = 0xe3; //为RX使能并校准频率合成器
  107.     FRMFILT0 &= ~(1 << 0); //禁止帧过滤
  108. }
  110. //通信
  111. void tx()
  112. {
  113.     unsigned char i;
  114.     RFST = 0xe3; //为RX使能并校准频率合成器
  115.     while (FSMSTAT1 & ((1 << 1) | (1 << 5)));// 等待发送状态不活跃并且没有接收到SFD
  116.     RFIRQM0 &= ~(1 << 6); //禁止RXPKTDONE接收数据包中断
  117.     IEN2 &= ~(1 << 0);    //禁止RF中断
  118.     RFST = 0xee;          // 清除TXFIFO缓存
  119.     RFIRQF1 = ~(1 << 1);  // 清除 TXDONE 发送完成中断
  120.     if (Recdata[7]=='N')
  121.     {
  122.         RFD = 8 + 2;                // 发送的第一个字节是传输的帧长度
  123.         for (i = 0; i < 8 + 2; i++) //将mac的内容写到RFD中
  124.             RFD = Recdata[i];
  125.     }
  126.     else
  127.     {
  128.         RFD = 9 + 2;                // 发送的第一个字节是传输的帧长度
  129.         for (i = 0; i < 9 + 2; i++) //将mac的内容写到RFD中
  130.             RFD = Recdata[i];
  131.     }
  132.     RFST = 0xe9; //校准后使能TX
  133.     while (!(RFIRQF1 & (1 << 1)));//等待传输结束
  134.     RFIRQF1 = ~(1 << 1); //清除 TXDONE状态
  135.     RFIRQM0 |= (1 << 6); // 打开RX中断
  136.     IEN2 |= (1 << 0);    //打开RF中断
  137. }
  139. //接收中断处理
  140. #pragma vector = RF_VECTOR
  141. __interrupt void rf_isr(void)
  142. {
  143.     unsigned char i;
  144.     //关中断
  145.     IEN2 &= ~0X01;
  146.     //接收帧结束
  147.     if (RFIRQF0 & (1 << 6))
  148.     {
  149.         len = RFD; //接收帧长度
  150.         len &= 0x7f;
  151.         for (i = 0; i < len; i++) //将接收的数据写入buf中
  152.         {
  153.             buf[i] = RFD;
  154.             Delay(200);
  155.         }
  156.         S1CON = 0;// 清RF中断
  157.         RFIRQF0 &= ~(1 << 6);//清RXPKTDONE中断
  158.         led1 = ~led1;//LED1等状态改变
  159.         //设置断点后，程序停止在断点处，但RF仍旧在接收，导致FIFO溢出，无法接收数据，继续运行后再也无法接收。所以要运行一下指令
  160.         RFST = 0xed; //清除RXFIFO缓冲区并复位解调器
  161.     }
  162.     IEN2 |= (1 << 0);
  163. }
  165. void main(void)
  166. {
  167.     P0DIR |= 0x73;
  168.     OLED_Init();//初始化OLED  
  169.     OLED_Clear();         
  170. #if NODE_TYPE
  171.     OLED_ShowString(30,1,"SEND_ADDR");//发送数据
  172. #else
  173.     OLED_ShowString(30,1,"RECV_ADDR ");//接收数据
  174. #endif
  175.     Led_Init();//初始化LED
  176.     P1DIR = 0x03;//P1控制LED
  177.     initUART0();//初始化串口0函数    
  178.     UartTX_Send_String(str,20);
  179.     while(1){
  180.         if(RXTXflag == 1){
  181.           if(temp!=0){
  182.             if((temp != '#') && (datanumber < 9)){
  183.                 Recdata[datanumber++] = temp;
  184.             }else{
  185.               RXTXflag = 3;
  186.               Recdata[datanumber++] = '\0';
  187.             }
  188.             temp = 0;
  189.           }
  190.         }
  191.         if(RXTXflag == 3){
  192.           U0CSR &= ~(1<<6);// 不能接收
  193.           if(Recdata[7]=='N'){
  194.             //显示OLED
  195.             led1=0;
  196.             UartTX_Send_String(Recdata,datanumber);
  197.             P0DIR |= 0x73;
  198.             //Recdata[8]=0;
  199.             OLED_Init();//初始化OLED  
  200.             OLED_Clear();         
  201.             OLED_ShowString(30,1,"SEND_ADDR");
  202.             OLED_ShowString(30,3,"MUSIC_ON ");
  203.             rf_init();
  204.             tx();
  205.             Delay(2000); //延时
  206.           }else if(Recdata[7]=='F'){
  207.             led1=1;
  208.             UartTX_Send_String(Recdata,datanumber);
  209.             P0DIR |= 0x73;
  210.             OLED_Init();//初始化OLED  
  211.             OLED_Clear();         
  212.             OLED_ShowString(30,1,"SEND_ADDR");
  213.             OLED_ShowString(30,3,"MUSIC_OFF");
  214.             rf_init();
  215.             tx();
  216.             Delay(2000); //延时
  217.           }
  218.           U0CSR |= (1<<6);//0x40允许接收
  219.           RXTXflag = 1;
  220.           datanumber = 0;
  221.         }
  222.      }
  223. }

接受代码

  1. #include "ioCC2530.h"
  2. #include "oled.h"
  3. #include <string.h>
  4. #include "type.h"
  6. #define RX
  8. #define JIEPAI 125 // us
  10. unsigned char buf[128];
  11. unsigned char len = 0;
  12. unsigned char i;
  14. uchar str1[8] = "ready.";
  15. char Recdata[20];
  16. uchar RXTXflag = 1;
  17. uchar temp;
  18. uint datanum = 0;
  19. uint stringlen = 0;
  21. //播放音乐模块
  22. unsigned char yuepu_cnt = 0; //乐谱数组计数
  23. unsigned char k = 0;
  24. unsigned int jiepai_cnt = 0;
  25. unsigned char sszymmh[] = { //乐谱数组  （音符，音高，节拍）
  26.     //   凉凉
  27.     6, 0, 2, 3, 1, 2, 3, 1, 2, 2, 1, 2, 3, 1, 2, 5, 1, 2, 3, 1, 2,
  28.     2, 1, 2, 3, 1, 4, 6, 0, 8, 7, 0, 2, 7, 0, 2, 7, 0, 2, 1, 1, 2,
  29.     7, 0, 4, 3, 0, 2, 5, 0, 2, 6, 0, 2, 5, 0, 10,
  30.     6, 0, 2, 3, 1, 2, 3, 1, 2, 2, 1, 2, 3, 1, 2, 2, 1, 2, 3, 1, 2,
  31.     5, 1, 4, 3, 1, 4, 2, 1, 2, 3, 1, 2, 5, 1, 2, 5, 1, 4, 6, 1, 4,
  32.     6, 1, 4, 5, 1, 4, 5, 1, 2, 6, 1, 10};
  34. unsigned int YINFU[] = { //音符数组
  35.                          //  低音  0
  36.     0X1DD2, 0X1A94, 0X17AD, 0X1663, 0X13EE, 0X11C1, 0X0FD1,
  37.     //中音    1
  38.     0x0EF0, 0X0D4F, 0X0BDB, 0X0B31, 0X09F7, 0X08E1, 0X07E8,
  39.     //高音    2
  40.     0X1912, 0X06A6, 0X05ED, 0X0598, 0X04FC, 0X0470, 0X03F9};
  42. //初始化函数声明
  43. void Init_Sys(void)
  44. {
  46.     CLKCONCMD &= ~0x7f; //晶振设置为32MHZ
  47.     while (CLKCONSTA & 0x40)
  48.         ; //等待晶振稳定
  49.     P1SEL &= ~((1 << 0) | (1 << 1));
  50.     P1DIR |= (1 << 0) | (1 << 1);
  51.     P2SEL &= ~(1 << 0); // P2_0通用I/O
  52.     P2DIR |= (1 << 0);  //输出
  53.     beep = 0;           //初始低电平 不叫
  54.     led1 = 0;
  55.     led2 = 1;
  56. }
  58. void Init_T1(void) //系统工作频率32MHz，定时器1工作频率4MHz(8分频)
  59. {
  60.     T1CCTL0 = (1 << 2) | (1 << 6); //通道0终端使能，比较模式
  61.     T1CTL = (1 << 2) | (2 << 0);   //启动，设8分频，设模模式,1/4Mhz(0.25ms)
  63.     T1IE = 1; //开T1中断
  64. }
  66. void Init_T3(void) //系统工作频率32MHz，定时器3工作频率1MHz(32分频)
  67. {
  68.     T3CC0 = JIEPAI; //定时器3比较模式模为125us
  69.     jiepai_cnt = 0;
  70.     T3CCTL0 = (1 << 2) | (1 << 6);                     //通道0终端使能，比较模式
  71.     T3CTL = (5 << 5) | (1 << 4) | (1 << 2) | (2 << 0); //设32分频，启动定时器，复位T3计数器，设模模式
  73.     T3IE = 1; //开T3中断
  74. }
  76. void delay_jiepai(void)
  77. {
  78.     jiepai_cnt = 0;
  79.     T3CTL |= (1 << 2) | (1 << 4); //复位并启动T3计数器
  80.     T3CC0 = JIEPAI;
  81.     while (jiepai_cnt != (sszymmh[yuepu_cnt + 2] * 1000))
  82.         ;
  83. }
  85. //---------------------------------------------------------------------------------------------------------射频模块-------
  86. /*******************
  87. 初始化系统时钟
  88. *******************/
  89. void InitClock(void)
  90. {
  91.     CLKCONCMD &= ~0x40; //设置系统时钟源为32MHZ晶振
  92.     while (CLKCONSTA & 0x40)
  93.         ;               //等待晶振稳定
  94.     CLKCONCMD &= ~0x47; //设置系统主时钟频率为32MHZ
  95.     SLEEPCMD |= 0x04;   //关闭其它无用频率信号
  96. }
  98. /*******************
  99. 延时
  100. *******************/
  101. void Delay(unsigned int n)
  102. {
  103.     unsigned int tt;
  104.     for (tt = 0; tt < n; tt++)
  105.         ;
  106.     for (tt = 0; tt < n; tt++)
  107.         ;
  108.     for (tt = 0; tt < n; tt++)
  109.         ;
  110.     for (tt = 0; tt < n; tt++)
  111.         ;
  112.     for (tt = 0; tt < n; tt++)
  113.         ;
  114. }
  116. void rf_init()
  117. {
  118.     FRMCTRL0 |= (1 << 5) | (1 << 6); //(0x20 | 0x40);//硬件CRC以及AUTO_ACK使能
  119.     TXFILTCFG = 0x09;                //设置TX抗混叠过滤器以获得合适的带宽
  120.     AGCCTRL1 = 0x15;                 //调整AGC目标值
  121.     FSCAL1 = 0x00;                   //获得最佳的EVM
  122.     RFIRQM0 |= (1 << 6);             // RXPKTDONE 中断位使能
  123.     IEN2 |= (1 << 0);                //  RF 中断使能
  124.     EA = 1;                          //开中断
  125.     FREQCTRL = 0x0a;                 //信道选择，选择11信道
  126.     SHORT_ADDR0 = 0x05;              // 0x0005                  //目标地址过滤期间使用的短地址
  127.     SHORT_ADDR1 = 0x00;
  128.     PAN_ID0 = 0x23; // 0x0022                    //目标地址过滤期间使用的PANID
  129.     PAN_ID1 = 0x00;
  130.     RFST = 0xed;           //清除RXFIFO缓冲区并复位解调器
  131.     RFST = 0xe3;           //为RX使能并校准频率合成器
  132.     FRMFILT0 &= ~(1 << 0); //禁止帧过滤
  133. }
  135. //接收中断处理
  136. #pragma vector = RF_VECTOR
  137. __interrupt void rf_isr(void)
  138. {
  139.     unsigned char i;
  140.     //关中断
  141.     IEN2 &= ~0X01;
  142.     //接收帧结束
  143.     if (RFIRQF0 & (1 << 6))
  144.     {
  145.         len = RFD; //接收帧长度
  146.         len &= 0x7f;
  147.         for (i = 0; i < len; i++) //将接收的数据写入buf中
  148.         {
  149.             buf[i] = RFD;
  150.             Delay(200);
  151.         }
  152.         if (buf[7] == 'N')
  153.         {
  154.             P0DIR |= 0x73;
  155.             OLED_Init(); //初始化OLED
  156.             OLED_Clear();
  157.             OLED_ShowString(30, 1, "RECV_ADDR");
  158.             OLED_ShowString(30, 3, "MUSIC_ON");
  159.             delay_ms(250);
  160.             //放歌
  161.             led1 = 1;
  162.             led2 = 0;
  163.             Init_Sys();
  164.             Init_T1();
  165.             k = sszymmh[yuepu_cnt] - 1 + 7 * sszymmh[yuepu_cnt + 1];
  166.             Init_T3();
  167.             EA = 1; //开总中断
  168.         }
  169.         else if (buf[7] == 'F')
  170.         {
  171.             //停止播放
  172.             beep = 0;
  173.             Delay(2000);
  174.             Delay(2000);
  175.             Delay(2000);
  176.             T1IE = 0;
  177.             T3IE = 0;
  178.             beep = 0;
  179.             jiepai_cnt = 0;
  180.             yuepu_cnt = 0;
  181.             led1 = 1;
  182.             led2 = 1;
  183.             // OLED
  184.             P0DIR |= 0x73;
  185.             OLED_Init(); //初始化OLED
  186.             OLED_Clear();
  187.             OLED_ShowString(30, 1, "RECV_ADDR");
  188.             OLED_ShowString(30, 3, "MUSIC_OFF");
  189.             delay_ms(250);
  190.         }
  192.         S1CON = 0;            // 清RF中断
  193.         RFIRQF0 &= ~(1 << 6); //清 RXPKTDONE中断
  194.                               //设置断点后，程序停止在断点处，但RF仍旧在接收，导致FIFO溢出，无法接收数据，继续运行后再也无法接收。所以要运行一下指令
  195.         RFST = 0xed;          //清除RXFIFO缓冲区并复位解调器
  196.     }
  197.     IEN2 |= (1 << 0);
  198. }
  200. #pragma vector = T1_VECTOR
  201. __interrupt void T1_ISR(void)
  202. {
  204.     if (buf[7] == 'F') //如果是F则
  205.     {
  206.         beep = 0; //初始低电平 不叫
  207.         led1 = 0;
  208.         led2 = 0;
  209.         yuepu_cnt = 0;
  210.         jiepai_cnt = 0;
  211.         T1CC0H = 0; //定时器1 通道0 捕获/比较值高字节
  212.         T1CC0L = 0; //定时器1 通道1 捕获/比较值低字节
  213.     }
  214.     else
  215.     {
  216.         beep = !beep; // 1电平 叫
  217.         T1CC0H = YINFU[k] >> 8;
  218.         T1CC0L = YINFU[k] & 0xFF;
  219.     }
  220. }
  222. #pragma vector = T3_VECTOR
  223. __interrupt void T3_ISR(void)
  224. {
  225.     //   T3CC0 = JIEPAI;
  226.     jiepai_cnt++;
  228.     if (jiepai_cnt >= (sszymmh[yuepu_cnt + 2] * 1000)) //节拍数组 1/4  单位：ms
  229.     {
  230.         jiepai_cnt = 0;
  231.         yuepu_cnt += 3;
  232.         if (yuepu_cnt >= sizeof(sszymmh))
  233.             yuepu_cnt = 0;
  234.         k = sszymmh[yuepu_cnt] - 1 + 7 * sszymmh[yuepu_cnt + 1];
  235.         T1CC0H = YINFU[k] >> 8;
  236.         T1CC0L = YINFU[k] & 0xFF;
  237.         led1 = !led1; //播放一个音符交替闪烁
  238.         led2 = !led2; //
  239.     }
  240. }
  241. int main(void)
  242. {
  243.     EA = 0;
  244.     InitClock(); //初始化系统时钟
  245.     rf_init();
  246.     EA = 1;
  247. }

任务

每组两个同学，使用两个IMOTE CC2530 无线通信节点板（无线发送端/接收端节点）与PC机。具体任务如下：
PC机通过串口通信软件向无线发送端节点的单片机发送字符串”MUSIC_ON”或”MUSIC_OFF”。
无线发送端节点：无线发送端单片机节点接收到PC机发送的字符串后在OLED显示屏上显示字符串内容，同时通过无线RF向无线接收端节点发送字符串数据。
无线发接收端节点：无线发接收端节点接收通过无线RF方式发送的字符数据，在OLED显示屏上显示字符串内容，并播放或停止播放音乐。

OLED

功能引脚 描述
VCC 3.3V/5V电源正
GND 电源地
NC NC
DIN SPI数据输入
CLK SPI时钟输入
CS 片选，低电平有效
RST 复位

GND：电源地
VCC：2.2V~5.5V
SCL（D0）：CLK 时钟（高电平2.2V~5.5V）
SDA(D1)：MOSI 数据（高电平2.2V~5.5V）
RST：复位（高电平2.2V~5.5V）
D/C：数据/命令（高电平2.2V~5.5V）
image.png
image.png