智能车制作

标题: 我用两个51做的无线加上位收发 请教问题 [打印本页]
作者: kxy352283883    时间: 2013-6-21 11:54
标题: 我用两个51做的无线加上位收发 请教问题
本帖最后由 kxy352283883 于 2013-6-21 12:03 编辑

接收端
  1. #include <reg52.h>
  2. #include <intrins.h>

  4. typedef unsigned char uchar;
  5. typedef unsigned char uint;
  6. //****************************************NRF24L01端口定义***************************************
  7. sbit CE   = P2^0;  // Chip Enable pin signal (output)
  8. sbit CSN  = P2^1;  // Slave Select pin, (output to CSN, nRF24L01)
  9. sbit IRQ  = P2^2;  // Interrupt signal, from nRF24L01 (input)
  10. sbit MISO = P2^3;  // Master In, Slave Out pin (input)
  11. sbit MOSI = P2^4;  // Serial Clock pin, (output)
  12. sbit SCK  = P2^5;  // Master Out, Slave In pin (output)
  13. sbit         LEDEN        =P1^7;
  14. //************************************按键***************************************************
  15. sbit        D0=P1^0;
  16. //************************************蜂明器***************************************************
  17. sbit         D1=P1^1;
  18. //*******************************************************************************************
  19. #define TX_ADR_WIDTH    5           // 5 uints TX address width
  20. #define RX_ADR_WIDTH    5           // 5 uints RX address width
  21. #define TX_PLOAD_WIDTH  32             // 20 uints TX payload
  22. #define RX_PLOAD_WIDTH  32          // 20 uints TX payload
  23. uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //本地地址
  24. uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //接收地址
  25. //***************************************NRF24L01寄存器指令*******************************************************
  26. #define READ_REG        0x00          // 读寄存器指令
  27. #define WRITE_REG       0x20         // 写寄存器指令
  28. #define RD_RX_PLOAD     0x61          // 读取接收数据指令
  29. #define WR_TX_PLOAD     0xA0          // 写待发数据指令
  30. #define FLUSH_TX        0xE1         // 冲洗发送 FIFO指令
  31. #define FLUSH_RX        0xE2          // 冲洗接收 FIFO指令
  32. #define REUSE_TX_PL     0xE3          // 定义重复装载数据指令
  33. #define NOP             0xFF          // 保留
  34. //*************************************SPI(nRF24L01)寄存器地址****************************************************
  35. #define CONFIG          0x00  // 配置收发状态，CRC校验模式以及收发状态响应方式
  36. #define EN_AA           0x01  // 自动应答功能设置
  37. #define EN_RXADDR       0x02  // 可用信道设置
  38. #define SETUP_AW        0x03  // 收发地址宽度设置
  39. #define SETUP_RETR      0x04  // 自动重发功能设置
  40. #define RF_CH           0x05  // 工作频率设置
  41. #define RF_SETUP        0x06  // 发射速率、功耗功能设置
  42. #define STATUS          0x07  // 状态寄存器
  43. #define OBSERVE_TX      0x08  // 发送监测功能
  44. #define CD              0x09  // 地址检测           
  45. #define RX_ADDR_P0      0x0A  // 频道0接收数据地址
  46. #define RX_ADDR_P1      0x0B  // 频道1接收数据地址
  47. #define RX_ADDR_P2      0x0C  // 频道2接收数据地址
  48. #define RX_ADDR_P3      0x0D  // 频道3接收数据地址
  49. #define RX_ADDR_P4      0x0E  // 频道4接收数据地址
  50. #define RX_ADDR_P5      0x0F  // 频道5接收数据地址
  51. #define TX_ADDR         0x10  // 发送地址寄存器
  52. #define RX_PW_P0        0x11  // 接收频道0接收数据长度
  53. #define RX_PW_P1        0x12  // 接收频道0接收数据长度
  54. #define RX_PW_P2        0x13  // 接收频道0接收数据长度
  55. #define RX_PW_P3        0x14  // 接收频道0接收数据长度
  56. #define RX_PW_P4        0x15  // 接收频道0接收数据长度
  57. #define RX_PW_P5        0x16  // 接收频道0接收数据长度
  58. #define FIFO_STATUS     0x17  // FIFO栈入栈出状态寄存器设置
  59. //**************************************************************************************
  60. void Delay(unsigned int s);
  61. void inerDelay_us(unsigned char n);
  62. void init_NRF24L01(void);
  63. uint SPI_RW(uint uchar);
  64. uchar SPI_Read(uchar reg);
  65. void SetRX_Mode(void);
  66. uint SPI_RW_Reg(uchar reg, uchar value);
  67. uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars);
  68. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars);
  69. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
  70. void nRF24L01_TxPacket(unsigned char * tx_buf);
  71. //*****************************************长延时*****************************************
  72. void Delay(unsigned int s)
  73. {
  74.         unsigned int i;
  75.         for(i=0; i<s; i++);
  76.         for(i=0; i<s; i++);
  77. }
  78. //******************************************************************************************
  79. uint         bdata sta;   //状态标志
  80. sbit        RX_DR        =sta^6;
  81. sbit        TX_DS        =sta^5;
  82. sbit        MAX_RT        =sta^4;
  83. /******************************************************************************************
  84. /*延时函数
  85. /******************************************************************************************/
  86. void inerDelay_us(unsigned char n)
  87. {
  88.         for(;n>0;n--)
  89.                 _nop_();
  90. }
  91. //****************************************************************************************
  92. /*NRF24L01初始化
  93. //***************************************************************************************/
  94. void init_NRF24L01(void)
  95. {
  96.     inerDelay_us(100);
  97.          CE=0;    // chip enable
  98.          CSN=1;   // Spi disable
  99.          SCK=0;   // Spi clock line init high
  100.         SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // 写本地地址        
  101.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
  102.         SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      //  频道0自动        ACK应答允许        
  103.         SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //  允许接收地址只有频道0，如果需要多频道可以参考Page21  
  104.         SPI_RW_Reg(WRITE_REG + RF_CH, 0);        //   设置信道工作为2.4GHZ，收发必须一致
  105.         SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
  106.         SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);                   //设置发射速率为1MHZ，发射功率为最大值0dB
  107.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);                   // IRQ收发完成中断响应，16位CRC        ，主接收
  108. }
  109. /****************************************************************************************************
  110. /*函数：uint SPI_RW(uint uchar)
  111. /*功能：NRF24L01的SPI写时序
  112. /****************************************************************************************************/
  113. uint SPI_RW(uint uchar)
  114. {
  115.         uint bit_ctr;
  116.            for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
  117.            {
  118.                 MOSI = (uchar & 0x80);         // output 'uchar', MSB to MOSI
  119.                 uchar = (uchar << 1);           // shift next bit into MSB..
  120.                 SCK = 1;                      // Set SCK high..
  121.                 uchar |= MISO;                         // capture current MISO bit
  122.                 SCK = 0;                              // ..then set SCK low again
  123.            }
  124.     return(uchar);                             // return read uchar
  125. }
  126. /****************************************************************************************************
  127. /*函数：uchar SPI_Read(uchar reg)
  128. /*功能：NRF24L01的SPI时序
  129. /****************************************************************************************************/
  130. uchar SPI_Read(uchar reg)
  131. {
  132.         uchar reg_val;
  133.         
  134.         CSN = 0;                // CSN low, initialize SPI communication...
  135.         SPI_RW(reg);            // Select register to read from..
  136.         reg_val = SPI_RW(0);    // ..then read registervalue
  137.         CSN = 1;                // CSN high, terminate SPI communication
  138.         
  139.         return(reg_val);        // return register value
  140. }
  141. /****************************************************************************************************/
  142. /*功能：NRF24L01读写寄存器函数
  143. /****************************************************************************************************/
  144. uint SPI_RW_Reg(uchar reg, uchar value)
  145. {
  146.         uint status;
  147.         
  148.         CSN = 0;                   // CSN low, init SPI transaction
  149.         status = SPI_RW(reg);      // select register
  150.         SPI_RW(value);             // ..and write value to it..
  151.         CSN = 1;                   // CSN high again
  152.         
  153.         return(status);            // return nRF24L01 status uchar
  154. }
  155. /****************************************************************************************************/
  156. /*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  157. /*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数
  158. /****************************************************************************************************/
  159. uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  160. {
  161.         uint status,uchar_ctr;
  162.         
  163.         CSN = 0;                                    // Set CSN low, init SPI tranaction
  164.         status = SPI_RW(reg);                       // Select register to write to and read status uchar
  165.         
  166.         for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
  167.                 pBuf[uchar_ctr] = SPI_RW(0);    //
  168.         
  169.         CSN = 1;                           
  170.         
  171.         return(status);                    // return nRF24L01 status uchar
  172. }
  173. /*********************************************************************************************************
  174. /*函数：uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  175. /*功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数
  176. /*********************************************************************************************************/
  177. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  178. {
  179.         uint status,uchar_ctr;
  180.         
  181.         CSN = 0;            //SPI使能      
  182.         status = SPI_RW(reg);   
  183.         for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
  184.                 SPI_RW(*pBuf++);
  185.         CSN = 1;           //关闭SPI
  186.         return(status);    //
  187. }
  188. /****************************************************************************************************/
  189. /*函数：void SetRX_Mode(void)
  190. /*功能：数据接收配置
  191. /****************************************************************************************************/
  192. void SetRX_Mode(void)
  193. {
  194.         CE=0;
  195. //        SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);                   // IRQ收发完成中断响应，16位CRC        ，主接收
  196.         CE = 1;
  197.         inerDelay_us(130);
  198. }
  199. /******************************************************************************************************/
  200. /*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  201. /*功能：数据读取后放如rx_buf接收缓冲区中
  202. /******************************************************************************************************/
  203. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  204. {
  205.     unsigned char revale=0;
  206.         sta=SPI_Read(STATUS);        // 读取状态寄存其来判断数据接收状况
  207.         if(RX_DR)                                // 判断是否接收到数据
  208.         {
  209.             CE = 0;                         //SPI使能
  210.                 SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
  211.                 revale =1;                        //读取数据完成标志
  212.         }
  213.         SPI_RW_Reg(WRITE_REG+STATUS,sta);   //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
  214.         return revale;
  215. }
  216. /***********************************************************************************************************
  217. /*函数：void nRF24L01_TxPacket(unsigned char * tx_buf)
  218. /*功能：发送 tx_buf中数据
  219. /**********************************************************************************************************/
  220. /*void nRF24L01_TxPacket(unsigned char * tx_buf)
  221. {
  222.         CE=0;                        //StandBy I模式        
  223.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
  224.         SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);                          // 装载数据        
  225.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);                    // IRQ收发完成中断响应，16位CRC，主发送
  226.         CE=1;                 //置高CE，激发数据发送
  227.         inerDelay_us(10);
  228. }          */
  229. //************************************串口初始化*********************************************************
  230. void StartUART( void )
  231. {                                                          //波特率9600
  232.      SCON = 0x50;
  233.      TMOD = 0x20;
  234.      TH1 = 0xFA;
  235.      TL1 = 0xFA;
  236.      PCON = 0x00;
  237.      TR1 = 1;
  238. }
  239. //************************************通过串口将接收到数据发送给PC端**************************************
  240. void Senddat(uchar dat)
  241. {        
  242.          SBUF = dat;  
  243.      while( TI == 0 );                                //查询法
  244.            TI = 0;   
  245. }
  246. //************************************主函数************************************************************
  247. void main(void)
  248. {
  249.         uchar i;
  250.         uchar RxBuf[32]={1,2,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};        
  251.     init_NRF24L01() ;
  252.         StartUART();
  253.         Delay(6000);
  254.         LEDEN=0;
  255.         while(1)
  256.         {
  257.                 D1=~D1;
  258.                 SetRX_Mode();
  259.                    if(nRF24L01_RxPacket(RxBuf))
  260.                 {
  261.                         for(i=0;i<32;i++)
  262.                         {
  263.                                 Senddat(RxBuf[i]);
  264.                                 Delay(600);
  265.                                 D0=~D0;
  266.                         }        
  267.                 }
  268.                 Delay(600);
  269.         }
  270.         
  271. }
复制代码


发送端
  1. #include <reg52.h>
  2. #include <intrins.h>

  4. typedef unsigned char uchar;
  5. typedef unsigned char uint;
  6. //****************************************IO端口定义***************************************
  7. sbit CE   = P2^0;  // Chip Enable pin signal (output)
  8. sbit CSN  = P2^1;  // Slave Select pin, (output to CSN, nRF24L01)
  9. sbit IRQ  = P2^2;  // Interrupt signal, from nRF24L01 (input)
  10. sbit MISO = P2^3;  // Master In, Slave Out pin (input)
  11. sbit MOSI = P2^4;  // Serial Clock pin, (output)
  12. sbit SCK  = P2^5;  // Master Out, Slave In pin (output)
  13. sbit         LEDEN        =P1^7;
  14. //************************************按键***************************************************
  15. sbit        D0=P1^0;
  16. //************************************蜂明器***************************************************
  17. sbit         D1=P1^1;
  18. //***********************************数码管0-9编码*******************************************
  19. uchar seg[10]={0xC0,0xCF,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};         //0~~9段码
  20. uchar TxBuf[32]=
  21. {
  22. 0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
  23. 0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
  24. 0x17,0x18,0x19,0x20,0x21,0x22,0x23,0x24,
  25. 0x25,0x26,0x27,0x28,0x29,0x30,0x31,0x32,
  26. };         //

  28. //*********************************************NRF24L01*************************************
  29. #define TX_ADR_WIDTH    5           // 5 uints TX address width
  30. #define RX_ADR_WIDTH    5           // 5 uints RX address width
  31. #define TX_PLOAD_WIDTH  32          // 20 uints TX payload
  32. #define RX_PLOAD_WIDTH  32          // 20 uints TX payload
  33. uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //本地地址
  34. uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //接收地址
  35. //***************************************NRF24L01寄存器指令*******************************************************
  36. #define READ_REG        0x00          // 读寄存器指令
  37. #define WRITE_REG       0x20         // 写寄存器指令
  38. #define RD_RX_PLOAD     0x61          // 读取接收数据指令
  39. #define WR_TX_PLOAD     0xA0          // 写待发数据指令
  40. #define FLUSH_TX        0xE1         // 冲洗发送 FIFO指令
  41. #define FLUSH_RX        0xE2          // 冲洗接收 FIFO指令
  42. #define REUSE_TX_PL     0xE3          // 定义重复装载数据指令
  43. #define NOP             0xFF          // 保留
  44. //*************************************SPI(nRF24L01)寄存器地址****************************************************
  45. #define CONFIG          0x00  // 配置收发状态，CRC校验模式以及收发状态响应方式
  46. #define EN_AA           0x01  // 自动应答功能设置
  47. #define EN_RXADDR       0x02  // 可用信道设置
  48. #define SETUP_AW        0x03  // 收发地址宽度设置
  49. #define SETUP_RETR      0x04  // 自动重发功能设置
  50. #define RF_CH           0x05  // 工作频率设置
  51. #define RF_SETUP        0x06  // 发射速率、功耗功能设置
  52. #define STATUS          0x07  // 状态寄存器
  53. #define OBSERVE_TX      0x08  // 发送监测功能
  54. #define CD              0x09  // 地址检测           
  55. #define RX_ADDR_P0      0x0A  // 频道0接收数据地址
  56. #define RX_ADDR_P1      0x0B  // 频道1接收数据地址
  57. #define RX_ADDR_P2      0x0C  // 频道2接收数据地址
  58. #define RX_ADDR_P3      0x0D  // 频道3接收数据地址
  59. #define RX_ADDR_P4      0x0E  // 频道4接收数据地址
  60. #define RX_ADDR_P5      0x0F  // 频道5接收数据地址
  61. #define TX_ADDR         0x10  // 发送地址寄存器
  62. #define RX_PW_P0        0x11  // 接收频道0接收数据长度
  63. #define RX_PW_P1        0x12  // 接收频道0接收数据长度
  64. #define RX_PW_P2        0x13  // 接收频道0接收数据长度
  65. #define RX_PW_P3        0x14  // 接收频道0接收数据长度
  66. #define RX_PW_P4        0x15  // 接收频道0接收数据长度
  67. #define RX_PW_P5        0x16  // 接收频道0接收数据长度
  68. #define FIFO_STATUS     0x17  // FIFO栈入栈出状态寄存器设置
  69. //**************************************************************************************
  70. void Delay(unsigned int s);
  71. void inerDelay_us(unsigned char n);
  72. void init_NRF24L01(void);
  73. uint SPI_RW(uint uchar);
  74. uchar SPI_Read(uchar reg);
  75. void SetRX_Mode(void);
  76. uint SPI_RW_Reg(uchar reg, uchar value);
  77. uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars);
  78. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars);
  79. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
  80. void nRF24L01_TxPacket(unsigned char * tx_buf);
  81. //*****************************************长延时*****************************************
  82. void Delay(unsigned int s)
  83. {
  84.         unsigned int i;
  85.         for(i=0; i<s; i++);
  86.         for(i=0; i<s; i++);
  87. }
  88. //******************************************************************************************
  89. uint         bdata sta;   //状态标志
  90. sbit        RX_DR        =sta^6;
  91. sbit        TX_DS        =sta^5;
  92. sbit        MAX_RT        =sta^4;
  93. /******************************************************************************************
  94. /*延时函数
  95. /******************************************************************************************/
  96. void inerDelay_us(unsigned char n)
  97. {
  98.         for(;n>0;n--)
  99.                 _nop_();
  100. }
  101. //****************************************************************************************
  102. /*NRF24L01初始化
  103. //***************************************************************************************/
  104. void init_NRF24L01(void)
  105. {
  106.     inerDelay_us(100);
  107.          CE=0;    // chip enable
  108.          CSN=1;   // Spi disable
  109.          SCK=0;   // Spi clock line init high
  110.         SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // 写本地地址        
  111.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
  112.         SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      //  频道0自动        ACK应答允许        
  113.         SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //  允许接收地址只有频道0，如果需要多频道可以参考Page21  
  114.         SPI_RW_Reg(WRITE_REG + RF_CH, 0);        //   设置信道工作为2.4GHZ，收发必须一致
  115.         SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
  116.         SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);                   //设置发射速率为1MHZ，发射功率为最大值0dB        
  117.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);                    // IRQ收发完成中断响应，16位CRC，主发送

  119. }
  120. /****************************************************************************************************
  121. /*函数：uint SPI_RW(uint uchar)
  122. /*功能：NRF24L01的SPI写时序
  123. /****************************************************************************************************/
  124. uint SPI_RW(uint uchar)
  125. {
  126.         uint bit_ctr;
  127.            for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
  128.            {
  129.                 MOSI = (uchar & 0x80);         // output 'uchar', MSB to MOSI
  130.                 uchar = (uchar << 1);           // shift next bit into MSB..
  131.                 SCK = 1;                      // Set SCK high..
  132.                 uchar |= MISO;                         // capture current MISO bit
  133.                 SCK = 0;                              // ..then set SCK low again
  134.            }
  135.     return(uchar);                             // return read uchar
  136. }
  137. /****************************************************************************************************
  138. /*函数：uchar SPI_Read(uchar reg)
  139. /*功能：NRF24L01的SPI时序
  140. /****************************************************************************************************/
  141. /*uchar SPI_Read(uchar reg)
  142. {
  143.         uchar reg_val;
  144.         
  145.         CSN = 0;                // CSN low, initialize SPI communication...
  146.         SPI_RW(reg);            // Select register to read from..
  147.         reg_val = SPI_RW(0);    // ..then read registervalue
  148.         CSN = 1;                // CSN high, terminate SPI communication
  149.         
  150.         return(reg_val);        // return register value
  151. }
  152. /****************************************************************************************************/
  153. /*功能：NRF24L01读写寄存器函数
  154. /****************************************************************************************************/
  155. uint SPI_RW_Reg(uchar reg, uchar value)
  156. {
  157.         uint status;
  158.         
  159.         CSN = 0;                   // CSN low, init SPI transaction
  160.         status = SPI_RW(reg);      // select register
  161.         SPI_RW(value);             // ..and write value to it..
  162.         CSN = 1;                   // CSN high again
  163.         
  164.         return(status);            // return nRF24L01 status uchar
  165. }
  166. /****************************************************************************************************/
  167. /*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  168. /*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数
  169. /****************************************************************************************************/
  170. /*uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  171. {
  172.         uint status,uchar_ctr;
  173.         
  174.         CSN = 0;                                    // Set CSN low, init SPI tranaction
  175.         status = SPI_RW(reg);                       // Select register to write to and read status uchar
  176.         
  177.         for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
  178.                 pBuf[uchar_ctr] = SPI_RW(0);    //
  179.         
  180.         CSN = 1;                           
  181.         
  182.         return(status);                    // return nRF24L01 status uchar
  183. }
  184. /*********************************************************************************************************
  185. /*函数：uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  186. /*功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数
  187. /*********************************************************************************************************/
  188. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  189. {
  190.         uint status,uchar_ctr;
  191.         
  192.         CSN = 0;            //SPI使能      
  193.         status = SPI_RW(reg);   
  194.         for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
  195.                 SPI_RW(*pBuf++);
  196.         CSN = 1;           //关闭SPI
  197.         return(status);    //
  198. }
  199. /****************************************************************************************************/
  200. /*函数：void SetRX_Mode(void)
  201. /*功能：数据接收配置
  202. /****************************************************************************************************/
  203. /*void SetRX_Mode(void)
  204. {
  205.         CE=0;
  206.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);                   // IRQ收发完成中断响应，16位CRC        ，主接收
  207.         CE = 1;
  208.         inerDelay_us(130);
  209. }
  210. /******************************************************************************************************/
  211. /*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  212. /*功能：数据读取后放如rx_buf接收缓冲区中
  213. /******************************************************************************************************/
  214. /*unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  215. {
  216.     unsigned char revale=0;
  217.         sta=SPI_Read(STATUS);        // 读取状态寄存其来判断数据接收状况
  218.         if(RX_DR)                                // 判断是否接收到数据
  219.         {
  220.             CE = 0;                         //SPI使能
  221.                 SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
  222.                 revale =1;                        //读取数据完成标志
  223.         }
  224.         SPI_RW_Reg(WRITE_REG+STATUS,sta);   //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
  225.         return revale;
  226. }
  227. /***********************************************************************************************************
  228. /*函数：void nRF24L01_TxPacket(unsigned char * tx_buf)
  229. /*功能：发送 tx_buf中数据
  230. /**********************************************************************************************************/
  231. void nRF24L01_TxPacket(unsigned char * tx_buf)
  232. {
  233.         CE=0;                        //StandBy I模式        
  234.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
  235.         SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);                          // 装载数据        
  236. //        SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);                    // IRQ收发完成中断响应，16位CRC，主发送
  237.         CE=1;                 //置高CE，激发数据发送
  238.         inerDelay_us(10);
  239. }
  240. //************************************主函数************************************************************
  241. void main(void)
  242. {
  243.         uchar temp =0;
  244.         LEDEN=0;        
  245.     init_NRF24L01() ;
  246.         nRF24L01_TxPacket(TxBuf);        // Transmit Tx buffer data
  247.         Delay(6000);
  248.         while(1)
  249.         {        
  250.                         if(temp<4)
  251.                 {
  252.                 switch(temp)
  253.                 {
  254.                 case         1:        
  255.                         D0=0;D1=0;
  256.                         break;        
  257.                 case         2:         
  258.                             D0=0;D1=1;
  259.                
  260.                                 break;        
  261.                 case         3:
  262.                         D0=1;D1=0;

  264.                           break;        
  265.                 default:  break;
  266.                 }
  267.                 }
  268.         if(temp==3)
  269.                 {
  270.                 temp=0;
  271.                 D0=1;D1=1;
  272.                 }
  273.                 nRF24L01_TxPacket(TxBuf);        // Transmit Tx buffer data
  274.                 Delay(20000);
  275.                 SPI_RW_Reg(WRITE_REG+STATUS,0XFF);  
  276.                 temp++;
  277.                 }
  278.         
  279. }
复制代码

程序代码如上

问题是接收端时刻有值送入PC（即使发送端没开启也是）  

请教高手帮忙改进 或者参考下你们的程序












/------------------------------------------------------------------------华丽丽的分割线-------------------------------------------------------------------------------------------------------------------/
同时我又发现了一份程序 一套收发程序 但是问题是接收端无论如何都没有数据传入PC
接收端
  1. #include <reg52.h>
  2. #include <intrins.h>

  4. typedef unsigned char uchar;
  5. typedef unsigned int uint;
  6. //****************************************NRF24L01端口定义***************************************
  7. sbit CE   = P2^0;  // Chip Enable pin signal (output)
  8. sbit CSN  = P2^1;  // Slave Select pin, (output to CSN, nRF24L01)
  9. sbit IRQ  = P2^2;  // Interrupt signal, from nRF24L01 (input)
  10. sbit MISO = P2^3;  // Master In, Slave Out pin (input)
  11. sbit MOSI = P2^4;  // Serial Clock pin, (output)
  12. sbit SCK  = P2^5;  // Master Out, Slave In pin (output)
  13. sbit LEDEN= P1^7;
  14. //************************************按键***************************************************
  15. sbit        KEY1=P3^4;
  16. //************************************蜂明器***************************************************
  17. sbit         LED=P1^0;
  18. //*******************************************************************************************
  19. #define TX_ADR_WIDTH    5           // 5 uints TX address width
  20. #define RX_ADR_WIDTH    5           // 5 uints RX address width
  21. #define TX_PLOAD_WIDTH  32         // 20 uints TX payload
  22. #define RX_PLOAD_WIDTH  32          // 20 uints TX payload
  23. uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //本地地址
  24. uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //接收地址
  25. //***************************************NRF24L01寄存器指令*******************************************************
  26. #define READ_REG        0x00          // 读寄存器指令
  27. #define WRITE_REG       0x20         // 写寄存器指令
  28. #define RD_RX_PLOAD     0x61          // 读取接收数据指令
  29. #define WR_TX_PLOAD     0xA0          // 写待发数据指令
  30. #define FLUSH_TX        0xE1         // 冲洗发送 FIFO指令
  31. #define FLUSH_RX        0xE2          // 冲洗接收 FIFO指令
  32. #define REUSE_TX_PL     0xE3          // 定义重复装载数据指令
  33. #define NOP             0xFF          // 保留
  34. //*************************************SPI(nRF24L01)寄存器地址****************************************************
  35. #define CONFIG          0x00  // 配置收发状态，CRC校验模式以及收发状态响应方式
  36. #define EN_AA           0x01  // 自动应答功能设置
  37. #define EN_RXADDR       0x02  // 可用信道设置
  38. #define SETUP_AW        0x03  // 收发地址宽度设置
  39. #define SETUP_RETR      0x04  // 自动重发功能设置
  40. #define RF_CH           0x05  // 工作频率设置
  41. #define RF_SETUP        0x06  // 发射速率、功耗功能设置
  42. #define STATUS          0x07  // 状态寄存器
  43. #define OBSERVE_TX      0x08  // 发送监测功能
  44. #define CD              0x09  // 地址检测           
  45. #define RX_ADDR_P0      0x0A  // 频道0接收数据地址
  46. #define RX_ADDR_P1      0x0B  // 频道1接收数据地址
  47. #define RX_ADDR_P2      0x0C  // 频道2接收数据地址
  48. #define RX_ADDR_P3      0x0D  // 频道3接收数据地址
  49. #define RX_ADDR_P4      0x0E  // 频道4接收数据地址
  50. #define RX_ADDR_P5      0x0F  // 频道5接收数据地址
  51. #define TX_ADDR         0x10  // 发送地址寄存器
  52. #define RX_PW_P0        0x11  // 接收频道0接收数据长度
  53. #define RX_PW_P1        0x12  // 接收频道0接收数据长度
  54. #define RX_PW_P2        0x13  // 接收频道0接收数据长度
  55. #define RX_PW_P3        0x14  // 接收频道0接收数据长度
  56. #define RX_PW_P4        0x15  // 接收频道0接收数据长度
  57. #define RX_PW_P5        0x16  // 接收频道0接收数据长度
  58. #define FIFO_STATUS     0x17  // FIFO栈入栈出状态寄存器设置
  59. //**************************************************************************************
  60. void Delay(unsigned int s);
  61. void inerDelay_us(unsigned char n);
  62. void init_NRF24L01(void);
  63. uint SPI_RW(uint uchar);
  64. uchar SPI_Read(uchar reg);
  65. void SetRX_Mode(void);
  66. uint SPI_RW_Reg(uchar reg, uchar value);
  67. uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars);
  68. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars);
  69. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
  70. void nRF24L01_TxPacket(unsigned char * tx_buf);
  71. //*****************************************长延时*****************************************
  72. void Delay(unsigned int s)
  73. {
  74.         unsigned int i;
  75.         for(i=0; i<s; i++);
  76.         for(i=0; i<s; i++);
  77. }
  78. //******************************************************************************************
  79. uint         bdata sta;   //状态标志
  80. sbit        RX_DR        =sta^6;
  81. sbit        TX_DS        =sta^5;
  82. sbit        MAX_RT        =sta^4;
  83. /******************************************************************************************
  84. /*延时函数
  85. /******************************************************************************************/
  86. void inerDelay_us(unsigned char n)
  87. {
  88.         for(;n>0;n--)
  89.                 _nop_();
  90. }
  91. //****************************************************************************************
  92. /*NRF24L01初始化
  93. //***************************************************************************************/
  94. void init_NRF24L01(void)
  95. {
  96.     inerDelay_us(100);
  97.         CE=0;    // chip enable
  98.         CSN=1;   // Spi disable
  99.         SCK=0;   // Spi clock line init high
  100.         SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // 写本地地址       
  101.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
  102.         SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      //  频道0自动        ACK应答允许       
  103.         SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //  允许接收地址只有频道0，如果需要多频道可以参考Page21  
  104.         SPI_RW_Reg(WRITE_REG + RF_CH, 0);        //   设置信道工作为2.4GHZ，收发必须一致
  105.         SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
  106.         SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);                   //设置发射速率为1MHZ，发射功率为最大值0dB
  107.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);                   // IRQ收发完成中断响应，16位CRC        ，主接收
  108. }
  109. /****************************************************************************************************
  110. /*函数：uint SPI_RW(uint uchar)
  111. /*功能：NRF24L01的SPI写时序
  112. /****************************************************************************************************/
  113. uint SPI_RW(uint uchar)
  114. {
  115.         uint bit_ctr;
  116.            for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
  117.            {
  118.                 MOSI = (uchar & 0x80);         // output 'uchar', MSB to MOSI
  119.                 uchar = (uchar << 1);           // shift next bit into MSB..
  120.                 SCK = 1;                      // Set SCK high..
  121.                 uchar |= MISO;                         // capture current MISO bit
  122.                 SCK = 0;                              // ..then set SCK low again
  123.            }
  124.     return(uchar);                             // return read uchar
  125. }
  126. /****************************************************************************************************
  127. /*函数：uchar SPI_Read(uchar reg)
  128. /*功能：NRF24L01的SPI时序
  129. /****************************************************************************************************/
  130. uchar SPI_Read(uchar reg)
  131. {
  132.         uchar reg_val;
  133.        
  134.         CSN = 0;                // CSN low, initialize SPI communication...
  135.         SPI_RW(reg);            // Select register to read from..
  136.         reg_val = SPI_RW(0);    // ..then read registervalue
  137.         CSN = 1;                // CSN high, terminate SPI communication
  138.        
  139.         return(reg_val);        // return register value
  140. }
  141. /****************************************************************************************************/
  142. /*功能：NRF24L01读写寄存器函数
  143. /****************************************************************************************************/
  144. uint SPI_RW_Reg(uchar reg, uchar value)
  145. {
  146.         uint status;
  147.        
  148.         CSN = 0;                   // CSN low, init SPI transaction
  149.         status = SPI_RW(reg);      // select register
  150.         SPI_RW(value);             // ..and write value to it..
  151.         CSN = 1;                   // CSN high again
  152.        
  153.         return(status);            // return nRF24L01 status uchar
  154. }
  155. /****************************************************************************************************/
  156. /*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  157. /*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数
  158. /****************************************************************************************************/
  159. uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  160. {
  161.         uint status,uchar_ctr;
  162.        
  163.         CSN = 0;                                    // Set CSN low, init SPI tranaction
  164.         status = SPI_RW(reg);                       // Select register to write to and read status uchar
  165.        
  166.         for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
  167.                 pBuf[uchar_ctr] = SPI_RW(0);    //
  168.        
  169.         CSN = 1;                           
  170.        
  171.         return(status);                    // return nRF24L01 status uchar
  172. }
  173. /*********************************************************************************************************
  174. /*函数：uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  175. /*功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数
  176. /*********************************************************************************************************/
  177. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  178. {
  179.         uint status,uchar_ctr;
  180.        
  181.         CSN = 0;            //SPI使能      
  182.         status = SPI_RW(reg);   
  183.         for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
  184.                 SPI_RW(*pBuf++);
  185.         CSN = 1;           //关闭SPI
  186.         return(status);    //
  187. }
  188. /****************************************************************************************************/
  189. /*函数：void SetRX_Mode(void)
  190. /*功能：数据接收配置
  191. /****************************************************************************************************/
  192. void SetRX_Mode(void)
  193. {
  194.         CE=0;
  195. //        SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);                   // IRQ收发完成中断响应，16位CRC        ，主接收
  196.         CE = 1;
  197.         inerDelay_us(130);
  198. }
  199. /******************************************************************************************************/
  200. /*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  201. /*功能：数据读取后放如rx_buf接收缓冲区中
  202. /******************************************************************************************************/
  203. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  204. {
  205.     unsigned char revale=0;
  206.         while(IRQ!=0);
  207.             CE = 0;                         //SPI使能
  208.                 SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
  209.                 revale =1;                        //读取数据完成标志

  211.         SPI_RW_Reg(WRITE_REG+STATUS,0XFF);  
  212.         return revale;
  213. }
  214. /***********************************************************************************************************
  215. /*函数：void nRF24L01_TxPacket(unsigned char * tx_buf)
  216. /*功能：发送 tx_buf中数据
  217. /**********************************************************************************************************/
  218. void nRF24L01_TxPacket(unsigned char * tx_buf)
  219. {
  220.         CE=0;                        //StandBy I模式       
  221.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
  222.         SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);                          // 装载数据       
  223.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);                    // IRQ收发完成中断响应，16位CRC，主发送
  224.         CE=1;                 //置高CE，激发数据发送
  225.         inerDelay_us(10);
  226. }
  227. //************************************串口初始化*********************************************************
  228. void StartUART( void )
  229. {                                                          //波特率4800
  230.      SCON = 0x50;
  231.      TMOD = 0x20;
  232.      TH1 = 0xFA;
  233.      TL1 = 0xFA;
  234.      PCON = 0x00;
  235.      TR1 = 1;
  236. }
  237. //************************************通过串口将接收到数据发送给PC端**************************************
  238. void R_S_Byte(uchar R_Byte)
  239. {       
  240.          SBUF = R_Byte;  
  241.      while( TI == 0 );                                //查询法
  242.            TI = 0;   
  243. }
  244. //************************************主函数************************************************************
  245. void main(void)
  246. {
  247.         uchar i,temp;
  248.         uchar RxBuf[32];       
  249.     init_NRF24L01() ;
  250.         StartUART();
  251.         LEDEN=0;
  252.         Delay(6000);
  253.         while(1)
  254.         {

  256.                 SetRX_Mode();
  257.                    if(nRF24L01_RxPacket(RxBuf))
  258.                 {
  259.                 LED=0;
  260.                         temp++;
  261.                         for(i=0;i<32;i++)
  262.                         {
  263.                                 R_S_Byte(RxBuf[i]);
  264.                                 Delay(600);
  265.                         }       
  266.                 }
  267.                 LED=1;
  268.                 Delay(600);
  269.         }
  270.        
  271. }
复制代码


发送端
  1. #include <reg52.h>
  2. #include <intrins.h>

  4. typedef unsigned char uchar;
  5. typedef unsigned int uint;
  6. //****************************************NRF24L01端口定义***************************************
  7. sbit CE   = P2^0;  // Chip Enable pin signal (output)
  8. sbit CSN  = P2^1;  // Slave Select pin, (output to CSN, nRF24L01)
  9. sbit IRQ  = P2^2;  // Interrupt signal, from nRF24L01 (input)
  10. sbit MISO = P2^3;  // Master In, Slave Out pin (input)
  11. sbit MOSI = P2^4;  // Serial Clock pin, (output)
  12. sbit SCK  = P2^5;  // Master Out, Slave In pin (output)
  13. //************************************按键***************************************************
  14. sbit        KEY1=P3^4;
  15. //************************************蜂明器***************************************************
  16. sbit         LED=P1^0;
  17. //***********************************发送缓冲区*********************************************
  18. uchar TxBuf[32]=
  19. {
  20. 0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
  21. 0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
  22. 0x17,0x18,0x19,0x20,0x21,0x22,0x23,0x24,
  23. 0x25,0x26,0x27,0x28,0x29,0x30,0x31,0x32,
  24. };         //
  25. //*********************************************NRF24L01*************************************
  26. #define TX_ADR_WIDTH    5           // 5 uints TX address width
  27. #define RX_ADR_WIDTH    5           // 5 uints RX address width
  28. #define TX_PLOAD_WIDTH  32          // 20 uints TX payload
  29. #define RX_PLOAD_WIDTH  32          // 20 uints TX payload
  30. uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //本地地址
  31. uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //接收地址
  32. //***************************************NRF24L01寄存器指令*******************************************************
  33. #define READ_REG        0x00          // 读寄存器指令
  34. #define WRITE_REG       0x20         // 写寄存器指令
  35. #define RD_RX_PLOAD     0x61          // 读取接收数据指令
  36. #define WR_TX_PLOAD     0xA0          // 写待发数据指令
  37. #define FLUSH_TX        0xE1         // 冲洗发送 FIFO指令
  38. #define FLUSH_RX        0xE2          // 冲洗接收 FIFO指令
  39. #define REUSE_TX_PL     0xE3          // 定义重复装载数据指令
  40. #define NOP             0xFF          // 保留
  41. //*************************************SPI(nRF24L01)寄存器地址****************************************************
  42. #define CONFIG          0x00  // 配置收发状态，CRC校验模式以及收发状态响应方式
  43. #define EN_AA           0x01  // 自动应答功能设置
  44. #define EN_RXADDR       0x02  // 可用信道设置
  45. #define SETUP_AW        0x03  // 收发地址宽度设置
  46. #define SETUP_RETR      0x04  // 自动重发功能设置
  47. #define RF_CH           0x05  // 工作频率设置
  48. #define RF_SETUP        0x06  // 发射速率、功耗功能设置
  49. #define STATUS          0x07  // 状态寄存器
  50. #define OBSERVE_TX      0x08  // 发送监测功能
  51. #define CD              0x09  // 地址检测           
  52. #define RX_ADDR_P0      0x0A  // 频道0接收数据地址
  53. #define RX_ADDR_P1      0x0B  // 频道1接收数据地址
  54. #define RX_ADDR_P2      0x0C  // 频道2接收数据地址
  55. #define RX_ADDR_P3      0x0D  // 频道3接收数据地址
  56. #define RX_ADDR_P4      0x0E  // 频道4接收数据地址
  57. #define RX_ADDR_P5      0x0F  // 频道5接收数据地址
  58. #define TX_ADDR         0x10  // 发送地址寄存器
  59. #define RX_PW_P0        0x11  // 接收频道0接收数据长度
  60. #define RX_PW_P1        0x12  // 接收频道0接收数据长度
  61. #define RX_PW_P2        0x13  // 接收频道0接收数据长度
  62. #define RX_PW_P3        0x14  // 接收频道0接收数据长度
  63. #define RX_PW_P4        0x15  // 接收频道0接收数据长度
  64. #define RX_PW_P5        0x16  // 接收频道0接收数据长度
  65. #define FIFO_STATUS     0x17  // FIFO栈入栈出状态寄存器设置
  66. //**************************************************************************************
  67. void Delay(unsigned int s);
  68. void inerDelay_us(unsigned char n);
  69. void init_NRF24L01(void);
  70. uint SPI_RW(uint uchar);
  71. uchar SPI_Read(uchar reg);
  72. void SetRX_Mode(void);
  73. uint SPI_RW_Reg(uchar reg, uchar value);
  74. uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars);
  75. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars);
  76. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
  77. void nRF24L01_TxPacket(unsigned char * tx_buf);
  78. //*****************************************长延时*****************************************
  79. void Delay(unsigned int s)
  80. {
  81.         unsigned int i;
  82.         for(i=0; i<s; i++);
  83.         for(i=0; i<s; i++);
  84. }
  85. //******************************************************************************************
  86. uint         bdata sta;   //状态标志
  87. sbit        RX_DR        =sta^6;
  88. sbit        TX_DS        =sta^5;
  89. sbit        MAX_RT        =sta^4;
  90. /******************************************************************************************
  91. /*延时函数
  92. /******************************************************************************************/
  93. void inerDelay_us(unsigned char n)
  94. {
  95.         for(;n>0;n--)
  96.                 _nop_();
  97. }
  98. //****************************************************************************************
  99. /*NRF24L01初始化
  100. //***************************************************************************************/
  101. void init_NRF24L01(void)
  102. {
  103.     inerDelay_us(100);
  104.         CE=0;    // chip enable
  105.         CSN=1;   // Spi disable
  106.         SCK=0;   // Spi clock line init high
  107.         SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // 写本地地址       
  108.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
  109.         SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      //  频道0自动        ACK应答允许       
  110.         SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //  允许接收地址只有频道0，如果需要多频道可以参考Page21  
  111.         SPI_RW_Reg(WRITE_REG + RF_CH, 0);        //   设置信道工作为2.4GHZ，收发必须一致
  112.         SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
  113.         SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);                   //设置发射速率为1MHZ，发射功率为最大值0dB       
  114.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);                    // IRQ收发完成中断响应，16位CRC，主发送

  116. }
  117. /****************************************************************************************************
  118. /*函数：uint SPI_RW(uint uchar)
  119. /*功能：NRF24L01的SPI写时序
  120. /****************************************************************************************************/
  121. uint SPI_RW(uint uchar)
  122. {
  123.         uint bit_ctr;
  124.            for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
  125.            {
  126.                 MOSI = (uchar & 0x80);         // output 'uchar', MSB to MOSI
  127.                 uchar = (uchar << 1);           // shift next bit into MSB..
  128.                 SCK = 1;                      // Set SCK high..
  129.                 uchar |= MISO;                         // capture current MISO bit
  130.                 SCK = 0;                              // ..then set SCK low again
  131.            }
  132.     return(uchar);                             // return read uchar
  133. }
  134. /****************************************************************************************************
  135. /*函数：uchar SPI_Read(uchar reg)
  136. /*功能：NRF24L01的SPI时序
  137. /****************************************************************************************************/
  138. uchar SPI_Read(uchar reg)
  139. {
  140.         uchar reg_val;
  141.        
  142.         CSN = 0;                // CSN low, initialize SPI communication...
  143.         SPI_RW(reg);            // Select register to read from..
  144.         reg_val = SPI_RW(0);    // ..then read registervalue
  145.         CSN = 1;                // CSN high, terminate SPI communication
  146.        
  147.         return(reg_val);        // return register value
  148. }
  149. /****************************************************************************************************/
  150. /*功能：NRF24L01读写寄存器函数
  151. /****************************************************************************************************/
  152. uint SPI_RW_Reg(uchar reg, uchar value)
  153. {
  154.         uint status;
  155.        
  156.         CSN = 0;                   // CSN low, init SPI transaction
  157.         status = SPI_RW(reg);      // select register
  158.         SPI_RW(value);             // ..and write value to it..
  159.         CSN = 1;                   // CSN high again
  160.        
  161.         return(status);            // return nRF24L01 status uchar
  162. }
  163. /****************************************************************************************************/
  164. /*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  165. /*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数
  166. /****************************************************************************************************/
  167. uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
  168. {
  169.         uint status,uchar_ctr;
  170.        
  171.         CSN = 0;                                    // Set CSN low, init SPI tranaction
  172.         status = SPI_RW(reg);                       // Select register to write to and read status uchar
  173.        
  174.         for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
  175.                 pBuf[uchar_ctr] = SPI_RW(0);    //
  176.        
  177.         CSN = 1;                           
  178.        
  179.         return(status);                    // return nRF24L01 status uchar
  180. }
  181. /*********************************************************************************************************
  182. /*函数：uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  183. /*功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数
  184. /*********************************************************************************************************/
  185. uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
  186. {
  187.         uint status,uchar_ctr;
  188.        
  189.         CSN = 0;            //SPI使能      
  190.         status = SPI_RW(reg);   
  191.         for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
  192.                 SPI_RW(*pBuf++);
  193.         CSN = 1;           //关闭SPI
  194.         return(status);    //
  195. }
  196. /****************************************************************************************************/
  197. /*函数：void SetRX_Mode(void)
  198. /*功能：数据接收配置
  199. /****************************************************************************************************/
  200. void SetRX_Mode(void)
  201. {
  202.         CE=0;
  203.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);                   // IRQ收发完成中断响应，16位CRC        ，主接收
  204.         CE = 1;
  205.         inerDelay_us(130);    //延时不能太短
  206. }
  207. /******************************************************************************************************/
  208. /*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  209. /*功能：数据读取后放如rx_buf接收缓冲区中
  210. /******************************************************************************************************/
  211. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
  212. {
  213.     unsigned char revale=0;
  214.         sta=SPI_Read(STATUS);        // 读取状态寄存其来判断数据接收状况
  215.         if(RX_DR)                                // 判断是否接收到数据
  216.         {
  217.             CE = 0;                         //SPI使能
  218.                 SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
  219.                 revale =1;                        //读取数据完成标志
  220.         }
  221.         SPI_RW_Reg(WRITE_REG+STATUS,sta);   //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
  222.         return revale;
  223. }
  224. /***********************************************************************************************************
  225. /*函数：void nRF24L01_TxPacket(unsigned char * tx_buf)
  226. /*功能：发送 tx_buf中数据
  227. /**********************************************************************************************************/
  228. void nRF24L01_TxPacket(unsigned char * tx_buf)
  229. {
  230.         CE=0;                        //StandBy I模式       
  231.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
  232.         SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);                          // 装载数据       
  233. //        SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);                    // IRQ收发完成中断响应，16位CRC，主发送
  234.         CE=1;                 //置高CE，激发数据发送
  235.         inerDelay_us(10);
  236. }
  237. //************************************主函数************************************************************
  238. void main(void)
  239. {
  240.         uchar temp =0;       
  241.     init_NRF24L01() ;
  242.         nRF24L01_TxPacket(TxBuf);        // Transmit Tx buffer data
  243.         Delay(6000);
  244. //        P0=0xBF;
  245.         while(1)
  246.         {       
  247.                 nRF24L01_TxPacket(TxBuf);        // Transmit Tx buffer data
  248.                 LED=0;
  249.                 Delay(10000);      //可变
  250.                 SPI_RW_Reg(WRITE_REG+STATUS,0XFF);  
  251.                 LED=1;
  252.                 Delay(8000);
  253.                 }
  254.        
  255. }
复制代码

第二套程序的问题就是  接收端无论如何都无数据传入PC  好蛋疼的说
求高手答疑。
http://hot.cdn.baidupcs.com/file/4e1d5f2988a935ef470a914a74c5a8d5?xcode=c08c060019747664cd2dc0923b911c78&fid=624244047-250528-2105781270&time=1371787258&sign=FDTAXER-DCb740ccc5511e5e8fedcff06b081203-J7GqNsNWrlpSDaYs52hUn2Xur%2FY%3D&to=hc&fm=N,B,U&expires=8h&rt=sh&r=557318659&logid=1027287380&sh=1


补充内容 (2013-6-21 22:49):
咋审核这么久



欢迎光临 智能车制作 (http://111.231.132.190/) Powered by Discuz! X3.2