2.4G nRF24L01无线通信

13009621840

火哥，flyleaf哥，各位坛友，最近在调试2.4G nRF24L01无线通信，按照官方提供的程序两个板子已经调通了，主从之间可以正常的收发数据，但是前提就是官方说明中提到的必须先给从机供电，再给主机供电才能正常的通信，现在想做的先给主机供电（主机一直被供电），再给从机供电，完成主从之间的通信，程序流程应该怎么修改？？

flyleaf

改成用按键发送，按按 键才发送数据，平时一直在接收状态等待

13009621840

flyleaf 发表于 2017-8-28 09:32
改成用按键发送，按按 键才发送数据，平时一直在接收状态等待

flyleaf哥，我的应用里不能用按键发送，要让主机自动发送，并且主机一直处于工作状态，当有从机时，从机接收数据，并把收到的数据再发给主机，这样应该怎么解决？？

flyleaf

13009621840 发表于 2017-8-28 11:34
flyleaf哥，我的应用里不能用按键发送，要让主机自动发送，并且主机一直处于工作状态，当有从机时，从机 ...

那主机就一直发，从机就一直收就好了

13009621840

flyleaf 发表于 2017-8-28 11:56
那主机就一直发，从机就一直收就好了

不行啊，我想让从机收到的数据再发给主机，主从机要有收发功能，这该怎么办

马贞茂

13009621840 发表于 2017-8-29 15:36
不行啊，我想让从机收到的数据再发给主机，主从机要有收发功能，这该怎么办

主从机的中断接口和自动应答功能要打开，利用好中断信号，使用起来就比较方便了。空闲时从机一直处于接受状态，主机处于发送状态。主机发送数据后等待发送完成中断，主机检测到发送完成信号后随即进入接收状态（未检测到发送完成信号就一直发送数据）。从机接收到主机发送的数据后随即进入发送模式发送数据，从机检测到发送完成信号后随即进入接收模式（整个过程中在有需要的地方加入容错机制）。实测，通讯非常稳定哦，不存在必须那方先后通电的问题。

13009621840

马贞茂 发表于 2017-8-29 16:14
主从机的中断接口和自动应答功能要打开，利用好中断信号，使用起来就比较方便了。空闲时从机一直处于接受 ...

我的程序里就是按您说的流程走的，主机程序：
        while(1)
                {
                   //主机端 进入自应答发送模式
                 NRF_TX_Mode();                        
                //开始发送数据       
                status = NRF_Tx_Dat(txbuf);                            
                 //判断发送状态
                 switch(status)
                  {
                           case MAX_RT:
                // 主机端 没接收到应答信号，发送次数超过限定值，发送失败。
                                LEDG_ON();        //绿灯                       
                                 break;
       
                          case ERROR:
               //未知原因导致发送失败。
                                LEDR_ON();        //红灯                                  
                                 break;       

                          case TX_DS:
                // 主机端 接收到 从机端 的应答信号，发送成功！
                                LEDB_ON();        //蓝灯                                                 
                                 break;                                                                 
                          }                                  
       
                 //主机端 进入接收模式。       
                NRF_RX_Mode();       
                        //等待接收数据
                status = NRF_Rx_Dat(rxbuf);       
                        //判断接收状态
                        switch(status)
                        {
                         case RX_DR:    //主机端 接收到 从机端 发送的数据为：rxbuf
                                 for(i=0;i<4;i++)
                                {                                               
                                        if(txbuf == rxbuf)
                                        {
                                        count++;
                                        }
                                }
                           if(count>=4)
                                 {
                                  count=0;
                                  LEDB_ON();
                                  Delay_MS(500);
                                  LEDB_OFF();
                                  Delay_MS(500);               
                                 }
                                 else
                                 {
                                  count=0;
                                  LEDR_ON();
                                  Delay_MS(500);
                                  LEDR_OFF();
                                  Delay_MS(500);
                                 }                                        
                                  break;
       
                         case ERROR:      //主机端 未接收任何数据
                                  {
                                  LEDR_ON();
                                  Delay_MS(500);
                                  LEDR_OFF();
                                  Delay_MS(500);
                                 }       
                                  break;                 
                        }
                }

这里面我自己定义了一个数组ceshi[]，用来测试主机发给从机，从机接收到数据后再原样发回来，数据和之前的一不一样。用到中断的地方就是您说的发送完成中断和接收完成中断，程序贴在下面：
u8 NRF_Tx_Dat(u8 *txbuf)     //发送数据函数
{
        u8 state;  
         /*ce为低，进入待机模式1*/
        NRF_CE_LOW();
        /*写数据到TX BUF 最大 32个字节*/                                               
   SPI_NRF_WriteBuf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);
      /*CE为高，txbuf非空，发送数据包 */   
         NRF_CE_HIGH();                 
          /*等待发送完成中断 */                           
        while(NRF_Read_IRQ()!=0);                
        /*读取状态寄存器的值 */                              
        state = SPI_NRF_ReadReg(STATUS);
         /*清除TX_DS或MAX_RT中断标志*/                  
        SPI_NRF_WriteReg(NRF_WRITE_REG+STATUS,state);        
        SPI_NRF_WriteReg(FLUSH_TX,NOP);    //清除TX FIFO寄存器
         /*判断中断类型*/   
        if(state&MAX_RT)                     //达到最大重发次数
                         return MAX_RT;
        else if(state&TX_DS)                  //发送完成
                         return TX_DS;
         else                                                  
                        return ERROR;                 //其他原因发送失败
}


u8 NRF_Rx_Dat(u8 *rxbuf)        //接收数据函数
{
        u8 state;
        NRF_CE_HIGH();         //进入接收状态
         /*等待接收中断*/
        while(NRF_Read_IRQ()!=0);        
        NRF_CE_LOW();           //进入待机状态
        /*读取status寄存器的值  */               
        state=SPI_NRF_ReadReg(STATUS);         
        /* 清除中断标志*/      
        SPI_NRF_WriteReg(NRF_WRITE_REG+STATUS,state);
        /*判断是否接收到数据*/
        if(state&RX_DR)                                 //接收到数据
        {
          SPI_NRF_ReadBuf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
             SPI_NRF_WriteReg(FLUSH_RX,NOP);          //清除RX FIFO寄存器
          return RX_DR;
        }
        else   
                return ERROR;                    //没收到任何数据
}


是不是在把配置寄存器配置为0x0e，然后下面是从机的程序：
  while(1)
  {                          
        //从机端 进入接收模式
        NRF_RX_Mode();         
        //等待接收数据
        status = NRF_Rx_Dat(rxbuf);
        //判断接收状态
        if(status == RX_DR)
        {
         for(i=0;i<4;i++)
         {       
                 //从机端 接收到 主机端 发送的数据为：rxbuf
                if(ceshi == rxbuf)
                   {
                count++;
                txbuf = rxbuf;
                }
         }
         if(count>=4)
         {
          count=0;
          LEDG_ON(); LEDR_ON();LEDB_ON();
          Delay_MS(500);
          LEDG_OFF(); LEDR_OFF();LEDB_OFF();
          Delay_MS(500);               
         }
         else
         {
          count=0;
          LEDB_ON();
          Delay_MS(500);
          LEDB_OFF();
          Delay_MS(500);
         }                  
   }  
  if( Key_Scan(GPIOB,GPIO_Pin_8) == KEY_ON  )
        {
         LEDG_OFF(); LEDR_OFF();LEDB_OFF();       
        }  
                //从机端 进入自应答发送模式
                  NRF_TX_Mode();
                //不断重发，直至发送成功          
         do
           {           
                status = NRF_Tx_Dat(txbuf);
                }while(status == MAX_RT);
  }

从机端的发送数据函数和接收数据函数和主机端的一样，麻烦您帮我看看我这个问题出在哪，这基本上是野火官方提供的程序，我只是加了一下指示灯和一些简单的判断，如果您方便的话能把您的程序给我发一下吗，2294166974@qq.com，谢谢您

马贞茂

这里说明一点，火哥的这个NRF程序注重的是功能的实现，做开发的话还有待优化。

1. while(1)
   
2. {
   
3.         //主机端 进入自应答发送模式
   
4.         NRF_TX_Mode();                        
   
5.         //开始发送数据        
   
6.         status = NRF_Tx_Dat(txbuf);                           
   
7.         //判断发送状态
   
8.         switch(status)
   
9.         {
   
10.                 case MAX_RT:
    
11.                 // 主机端 没接收到应答信号，发送次数超过限定值，发送失败。
    
12.                 LEDG_ON();        //绿灯                        
    
13.                 break;
    
14. 
    
15.                 case ERROR:
    
16.                 //未知原因导致发送失败。
    
17.                 LEDR_ON();        //红灯                                   
    
18.                 break;        
    
19. 
    
20.                 case TX_DS:
    
21.                 // 主机端 接收到 从机端 的应答信号，发送成功！
    
22.                 LEDB_ON();        //蓝灯                                                  
    
23.                 break;                                                                  
    
24.         }                                   
    
25. 
    
26.         //主机端 进入接收模式。        
    
27.         NRF_RX_Mode();       //(从以上程序可以看出来，不管主机数据是不是发送成功，都会进入接收模式)
    
28.         //等待接收数据
    
29.         status = NRF_Rx_Dat(rxbuf);        
    
30.         //判断接收状态
    
31.         switch(status)
    
32.         {
    
33.                 case RX_DR:    //主机端 接收到 从机端 发送的数据为：rxbuf
    
34.                 for(i=0;i<4;i++)
    
35.                 {                                                
    
36.                         if(txbuf == rxbuf)
    
37.                         {
    
38.                         count++;
    
39.                         }
    
40.                 }
    
41.                 if(count>=4)
    
42.                 {
    
43.                         count=0;
    
44.                         LEDB_ON();
    
45.                         Delay_MS(500);
    
46.                         LEDB_OFF();
    
47.                         Delay_MS(500);               
    
48.                 }
    
49.                 else
    
50.                 {
    
51.                         count=0;
    
52.                         LEDR_ON();
    
53.                         Delay_MS(500);
    
54.                         LEDR_OFF();
    
55.                         Delay_MS(500);
    
56.                 }                                         
    
57.                 break;
    
58. 
    
59.                 case ERROR:      //主机端 未接收任何数据
    
60.                 {
    
61.                         LEDR_ON();
    
62.                         Delay_MS(500);
    
63.                         LEDR_OFF();
    
64.                         Delay_MS(500);
    
65.                 }        
    
66.                 break;                  
    
67.         }
    
68. }
    
69. 
    
70. //这里面我自己定义了一个数组ceshi[]，用来测试主机发给从机，从机接收到数据后再原样发回来，数据和之前的一不一样。用到中断的地方就是您说的发送完成中断和接收完成中断，程序贴在下面：
    
71. u8 NRF_Tx_Dat(u8 *txbuf)     //发送数据函数
    
72. {
    
73.         u8 state;  
    
74.         /*ce为低，进入待机模式1*/
    
75.         NRF_CE_LOW();
    
76.         /*写数据到TX BUF 最大 32个字节*/                                                
    
77.         SPI_NRF_WriteBuf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);
    
78.         /*CE为高，txbuf非空，发送数据包 */   
    
79.         NRF_CE_HIGH();                  
    
80.         /*等待发送完成中断 */                           
    
81.         while(NRF_Read_IRQ()!=0);                 
    
82.         /*读取状态寄存器的值 */                              
    
83.         state = SPI_NRF_ReadReg(STATUS);
    
84.         /*清除TX_DS或MAX_RT中断标志*/                  
    
85.         SPI_NRF_WriteReg(NRF_WRITE_REG+STATUS,state);         
    
86.         SPI_NRF_WriteReg(FLUSH_TX,NOP);    //清除TX FIFO寄存器
    
87.         /*判断中断类型*/   
    
88.         if(state&MAX_RT)                     //达到最大重发次数
    
89.                 return MAX_RT;
    
90.         else if(state&TX_DS)                  //发送完成
    
91.                 return TX_DS;
    
92.         else                                                  
    
93.                 return ERROR;                 //其他原因发送失败
    
94. }
    
95. 
    
96. 
    
97. u8 NRF_Rx_Dat(u8 *rxbuf)        //接收数据函数
    
98. {
    
99.         u8 state;
    
100.         NRF_CE_HIGH();         //进入接收状态
     
101.         /*等待接收中断*/
     
102.         while(NRF_Read_IRQ()!=0);        //(假如没接收到数据，程序是不是会死在这里？估计你先后上电得问题就出在这里)
     
103.         NRF_CE_LOW();           //进入待机状态
     
104.         /*读取status寄存器的值  */               
     
105.         state=SPI_NRF_ReadReg(STATUS);         
     
106.         /* 清除中断标志*/      
     
107.         SPI_NRF_WriteReg(NRF_WRITE_REG+STATUS,state);
     
108.         /*判断是否接收到数据*/
     
109.         if(state&RX_DR)                                 //接收到数据
     
110.         {
     
111.                 SPI_NRF_ReadBuf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
     
112.                 SPI_NRF_WriteReg(FLUSH_RX,NOP);          //清除RX FIFO寄存器
     
113.                 return RX_DR;
     
114.         }
     
115.         else   
     
116.                 return ERROR;                    //没收到任何数据
     
117. }
     
118. 
     
119. 
     
120. //是不是在把配置寄存器配置为0x0e，然后下面是从机的程序：
     
121. while(1)
     
122. {                           
     
123.         //从机端 进入接收模式
     
124.         NRF_RX_Mode();         
     
125.         //等待接收数据
     
126.         status = NRF_Rx_Dat(rxbuf);
     
127.         //判断接收状态
     
128.         if(status == RX_DR)
     
129.         {
     
130.                 for(i=0;i<4;i++)
     
131.                 {        
     
132.                 //从机端 接收到 主机端 发送的数据为：rxbuf
     
133.                         if(ceshi == rxbuf)       //(这两个不变的数组指针在这里比较四次是什么意思？)
     
134.                         {
     
135.                                 count++;
     
136.                                 txbuf = rxbuf;
     
137.                         }
     
138.                 }
     
139.                 if(count>=4)
     
140.                 {
     
141.                         count=0;
     
142.                         LEDG_ON(); LEDR_ON();LEDB_ON();
     
143.                         Delay_MS(500);
     
144.                         LEDG_OFF(); LEDR_OFF();LEDB_OFF();
     
145.                         Delay_MS(500);               
     
146.                 }
     
147.                 else
     
148.                 {
     
149.                         count=0;
     
150.                         LEDB_ON();
     
151.                         Delay_MS(500);
     
152.                         LEDB_OFF();
     
153.                         Delay_MS(500);
     
154.                 }                  
     
155.         }  
     
156.         if( Key_Scan(GPIOB,GPIO_Pin_8) == KEY_ON  )
     
157.         {
     
158.                 LEDG_OFF(); LEDR_OFF();LEDB_OFF();        
     
159.         }  
     
160.         //从机端 进入自应答发送模式
     
161.         NRF_TX_Mode();
     
162.         //不断重发，直至发送成功         
     
163.         do
     
164.         {           
     
165.                 status = NRF_Tx_Dat(txbuf);
     
166.         }while(status == MAX_RT);
     
167. }
     
168. 
     
169. /***********分割线************/
     
170. 这里贴出我的部分代码，仅供参考，不足的地方欢迎指正。
     
171. 
     
172. extern         uint8_t        TX_End_Flag;
     
173. void NRF_Tx_Dat(u8 *txbuf)
     
174. {
     
175.         while(TX_End_Flag);
     
176.         SPI_NRF_WriteBuf(WR_TX_PLOAD,txbuf,PLOAD_WIDTH); /*写数据到TX BUF 最大 32个字节*/
     
177.         TX_End_Flag=1;                     
     
178. }
     
179. 
     
180. uint8_t                RX_Buf[32];
     
181. uint8_t                TX_End_Flag=0;
     
182. void EXTI4_IRQHandler(void)
     
183. {
     
184.         uint8_t states;
     
185.         if((EXTI->PR&EXTI_Line4)==EXTI_Line4)
     
186.         {
     
187.                 states = SPI_NRF_ReadReg(STATUS);
     
188.                 SPI_NRF_WriteReg(NRF_WRITE_REG+STATUS,states);
     
189.                 switch(states&0x70)
     
190.                 {
     
191.                         case RX_DR:                                                                                //接收中断
     
192.                                 SPI_NRF_ReadBuf(RD_RX_PLOAD,RX_Buf,PLOAD_WIDTH);
     
193.                                 break;
     
194.                         case TX_DS:                                                                                //发送中断
     
195.                                 TX_End_Flag=0;
     
196.                                 break;
     
197.                         case MAX_RT:                                                                        //达到最大重发次数中断
     
198.                                 SPI_NRF_WriteReg(FLUSH_TX,NOP);
     
199.                                 TX_End_Flag=0;
     
200.                                 break;
     
201.                 }
     
202.                 EXTI->PR = EXTI_Line4;
     
203.         }
     
204. }
     

复制代码

马贞茂

源码不方便给你（商用的）。另外在仔细考虑一下我这句话的意思“主从机的中断接口和自动应答功能要打开，利用好中断信号，使用起来就比较方便了。空闲时从机一直处于接受状态，主机处于发送状态。主机发送数据后等待发送完成中断，主机检测到发送完成信号后随即进入接收状态（未检测到发送完成信号就一直发送数据）。从机接收到主机发送的数据后随即进入发送模式发送数据，从机检测到发送完成信号后随即进入接收模式（整个过程中在有需要的地方加入容错机制）。”

13009621840

马贞茂 发表于 2017-8-29 19:56
源码不方便给你（商用的）。另外在仔细考虑一下我这句话的意思“主从机的中断接口和自动应答功能要打开，利 ...

好吧，还是谢谢您