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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 15单片机进行通过NRF24L01的双向通信有问题
返回列表 发新帖
查看: 1740|回复: 1
收起左侧

15单片机进行通过NRF24L01的双向通信有问题

[复制链接]
ID:922838 发表于 2021-10-23 15:30 | 显示全部楼层 |阅读模式
这个是我写的程序，大部分是网上找的程序，用的是15单片机，然后两个MCU通过NRF24L01通信，但不知道为什么就是通信不了，就接收不到数据。有没有大佬找找我的问题。

单片机源程序如下:
  1. #include <reg51.h>
  2. #include <intrins.h>
  3. #define TX_ADR_WIDTH 5 //5字节宽度的发送/接收地址
  4. #define TX_PLOAD_WIDTH 4//数据通道有效数据宽度
  5. #define uchar        unsigned char
  6. #define uint        unsigned int
  7. #define out P0
  8. uchar code lcd1602[]={0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39};

  10. uchar code TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};  // 定义一个静态发送地址
  11. uchar RX_BUF[TX_PLOAD_WIDTH];
  12. uchar TX_BUF[TX_PLOAD_WIDTH];
  13. uchar flag;
  14. uchar bdata sta;
  15. sbit RX_DR =sta^6;
  16. sbit TX_DS =sta^5;
  17. sbit MAX_RT=sta^4;

  19. /*sbit CE   = P1^5;
  20. sbit CSN  = P1^4;
  21. sbit SCK  = P1^2;
  22. sbit MOSI = P1^1;
  23. sbit MISO = P1^3;
  24. sbit IRQ  = P1^0;*/
  25. sbit CE   = P2^4;
  26. sbit CSN  = P2^0;
  27. sbit SCK  = P2^3;
  28. sbit MOSI = P2^1;
  29. sbit MISO = P3^3;
  30. sbit IRQ  = P2^2;
  31. //SPI要使用的IO
  32. sbit MOSIO=P3^4;
  33. sbit R_CLK=P3^5;
  34. sbit S_CLK=P3^6;
  35. //SPI(NFR24L01)命令
  36. #define RFAD_REG 0x00      //定义读命令以注册
  37. #define WRITE_REG 0x20     //定义要写的命令
  38. #define RD_RX_PLOAD 0x61   //定义RX有效负载寄存器地址
  39. #define WR_TX_PLOAD 0xA0   //定义TX有效负载寄存器地址
  40. #define FLUSH_TX    0xE1   //定义刷新 Tx寄存器命令
  41. #define FLUSH_RX    0xE2   //定义刷新 Rx寄存器命令
  42. #define REUSE_TX_PL 0xE3   //定义重复TX负载寄存器命令
  43. #define NOP                                        0xFF   //定义无操作

  45. //SPI(NRF24L01)寄存器
  46. #define CONFIG     0x00    //配置寄存器地址
  47. #define EN_AA      0x01    //“启用自动确认”的注册地址
  48. #define EN_RXADDR  0x02    //'Enabled RX addresses'寄存器地址
  49. #define SETUP_AW   0x03    //“设置地址宽度”寄存器地址
  50. #define SETUP_RETR 0x04    //“自动设置。Retrans的寄存器地址
  51. #define RF_CH                         0x05                 //        '射频信道'寄存器地址
  52. #define RF_SETUP         0x06          //射频设置寄存器地址
  53. #define STATUS                  0x07                 //        状态寄存器地址
  54. #define OBSERVE_TX 0x08                 //“收到Tx”寄存器地址
  55. #define CD                                 0x09    //"载波检测'寄存器地址
  56. #define RX_ADDR_P0 0x0A    //RX地址0管道的寄存器地址
  57. #define RX_ADDR_P1 0x0B    //RX地址1管道的寄存器地址
  58. #define RX_ADDR_P2 0x0C    //RX地址2管道的寄存器地址
  59. #define RX_ADDR_P3 0x0D    //RX地址3管道的寄存器地址
  60. #define RX_ADDR_P4 0x0E    //RX地址4管道的寄存器地址
  61. #define RX_ADDR_P5 0x0F    //RX地址5管道的寄存器地址
  62. #define TX_ADDR    0x10                 //“Tx address”的寄存器地址
  63. #define RX_PW_P0         0x11                 //"RX有效载荷宽度，0管'寄存器地址
  64. #define RX_PE_P1         0x12                 //"RX有效载荷宽度，1管'寄存器地址
  65. #define RX_PE_P2   0x13                 //"RX有效载荷宽度，2管'寄存器地址
  66. #define RX_PE_P3   0x14                 //"RX有效载荷宽度，3管'寄存器地址
  67. #define RX_PE_P4   0x15                 //"RX有效载荷宽度，4管'寄存器地址
  68. #define RX_PE_P5   0x16                 //"RX有效载荷宽度，5管'寄存器地址
  69. #define FIFO_STATUS 0x17   //“FIFO状态寄存器”的寄存器地址


  72. void delay500ms(void);
  73. void lcd_initial (void);                                //LCD1602初始化
  74. void  write_data(uchar dat);                //写数据函数
  75. void check_busy (void);                                        //忙检测
  76. void write_command (uchar com); //写命令函数
  77. void string (uchar ad,uchar *s);//字符写入，（字符开始地址，字符）
  78. void delay100ms(void);                                        //延时100MS
  79. void delay10ms(void);                                          //延时10MS
  80. void delay1ms(void);                                                //延时1ms
  81. uchar ajlb(uchar x);                        //按键滤波
  82. uchar JCAJ(void);                                                //检测按键按下
  83. uchar HC08JS = 0;
  84. bit                flag1 = 0;
  85. sbit        E=P2^5;
  86. sbit        RW=P2^6;
  87. sbit        RS=P2^7;
  88. sbit        FMQ=P1^2;
  89. sbit        BG=P2^4;
  90. sbit  DQ=P1^0;
  91. sbit K1=P1^3;
  92. sbit K2=P1^4;
  93. sbit K3=P1^5;
  94. sbit K4=P1^6;
  95. sfr AUXR   = 0x8E;
  96. sfr T2H = 0xd6;
  97. sfr T2L = 0xd7;


  100. void lcd_initial (void)   //LCD1602初始化
  101. {
  102.         write_command(0x38);//写入0x38（命令6）：两行显示，5X7点阵，8位数据接口
  103.         _nop_();                                                //空操作
  104.         write_command(0x0C);//写入0x38（命令4）：开整体显示，光标关，无闪烁
  105.         _nop_();                                                //空操作
  106.         write_command(0x04);//写入0x38（命令3）：
  107.         _nop_();                                                //空操作
  108.         write_command(0x01);//写入0x38（命令1）：清屏
  109.         delay1ms();
  110. }
  111. void check_busy (void)//忙检测
  112. {
  113.         uchar dt;
  114.         do
  115.         {
  116.                 dt=0xff;                                        //dt为变量单元，初值为0xff
  117.                 E=0;
  118.                 RS=0;
  119.                 RW=1;
  120.                 E=1;
  121.                 dt=out;                                                //out为LCD数据口，将out的状态送入dt
  122.         }
  123.         while(dt&0x80);                //如果忙标志位BF=1，继续循环检测，等待BF=0
  124.         E=0;                                                                //BF=0，LCD不忙，结束检测
  125. }
  126. void write_command (uchar com)//写命令函数
  127. {
  128.         check_busy();
  129.         E=0;
  130.         RS=0;                                                                                                //RS与E同时为零时。才可以写入命令
  131.         RW=0;
  132.         out=com;                                                                                //将命令com写入数据口
  133.         E=1;                                                                                                //写入命令时，E为上升沿，所以E开始为0
  134.         _nop_();                                       
  135.         E=0;                                                                                                //E由高变低，LCD开始执行命令
  136.         delay1ms();
  137. }
  138. void  write_data(uchar dat)                //写数据函数
  139. {
  140.         check_busy();
  141.         E=0;
  142.         RS=1;
  143.         RW=0;
  144.         out=dat;
  145.         E=1;
  146.         _nop_();
  147.         E=0;
  148.         delay1ms();
  149. }
  150. void string (uchar ad,uchar *s)
  151. {
  152.         write_command(ad);
  153.         while(*s>0)
  154.         {
  155.                 write_data(*s++);                                        //输出字符串，且指针加一
  156.                 delay1ms();
  157.         }
  158. }
  159. void string1(uchar ad,uchar a)
  160. {uchar b=0,c=0;
  161.         write_command(ad);
  162.         ad=ad+0x01;
  163.         b=a/10;
  164.         b=lcd1602[b];
  165.         write_data(b);
  166.         c=a%10;
  167.         c=lcd1602[c];
  168.         write_data(c);
  169.         
  170. }
  171. void lcd_xs(uchar a)
  172. {
  173.         if(a==0)
  174.         {string(0x83,"->NRF24L01");
  175.          string(0xC5,"HC-08");
  176.         }
  177.                 else if(a==1)
  178.         {string(0x83,"->HC-08");
  179.          string(0xC5,"EV1527");
  180.         }
  181.                 else if(a==2)
  182.         {string(0x83,"->EV1527");
  183.          string(0xC5,"NRF24L01");
  184.         }
  185. }
  186. void delay5us(void)   //误差 0us
  187. {
  188.     unsigned char a;
  189.     for(a=12;a>0;a--);
  190. }

  192. void delay5(uchar n)                        //延时5us程序
  193. {
  194.         do
  195.         {
  196.                 delay5us();
  197.                 n--;
  198.         }
  199.         while(n);
  200. }

  202. void delay1ms(void)   //误差 0us
  203. {
  204.     unsigned char a,b;
  205.     for(b=222;b>0;b--)
  206.         for(a=12;a>0;a--);
  207. }

  209. void delay10ms(void)   //误差 -0.000000000001us
  210. {
  211.     unsigned char a,b;
  212.     for(b=202;b>0;b--)
  213.         for(a=147;a>0;a--);
  214. }
  215. void delay50ms(void)   //误差 -0.000000000003us
  216. {
  217.     unsigned char a,b,c;
  218.     for(c=6;c>0;c--)
  219.         for(b=116;b>0;b--)
  220.             for(a=214;a>0;a--);
  221. }

  223. void delay100ms(void)   //误差 -0.000000000006us
  224. {
  225.     unsigned char a,b,c;
  226.     for(c=246;c>0;c--)
  227.         for(b=116;b>0;b--)
  228.             for(a=9;a>0;a--);
  229. }

  231. //////////////////////////////////////////////////////DS18B20程序开头
  232. void init_ds18b20(void)                        //18B20初始化
  233. {
  234.         uchar x=0;
  235.         DQ=0;
  236.         delay5(120);
  237.         DQ=1;
  238.         delay5(16);
  239.         delay5(80);
  240. }
  241. uchar readbyte(void)                //读取1字节数据
  242. {
  243.         uchar i=0;
  244.         uchar date=0;
  245.         for(i=8;i>0;i--)
  246.         {
  247.                 DQ=0;
  248.                 delay5(1);
  249.                 DQ=1;
  250.                 date>>=1;
  251.                 if(DQ)
  252.                 date|=0x80;
  253.                 delay5(11);               
  254.         }
  255.         return(date);
  256. }
  257. void writebyte(uchar dat)                //写1B函数
  258. {
  259.         uchar i=0;
  260.         for(i=8;i>0;i--)
  261.         {
  262.                 DQ=0;
  263.                 DQ=dat&0x01;
  264.                 delay5(12);
  265.                 DQ=1;
  266.                 dat>>=1;
  267.                 delay5(5);
  268.         }
  269. }
  270. uchar retemp(void)                        //读取温度
  271. {
  272.         uchar a,b,tt;
  273.         uint t;
  274.         init_ds18b20();
  275.         writebyte(0xcc);
  276.         writebyte(0x44);
  277.         init_ds18b20();
  278.         writebyte(0xcc);
  279.         writebyte(0xBE);
  280.         a=readbyte();
  281.         b=readbyte();
  282.         t=b;
  283.         t<<=8;
  284.         t=t|a;
  285.         tt=t*0.0625;
  286.         
  287.         return(tt);
  288. }
  289. ////////////////////////////////////////////DS18B20程序结尾
  290. //NFR24L01发送
  291. void init_io (void)                                                //2401初始化
  292. {
  293.         CE =0;                                                                                        //待机
  294.         CSN=1;                                                                                        //SPI禁止
  295.         SCK=0;                                                                                        //SPI时钟置低
  296.         IRQ=1;                                                                                        //中断复位
  297. }
  298. uchar SPI_RW(uchar byte)                        //根据spi协议，写一节数据到2401，同时读出一节数据
  299. {
  300.         uchar i;
  301.         for(i=0;i<8;i++)                                                        //循环8次
  302.         {
  303.                 MOSI=(byte&0x80);                                        //byte最高位输出到MOSI
  304.                 byte<<=1;                                                                        //低一位移到最高位
  305.                 SCK=1;
  306.                 byte |=MISO;                                                        //读MSIO到byte最低位
  307.                 SCK=0;
  308.         }
  309.         return(byte);                                                                //发回读出的一字节
  310. }
  311. uchar SPI_RW_Reg(uchar reg, uchar value)                //写数据value到reg寄存器
  312. {
  313.         uchar status;
  314.           CSN = 0;                   // CSN置低，开始传输数据
  315.           status = SPI_RW(reg);      // 选择寄存器，同时返回状态字
  316.           SPI_RW(value);             // 然后写数据到该寄存器
  317.           CSN = 1;                   // CSN拉高，结束数据传输
  318.           return(status);            // 返回状态寄存器
  319. }
  320. uchar SPI_Read(uchar reg)                        //从reg寄存器读一字节
  321. {
  322.         uchar reg_val;
  323.         CSN=0;                                                                                        //CSN置低，开始传输数据
  324.         SPI_RW(reg);
  325.         reg_val=SPI_RW(0);
  326.         CSN=1;
  327.         return(reg_val);
  328. }
  329. uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes)        //从reg寄存器读出bytes个字节，通常用来读取接收通道数据或接收/发送地址
  330. {
  331.         uchar status,i;
  332.         CSN=0;
  333.         status=SPI_RW(reg);
  334.         for(i=0;i<bytes;i++)
  335.         pBuf[i]=SPI_RW(0);
  336.         CSN=1;
  337.         return(status);
  338. }
  339. uchar SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)                //把pBuf缓存中的数据写入到nRF24L01，通常用来写入发射通道数据或接收/发送地址
  340. {
  341.         uchar status, i;
  342.           CSN = 0;                    // CSN置低，开始传输数据
  343.           status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
  344.           for(i=0; i<bytes; i++)
  345.             SPI_RW(pBuf[i]);        // 逐个字节写入nRF24L01
  346.           CSN = 1;                    // CSN拉高，结束数据传输
  347.           return(status);             // 返回状态寄存器
  348. }

  350. void RX_Mode(void)                        //这个函数设置nRF24L01为接收模式，等待接收发送设备的数据包
  351. {
  352.         CE = 0;
  353.           SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 接收设备接收通道0使用和发送设备相同的发送地址
  354.           SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);               // 使能接收通道0自动应答
  355.           SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);           // 使能接收通道0
  356.           SPI_RW_Reg(WRITE_REG + RF_CH, 40);                 // 选择射频通道0x40
  357.           SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH);  // 接收通道0选择和发送通道相同有效数据宽度
  358.           SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);            // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
  359.           SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);              // CRC使能，16位CRC校验，上电，接收模式
  360.           CE = 1;                                            // 拉高CE启动接收设备
  361. }
  362. void TX_Mode(uchar * BUF)
  363. {
  364.         CE = 0;
  365.           SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);     // 写入发送地址
  366.           SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 为了应答接收设备，接收通道0地址和发送地址相同
  367.           SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);                  // 写数据包到TX FIFO
  368.           SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);       // 使能接收通道0自动应答
  369.           SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);   // 使能接收通道0
  370.           SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);  // 自动重发延时等待250us+86us，自动重发10次
  371.           SPI_RW_Reg(WRITE_REG + RF_CH, 40);         // 选择射频通道0x40
  372.           SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);    // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
  373.           SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);      // CRC使能，16位CRC校验，上电
  374.         CE = 1;
  375. }
  376. uchar Check_ACK(bit clear)                                //检查接收设备有无接收到数据包，设定没有收到应答信号是否重发
  377. {
  378.         while(IRQ);
  379.         sta = SPI_RW(NOP);                    // 返回状态寄存器
  380.         if(MAX_RT)
  381.                 if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
  382.                         SPI_RW(FLUSH_TX);
  383.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  384.         IRQ = 1;
  385.         if(TX_DS)
  386.                 return(0x00);
  387.         else
  388.                 return(0xff);
  389. }
  390. void NRF24L01_CX(void)                //NRF24L01程序执行
  391. {uchar b=1,temp,a=0,temp1=0x00;
  392.         FMQ=1;
  393.         lcd_initial();                                        //调用lcd初始化
  394.         string(0x80,"24L01TXD:");
  395.         string(0xc0,"RXD:");
  396.         init_io();
  397.         while(b)
  398.         {               
  399.                 temp=retemp();
  400.                 string1(0x8A,temp);        
  401.                 TX_BUF[0] = ~temp;          // 数据送到缓存
  402.                 TX_Mode(TX_BUF);                        // 把nRF24L01设置为发送模式并发送数据
  403.                 //IRQ=0;
  404.                 a=JCAJ();
  405.                 if(a==4)
  406.                         b=0;
  407.                 Check_ACK(1);               // 等待发送完毕，清除TX FIFO
  408.                 RX_Mode();                                // 设置为接收模式
  409.                 sta = SPI_Read(STATUS);          // 读状态寄存器
  410.                  if(RX_DR)                                  // 判断是否接受到数据
  411.                 {
  412.                         SPI_Read_Buf(RD_RX_PLOAD, RX_BUF, TX_PLOAD_WIDTH);  // 从RX FIFO读出数据
  413.                         flag = 1;
  414.                 }
  415.                 SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除RX_DS中断标志
  416.                 if(flag)                           // 接受完成
  417.                         {
  418.                         flag = 0;                       // 清标志
  419.                         temp1 = RX_BUF[0];           // 数据送到temp1
  420.                 }
  421.                         string1(0xCA,temp1);
  422.                 delay50ms();
  423.                 a=JCAJ();
  424.                 if(a==4)
  425.                         b=0;
  426.         }
  427.         
  428. }uchar JCAJ(void)                                                //检测按键按下
  429. {
  430.         uchar x=0,y=0;
  431.         if(K1==0)
  432.         {y=1;
  433.         x=ajlb(y);
  434.                 return x;
  435.         }
  436.         else if(K2==0)
  437.         {y=2;
  438.         x=ajlb(y);
  439.                 return x;
  440.         }
  441.         else if(K3==0)
  442.         {y=3;
  443.         x=ajlb(y);
  444.                 return x;
  445.         }
  446.         else if(K4==0)
  447.         {y=4;
  448.         x=ajlb(y);
  449.                 return x;
  450.         }
  451.         return x;
  452. }
  453. uchar ajlb(uchar x)                        //按键滤波
  454. {
  455.         delay10ms();
  456.         if(x==1)
  457.         {
  458.                 if(K1==0)
  459.                 {return x;}
  460.                 else
  461.                 {x=0;
  462.                  return x;}
  463.         }
  464.         else if(x==2)
  465.         {
  466.                 if(K2==0)
  467.                 {return x;}
  468.                 else
  469.                 {x=0;
  470.                  return x;}
  471.         }
  472.         else if(x==3)
  473.         {
  474.                 if(K3==0)
  475.                 {return x;}
  476.                 else
  477.                 {x=0;
  478.                  return x;}
  479.         }
  480.         else if(x==4)
  481.         {
  482.                 if(K4==0)
  483.                 {return x;}
  484.                 else
  485.                 {x=0;
  486.                  return x;}
  487.         }
  488.                 return x;
  489. }

  491. void main ()
  492. {
  493.                                                                         
  494. NRF24L01_CX();
  495. }
复制代码
回复

使用道具 举报

ID:973695 发表于 2021-10-24 22:21 | 显示全部楼层
粗略看了一下，程序有几个问题：1、两个单片机的程序收发地址应该设置不同；2、工作时得有握手协议来协调收发状态的切换。
建议你先单独写收、发两个程序，调试通过了再合并一起。

评分

参与人数 1黑币 +20 收起 理由
admin + 20

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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