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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › NRF24l01无线收发程序（4数码管显示4路口车流量）
返回列表 发新帖
查看: 6657|回复: 19
打印 上一主题 下一主题
收起左侧

NRF24l01无线收发程序（4数码管显示4路口车流量）

  [复制链接]
跳转到指定楼层
楼主
ID:70650 发表于 2014-12-19 02:29 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
之前我在弄这个无线模块的时候，很迷茫，网上也很难找到资料，调了很久才调通。所以我上传这个给大家，我之前是用来检测车流量的，所以有些程序对于大家是多余的。有兴趣的可以研究下。单通道跟，多通道的也调通了。只要在发射器的IP地址按顺序修改IP地址就能够同时接收6个通道信号，再通过信道号区别哪个发射器发射。大家慢慢研究。

电路图： NRF24L01多通道通信（4数码管显示4路口车流量）.rar (1.53 MB, 下载次数: 186)
收发程序： NRF24L01多通道（直接修改发射器地址）.rar (62.27 KB, 下载次数: 140)
IP地址, 数码管, 发射器, 程序, 无线

评分

参与人数 3黑币 +40 收起 理由
飞翔的大娃 + 20 赞一个！
暗光 + 15
13465309885 + 5

查看全部评分

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

相关帖子
回复

使用道具 举报

沙发
ID:70650 发表于 2014-12-19 02:31 | 只看该作者
发送程序：
  1. #include <reg51.h>

  3. #define uchar unsigned char
  4. #define uint unsigned int

  6. sbit  MOSI = P1^5;
  7. sbit  MISO = P1^6;
  8. sbit  SCK  = P1^7;
  9. sbit  CE   = P1^3;         //模式
  10. sbit  CSN  = P1^2;          //SPI en
  11. sbit  IRQ  = P3^2;

  13. //sbit  LCD_RS = P2^0;                        //LCD1602操作线
  14. //sbit  LCD_RW = P2^1;
  15. //sbit  LCD_E  = P2^2;

  17. sbit  LED0 = P2^7;


  20. // SPI(nRF24L01) commands
  21. #define READ_REG            0x00  // Define read command to register
  22. #define WRITE_REG           0x20  // Define write command to register
  23. #define RD_RX_PLOAD         0x61  // Define RX payload register address
  24. #define WR_TX_PLOAD         0xA0  // Define TX payload register address
  25. #define FLUSH_TX            0xE1  // Define flush TX register command
  26. #define FLUSH_RX            0xE2  // Define flush RX register command
  27. #define REUSE_TX_PL         0xE3  // Define reuse TX payload register command
  28. #define NOP                 0xFF  // Define No Operation, might be used to read status register


  31. // SPI(nRF24L01) registers(addresses)
  32. #define CONFIG              0x00  // 'Config' register address
  33. #define EN_AA               0x01  // 'Enable Auto Acknowledgment' register address
  34. #define EN_RXADDR           0x02  // 'Enabled RX addresses' register address
  35. #define SETUP_AW            0x03  // 'Setup address width' register address
  36. #define SETUP_RETR          0x04  // 'Setup Auto. Retrans' register address
  37. #define RF_CH               0x05  // 'RF channel' register address
  38. #define RF_SETUP            0x06  // 'RF setup' register address
  39. #define STATUS              0x07  // 'Status' register address
  40. #define OBSERVE_TX          0x08  // 'Observe TX' register address
  41. #define CD                  0x09  // 'Carrier Detect' register address
  42. #define RX_ADDR_P0          0x0A  // 'RX address pipe0' register address
  43. #define RX_ADDR_P1          0x0B  // 'RX address pipe1' register address
  44. #define RX_ADDR_P2          0x0C  // 'RX address pipe2' register address
  45. #define RX_ADDR_P3          0x0D  // 'RX address pipe3' register address
  46. #define RX_ADDR_P4          0x0E  // 'RX address pipe4' register address
  47. #define RX_ADDR_P5          0x0F  // 'RX address pipe5' register address
  48. #define TX_ADDR             0x10  // 'TX address' register address
  49. #define RX_PW_P0            0x11  // 'RX payload width, pipe0' register address
  50. #define RX_PW_P1            0x12  // 'RX payload width, pipe1' register address
  51. #define RX_PW_P2            0x13  // 'RX payload width, pipe2' register address
  52. #define RX_PW_P3            0x14  // 'RX payload width, pipe3' register address
  53. #define RX_PW_P4                   0x15  // 'RX payload width, pipe4' register address
  54. #define RX_PW_P5            0x16  // 'RX payload width, pipe5' register address
  55. #define FIFO_STATUS         0x17  // 'FIFO Status Register' register address
  56. #define TX_ADR_WIDTH    5  // 5字节宽度的发送/接收地址
  57. #define TX_PLOAD_WIDTH  1// 数据通道有效数据宽度
  58. //#define LED P1

  60. uchar  TX_ADDRESS[TX_ADR_WIDTH] = {0x04,0x43,0x10,0x10,0x12};

  62. // 定义一个静态发送地址
  63. uchar RX_BUF[TX_PLOAD_WIDTH];
  64. uchar TX_BUF[TX_PLOAD_WIDTH];
  65. uchar Table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  66. uchar temp;
  67. unsigned long av;
  68. unsigned long sum;
  69. unsigned long num;
  70. uint N;
  71. uint  i;
  72. char chN;
  73. uchar Nrf;
  74. uchar flag=1;
  75. uchar bdata sta;
  76. sbit  RX_DR  = sta^6;
  77. sbit  TX_DS  = sta^5;
  78. sbit  MAX_RT = sta^4;
  79. uchar flag1;
  80. void init_io(void)
  81. {
  82.         CE  = 0;        // 待机
  83.         CSN = 1;        // SPI禁止
  84.         SCK = 0;        // SPI时钟置低
  85.         IRQ = 1;        // 中断复位
  86.         //LED = 0xff; // 关闭指示灯
  87. }

  89. void delay_ms(char x)
  90. {
  91.     int j;

  93.     while(x--)
  94.     {
  95.        j = 1000;
  96.            while(j--);
  97.     }
  98. }

  100. void delay_us(int x)
  101. {
  102.     while(x--);
  103. }

  105. /*uchar Read_LCD1602()                       
  106. {
  107.     uchar busy = 0x80;

  109.         LCD_RS = 0;
  110.         LCD_RW = 1;

  112.     delay_ms(1);
  113.         LCD_E = 1;
  114.     delay_ms(1);
  115.         busy  = P0;
  116.     delay_ms(1);
  117.         LCD_E = 0;

  119.         return(busy);
  120. }

  122. void Write_Data(uchar dat)
  123. {
  124.         while(Read_LCD1602()&0x80);       
  125.        
  126.         LCD_RW = 0;
  127.         LCD_RS = 1;

  129.         P0 = dat;
  130.     delay_ms(1);
  131.         LCD_E  = 1;
  132.     delay_ms(1);
  133.         LCD_E  = 0;
  134. }

  136. void Write_Com(uchar com)
  137. {
  138.         while(Read_LCD1602() & 0x80);
  139.        
  140.         LCD_RW = 0;
  141.         LCD_RS = 0;

  143.         P0 = com;
  144.     delay_ms(1);
  145.         LCD_E  = 1;
  146.     delay_ms(1);
  147.         LCD_E  = 0;       
  148. }

  150. void Write_Add_Dat(uchar add, uchar dat)
  151. {
  152.         Write_Com(add);
  153.         Write_Data(dat);   
  154. }

  156. void LCD_Init()
  157. {
  158.         Write_Com(0x38);
  159.         Write_Com(0x0c);
  160.         Write_Com(0x06);  
  161.     Write_Com(0x01);
  162. }         */

  164. uchar SPI_RW(uchar byte)
  165. {
  166.     uchar i;

  168.     for(i=0; i<8; i++)          // 循环8次
  169.     {
  170.                 MOSI = (byte & 0x80);   // byte最高位输出到MOSI
  171.                 byte <<= 1;             // 低一位移位到最高位
  172.                 SCK = 1;                // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
  173.                 byte |= MISO;       // 读MISO到byte最低位
  174.                 SCK = 0;             // SCK置?
  175.     }

  177.     return(byte);           // 返回读出的一字节
  178. }

  180. uchar SPI_RW_Reg(uchar reg, uchar value)
  181. {
  182.    uchar status;

  184.    CSN = 0;                   // CSN置低，开始传输数据
  185.    status = SPI_RW(reg);      // 选择寄存器，同时返回状态字
  186.    SPI_RW(value);             // 然后写数据到该寄存器
  187.    CSN = 1;                   // CSN拉高，结束数据传输

  189.    return(status);            // 返回状态寄存器
  190. }

  192. uchar SPI_Read(uchar reg)
  193. {
  194.         uchar reg_val;
  195.        
  196.         CSN = 0;                    // CSN置低，开始传输数据
  197.         SPI_RW(reg);                // 选择寄存器
  198.         reg_val = SPI_RW(0);        // 然后从该寄存器读数据
  199.         CSN = 1;                    // CSN拉高，结束数据传输
  200.        
  201.         return(reg_val);            // 返回寄存器数据
  202. }

  204. uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes)
  205. {
  206.         uchar status, i;
  207.        
  208.         CSN = 0;                    // CSN置低，开始传输数据
  209.         status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
  210.         for(i=0; i<bytes; i++)
  211.         {
  212.            pBuf[ i] = SPI_RW(0);    // 逐个字节从nRF24L01读出
  213.         }
  214.         CSN = 1;                    // CSN拉高，结束数据传输
  215.        
  216.         return(status);             // 返回状态寄存器
  217. }

  219. uchar SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)
  220. {
  221.         uchar status, i;

  223.         CSN = 0;                    // CSN置低，开始传输数据
  224.         status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
  225.         for(i=0; i<bytes; i++)
  226.         {
  227.            SPI_RW(pBuf[ i]);        // 逐个字节写入nRF24L01
  228.         }
  229.         CSN = 1;                    // CSN拉高，结束数据传输
  230.        
  231.         return(status);             // 返回状态寄存器
  232. }



  236. void TX_Mode(uchar *BUF)
  237. {
  238.         CE = 0;
  239. // 写入发送地址

  241.         SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);     // 写入发送地址
  242.           SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 为了应答接收设备，接收通道0地址和发送地址相同
  243.           SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);                  // 写数据包到TX FIFO
  244.           SPI_RW_Reg(WRITE_REG + EN_AA, 0x3f);       // 使能接收通道0自动应答
  245.           SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x3f);   // 使能接收通道0
  246.           SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);  // 自动重发延时等待250us+86us，自动重发10次
  247.           SPI_RW_Reg(WRITE_REG + RF_CH, 40);         // 选择射频通道0x40
  248.           SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);    // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
  249.           SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);      // CRC使能，16位CRC校验，上电

  251.     CE=1;       
  252. }

  254. uchar Check_ACK(bit clear)
  255. {
  256.         while(IRQ);
  257.         sta = SPI_RW(NOP);                    // 返回状态寄存器
  258.         if(MAX_RT)
  259.         {
  260.            if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
  261.        {
  262.                      SPI_RW(FLUSH_TX);
  263.            }
  264.         }
  265.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  266.         IRQ = 1;
  267.         if(TX_DS)
  268.         {
  269.                 return(0x00);
  270.         }
  271.         else
  272.         {
  273.             return(0xff);
  274.         }
  275. }

  277. unsigned char nRF24L01_RxPacket(unsigned char *RX_BUF)
  278. {
  279.         unsigned char revale=0;
  280.         //SetRX_Mode();
  281.        
  282.         sta  = SPI_Read(STATUS);   //read register STATUS's value
  283.         temp = sta;

  285.         if(RX_DR)                 //if receive data ready (RX_DR) interrupt
  286.         {
  287.                 CE = 0;
  288.                 SPI_Read_Buf(RD_RX_PLOAD,RX_BUF,TX_PLOAD_WIDTH); // read receive payload from RX_FIFO buffer
  289.                 revale =1;                                       //we have receive data
  290.         }

  292.         SPI_RW_Reg(WRITE_REG+STATUS,sta);                    // clear RX_DR or TX_DS or MAX_RT interrupt flag
  293.        
  294.         return revale;
  295. }

  297. void init_T0()
  298. {
  299.     TMOD = 0x15;
  300.     TH0 = 0xfc;
  301.     TL0 = 0x47;
  302.     EA = 1;
  303.     ET0 = 1;
  304.     TR0 = 1;
  305. }
  306. void init_T1()
  307. {

  309.     TH1 = 0x00;
  310.     TL1 = 0x00;
  311.     ET1 = 1;
  312.     TR1 = 1;
  313. }

  315. void baojing()
  316. {
  317.   while(1)
  318.   {
  319.   LED0=~LED0;
  320.   delay_ms(500);
  321.   }
  322. }


  325.   
  326. void main(void)
  327. {
  328.          
  329.           init_io();
  330.           init_T0();                    // 初始化IO
  331.         //LCD_Init();
  332.           init_T1();                // 设置为接收模式
  333.          
  334.         while(1)
  335.         {

  337.            if(flag1)
  338.            {
  339.              if(chN<1)
  340.                   {
  341.                     N++;
  342.                         flag1=0;
  343.                         TR0=0;
  344.                         TR1=0;
  345.                         TH1=0;
  346.             TL1=0;
  347.             TH0=0xfc;
  348.             TL0=0x47;
  349.                   }
  350.            }

  352.             TX_BUF[0]=N;
  353.                 LED0 =0;
  354.                 TX_Mode(TX_BUF);                  // 把nRF24L01设置为发送模式并发送数据
  355.                 Check_ACK(1);
  356.                 TR0=1;
  357.         TR1=1;                   // 等待发送完毕，清除TX FIFO
  358.         /*        Write_Add_Dat(0x80,'0'+temp/100);
  359.                 Write_Add_Dat(0x81,'0'+temp%100/10);
  360.                 Write_Add_Dat(0x82,'0'+temp%10);  */
  361.                 P2=0XFD;
  362.                 P0=Table[TX_BUF[0]/100];
  363.                 delay_ms(2);
  364.                 P2=0XFB;
  365.                 P0=Table[TX_BUF[0]%100/10];
  366.                 delay_ms(2);
  367.                 P2=0XF7;
  368.                 P0=Table[TX_BUF[0]%10];
  369.                 delay_ms(2);  
  370.         }
  371. }
  372. void TIME0() interrupt 1
  373. {

  375.    TR0=0;
  376.    TR1=0;
  377.    if(flag)
  378.     {
  379.       Nrf=TH1*256+TL1;
  380.           flag=0;
  381.         }
  382.    else
  383.    {
  384.      chN=TH1*256+TL1-Nrf;
  385.          if(chN<(-7)||chN>7)
  386.            {
  387.              flag1=1;
  388.            }
  389.          else
  390.            {
  391.                     Nrf=TH1*256+TL1;
  392.            }
  393.    }
  394.    delay_ms(100);
  395.    TH1=0;
  396.    TL1=0;
  397.    TH0=0xfc;
  398.    TL0=0x47;
  399.    TR0=1;
  400.    TR1=1;
  401. }


  404. void TIME1() interrupt 3
  405. {
  406.    TR0=0;
  407.    TR1=0;
  408.    baojing();
  409. }

复制代码
回复

使用道具 举报

板凳
ID:70650 发表于 2014-12-19 02:32 | 只看该作者
接受程序：
  1. #include <reg51.h>

  3. #define uchar unsigned char
  4. #define uint unsigned int

  6. sbit  MOSI = P1^5;
  7. sbit  MISO = P1^6;
  8. sbit  SCK  = P1^7;
  9. sbit  CE   = P1^3;         //模式
  10. sbit  CSN  = P1^2;          //SPI en
  11. sbit  IRQ  = P3^2;

  13. //sbit  LCD_RS = P2^0;                        //LCD1602操作线
  14. //sbit  LCD_RW = P2^1;
  15. //sbit  LCD_E  = P2^2;

  17. sbit  LED0 = P1^0;


  20. // SPI(nRF24L01) commands
  21. #define READ_REG            0x00  // Define read command to register
  22. #define WRITE_REG           0x20  // Define write command to register
  23. #define RD_RX_PLOAD         0x61  // Define RX payload register address
  24. #define WR_TX_PLOAD         0xA0  // Define TX payload register address
  25. #define FLUSH_TX            0xE1  // Define flush TX register command
  26. #define FLUSH_RX            0xE2  // Define flush RX register command
  27. #define REUSE_TX_PL         0xE3  // Define reuse TX payload register command
  28. #define NOP                 0xFF  // Define No Operation, might be used to read status register


  31. // SPI(nRF24L01) registers(addresses)
  32. #define CONFIG              0x00  // 'Config' register address
  33. #define EN_AA               0x01  // 'Enable Auto Acknowledgment' register address
  34. #define EN_RXADDR           0x02  // 'Enabled RX addresses' register address
  35. #define SETUP_AW            0x03  // 'Setup address width' register address
  36. #define SETUP_RETR          0x04  // 'Setup Auto. Retrans' register address
  37. #define RF_CH               0x05  // 'RF channel' register address
  38. #define RF_SETUP            0x06  // 'RF setup' register address
  39. #define STATUS              0x07  // 'Status' register address
  40. #define OBSERVE_TX          0x08  // 'Observe TX' register address
  41. #define CD                  0x09  // 'Carrier Detect' register address
  42. #define RX_ADDR_P0          0x0A  // 'RX address pipe0' register address
  43. #define RX_ADDR_P1          0x0B  // 'RX address pipe1' register address
  44. #define RX_ADDR_P2          0x0C  // 'RX address pipe2' register address
  45. #define RX_ADDR_P3          0x0D  // 'RX address pipe3' register address
  46. #define RX_ADDR_P4          0x0E  // 'RX address pipe4' register address
  47. #define RX_ADDR_P5          0x0F  // 'RX address pipe5' register address
  48. #define TX_ADDR             0x10  // 'TX address' register address
  49. #define RX_PW_P0            0x11  // 'RX payload width, pipe0' register address
  50. #define RX_PW_P1            0x12  // 'RX payload width, pipe1' register address
  51. #define RX_PW_P2            0x13  // 'RX payload width, pipe2' register address
  52. #define RX_PW_P3            0x14  // 'RX payload width, pipe3' register address
  53. #define RX_PW_P4                   0x15  // 'RX payload width, pipe4' register address
  54. #define RX_PW_P5            0x16  // 'RX payload width, pipe5' register address
  55. #define FIFO_STATUS         0x17  // 'FIFO Status Register' register address
  56. #define TX_ADR_WIDTH    5  // 5字节宽度的发送/接收地址
  57. #define TX_PLOAD_WIDTH  1  // 数据通道有效数据宽度
  58. //#define LED P1
  59. uchar  TX_ADDRESS[TX_ADR_WIDTH] = {0x01,0x43,0x10,0x10,0x12};
  60. uchar  RX_ADDRESS0[5] = {0x01,0x43,0x10,0x10,0x12};  // 定义一个静态发送地址
  61. uchar  RX_ADDRESS1[5]= {0x02,0x43,0x10,0x10,0x12};        //接收地址1
  62. uchar  RX_ADDRESS2[1]= {0x03};        //接收地址2
  63. uchar  RX_ADDRESS3[1]= {0x04};        //接收地址3
  64. uchar  RX_ADDRESS4[1]= {0x05};        //接收地址4
  65. uchar  RX_ADDRESS5[1]= {0x06};        //接收地址5
  66. uchar RX_BUF[TX_PLOAD_WIDTH];
  67. uchar TX_BUF[TX_PLOAD_WIDTH];
  68. uchar temp;
  69. uchar Table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  70. uchar bdata sta;
  71. sbit  RX_DR  = sta^6;
  72. sbit  TX_DS  = sta^5;
  73. sbit  MAX_RT = sta^4;
  74. uchar Number[4];
  75. void init_io(void)
  76. {
  77.         CE  = 0;        // 待机
  78.         CSN = 1;        // SPI禁止
  79.         SCK = 0;        // SPI时钟置低
  80.         IRQ = 1;        // 中断复位
  81.         //LED = 0xff; // 关闭指示灯
  82. }

  84. void delay_ms(char x)
  85. {
  86.     int j;

  88.     while(x--)
  89.     {
  90.        j = 1000;
  91.            while(--j);
  92.     }
  93. }

  95. void delay_us(int x)
  96. {
  97.     while(x--);
  98. }

  100. /*uchar Read_LCD1602()                       
  101. {
  102.     uchar busy = 0x80;

  104.         LCD_RS = 0;
  105.         LCD_RW = 1;

  107.     delay_ms(1);
  108.         LCD_E = 1;
  109.     delay_ms(1);
  110.         busy  = P0;
  111.     delay_ms(1);
  112.         LCD_E = 0;

  114.         return(busy);
  115. }

  117. void Write_Data(uchar dat)
  118. {
  119.         while(Read_LCD1602()&0x80);       
  120.        
  121.         LCD_RW = 0;
  122.         LCD_RS = 1;

  124.         P0 = dat;
  125.     delay_ms(1);
  126.         LCD_E  = 1;
  127.     delay_ms(1);
  128.         LCD_E  = 0;
  129. }

  131. void Write_Com(uchar com)
  132. {
  133.         while(Read_LCD1602() & 0x80);
  134.        
  135.         LCD_RW = 0;
  136.         LCD_RS = 0;

  138.         P0 = com;
  139.     delay_ms(1);
  140.         LCD_E  = 1;
  141.     delay_ms(1);
  142.         LCD_E  = 0;       
  143. }

  145. void Write_Add_Dat(uchar add, uchar dat)
  146. {
  147.         Write_Com(add);
  148.         Write_Data(dat);   
  149. }

  151. void LCD_Init()
  152. {
  153.         Write_Com(0x38);
  154.         Write_Com(0x0c);
  155.         Write_Com(0x06);  
  156.     Write_Com(0x01);
  157. }  */

  159. uchar SPI_RW(uchar byte)
  160. {
  161.     uchar i;

  163.     for(i=0; i<8; i++)          // 循环8次
  164.     {
  165.                 MOSI = (byte & 0x80);   // byte最高位输出到MOSI
  166.                 byte <<= 1;             // 低一位移位到最高位
  167.                 SCK = 1;                // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
  168.                 byte |= MISO;       // 读MISO到byte最低位
  169.                 SCK = 0;             // SCK置?
  170.     }

  172.     return(byte);           // 返回读出的一字节
  173. }

  175. uchar SPI_RW_Reg(uchar reg, uchar value)
  176. {
  177.    uchar status;

  179.    CSN = 0;                   // CSN置低，开始传输数据
  180.    status = SPI_RW(reg);      // 选择寄存器，同时返回状态字
  181.    SPI_RW(value);             // 然后写数据到该寄存器
  182.    CSN = 1;                   // CSN拉高，结束数据传输

  184.    return(status);            // 返回状态寄存器
  185. }

  187. uchar SPI_Read(uchar reg)
  188. {
  189.         uchar reg_val;
  190.        
  191.         CSN = 0;                    // CSN置低，开始传输数据
  192.         SPI_RW(reg);                // 选择寄存器
  193.         reg_val = SPI_RW(0);        // 然后从该寄存器读数据
  194.         CSN = 1;                    // CSN拉高，结束数据传输
  195.        
  196.         return(reg_val);            // 返回寄存器数据
  197. }

  199. uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes)
  200. {
  201.         uchar status, i;
  202.        
  203.         CSN = 0;                    // CSN置低，开始传输数据
  204.         status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
  205.         for(i=0; i<bytes; i++)
  206.         {
  207.            pBuf[ i] = SPI_RW(0);    // 逐个字节从nRF24L01读出
  208.         }
  209.         CSN = 1;                    // CSN拉高，结束数据传输
  210.        
  211.         return(status);             // 返回状态寄存器
  212. }

  214. uchar SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)
  215. {
  216.         uchar status, i;

  218.         CSN = 0;                    // CSN置低，开始传输数据
  219.         status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
  220.         for(i=0; i<bytes; i++)
  221.         {
  222.            SPI_RW(pBuf[ i]);        // 逐个字节写入nRF24L01
  223.         }
  224.         CSN = 1;                    // CSN拉高，结束数据传输
  225.        
  226.         return(status);             // 返回状态寄存器
  227. }

  229. void RX_Mode(void)
  230. {
  231.         CE = 0;// 接收设备接收通道0使用和发送设备相同的发送地址

  233.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);//写接收通道0的接收地址，与发送地址相同
  234.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P1, RX_ADDRESS1, TX_ADR_WIDTH); //写接收通道1的接收地址
  235.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P2, RX_ADDRESS2, 1);//写接收通道2的接收地址
  236.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P3, RX_ADDRESS3, 1);//写接收通道3的接收地址
  237.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P4, RX_ADDRESS4, 1);//写接收通道4的接收地址
  238.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P5, RX_ADDRESS5, 1);//写接收通道5的接收地址
  239.         SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH);  // 接收通道0选择和发送通道相同有效数据宽度，32字节长度
  240.           SPI_RW_Reg(WRITE_REG + RX_PW_P1, TX_PLOAD_WIDTH);//32字节长度
  241.           SPI_RW_Reg(WRITE_REG + RX_PW_P2, TX_PLOAD_WIDTH);//32字节长度
  242.           SPI_RW_Reg(WRITE_REG + RX_PW_P3, TX_PLOAD_WIDTH);//32字节长度
  243.           SPI_RW_Reg(WRITE_REG + RX_PW_P4, TX_PLOAD_WIDTH);//32字节长度
  244.           SPI_RW_Reg(WRITE_REG + RX_PW_P5, TX_PLOAD_WIDTH);//32字节长度
  245.           SPI_RW_Reg(WRITE_REG + EN_AA, 0x3f);       // 使能所有接收通道自动应答
  246.           SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x3f);   // 使能所有接收通道
  247.         SPI_RW_Reg(WRITE_REG + RF_CH, 40);                 // 选择射频通道0x40
  248.         SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);            // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
  249.         SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);      // CRC使能，16位CRC校验，上电
  250.         SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);  // 自动重发延时等待250us+86us，自动重发10次
  251.         CE = 1;                                                // 拉高CE启动接收设备
  252.         delay_us(200);
  253. }



  257. uchar Check_ACK(bit clear)
  258. {
  259.         while(IRQ);
  260.         sta = SPI_RW(NOP);                    // 返回状态寄存器
  261.         if(MAX_RT)
  262.         {
  263.            if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
  264.        {
  265.                      SPI_RW(FLUSH_TX);
  266.            }
  267.         }
  268.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  269.         IRQ = 1;
  270.         if(TX_DS)
  271.         {
  272.                 return(0x00);
  273.         }
  274.         else
  275.         {
  276.             return(0xff);
  277.         }
  278. }

  280. unsigned char nRF24L01_RxPacket(unsigned char *RX_BUF)
  281. {
  282.         unsigned char revale=0;
  283.         //SetRX_Mode();
  284.        
  285.         sta  = SPI_Read(STATUS);   //read register STATUS's value
  286.         temp = sta;

  288.         if(RX_DR)                 //if receive data ready (RX_DR) interrupt
  289.         {
  290.                
  291.                 SPI_Read_Buf(RD_RX_PLOAD,RX_BUF,TX_PLOAD_WIDTH); // read receive payload from RX_FIFO buffer
  292.                 revale =1;
  293.                                                     //we have receive data
  294.         }

  296.         SPI_RW_Reg(WRITE_REG+STATUS,sta);                    // clear RX_DR or TX_DS or MAX_RT interrupt flag
  297.        
  298.         return revale;
  299. }

  301. void main(void)
  302. {
  303.       
  304.         uchar reveal;
  305.     init_io();
  306.         RX_Mode();         // 初始化IO
  307.                    // 设置为接收模式
  308.         //LCD_Init();

  310.         while(1)       
  311.         {
  312.   
  313.         reveal=nRF24L01_RxPacket(RX_BUF);
  314.                
  315.                 if(reveal==1)           // 接受完成
  316.                  {
  317.                         LED0 = ~LED0;
  318.                         reveal = 0;   
  319.                 /*        Write_Add_Dat(0x80,0x30+RX_BUF[0]/100);
  320.                         Write_Add_Dat(0x81,0x30+RX_BUF[0]%100/10);
  321.                         Write_Add_Dat(0x82,0x30+RX_BUF[0]%10);

  323.                         Write_Add_Dat(0x85,0x30+RX_BUF[1]/100);
  324.                         Write_Add_Dat(0x86,0x30+RX_BUF[1]%100/10);
  325.                         Write_Add_Dat(0x87,0x30+RX_BUF[1]%10);

  327.                         Write_Add_Dat(0x8A,0x30+RX_BUF[2]/100);
  328.                         Write_Add_Dat(0x8B,0x30+RX_BUF[2]%100/10);
  329.                         Write_Add_Dat(0x8C,0x30+RX_BUF[2]%10);
  330.                        
  331.                          */
  332.                    }
  333.                  Number[0]=RX_BUF[0];
  334.                 P2=0XFD;
  335.                 P0=Table[RX_BUF[0]/100];
  336.                 delay_ms(2);
  337.                 P2=0XFB;
  338.                 P0=Table[RX_BUF[0]%100/10];
  339.                 delay_ms(2);
  340.                 P2=0XF7;
  341.                 P0=Table[RX_BUF[0]%10];
  342.                 delay_ms(2);
  343.                 P2=0XFE;
  344.                 P0=Table[RX_BUF[0]/100];
  345.                 delay_ms(2);
  346.                 P2=0X7F;
  347.                 P0=Table[RX_BUF[0]%100/10];
  348.                 delay_ms(2);
  349.                 P2=0XBF;
  350.                 P0=Table[RX_BUF[0]%10];
  351.                 delay_ms(2);
  352.         }
  353. }


复制代码
回复

使用道具 举报

地板
ID:70769 发表于 2014-12-20 19:45 | 只看该作者
很好，正需要
回复

使用道具 举报

5#
ID:68369 发表于 2015-1-25 19:18 | 只看该作者
现在做毕设，也是NRF24L01，刚刚完成硬件电路，接下来就慢慢调程序了，学习了
回复

使用道具 举报

6#
ID:60706 发表于 2015-1-27 12:35 | 只看该作者
学习了
回复

使用道具 举报

7#
ID:43600 发表于 2015-2-9 01:16 | 只看该作者
very good ! nice job !!!
回复

使用道具 举报

8#
ID:72611 发表于 2015-4-4 17:47 | 只看该作者
谢谢分享，学习了
回复

使用道具 举报

9#
ID:75928 发表于 2015-4-5 01:00 | 只看该作者
想问下怎么配置好不同单片机通过NRF24L01通信？比如 STC89C52RC 和 STC12C5A60S2 ？
回复

使用道具 举报

10#
ID:75829 发表于 2015-4-8 20:18 | 只看该作者
正需要的东西！
回复

使用道具 举报

11#
ID:44267 发表于 2015-10-18 15:29 | 只看该作者
一看，好强大啊
回复

使用道具 举报

12#
ID:25826 发表于 2015-11-21 16:35 | 只看该作者
很好，正需要,刚买了两个模块，谢谢楼主分享
回复

使用道具 举报

13#
ID:101231 发表于 2015-12-30 16:47 | 只看该作者
楼主 第一个 有2个warnimg； 第二个有1个warning
回复

使用道具 举报

14#
ID:109511 发表于 2016-3-21 23:02 | 只看该作者
very good !
回复

使用道具 举报

15#
ID:108660 发表于 2016-3-22 19:01 | 只看该作者
放大开发单词
回复

使用道具 举报

16#
ID:108660 发表于 2016-3-22 19:02 | 只看该作者
顶啊 哈哈哈哈哈哈
回复

使用道具 举报

17#
ID:110278 发表于 2016-3-22 22:35 | 只看该作者
非常好，感谢分享。
回复

使用道具 举报

18#
ID:143016 发表于 2016-12-9 19:44 | 只看该作者
学习了，这个无线传输是多少米的啊！
回复

使用道具 举报

19#
ID:162247 发表于 2017-1-18 09:41 | 只看该作者
很好的资料！谢谢
回复

使用道具 举报

20#
ID:614724 发表于 2019-10-22 23:04 | 只看该作者
谢谢分享
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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