nrf24l01 IRQ脚无法恢复到高电位

zjsxwc

我用中断写的接收端程序，但是只有第一次他irq脚由高电位跳到低电位，然后向status寄存器写相应的位
为1后，irq脚仍旧没有恢复为高电位。然后就无法响应后面的事情了

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. 
   
4. 
   
5. typedef unsigned char uint;//uint is a byte long
   
6. 
   
7. sbit         MISO        =P1^5;
   
8. sbit         MOSI        =P1^1;
   
9. sbit        SCK          =P1^6;
   
10. sbit        CE          =P1^7;
    
11. sbit        CSN                =P1^2;
    
12. sbit        IRQ                =P3^3;
    
13. 
    
14. sbit LED=P3^7;
    
15. 
    
16. #define ADR_WIDTH 5       
    
17. #define AW_ADR_WIDTH 0x03
    
18. #define PLOAD_WIDTH  20
    
19. 
    
20. 
    
21. uint const TX_ADDRESS[ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //address that the RF packets contain
    
22. uint const RX_ADDRESS[ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //RF packets with *which address* that the pipes like to receive
    
23. 
    
24. //THE COMMANDS
    
25. #define READ_REG        0x00           
    
26. #define WRITE_REG       0x20          
    
27. #define RD_RX_PLOAD     0x61           
    
28. #define WR_TX_PLOAD     0xA0           
    
29. #define FLUSH_TX        0xE1          
    
30. #define FLUSH_RX        0xE2           
    
31. #define REUSE_TX_PL     0xE3           
    
32. #define NOP             0xFF           
    
33. 
    
34. //THE REGISTERS' ADDRESSES
    
35. #define CONFIG          0x00   
    
36. #define EN_AA           0x01  
    
37. #define EN_RXADDR       0x02   
    
38. #define SETUP_AW        0x03   
    
39. #define SETUP_RETR      0x04  
    
40. #define RF_CH           0x05  
    
41. #define RF_SETUP        0x06   
    
42. #define STATUS          0x07   
    
43. #define OBSERVE_TX      0x08   
    
44. #define CD              0x09   
    
45. #define RX_ADDR_P0      0x0A   
    
46. #define RX_ADDR_P1      0x0B  
    
47. #define RX_ADDR_P2      0x0C  
    
48. #define RX_ADDR_P3      0x0D  
    
49. #define RX_ADDR_P4      0x0E  
    
50. #define RX_ADDR_P5      0x0F   
    
51. #define TX_ADDR         0x10   
    
52. #define RX_PW_P0        0x11  
    
53. #define RX_PW_P1        0x12   
    
54. #define RX_PW_P2        0x13   
    
55. #define RX_PW_P3        0x14  
    
56. #define RX_PW_P4        0x15   
    
57. #define RX_PW_P5        0x16   
    
58. #define FIFO_STATUS     0x17  
    
59. 
    
60. 
    
61. uint         bdata sta;  
    
62. sbit        RX_DR        =sta^6;
    
63. sbit        TX_DS        =sta^5;
    
64. sbit        MAX_RT        =sta^4;
    
65. 
    
66. 
    
67. //THE FUNCTIONS
    
68. uint SPI_write_byte(uint the_byte){
    
69.         uint count;
    
70.         SCK=0;
    
71.         for (count=0;count<8;count++){
    
72.                 MOSI=(the_byte&0x80);//get the left most bit of the byte,and put on MOSI
    
73.                 the_byte=the_byte<<1;//left move one bit
    
74.                 SCK=1;                                                        //the SCK upside occurs,nrf24 eats the bit on mosi,nrf24 generates the bit on miso
    
75.                 the_byte = the_byte|MISO;//the right most bit of the byte become MISO
    
76.                 SCK=0;
    
77.         }
    
78.         return the_byte;
    
79. }
    
80. 
    
81. uint SPI_WRITE_REG_DATA_OR_CMD(uint reg,uint data_cmd){
    
82.         uint status;
    
83.         CSN =0;
    
84.         status =SPI_write_byte(reg);
    
85.         SPI_write_byte(data_cmd);
    
86.         CSN=1;
    
87.         return status;
    
88. }
    
89. 
    
90. uint SPI_WRITE_REG_ARRAY(uint reg,uint * array,uint length){
    
91.         uint status,count;
    
92.         CSN=0;
    
93.         status =SPI_write_byte(reg);
    
94.         for (count=0;count<length;count++){
    
95.                 SPI_write_byte(array[count]);
    
96.         }
    
97.         CSN=1;
    
98.         return status;
    
99. }
    
100. 
     
101. void inerDelay_us(unsigned char n){
     
102.         for(;n>0;n--) _nop_();
     
103. }
     
104. void init_NRF24L01(void){
     
105.         inerDelay_us(200);//100 us is okay,but 100 us as redundance
     
106.         CE=0;         //let nrf24 stop Trans/Recev packets
     
107.         CSN=0;        //let spi starts to work
     
108.         SCK=0;        //ready for SCK upside
     
109.        
     
110.         //set the addresses width
     
111.         SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+SETUP_AW,AW_ADR_WIDTH);
     
112.         //write the addr width
     
113.         SPI_WRITE_REG_ARRAY(WRITE_REG+TX_ADDR,TX_ADDRESS,ADR_WIDTH);
     
114.         SPI_WRITE_REG_ARRAY(WRITE_REG+RX_ADDR_P0,RX_ADDRESS,ADR_WIDTH);
     
115.        
     
116.         SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+EN_RXADDR,0x01);        //allow pipe0 to receive packets
     
117. //        SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+EN_AA,0x01);                        //allow pipe0 auto ACK,enter the SHOCKBURST MODE
     
118.         SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+EN_AA,0x00);
     
119.         SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+RF_CH,0);                                        //let the channel become 2.4000 GHz
     
120.         SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+RX_PW_P0,PLOAD_WIDTH);//set the payload width of pipe0
     
121.   SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+RF_SETUP,0x07);                //let the data rate 1 Mbps,the power amplifier 0 dBm
     
122.        
     
123.         CSN=1;
     
124.        
     
125. }
     
126. 
     
127. void SET_RX_MODE(void){
     
128.         CE=0;                //stop nrf24 Trans/Recv
     
129.         SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+CONFIG,0x0f);
     
130.         //1. allow all 3 interrupts,
     
131.         //2. allow 16 bits CRC code,
     
132.         //3. start PWR_UP,
     
133.         //4. PRIM_RX=1,let nrf24 become RX MODE
     
134.        
     
135.         CE=1;                //start listining to receive packets
     
136.         inerDelay_us(200);//130 us is okay,but 70 us as redundance
     
137. }
     
138. 
     
139. 
     
140. 
     
141. 
     
142. 
     
143. 
     
144. uint SPI_READ_REG(uint reg){
     
145.         uint status,val;
     
146.         CSN=0;
     
147.         status=SPI_write_byte(READ_REG+reg);//bcs READ_REG =0,so just a form for uinty
     
148.         val=SPI_write_byte(READ_REG+0);
     
149.         CSN=1;
     
150.         return val;
     
151. }
     
152. 
     
153. uint SPI_READ_REG_ARRAY(uint reg, uint * array, uint length)
     
154. {
     
155.         uint status,count;
     
156.        
     
157.         CSN = 0;                                   
     
158.         status = SPI_write_byte(reg);                      
     
159.        
     
160.         for(count=0;count<length;count++)
     
161.                 array[count] = SPI_write_byte(0);   
     
162.         SPI_write_byte(FLUSH_RX );
     
163.         CSN = 1;                           
     
164.        
     
165.         return(status);                    
     
166. }
     
167. 
     
168.        
     
169. 
     
170. 
     
171. 
     
172. 
     
173. 
     
174. 
     
175. 
     
176. 
     
177. //THE NORMAL FUNCTION
     
178. /*
     
179. void longdelay(void){
     
180.         uint n=100,m=100,k=200;
     
181.         for (;k>0;k--) for (;m>0;m--) for (;n>0;n--) _nop_();
     
182. }*/
     
183. uint payload[PLOAD_WIDTH]={0};
     
184. 
     
185. void main(){
     
186. 
     
187. 
     
188. 
     
189.   init_NRF24L01();
     
190.         CE=0;
     
191.         SET_RX_MODE();
     
192.         CE=1;
     
193.   
     
194.         IT1=0;
     
195.         EX1=1;
     
196.         EA=1;
     
197.         PX1=0;
     
198. 
     
199. 
     
200.         LED=0;
     
201.   while (1){
     
202.                         payload[2]=0;
     
203.                         sta=SPI_READ_REG(STATUS);
     
204.        
     
205.                         if (RX_DR)        {
     
206.                                 SPI_READ_REG_ARRAY(RD_RX_PLOAD,payload,PLOAD_WIDTH);
     
207.        
     
208.                
     
209.                
     
210.                         }
     
211.                                 SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+STATUS,sta);//回写后irq没恢复。
     
212.                         if (payload[2]) LED=~LED;
     
213.                
     
214.         }
     
215.                
     
216. }
     
217. 
     
218. void Renrf24() interrupt 2
     
219. {
     
220.         payload[2]=0;
     
221.        
     
222.         sta=SPI_READ_REG(STATUS);
     
223.        
     
224.         if (RX_DR)        {
     
225.                 SPI_READ_REG_ARRAY(RD_RX_PLOAD,payload,PLOAD_WIDTH);
     
226.                 SPI_WRITE_REG_DATA_OR_CMD(WRITE_REG+STATUS,sta);//回写后irq没恢复。
     
227.        
     
228.                
     
229.         }
     
230. 
     
231.        
     
232.        
     
233.        
     
234.        
     
235.         if (payload[2]==1) {
     
236.                 if (LED=0) LED=1;
     
237.                 else LED=0;
     
238.         }
     
239. 
     
240. }
     

复制代码

noynot

中断状态要手动清除，回写状态字

zjsxwc

noynot 发表于 2013-3-24 17:49
中断状态要手动清除，回写状态字

就是回写了后没有恢复

noynot

中断PIN是几个共用的，特别是接收数据缓冲，需要把缓冲区的数据都读取

zjsxwc

noynot 发表于 2013-3-24 21:13
中断PIN是几个共用的，特别是接收数据缓冲，需要把缓冲区的数据都读取

多谢你的回复，我发现原因了，是因为我本来不想使用自动回复，于是把AA都设置为0，把pipe 0的AA设置为自动恢复后就可以恢复irq脚了。应该是在没有自动回复时tx fifo中有东西没发完