设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 基于两个nrf24l01之间通信
返回列表 发新帖
查看: 1188|回复: 1
打印 上一主题 下一主题
收起左侧

基于两个nrf24l01之间通信

[复制链接]
跳转到指定楼层
楼主
ID:741924 发表于 2020-5-1 21:45 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. 发射
  2. #include "reg52.h"
  3. #include "string.h"

  5. // 宏定义
  6. #define     uchar       unsigned char
  7. #define     uint        unsigned int

  9. #define     TX_ADR_WIDTH    5  // 5字节宽度的发送/接收地址
  10. #define     TX_PLOAD_WIDTH  4  // 数据通道有效数据宽度

  12. // LED灯及按键位定义
  13. sbit LED = P2^0;
  14. sbit KEY1 = P3^1;
  15. sbit KEY2 = P3^2;
  16. sbit BEEP = P1^5;

  18. uchar code TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};  // 定义一个静态发送地址

  20. uchar RX_BUF[TX_PLOAD_WIDTH];
  21. uchar TX_BUF[TX_PLOAD_WIDTH];
  22. uchar flag;
  23. uchar DATA = 0x01;
  24. uchar bdata sta;
  25. sbit  RX_DR     = sta^6;
  26. sbit  TX_DS     = sta^5;
  27. sbit  MAX_RT    = sta^4;

  29. // NRF24L01 模块引脚位定义
  30. sbit CE  =  P1^2;
  31. sbit CSN =  P1^3;
  32. sbit SCK =  P1^7;
  33. sbit MOSI= P1^1;
  34. sbit MISO= P1^6;
  35. sbit IRQ = P1^4;



  39. /********************** 下面的指令设置 和 寄存器地址设置     ***********************
  40. * ******************* 参考深圳市云佳科技有限公司给的PDF文档 ***********************
  41. * *******************           NRF24L01模块说明书        ***********************
  42. */
  43. /*  
  44.     SPI(nRF24L01) 指令设置
  45.     指令格式
  46.     <命令字  : 由高位到低位(每字节)>
  47.     <数据字节: 低字节到高字节，每一字节高位在前>
  48. */
  49. #define READ_REG    0x00  // Define read command to register
  50. #define WRITE_REG   0x20  // Define write command to register
  51. #define RD_RX_PLOAD 0x61  // Define RX payload register address
  52. #define WR_TX_PLOAD 0xA0  // Define TX payload register address
  53. #define FLUSH_TX    0xE1  // 清除 TX FIFO寄存器  应用于发射模式下
  54. #define FLUSH_RX    0xE2  // 清除 RX FIFO寄存器  应用于接收模式下。
  55. #define REUSE_TX_PL 0xE3  // 重新使用上一包有效数据。 当CE=1，数据包被不断重新发射 发射过程中必须禁止数据包重利用功能
  56. #define NOP         0xFF  // 空操作。可以用来读状态寄存器

  58. /*  
  59.     SPI(nRF24L01) registers(addresses)
  60.     一下寄存器都是默认只使用 数据通道0 不开启其他通道
  61. */
  62. #define CONFIG      0x00  // 'Config' register address
  63. #define EN_AA       0x01  // 'Enable Auto Acknowledgment' register address
  64. #define EN_RXADDR   0x02  // 'Enabled RX addresses' register address
  65. #define SETUP_AW    0x03  // 'Setup address width' register address
  66. #define SETUP_RETR  0x04  // 'Setup Auto. Retrans' register address
  67. #define RF_CH       0x05  // 'RF channel' register address
  68. #define RF_SETUP    0x06  // 'RF setup' register address
  69. #define STATUS      0x07  // 'Status' register address
  70. #define OBSERVE_TX  0x08  // 'Observe TX' register address
  71. #define CD          0x09  // 'Carrier Detect' register address
  72. #define RX_ADDR_P0  0x0A  // 'RX address pipe0' register address
  73. #define RX_ADDR_P1  0x0B  // 'RX address pipe1' register address
  74. #define RX_ADDR_P2  0x0C  // 'RX address pipe2' register address
  75. #define RX_ADDR_P3  0x0D  // 'RX address pipe3' register address
  76. #define RX_ADDR_P4  0x0E  // 'RX address pipe4' register address
  77. #define RX_ADDR_P5  0x0F  // 'RX address pipe5' register address
  78. #define TX_ADDR     0x10  // 'TX address' register address
  79. #define RX_PW_P0    0x11  // 'RX payload width, pipe0' register address
  80. #define RX_PW_P1    0x12  // 'RX payload width, pipe1' register address
  81. #define RX_PW_P2    0x13  // 'RX payload width, pipe2' register address
  82. #define RX_PW_P3    0x14  // 'RX payload width, pipe3' register address
  83. #define RX_PW_P4    0x15  // 'RX payload width, pipe4' register address
  84. #define RX_PW_P5    0x16  // 'RX payload width, pipe5' register address
  85. #define FIFO_STATUS 0x17  // 'FIFO Status Register' register address

  87. // 毫秒级延时
  88. void delay_ms(uint z)
  89. {
  90.         uint x, y;
  91.         for (x = z; x > 0; x--)
  92.                 for (y = 123; y > 0; y--);

  94. }


  97. // led闪烁
  98. void blink(char i)
  99. {
  100.     while(i--)
  101.     {
  102.         LED = 1;
  103.         delay_ms(500);
  104.         LED = 0;
  105.         delay_ms(500);
  106.     }

  108. }

  110. // 初始化IO
  111. void init_io(void)
  112. {
  113.     CE  = 0;        // 待机
  114.     CSN = 1;        // SPI禁止
  115.     SCK = 0;        // SPI时钟置低
  116.     IRQ = 1;        // 中断复位
  117.     LED = 1;        // 关闭指示灯
  118. }


  121. /*******************************************************************
  122. @func                : SPI_RW(uchar byte)
  123. @brief                : 写一个字节到24L01 同时读出一个字节
  124. @pram                : byte : 要写入24l01的字节
  125. @retval        : 返回读取的字节
  126. *******************************************************************/
  127. uchar SPI_RW(uchar byte)
  128. {
  129.     uchar   bit_ctr;
  130.     // output 8-bits
  131.     for (bit_ctr = 0; bit_ctr < 8; bit_ctr++)
  132.     {
  133.         MOSI = (byte & 0x80);   // output ‘byte’  MSB to MOSI
  134.         byte = (byte << 1);     // shift next bit into MSB..
  135.         SCK = 1;                // Set SCK high.. 24L01 read 1-bit from MOSI and output 1-bit to MISO
  136.         byte |= MISO;           // capture current MISO bit
  137.         SCK = 0;                // ..then set SCK low again
  138.     }

  140.     return (byte);  // return read byte
  141. }


  144. /*******************************************************************
  145. @func                : SPI_RW_Reg(BYTE reg, BYTE value)
  146. @brief                : 向寄存器reg写一个字节，同时返回状态字节
  147. @pram                : reg  : 要写数据的寄存器地址
  148.               value: 要写入寄存器的数据
  149. @retval        : 返回状态寄存器
  150. @NOTE                : 其他提示
  151. *******************************************************************/
  152. uchar SPI_RW_Reg(uchar reg, uchar value)
  153. {
  154.     uchar status;
  155.     CSN = 0;                // CSN low, init SPI transaction， start transmitting data
  156.     status = SPI_RW(reg);   // select register and return status byte
  157.     SPI_RW(value);          // ..and write value to it..
  158.     CSN = 1;                // CSN high again, transmission end
  159.     return(status);         // return nRF24L01 status byte
  160. }


  163. /*******************************************************************
  164. @func                : SPI_Read(uchar reg)
  165. @brief                : 从reg寄存器读一字节
  166. @pram                : reg  : 要读取数据的寄存器地址
  167. @retval        : 返回寄存器数据
  168. *******************************************************************/
  169. uchar SPI_Read(uchar reg)
  170. {
  171.         uchar reg_val;
  172.     CSN = 0;
  173.         SPI_RW(reg);
  174.         reg_val = SPI_RW(0);  
  175.         CSN = 1;            
  176.         return(reg_val);  
  177. }


  180. /*******************************************************************
  181. @func                : SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes)
  182. @brief                : 从reg寄存器读 bytes 个字节  通常用来读取接收通道
  183. @pram                : reg  : 要从中读取数据的寄存器
  184.               pBuf : 存储读取的数据
  185.               bytes: 读取的字节数
  186. @retval        : 返回状态寄存器
  187. @NOTE                : 其他提示
  188. *******************************************************************/
  189. uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes)
  190. {
  191.     uchar status,byte_ctr;
  192.     CSN = 0;                    // Set CSN low, init SPI tranaction
  193.     status = SPI_RW(reg);       // Select register to read & return status byte
  194.    
  195.     for (byte_ctr = 0; byte_ctr < bytes; byte_ctr++)
  196.         pBuf[byte_ctr] = SPI_RW(0); //逐个字节从nRF24L01读出
  197.     CSN = 1;                    // set CSN high, stop transaction
  198.     return(status);             // return nRF24L01 status byte
  199. }


  202. /*******************************************************************
  203. @func                : SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)
  204. @brief                : 往reg寄存器写入 bytes 个字节  通常用来写入发射通道或接收/发送地址
  205. @pram                : reg  : 要写入数据的寄存器
  206.               pBuf : 要写入的的数据
  207.               bytes: 写入的字节数
  208. @retval        : 返回状态寄存器
  209. @NOTE                : 其他提示
  210. *******************************************************************/
  211. uchar SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)
  212. {
  213.     uchar status,byte_ctr;
  214.     CSN = 0;                // Set CSN low, init SPI tranaction
  215.     status = SPI_RW(reg);   // Select register to write to & return status byte
  216.    
  217.     for (byte_ctr = 0; byte_ctr < bytes; byte_ctr++)
  218.         SPI_RW(*pBuf++);    // 逐个字节写入nRF24L01
  219.     CSN = 1;                // Set CSN high again 结束数据传输
  220.     return(status);         // 返回状态寄存器
  221. }


  224. /*******************************************************************
  225. @func                : RX_Mode(void)
  226. @brief                : 这个函数设置nRF24L01为接收模式，等待接收发送设备的数据包
  227. @pram                : None
  228. @retval        : None
  229. *******************************************************************/
  230. void RX_Mode(void)
  231. {
  232.     CE = 0;
  233.     SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);
  234.     SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);  
  235.     SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);
  236.     SPI_RW_Reg(WRITE_REG + RF_CH, 40);  
  237.     SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH);
  238.     SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);
  239.     SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);
  240.     delay_ms(150);
  241.     CE = 1;               
  242. }


  245. /*******************************************************************
  246. @func                : TX_Mode(uchar * BUF)
  247. @brief                : 这个函数设置nRF24L01为发送模式，（CE=1持续至少10us），
  248.               130us后启动发射，数据发送结束后，发送模块自动转入接收
  249.               模式等待应答信号
  250. @pram                : BUF : 要发送的数据
  251. @retval        : None
  252. *******************************************************************/
  253. void TX_Mode(uchar *BUF)
  254. {
  255.     CE = 0;
  256.     SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);
  257.     SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);
  258.     SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);
  259.     SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);  
  260.     SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);
  261.     SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);
  262.     SPI_RW_Reg(WRITE_REG + RF_CH, 40);  
  263.     SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);
  264.     SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);
  265.     delay_ms(150);
  266.     CE = 1;
  267. }



  271. /*******************************************************************
  272. @func                : Check_ACK(bit clear)
  273. @brief                : 检查接收设备有无接收到数据包，设定没有收到应答信号是否重发
  274. @pram                : clear : 判断是否清楚标志位
  275. @retval        : 返回0x00 或 0xff
  276. *******************************************************************/
  277. uchar Check_ACK(bit clear)
  278. {
  279.     delay_ms(200);
  280.     while(IRQ);             // 等待数据接收完成
  281.     sta = SPI_RW(NOP);      // 返回状态寄存器
  282.     if(TX_DS)
  283.     {
  284.         blink(3);
  285.     }
  286.     //blink(5);
  287.     if(MAX_RT)
  288.         if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
  289.             SPI_RW(FLUSH_TX);
  290.     SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  291.     IRQ = 1;
  292.     if(TX_DS)
  293.         return(0x00);
  294.     else
  295.         return(0xff);
  296. }


  299. // 按键扫描
  300. void CheckButtons()
  301. {
  302.     if(KEY1 == 0)
  303.     {
  304.         delay_ms(10);
  305.         if(KEY1 == 0)
  306.         {
  307.                         while(!KEY1);
  308.             TX_BUF[0] = 1;          // 数据送到缓存
  309.             TX_Mode(TX_BUF);        // 把nRF24L01设置为发送模式并发送数据
  310.             Check_ACK(0);           // 等待发送完毕，清除TX FIFO
  311.             delay_ms(250);
  312.             delay_ms(250);
  313.         }
  314.     }

  316.     if(KEY2 == 0)
  317.     {
  318.         delay_ms(10);
  319.         if(KEY2 == 0)
  320.         {
  321.                         while(!KEY2);
  322.             TX_BUF[0] = 2;          // 数据送到缓存
  323.             TX_Mode(TX_BUF);            // 把nRF24L01设置为发送模式并发送数据
  324.             Check_ACK(0);               // 等待发送完毕，清除TX FIFO
  325.             delay_ms(250);
  326.             delay_ms(250);
  327.         }
  328.     }
  329. }



  333. void main(void)
  334. {
  335.     init_io();                      // 初始化IO
  336.     while(1)
  337.     {
  338.         CheckButtons();           // 按键扫描
  339.     }
  340. }
复制代码
  1. <div>接收</div><div>#include "reg52.h"
  2. </div>#include "string.h"


  5. // 宏定义
  6. #define     uchar       unsigned char
  7. #define     uint        unsigned int
  8. #define     ulong        unsigned long

  10. #define     TX_ADR_WIDTH    5  // 5字节宽度的发送/接收地址
  11. #define     TX_PLOAD_WIDTH  4  // 数据通道有效数据宽度

  13. // LED灯及按键位定义
  14. sbit LED = P2^0;
  15. sbit KEY1 = P3^1;
  16. sbit KEY2 = P3^2;
  17. sbit BEEP = P1^5;

  19. uchar code TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};  // 定义一个静态发送地址

  21. uchar RX_BUF[TX_PLOAD_WIDTH];
  22. uchar TX_BUF[TX_PLOAD_WIDTH];
  23. uchar flag;
  24. uchar DATA = 0x01;
  25. uchar bdata sta;// 状态寄存器
  26. sbit  RX_DR     = sta^6;
  27. sbit  TX_DS     = sta^5;
  28. sbit  MAX_RT         = sta^4;

  30. // NRF24L01 模块引脚位定义
  31. sbit CE   =  P1^2;
  32. sbit CSN  =  P1^3;
  33. sbit SCK  =  P1^7;
  34. sbit MOSI =  P1^1;
  35. sbit MISO =  P1^6;
  36. sbit IRQ  =  P1^4;


  39. /*  
  40.     SPI(nRF24L01) 指令设置
  41.     指令格式
  42.     <命令字  : 由高位到低位(每字节)>
  43.     <数据字节: 低字节到高字节，每一字节高位在前>
  44. */
  45. #define READ_REG    0x00  // Define read command to register
  46. #define WRITE_REG   0x20  // Define write command to register
  47. #define RD_RX_PLOAD 0x61  // Define RX payload register address
  48. #define WR_TX_PLOAD 0xA0  // Define TX payload register address
  49. #define FLUSH_TX    0xE1  // 清除 TX FIFO寄存器  应用于发射模式下
  50. #define FLUSH_RX    0xE2  // 清除 RX FIFO寄存器  应用于接收模式下。
  51. #define REUSE_TX_PL 0xE3  // 重新使用上一包有效数据。 当CE=1，数据包被不断重新发射 发射过程中必须禁止数据包重利用功能
  52. #define NOP         0xFF  // 空操作。可以用来读状态寄存器

  54. /*  
  55.     SPI(nRF24L01) registers(addresses)
  56.     一下寄存器都是默认只使用 数据通道0 不开启其他通道
  57. */
  58. #define CONFIG      0x00  // 'Config' register address
  59. #define EN_AA       0x01  // 'Enable Auto Acknowledgment' register address
  60. #define EN_RXADDR   0x02  // 'Enabled RX addresses' register address
  61. #define SETUP_AW    0x03  // 'Setup address width' register address
  62. #define SETUP_RETR  0x04  // 'Setup Auto. Retrans' register address
  63. #define RF_CH       0x05  // 'RF channel' register address
  64. #define RF_SETUP    0x06  // 'RF setup' register address
  65. #define STATUS      0x07  // 'Status' register address
  66. #define OBSERVE_TX  0x08  // 'Observe TX' register address
  67. #define CD          0x09  // 'Carrier Detect' register address
  68. #define RX_ADDR_P0  0x0A  // 'RX address pipe0' register address
  69. #define RX_ADDR_P1  0x0B  // 'RX address pipe1' register address
  70. #define RX_ADDR_P2  0x0C  // 'RX address pipe2' register address
  71. #define RX_ADDR_P3  0x0D  // 'RX address pipe3' register address
  72. #define RX_ADDR_P4  0x0E  // 'RX address pipe4' register address
  73. #define RX_ADDR_P5  0x0F  // 'RX address pipe5' register address
  74. #define TX_ADDR     0x10  // 'TX address' register address
  75. #define RX_PW_P0    0x11  // 'RX payload width, pipe0' register address
  76. #define RX_PW_P1    0x12  // 'RX payload width, pipe1' register address
  77. #define RX_PW_P2    0x13  // 'RX payload width, pipe2' register address
  78. #define RX_PW_P3    0x14  // 'RX payload width, pipe3' register address
  79. #define RX_PW_P4    0x15  // 'RX payload width, pipe4' register address
  80. #define RX_PW_P5    0x16  // 'RX payload width, pipe5' register address
  81. #define FIFO_STATUS 0x17  // 'FIFO Status Register' register address



  85. // 毫秒级延时
  86. void delay_ms(uint z)
  87. {
  88.         uint x,y;
  89.         for(x=z;x>0;x--)
  90.                 for(y=123;y>0;y--);
  91. }

  93. // led闪烁
  94. void blink(char i)
  95. {
  96.     while(i--)
  97.     {
  98.         LED = 1;
  99.         delay_ms(500);
  100.         LED = 0;
  101.         delay_ms(500);
  102.     }
  103. }


  106. // 初始化IO
  107. void init_io(void)
  108. {
  109.     CE  = 0;        // 待机
  110.     CSN = 1;        // SPI禁止
  111.     SCK = 0;        // SPI时钟置低
  112.     IRQ = 1;        // 中断复位
  113.     LED = 1;        // 关闭指示灯
  114. }


  117. /*******************************************************************
  118. @func                : SPI_RW(uchar byte)
  119. @brief                : 写一个字节到24L01 同时读出一个字节
  120. @pram                : byte : 要写入24l01的字节
  121. @retval        : 返回读取的字节
  122. @NOTE                : 其他提示
  123. *******************************************************************/
  124. uchar SPI_RW(uchar byte)
  125. {
  126.     uchar   bit_ctr;
  127.     // output 8-bits
  128.     for (bit_ctr = 0; bit_ctr < 8; bit_ctr++)
  129.     {
  130.         MOSI = (byte & 0x80);   // output ‘byte’  MSB to MOSI
  131.         byte = (byte << 1);     // shift next bit into MSB..
  132.         SCK = 1;                // Set SCK high.. 24L01 read 1-bit from MOSI and output 1-bit to MISO
  133.         byte |= MISO;           // capture current MISO bit
  134.         SCK = 0;                // ..then set SCK low again
  135.     }

  137.     return (byte);  // return read byte
  138. }


  141. /*******************************************************************
  142. @func                : SPI_RW_Reg(BYTE reg, BYTE value)
  143. @brief                : 向寄存器reg写一个字节，同时返回状态字节
  144. @pram                : reg  : 要写数据的寄存器地址
  145.               value: 要写入寄存器的数据
  146. @retval        : 返回状态寄存器
  147. @NOTE                : 其他提示
  148. *******************************************************************/
  149. uchar SPI_RW_Reg(uchar reg, uchar value)
  150. {
  151.     uchar status;
  152.     CSN = 0;                // CSN low, init SPI transaction， start transmitting data
  153.     status = SPI_RW(reg);   // select register and return status byte
  154.     SPI_RW(value);          // ..and write value to it..
  155.     CSN = 1;                // CSN high again, transmission end
  156.     return(status);         // return nRF24L01 status byte
  157. }


  160. /*******************************************************************
  161. @func                : SPI_Read(uchar reg)
  162. @brief                : 从reg寄存器读一字节
  163. @pram                : reg  : 要读取数据的寄存器地址
  164. @retval        : 返回寄存器数据
  165. *******************************************************************/
  166. uchar SPI_Read(uchar reg)
  167. {
  168.         uchar reg_val;
  169.     CSN = 0;                    // CSN置低，开始传输数据
  170.         SPI_RW(reg);                // 选择寄存器
  171.         reg_val = SPI_RW(0);        // 然后从该寄存器读数据
  172.         CSN = 1;                    // CSN拉高，结束数据传输
  173.         return(reg_val);            // 返回寄存器数据

  175. }


  178. /*******************************************************************
  179. @func                : SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes)
  180. @brief                : 从reg寄存器读 bytes 个字节  通常用来读取接收通道
  181. @pram                : reg  : 要从中读取数据的寄存器
  182.               pBuf : 存储读取的数据
  183.               bytes: 读取的字节数
  184. @retval        : 返回状态寄存器
  185. @NOTE                : 其他提示
  186. *******************************************************************/
  187. uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes)
  188. {
  189.     uchar status, byte_ctr;
  190.     CSN = 0;                    // Set CSN low, init SPI tranaction
  191.     status = SPI_RW(reg);       // Select register to read & return status byte
  192.    
  193.     for (byte_ctr = 0; byte_ctr < bytes; byte_ctr++)
  194.         pBuf[byte_ctr] = SPI_RW(0); //逐个字节从nRF24L01读出
  195.     CSN = 1;                    // set CSN high, stop transaction
  196.     return(status);             // return nRF24L01 status byte
  197. }


  200. /*******************************************************************
  201. @func                : SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)
  202. @brief                : 往reg寄存器写入 bytes 个字节  通常用来写入发射通道或接收/发送地址
  203. @pram                : reg  : 要写入数据的寄存器
  204.               pBuf : 要写入的的数据
  205.               bytes: 写入的字节数
  206. @retval        : 返回状态寄存器
  207. @NOTE                : 其他提示
  208. *******************************************************************/
  209. uchar SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)
  210. {
  211.     uchar status, byte_ctr;
  212.     CSN = 0;                // Set CSN low, init SPI tranaction
  213.     status = SPI_RW(reg);   // Select register to write to & return status byte
  214.    
  215.     for (byte_ctr = 0; byte_ctr < bytes; byte_ctr++)
  216.         SPI_RW(*pBuf++);    // 逐个字节写入nRF24L01
  217.     CSN = 1;                // Set CSN high again 结束数据传输
  218.     return(status);         // 返回状态寄存器
  219. }


  222. /*******************************************************************
  223. @func                : RX_Mode(void)
  224. @brief                : 这个函数设置nRF24L01为接收模式，等待接收发送设备的数据包
  225. @pram                : None
  226. @retval        : None
  227. *******************************************************************/
  228. void RX_Mode(void)
  229. {
  230.     CE = 0;
  231.     SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);   
  232.     SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      
  233.     SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);   
  234.     SPI_RW_Reg(WRITE_REG + RF_CH, 40);   
  235.     SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH);
  236.     SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);   
  237.     SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);
  238.     delay_ms(150);
  239.     CE = 1;                                    
  240. }


  243. /*******************************************************************
  244. @func                : TX_Mode(uchar * BUF)
  245. @brief                : 这个函数设置nRF24L01为发送模式，（CE=1持续至少10us），
  246.               130us后启动发射，数据发送结束后，发送模块自动转入接收
  247.               模式等待应答信号
  248. @pram                : BUF : 要发送的数据
  249. @retval        : None
  250. *******************************************************************/
  251. void TX_Mode(uchar * BUF)
  252. {
  253.     CE = 0;
  254.     SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);     
  255.     SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  
  256.     SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);
  257.     SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);
  258.     SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);
  259.     SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);
  260.     SPI_RW_Reg(WRITE_REG + RF_CH, 40);
  261.     SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);
  262.     SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);
  263.     delay_ms(150);
  264.     CE = 1;
  265. }


  268. /*******************************************************************
  269. @func                : Check_ACK(bit clear)
  270. @brief                : 检查接收设备有无接收到数据包，设定没有收到应答信号是否重发
  271. @pram                : clear : 判断是否清楚标志位
  272. @retval        : 返回0x00 或 0xff
  273. *******************************************************************/
  274. uchar Check_ACK(bit clear)
  275. {
  276.     //delay_ms(200);
  277.     while(IRQ);             // 等待数据接收完成
  278.     sta = SPI_RW(NOP);      // 返回状态寄存器
  279.     if(TX_DS)
  280.     {
  281.         //blink(3);
  282.     }
  283.     //blink(5);
  284.     if(MAX_RT)
  285.         if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
  286.             SPI_RW(FLUSH_TX);
  287.     SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  288.     IRQ = 1;
  289.     if(TX_DS)
  290.         return(0x00);
  291.     else
  292.         return(0xff);
  293. }


  296. // 按键扫描
  297. /*void CheckButtons()
  298. {
  299.     P3 |= 0x00;
  300.     if(!(P3 & 0x01))                    // 读取P3^0状态
  301.     {
  302.         delay_ms(20);
  303.         if(!(P3 & 0x01))                // 读取P3^0状态
  304.         {
  305.             TX_BUF[0] = ~DATA;          // 数据送到缓存
  306.             //TX_BUF[0] = 0xff;          // 数据送到缓存
  307.             TX_Mode(TX_BUF);            // 把nRF24L01设置为发送模式并发送数据            
  308.             //LED = ~DATA;                // 数据送到LED显示
  309.             Check_ACK(0);               // 等待发送完毕，清除TX FIFO
  310.             delay_ms(250);
  311.             delay_ms(250);
  312.             LED = 1;                    // 关闭LED
  313.             RX_Mode();                    // 设置为接收模式
  314.             while(!(P3 & 0x01));
  315.             DATA <<= 1;
  316.             if(!DATA)
  317.                 DATA = 0x01;
  318.         }
  319.     }


  322. }  */



  326. void main(void)
  327. {
  328.     init_io();                      // 初始化IO
  329.         RX_Mode();                                                // 设置为接收模式

  331.     while(1)
  332.     {
  333.         sta = SPI_Read(STATUS);      // 读状态寄存器
  334.         //delay_ms(200);
  335.         if(RX_DR)                    // 判断是否接受到数据
  336.         {
  337.             SPI_Read_Buf(RD_RX_PLOAD, RX_BUF, TX_PLOAD_WIDTH);  // 从RX FIFO读出数据
  338.             flag = 1;
  339.         }
  340.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除RX_DS中断标志

  342.         if(flag)                   // 接受完成
  343.         {
  344.             if(RX_BUF[0] == 1)      // RX_BUF[0] = 1 则蜂鸣器响一下
  345.             {
  346.                 BEEP = 0;
  347.                 delay_ms(500);
  348.                 BEEP = 1;
  349.                 delay_ms(500);
  350.             }

  352.             if(RX_BUF[0] == 2)  // RX_BUF[0] = 2 则LED闪烁三下
  353.             {
  354.                 BEEP = 0;
  355.                 delay_ms(500);
  356.                 BEEP = 1;
  357.                 delay_ms(500);
  358.                 BEEP = 0;
  359.                 delay_ms(500);
  360.                 BEEP = 1;
  361.                 delay_ms(500);
  362.                 BEEP = 0;
  363.                 delay_ms(500);
  364.                 BEEP = 1;
  365.                 delay_ms(500);
  366.             }
  367.             flag = 0;               // 清标志
  368.             delay_ms(250);
  369.             delay_ms(250);
  370.             LED = 1;                // 关闭LED
  371.         }
  372.     }
  373. }
复制代码




分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:1 发表于 2020-5-2 13:55 | 只看该作者
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表