用NRF2401做遥控小车，硬件没有问题，不明白为什么不能收到信息

附上代码
发送：

1. #include<stc15.h>
   
2. #include<intrins.h>
   
3. #include <STC15F2K60S2.H>
   
4. #define unchar unsigned char
   
5. #define unint unsigned int
   
6. #define MAX_TX 0X10  //???????????ж?
   
7. #define TX_OK 0X20    //TX????????ж?
   
8. #define RX_OK  0X40   //??????????ж?
   
9. //NRF24l01????????
   
10. /*******************************************************/
    
11. #define TX_ADDR_WITDH 5 //??????????????5?????
    
12. #define RX_ADDR_WITDH 5 //??????????????5?????
    
13. #define TX_DATA_WITDH 3//??????????2?????
    
14. #define RX_DATA_WITDH 3//??????????2?????
    
15. /*******************????????***************************/
    
16. #define  R_REGISTER      0x00//??????ü????
    
17. #define  W_REGISTER      0x20//д???ü????
    
18. #define  R_RX_PAYLOAD   0x61//???RX??Ч????
    
19. #define  W_TX_PAYLOAD  0xa0//дTX??Ч????
    
20. #define  FLUSH_TX   0xe1//???TXFIFO?????
    
21. #define  FLUSH_RX   0xe2//???RXFIFO?????
    
22. #define  REUSE_TX_PL     0xe3//??????????????Ч????
    
23. #define  NOP             0xff//?????
    
24. /******************????????****************************/
    
25. #define  CONFIG          0x00//???ü????
    
26. #define  EN_AA    0x01//?????????
    
27. #define  EN_RXADDR       0x02//??????????0-5?????
    
28. #define  SETUP_AW        0x03//?????????????????3-5
    
29. #define  SETUP_RETR      0x04//??????????
    
30. #define  RF_CH           0x05//??????????
    
31. #define  RF_SETUP        0x06//????????
    
32. #define  STATUS          0x07//???????
    
33. #define  OBSERVE_TX      0x08//??????????
    
34. #define  CD              0x09//???
    
35. #define  RX_ADDR_P0      0x0a//???????0??????
    
36. #define  RX_ADDR_P1      0x0b//???????1??????
    
37. #define  RX_ADDR_P2      0x0c//???????2??????
    
38. #define  RX_ADDR_P3      0x0d//???????3??????
    
39. #define  RX_ADDR_P4      0x0e//???????4??????
    
40. #define  RX_ADDR_P5      0x0f//???????5??????
    
41. #define  TX_ADDR         0x10//??????
    
42. #define  RX_PW_P0        0x11//P0?????????????
    
43. #define  RX_PW_P1        0x12//P1?????????????
    
44. #define  RX_PW_P2        0x13//P2?????????????
    
45. #define  RX_PW_P3        0x14//P3?????????????
    
46. #define  RX_PW_P4        0x15//P4?????????????
    
47. #define  RX_PW_P5        0x16//P5?????????????
    
48. #define  FIFO_STATUS     0x17//FIFO???????
    
49. #define ADC_POWER   0x80            
    
50. #define ADC_FLAG    0x10            
    
51. #define ADC_START   0x08           
    
52. #define ADC_SPEEDLL 0x00         
    
53. #define ADC_SPEEDL  0x20           
    
54. #define ADC_SPEEDH  0x40         
    
55. #define ADC_SPEEDHH 0x60
    
56. #define uchar unsigned char
    
57. #define uint unsigned int
    
58. sbit IRQ  =P2^4;
    
59. sbit  MISO =P2^5;    //????
    
60. sbit  MOSI =P2^6;     //???
    
61. sbit SCLK =P2^7;     //???
    
62. sbit CSN  =P0^0;  //???
    
63. sbit CE     =P0^1;      //???
    
64. unchar code TxAddr[]={0x11,0x98,0x10,0x10,0x01};//??????
    
65. unchar code RxAddr[]={0x11,0x98,0x10,0x10,0x01};//??????
    
66. uchar aa,bb,cc;
    
67. unchar bdata sta;   //?????         
    
68. sbit  RX_DR=sta^6;
    
69. sbit  TX_DS=sta^5;
    
70. sbit  MAX_RT=sta^4;
    
71. void IO_init()
    
72. {
    
73. P0M0 =0X0F;
    
74. P0M1 =0X10;
    
75. P1M0 =0X00;  //P18?????????
    
76. P1M1 =0X0F;
    
77. //P0M1=0XFF;
    
78. //P0M0=0X00;
    
79. //P3M1=0X00;
    
80. //P3M0=0X00;
    
81. //P4M1=0X00;
    
82. //P4M0=0X01;
    
83. //
    
84. //P6M1=0X80;
    
85. //P6M0=0X70;
    
86. }
    
87. //?????????????
    
88. /**********************???????**************************/
    
89. void NRFDelay(unint t)
    
90. {
    
91.    unint x,y;
    
92.    for(x=t;x>0;x--)
    
93.     for(y=110;y>0;y--);
    
94. }
    
95. /**********************NRF24L01?????????*******************************/
    
96. void NRF24L01Int()
    
97. {
    
98. NRFDelay(2);//????????????
    
99. CE=0;
    
100. CSN=1;   //????????Ч??
     
101. SCLK=0;  //?????
     
102. IRQ=1;   //?ж????????????
     
103. }
     
104. /***SPI???????????8λ????***********************************/
     
105. unchar NRFSPI(unchar date) //?????д???????????
     
106. {
     
107.     unchar i;
     
108.     for(i=0;i<8;i++)          // ???8??
     
109.     {
     
110.    if(date&0x80)
     
111.      MOSI=1;
     
112.    else
     
113.      MOSI=0;             // byte???λ?????MOSI
     
114.         date<<=1;             // ?θ?λ??λ?????λ
     
115.         SCLK=1;
     
116.    if(MISO)               // ????SCK??nRF24L01??MOSI????1λ?????????MISO???1λ????
     
117.         
     
118.   date|=0x01;        // ??MISO??byte???λ
     
119.       SCLK=0;             // SCK???
     
120.     }
     
121.     return(date);            // ?????????????
     
122. }
     
123. /*****************SPI***??***????????????*********************************/
     
124. unchar NRFReadReg(unchar RegAddr)
     
125. {
     
126.    unchar BackDate;
     
127.    CSN=0;//??????
     
128.    NRFSPI(RegAddr);//д????????
     
129.    BackDate=NRFSPI(0x00);//д???????????  
     
130.    CSN=1;
     
131.    return(BackDate); //??????
     
132. }
     
133. /*****************SPI***д***????????????*********************************/
     
134. unchar NRFWriteReg(unchar RegAddr,unchar date)
     
135. {
     
136.    unchar BackDate;
     
137.    CSN=0;//??????
     
138.    BackDate=NRFSPI(RegAddr);//д????
     
139.    NRFSPI(date);//д???
     
140.    CSN=1;  
     
141.    return(BackDate);
     
142. }
     
143. /*****************SPI***???***RXFIFO????????********************************/
     
144. unchar NRFReadRxDate(unchar RegAddr,unchar *RxDate,unchar DateLen)
     
145. {  //????????//????????????//??????????//???????
     
146.     unchar BackDate,i;
     
147. CSN=0;                     //??????????Ч
     
148. BackDate=NRFSPI(RegAddr);  //д???????????????
     
149. for(i=0;i<DateLen;i++)     //???????
     
150.    {
     
151.       RxDate[i]=NRFSPI(0x00);
     
152.    }
     
153.     CSN=1;
     
154.    return(BackDate);
     
155. }
     
156. /*****************SPI***д??***TXFIFO????????**********************************/
     
157. unchar NRFWriteTxDate(unchar RegAddr,unchar *TxDate,unchar DateLen)  //RegAddr   =0x30 , DateLen  ???????5
     
158. {
     
159.    //????????//д???????????//??????????//???????
     
160.    unchar BackDate,i;
     
161.    CSN=0;
     
162.          
     
163.   BackDate=NRFSPI(RegAddr);//д???д??????????
     
164.    for(i=0;i<DateLen;i++)   //д??????
     
165.      {
     
166.      NRFSPI(*TxDate++);
     
167.   }   
     
168.    CSN=1;
     
169.    return(BackDate);
     
170. }
     
171. //????????????????
     
172. //???????0 ?????1 ???
     
173. unchar Check()
     
174. {
     
175. int i;
     
176. unchar buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
     
177. NRFWriteTxDate ( W_REGISTER + TX_ADDR , buf , TX_ADDR_WITDH );  //д??????
     
178. NRFReadRxDate ( R_REGISTER + TX_ADDR , buf , RX_ADDR_WITDH);   //????????
     
179. for(i=0;i<5;i++)   //?ж?
     
180.     if(buf[i]!=0XA5)
     
181.      break;
     
182.   if(i==5)
     
183.    return 0;
     
184.    return 1;
     
185. }
     
186. /****????????????????????*************/
     
187. void NRF24L01_TX_Mode()
     
188. {
     
189. NRFWriteTxDate ( W_REGISTER + TX_ADDR , TxAddr , TX_ADDR_WITDH );    //дTX?????
     
190. NRFWriteTxDate ( W_REGISTER + RX_ADDR_P0 , RxAddr , RX_ADDR_WITDH ); //????RX????????????????ACK
     
191. NRFWriteReg( W_REGISTER + EN_AA , 0X01);   //??????0??????
     
192. NRFWriteReg( W_REGISTER + EN_RXADDR , 0X01);   //??????0???????
     
193. NRFWriteReg( W_REGISTER + SETUP_RETR , 0X1A);  //??????????????500us + 86us?????????????????10??
     
194. NRFWriteReg( W_REGISTER + RF_CH , 40);  //????RF????40
     
195. NRFWriteReg( W_REGISTER + RF_SETUP , 0X0F);  //????TX?????????2M,0db???棬?????????濪??
     
196. NRFWriteReg( W_REGISTER + CONFIG , 0X0E);  //????????????????????PWR_UP,EN_CRC,16BIT_CRC,?????????????????ж?
     
197. }
     
198. void Delay100us()  //@11.0592MHz
     
199. {
     
200. unsigned char i, j;
     
201. _nop_();
     
202. _nop_();
     
203. i = 2;
     
204. j = 15;
     
205. do
     
206. {
     
207.   while (--j);
     
208. } while (--i);
     
209. }
     
210. /*****???????????********
     
211. txbuf????????????????
     
212. //????????????????
     
213. ***************************/
     
214. unchar NRF24L01_TxPacket(unchar *txbuf)
     
215. {
     
216. 
     
217. CE = 0;
     
218. NRFWriteTxDate ( W_TX_PAYLOAD , txbuf , TX_DATA_WITDH );   //д?????TX BUF?У?2?????
     
219. CE = 1;  //???????
     
220. Delay100us();   //??????????
     
221. 
     
222. sta =  NRFReadReg(STATUS);  //?????????????
     
223. if(TX_DS||MAX_RT) //????????ж?
     
224. {
     
225.     NRFWriteReg(W_REGISTER+STATUS,0xff);  // ???TX_DS??MAX_RT?ж???
     
226.     CSN=0;
     
227.     NRFSPI( FLUSH_TX );//???????FIFO ????????????????????????????????????????????  
     
228.        CSN=1;
     
229.     return 0x01;     
     
230. }
     
231. return 0XFF;
     
232. }
     
233. void Delay1000ms()  //@11.0592MHz
     
234. {
     
235. unsigned char i, j, k;
     
236. _nop_();
     
237. _nop_();
     
238. i = 43;
     
239. j = 6;
     
240. k = 203;
     
241. do
     
242. {
     
243.   do
     
244.   {
     
245.    while (--k);
     
246.   } while (--j);
     
247. } while (--i);
     
248. }
     
249. // int k,m;
     
250. void Delay(unsigned int s)
     
251. {
     
252. unsigned int i;
     
253. for(i=0; i<s; i++);
     
254. for(i=0; i<s; i++);
     
255. }
     
256. //*********************************?????A/D???*************************************************
     
257. void adc_init()
     
258. {
     
259. P1ASF=0xff;
     
260. ADC_RES=0;  
     
261. ADC_CONTR = ADC_POWER | ADC_SPEEDLL;
     
262. Delay(10);             //??????
     
263. }
     
264. //**********************************???A/D?????????********************************************
     
265. uint getADCResult(char ch)
     
266. {
     
267. // uint result;
     
268. ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ch | ADC_START;
     
269. _nop_();                        //???4??NOP
     
270.     _nop_();
     
271.     _nop_();
     
272.     _nop_();
     
273. while (!(ADC_CONTR & ADC_FLAG));//?????????
     
274. ADC_CONTR &= ~ADC_FLAG; //??
     
275. return ADC_RES;
     
276. }
     
277. void main()
     
278. {  
     
279.     unchar j=0;
     
280. unchar T_X[3]={0x00,0x00,0x00};
     
281. _nop_();
     
282. IO_init();  //I/O????????
     
283. NRF24L01Int();
     
284. j=Check();
     
285. if(j==0)
     
286. {
     
287. //???
     
288. P22= 1;
     
289. }
     
290. if(j==1)
     
291. {
     
292.     while(1)
     
293.     {
     
294.     P22=!P22;
     
295.     Delay1000ms();
     
296.     }
     
297. }
     
298. NRF24L01_TX_Mode();   //????????????ó??????
     
299.     adc_init();
     
300.    
     
301. while(1)
     
302.   {  
     
303.       P21=1;P36=1; P37=1;P23=1;
     
304.     T_X[0]=getADCResult(0x03);
     
305.   T_X[1]=getADCResult(0x00);
     
306.                      
     
307.   NRF24L01_TxPacket(T_X);
     
308.     aa=getADCResult(0x03);
     
309.      if(aa>140)
     
310.    {
     
311.     P36=0;
     
312.    }
     
313.      else if(aa<115)
     
314.    {
     
315.       P37=0;
     
316.    }                                                                                                                                                                 
     
317.    bb=getADCResult(0x00);
     
318.     if(bb>140)
     
319.    {
     
320.      P23=0;
     
321. 
     
322.    }
     
323.      else if(bb<115)
     
324.    {                                
     
325.       P21=0;
     
326.    }      
     
327.    
     
328. 
     
329.    }
     
330. [/i][/i][i][i]}[/i][/i]
     
331. 接收：
     
332. 
     
333. #include <STC15F2K60S2.H>
     
334. #include <intrins.h>
     
335. #define unchar unsigned char
     
336. #define unint unsigned int
     
337. //?ж?
     
338. #define MAX_TX 0X10  //???????????ж?
     
339. #define TX_OK 0X20    //TX????????ж?
     
340. #define RX_OK  0X40   //??????????ж?
     
341. //NRF24l01????????
     
342. /*******************************************************/
     
343. #define TX_ADDR_WITDH 5 //??????????????5?????
     
344. #define RX_ADDR_WITDH 5 //??????????????5?????
     
345. #define TX_DATA_WITDH 3//??????????2?????
     
346. #define RX_DATA_WITDH 3//??????????2?????
     
347. /*******************????????***************************/
     
348. #define  R_REGISTER      0x00//??????ü????
     
349. #define  W_REGISTER      0x20//д???ü????
     
350. #define  R_RX_PAYLOAD   0x61//???RX??Ч????
     
351. #define  W_TX_PAYLOAD  0xa0//дTX??Ч????
     
352. #define  FLUSH_TX   0xe1//???TXFIFO?????
     
353. #define  FLUSH_RX   0xe2//???RXFIFO?????
     
354. #define  REUSE_TX_PL     0xe3//??????????????Ч????
     
355. #define  NOP             0xff//?????
     
356. /******************????????****************************/
     
357. #define  CONFIG          0x00//???ü????
     
358. #define  EN_AA    0x01//?????????
     
359. #define  EN_RXADDR       0x02//??????????0-5?????
     
360. #define  SETUP_AW        0x03//?????????????????3-5
     
361. #define  SETUP_RETR      0x04//??????????
     
362. #define  RF_CH           0x05//??????????
     
363. #define  RF_SETUP        0x06//????????
     
364. #define  STATUS          0x07//???????
     
365. #define  OBSERVE_TX      0x08//??????????
     
366. #define  CD              0x09//???
     
367. #define  RX_ADDR_P0      0x0a//???????0??????
     
368. #define  RX_ADDR_P1      0x0b//???????1??????
     
369. #define  RX_ADDR_P2      0x0c//???????2??????
     
370. #define  RX_ADDR_P3      0x0d//???????3??????
     
371. #define  RX_ADDR_P4      0x0e//???????4??????
     
372. #define  RX_ADDR_P5      0x0f//???????5??????
     
373. #define  TX_ADDR         0x10//??????
     
374. #define  RX_PW_P0        0x11//P0?????????????
     
375. #define  RX_PW_P1        0x12//P1?????????????
     
376. #define  RX_PW_P2        0x13//P2?????????????
     
377. #define  RX_PW_P3        0x14//P3?????????????
     
378. #define  RX_PW_P4        0x15//P4?????????????
     
379. #define  RX_PW_P5        0x16//P5?????????????
     
380. #define  FIFO_STATUS     0x17//FIFO???????
     
381. #define uchar unsigned char
     
382. #define uint unsigned int
     
383. #define CYCLE   5000  
     
384. sbit INL1=P2^0;
     
385. sbit INL2=P4^4;
     
386. sbit INR1=P4^2;                  
     
387. sbit INR2=P4^1;
     
388. sbit INZ1=P7^1;                 
     
389. sbit INZ2=P7^0;
     
390. sbit IRQ  =P4^0;
     
391. sbit  MISO =P6^5;    //????
     
392. sbit  MOSI =P6^7;     //???
     
393. sbit SCLK =P6^4;     //???
     
394. sbit CSN  =P6^6;  //???
     
395. sbit CE     =P3^2;      //???
     
396. sbit ENL=P2^1;
     
397. sbit ENR=P4^3;
     
398. unchar code TxAddr[]={0x11,0x98,0x10,0x10,0x01};//??????
     
399. unchar code RxAddr[]={0x11,0x98,0x10,0x10,0x01};//??????
     
400. uchar  AD[3];
     
401. uchar  aa,ab,bb,ba,j;
     
402. void dire(uchar x);   
     
403. void  Cspeed(uchar x);   
     
404. void IO_Init()
     
405. {
     
406. P1M0 =0X1B;
     
407.     P1M1 =0X20;
     
408. 
     
409. P0M0 =0X00;  
     
410. P0M1 =0X00;
     
411.   
     
412. P2M1=0x00;
     
413. P2M0=0x00;
     
414.    
     
415. P3M1=0x00;
     
416. P3M0=0x00;
     
417.   
     
418. P4M1=0X00;
     
419. P4M0=0X00;
     
420. 
     
421. P5M1=0x00;
     
422. P5M0=0x00;
     
423. 
     
424. P6M1=0X00;
     
425. P6M0=0X00;
     
426. 
     
427. P7M1=0x00;
     
428. P7M0=0x00;  
     
429. }
     
430. void PWM_Init()
     
431. {         
     
432. P_SW2|=0x80;                //??BIT7λ??1????XSFR   
     
433. PWMCFG|=0x0C;             //????PWM4PEM5?????????????1
     
434. PWMCKS&=0xE0;          //PWMCKS,PWM??????PwmC1K_1T
     
435. PWMC=CYCLE;                    //PWM????????????   2.2KHz
     
436. PWM4T1=0;                 //????η??????
     
437. PWM4T2=4500;   
     
438. PWM5T1=0;                 //????η??????
     
439. PWM5T2=4500;
     
440. PWM4CR&=0XF0;              //PWM4??????P2.2?????ж?
     
441. PWMCR&=~0x40;             //???PWM???????????ж?
     
442. PWMCR|=0x0C;                   //PWM4,PWM5???
     
443.     PWMCR|=0x80;        //???PWM???η???????PWM?????????????
     
444.    P_SW2&=~0x80;             //???????XRAM
     
445.   ENL=0;
     
446.   ENR=0;
     
447. }
     
448. void NRFDelay(unint t)
     
449. {
     
450.    unint x,y;
     
451.    for(x=t;x>0;x--)
     
452.     for(y=110;y>0;y--);
     
453. }
     
454. /**********************NRF24L01?????????*******************************/
     
455. void NRF24L01Int()
     
456. {
     
457. NRFDelay(2);//????????????
     
458. CE=0;
     
459. CSN=1;   //????????Ч??
     
460. SCLK=0;  //?????
     
461. IRQ=1;   //?ж????????????
     
462. }
     
463. /***SPI???????????8λ????***********************************/
     
464. unchar NRFSPI(unchar date)
     
465. {
     
466.     unchar i;
     
467.     for(i=0;i<8;i++)          // ???8??
     
468.     {
     
469.    if(date&0x80)
     
470.      MOSI=1;
     
471.    else
     
472.      MOSI=0;             // byte???λ?????MOSI
     
473.         date<<=1;             // ?θ?λ??λ?????λ
     
474.         SCLK=1;
     
475.    if(MISO)               // ????SCK??nRF24L01??MOSI????1λ?????????MISO???1λ????
     
476.         
     
477.   date|=0x01;        // ??MISO??byte???λ
     
478.       SCLK=0;             // SCK???
     
479.     }
     
480.     return(date);            // ?????????????
     
481. }
     
482. /*****************SPI***??***????????????*********************************/
     
483. unchar NRFReadReg(unchar RegAddr)
     
484. {
     
485.    unchar BackDate;
     
486.    CSN=0;//??????
     
487.    NRFSPI(RegAddr);//д????????
     
488.    BackDate=NRFSPI(0x00);//д???????????  
     
489.    CSN=1;
     
490.    return(BackDate); //??????
     
491. }
     
492. /*****************SPI***д***????????????*********************************/
     
493. unchar NRFWriteReg(unchar RegAddr,unchar date)
     
494. {
     
495.    unchar BackDate;
     
496.    CSN=0;//??????                                                                             
     
497.    BackDate=NRFSPI(RegAddr);//д????
     
498.    NRFSPI(date);//д???
     
499.    CSN=1;  
     
500.    return(BackDate);
     
501. }
     
502. /*****************SPI***???***RXFIFO????????********************************/
     
503. unchar NRFReadRxDate(unchar RegAddr,unchar *RxDate,unchar DateLen)
     
504. {  //????????//????????????//??????????//???????
     
505.     unchar BackDate,i;
     
506. CSN=0;                     //??????????Ч
     
507. BackDate=NRFSPI(RegAddr);  //д???????????????
     
508. for(i=0;i<DateLen;i++)     //???????
     
509.    {
     
510.       RxDate[i]=NRFSPI(0x00);
     
511.    }
     
512.     CSN=1;
     
513.    return(BackDate);
     
514. }
     
515. /*****************SPI***д??***TXFIFO????????**********************************/
     
516. unchar NRFWriteTxDate(unchar RegAddr,unchar *TxDate,unchar DateLen)
     
517. {
     
518.    //????????//д???????????//??????????//???????
     
519.    unchar BackDate,i;
     
520.    CSN=0;
     
521.    BackDate=NRFSPI(RegAddr);//д???д??????????
     
522.    for(i=0;i<DateLen;i++)   //д??????
     
523.      {
     
524.      NRFSPI(*TxDate++);
     
525.   }   
     
526.    CSN=1;
     
527.    return(BackDate);
     
528. }
     
529. //????????????????
     
530. //???????0 ?????1 ???
     
531. unchar Check()
     
532. {
     
533. int i;
     
534. unchar buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
     
535. //д??????
     
536. NRFWriteTxDate ( W_REGISTER + TX_ADDR , buf , TX_ADDR_WITDH );
     
537. //????????
     
538. NRFReadRxDate ( R_REGISTER + TX_ADDR , buf , RX_ADDR_WITDH);
     
539. //?ж?
     
540. for(i=0;i<5;i++)
     
541.     if(buf[i]!=0XA5)
     
542.      break;
     
543.   if(i==5)
     
544.    return 0;
     
545.    return 1;
     
546. }
     
547. //void Delay(unsigned int s)
     
548. //{
     
549. // unsigned int i;
     
550. // for(i=0; i<s; i++);
     
551. // for(i=0; i<s; i++);
     
552. //}
     
553. /*****????????????????????******/
     
554. void NRF24L01_RX_Mode(void)
     
555. {
     
556. NRFWriteTxDate ( W_REGISTER + RX_ADDR_P0 , RxAddr , RX_ADDR_WITDH );
     
557. NRFWriteReg( W_REGISTER + EN_AA , 0X01);   //??????0??????
     
558. NRFWriteReg( W_REGISTER + EN_RXADDR , 0X01);   //??????0???????
     
559. NRFWriteReg( W_REGISTER + RF_CH , 40);  //????RF????40
     
560. NRFWriteReg( W_REGISTER + RX_PW_P0 , RX_DATA_WITDH); //2?????
     
561. NRFWriteReg( W_REGISTER + RF_SETUP , 0X0F);  //????TX?????????0db???棬?????????濪??
     
562. NRFWriteReg( W_REGISTER + CONFIG , 0X0F);
     
563. CE = 1;  //?????????
     
564. }
     
565. /********???????************/
     
566. unchar NRF24L01_RxPacket(unchar *rxbuf)
     
567. {
     
568. unchar sta;
     
569. sta = NRFReadReg(STATUS);  //?????????????
     
570. NRFWriteReg( W_REGISTER + STATUS , sta);  
     
571. if(sta & RX_OK)
     
572. {
     
573. NRFReadRxDate( R_RX_PAYLOAD , rxbuf , RX_DATA_WITDH );    //??????????
     
574. NRFSPI( FLUSH_RX );    //???RX
     
575. return 0;
     
576. }
     
577. return 1;  //??н????????
     
578. }
     
579. void Delay1000ms()  //@11.0592MHz
     
580. {
     
581. unsigned char i, j, k;
     
582. _nop_();
     
583. _nop_();
     
584. i = 43;
     
585. j = 6;
     
586. k = 203;
     
587. do
     
588. {
     
589.   do
     
590.   {
     
591.      while (--k);
     
592.   } while (--j);
     
593. } while (--i);
     
594. }
     
595. 
     
596. void dire(uchar x)     //???????
     
597. {
     
598. switch(x)  
     
599. {
     
600. case 0:INL1=1; INL2=0; //??
     
601.     INR1=0; INR2=1;      
     
602.     break;
     
603. case 1:INL1=1; INL2=0; //??
     
604.     INR1=1; INR2=0;
     
605.     break;
     
606. case 2:INL1=0; INL2=1; //?
     
607.     INR1=0; INR2=1;
     
608.     break;
     
609. case 3:INL1=0; INL2=1; //??
     
610.     INR1=1; INR2=0;
     
611.     break;
     
612. case 4:INL1=0; INL2=0; //??
     
613.     INR1=0; INR2=0;
     
614.     break;
     
615. default : break;
     
616. }                                                   
     
617. }
     
618. void  transAD()
     
619. {
     
620.      
     
621.     if(AD[0]>140)
     
622.     {      
     
623.        Cspeed(0);
     
624.     }
     
625.      if(AD[0]<110)
     
626.     {
     
627.        Cspeed(1);
     
628.     }
     
629.     if(AD[1]>140)
     
630.     {
     
631.        Cspeed(2);
     
632.     }
     
633.     if(AD[1]<110)  
     
634.     {
     
635.        Cspeed(3);
     
636.     }
     
637.     if(((AD[0]<139)&&(AD[0]>109))&&((AD[1]<139)&&(AD[1]>109)))
     
638.        {
     
639.        dire(4);
     
640.     }
     
641. }
     
642. 
     
643. void  Cspeed(uchar x)
     
644. {
     
645.    switch(x)  
     
646. {
     
647. case 0: aa=AD[0]-128;
     
648.    P_SW2|=0x80;
     
649.       PWM4T2=39*aa;                //????η???????????
     
650.       PWM5T2=39*aa;                //????η???????????
     
651.       P_SW2&=~0x80;
     
652.     dire(0);         //??      
     
653.        break;                                                                                                                                      
     
654. case 1: ab=128-AD[0];
     
655.    P_SW2|=0x80;
     
656.       PWM4T2=39*ab;                //????η???????????
     
657.       PWM5T2=39*ab;                //????η???????????
     
658.       P_SW2&=~0x80;
     
659.    dire(3);          //??
     
660.    break;
     
661. case 2: bb=(AD[1]-128);
     
662.       P_SW2|=0x80;
     
663.       PWM4T2=39*bb;                //????η???????????
     
664.       PWM5T2=39*bb;                //????η???????????
     
665.    dire(2);
     
666.       break;
     
667. case 3: ba=(128-AD[1]);
     
668.     P_SW2|=0x80;
     
669.       PWM4T2=39*ba;                //????η???????????
     
670.       PWM5T2=39*ba;  
     
671.    dire(1);
     
672.    break;
     
673.    default: dire(4);
     
674.          break;
     
675. }
     
676. 
     
677. }
     
678. void main()
     
679. {
     
680. IO_Init();  //I/O????????
     
681. NRF24L01Int();
     
682. NRF24L01_RX_Mode();
     
683.       
     
684. PWM_Init();
     
685. j=Check();
     
686.     if(j==0)
     
687. {
     
688. //???
     
689. P77=0;
     
690. }
     
691. if(j==1)
     
692. {
     
693.     while(1)
     
694.     {
     
695.     P77=!P77;
     
696.     Delay1000ms();
     
697.     }
     
698. }  
     
699.   dire(4);  
     
700.     while(1)
     
701.   {  
     
702.     if(NRF24L01_RxPacket(AD))
     
703.     {
     
704.     P77=0;
     
705.     Delay1000ms();
     
706.      P77=1;
     
707.     Delay1000ms();
     
708.     }
     
709.    transAD();
     
710. }
     
711. }

复制代码