关于2.4g的自动应答模式的问题。

最近在弄2.4g，在用2.4g的自动应答模式的时候遇到了个问题，发现发送端有时会接收不到应答信号，导致重复发送数据，但是每次发送数据接收端都能收到，接收端接收到数据之后是会自动发送应答信号的，所以我觉得不会是接收端没有发送应答信号，应该是发送端没收到，不知道有没有人能帮我解答一下这个问题。

1. #include <reg51.h>
   
2. #include <api.h>
   
3. 
   
4. #define uchar unsigned char
   
5. 
   
6. /***************************************************/
   
7. #define TX_ADR_WIDTH   5  // 5字节宽度的发送/接收地址
   
8. #define TX_PLOAD_WIDTH 4  // 数据通道有效数据宽度
   
9. #define LED P1
   
10. 
    
11. uchar code TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};  // 定义一个静态发送地址
    
12. uchar RX_BUF[TX_PLOAD_WIDTH];
    
13. uchar TX_BUF[TX_PLOAD_WIDTH];
    
14. uchar DATA = 0x0f;
    
15. uchar bdata sta;
    
16. uchar buff[4]={0x01,0x02,0x03,0x04};
    
17. sbit  RX_DR         = sta^6;
    
18. sbit  TX_DS         = sta^5;
    
19. sbit  MAX_RT = sta^4;
    
20. /**************************************************/
    
21. 
    
22. /**************************************************
    
23. 函数：delay_ms()
    
24. 
    
25. 描述：
    
26.     延迟x毫秒
    
27. /**************************************************/
    
28. void delay_ms(uchar x)
    
29. {
    
30.     uchar i, j;
    
31.     i = 0;
    
32.     for(i=0; i<x; i++)
    
33.     {
    
34.        j = 250;
    
35.        while(--j);
    
36. 
    
37.            j = 250;
    
38.        while(--j);
    
39.     }
    
40. }
    
41. /**************************************************/
    
42. 
    
43. /**************************************************
    
44. 函数：SPI_RW()
    
45. 
    
46. 描述：
    
47.     根据SPI协议，写一字节数据到nRF24L01，同时从nRF24L01
    
48.         读出一字节
    
49. /**************************************************/
    
50. uchar SPI_RW(uchar byte)
    
51. {
    
52.         uchar i;
    
53.            for(i=0; i<8; i++)          // 循环8次
    
54.            {
    
55.                    MOSI = (byte & 0x80);   // byte最高位输出到MOSI
    
56.                    byte <<= 1;             // 低一位移位到最高位
    
57.                    SCK = 1;                // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
    
58.                    byte |= MISO;               // 读MISO到byte最低位
    
59.                    SCK = 0;                    // SCK置低
    
60.            }
    
61.     return(byte);                   // 返回读出的一字节
    
62. }
    
63. /**************************************************/
    
64. 
    
65. /**************************************************
    
66. 函数：SPI_RW_Reg()
    
67. 
    
68. 描述：
    
69.     写数据value到reg寄存器
    
70. /**************************************************/
    
71. uchar SPI_RW_Reg(uchar reg, uchar value)
    
72. {
    
73.         uchar status;
    
74.           CSN = 0;                   // CSN置低，开始传输数据
    
75.           status = SPI_RW(reg);      // 选择寄存器，同时返回状态字
    
76.           SPI_RW(value);             // 然后写数据到该寄存器
    
77.           CSN = 1;                   // CSN拉高，结束数据传输
    
78.           return(status);            // 返回状态寄存器
    
79. }
    
80. /**************************************************/
    
81. 
    
82. /**************************************************
    
83. 函数：SPI_Read()
    
84. 
    
85. 描述：
    
86.     从reg寄存器读一字节
    
87. /**************************************************/
    
88. uchar SPI_Read(uchar reg)
    
89. {
    
90.         uchar reg_val;
    
91.           CSN = 0;                    // CSN置低，开始传输数据
    
92.           SPI_RW(reg);                // 选择寄存器
    
93.           reg_val = SPI_RW(0);        // 然后从该寄存器读数据
    
94.           CSN = 1;                    // CSN拉高，结束数据传输
    
95.           return(reg_val);            // 返回寄存器数据
    
96. }
    
97. /**************************************************/
    
98. 
    
99. /**************************************************
    
100. 函数：SPI_Read_Buf()
     
101. 
     
102. 描述：
     
103.     从reg寄存器读出bytes个字节，通常用来读取接收通道
     
104.         数据或接收/发送地址
     
105. /**************************************************/
     
106. uchar SPI_Read_Buf(uchar reg, uchar * pBuf, uchar bytes)
     
107. {
     
108.         uchar status, i;
     
109.           CSN = 0;                    // CSN置低，开始传输数据
     
110.           status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
     
111.           for(i=0; i<bytes; i++)
     
112.             pBuf[i] = SPI_RW(0);    // 逐个字节从nRF24L01读出
     
113.           CSN = 1;                    // CSN拉高，结束数据传输
     
114.           return(status);             // 返回状态寄存器
     
115. }
     
116. /**************************************************/
     
117. 
     
118. /**************************************************
     
119. 函数：SPI_Write_Buf()
     
120. 
     
121. 描述：
     
122.     把pBuf缓存中的数据写入到nRF24L01，通常用来写入发
     
123.         射通道数据或接收/发送地址
     
124. /**************************************************/
     
125. uchar SPI_Write_Buf(uchar reg, uchar * pBuf, uchar bytes)
     
126. {
     
127.         uchar status, i;
     
128.           CSN = 0;                    // CSN置低，开始传输数据
     
129.           status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
     
130.           for(i=0; i<bytes; i++)
     
131.             SPI_RW(pBuf[i]);        // 逐个字节写入nRF24L01
     
132.           CSN = 1;                    // CSN拉高，结束数据传输
     
133.           return(status);             // 返回状态寄存器
     
134. }
     
135. /**************************************************/
     
136. 
     
137. /**************************************************
     
138. 函数: init_io()
     
139. 
     
140. 描述:
     
141.     初始化IO
     
142. /**************************************************/
     
143. void init_io(void)
     
144. {
     
145.         CE  = 0;        // 待机
     
146.         CSN = 1;        // SPI禁止
     
147.         SCK = 0;        // SPI时钟置低
     
148.         IRQ = 1;        // 中断复位
     
149.         LED = 0xff;                // 关闭指示灯
     
150.         SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);       // 使能自动应答
     
151.           SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);   // 使能接收通道0
     
152.           SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // 接收通道0选择和发送通道相同有效数据宽度
     
153.         SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0xfa);  // 自动重发延时等待4000us+86us，自动重发10次
     
154.           SPI_RW_Reg(WRITE_REG + RF_CH, 0x00);       // 选择射频通道0x40
     
155.           SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);    // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
     
156. }
     
157. /**************************************************/
     
158. 
     
159. /**************************************************
     
160. 函数：TX_Mode()
     
161. 
     
162. 描述：
     
163.     这个函数设置nRF24L01为发送模式，（CE=1持续至少10us），
     
164.         130us后启动发射，数据发送结束后，发送模块自动转入接收
     
165.         模式等待应答信号。
     
166. /**************************************************/
     
167. void TX_Mode(uchar * BUF)
     
168. {
     
169.         CE = 0;
     
170.           SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);     // 写入发送地址
     
171.     SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 为了应答接收设备，接收通道0地址和发送地址相同
     
172.           SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);                  // 写数据包到TX FIFO
     
173.           SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);      // CRC使能，16位CRC校验，上电,设置为发射模式
     
174.         CE = 1;
     
175.         delay_ms(5);
     
176. }
     
177. /**************************************************/
     
178. 
     
179. /**************************************************
     
180. 函数：main()
     
181. 
     
182. 描述：
     
183.     主函数
     
184. /**************************************************/
     
185. void main(void)
     
186. {
     
187.         init_io();                              // 初始化I
     
188.     while(1)
     
189.         {
     
190.                 TX_BUF[0] = ~DATA;          // 数据送到缓存
     
191.                 TX_Mode(TX_BUF);                        // 把nRF24L01设置为发送模式并发送数据
     
192.                 delay_ms(250);
     
193.                 while(IRQ);
     
194.                 sta = SPI_Read(STATUS);          // 读状态寄存器
     
195.                 SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
     
196.                 SPI_RW(FLUSH_TX);
     
197.                 if(TX_DS&sta){
     
198.                         LED = 0x0f;
     
199.                         DATA <<= 1;
     
200.                         if(！DATA)
     
201.                                 DATA = 0x01;
     
202.                         delay_ms(250);
     
203.                         LED = 0xff;
     
204.                 }
     
205. //                if(MAX_RT&sta){
     
206. //                        LED = 0x00;                                                                                                                                          
     
207. //                        delay_ms(250);
     
208. //                        LED = 0xff;
     
209. //                        }                                                                                               
     
210.         }
     
211. }
     
212. /*****************************************

复制代码