关于arm＋nrf２４l０１通信，请高手指点

情部况是这样的，我想做linux arm + nrf24l01通信，　在网上找了一些资料,调试了很久才把驱动编译完成，本以为可以用了，测试一下发不出数据，和厂家送的资料对比了一下，也没发出问题，现在很困惑，

1. #include <linux/config.h>
   
2. #include <linux/module.h>
   
3. #include <linux/kernel.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/init.h>
   
6. #include <linux/devfs_fs_kernel.h>
   
7. #include <linux/miscdevice.h>
   
8. #include <linux/delay.h>
   
9. #include <asm/irq.h>
   
10. #include <asm/arch/regs-gpio.h>
    
11. #include <asm/hardware.h>
    
12. #include <asm/uaccess.h>
    
13. 
    
14. MODULE_LICENSE("GPL");
    
15. 
    
16. typedef unsigned int uint16;
    
17. typedef unsigned char uint8;
    
18. 
    
19. #define CSN                 S3C2410_GPF3
    
20. #define CSN_OUTP        S3C2410_GPIO_OUTPUT
    
21. #define MOSI                S3C2410_GPF4
    
22. #define MOSI_OUTP        S3C2410_GPIO_OUTPUT
    
23. #define IRQ                        S3C2410_GPG3
    
24. #define IRQ_INP                S3C2410_GPIO_INPUT
    
25. #define MISO                S3C2410_GPG0
    
26. #define MISO_INP        S3C2410_GPIO_INPUT
    
27. #define SCK                        S3C2410_GPG5
    
28. #define SCK_OUTP                S3C2410_GPIO_OUTPUT
    
29. #define CE                        S3C2410_GPG6
    
30. #define CE_OUTP                S3C2410_GPIO_OUTPUT
    
31. #define DEVICE_NAME        "NRF24L01"
    
32. #define NRF24L01_MAJOR 255
    
33. #define TxBufSize 32
    
34. 
    
35. uint8 TxBuf[TxBufSize] = {
    
36. 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
    
37. 0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
    
38. 0x17,0x18,0x19,0x20,0x21,0x22,0x23,0x24,
    
39. 0x25,0x26,0x27,0x28,0x29,0x30,0x31,0x32,
    
40. };
    
41. #define CE_OUT                s3c2410_gpio_cfgpin(CE,CE_OUTP)
    
42. #define CE_UP                s3c2410_gpio_pullup(CE,1)
    
43. #define CE_L                s3c2410_gpio_setpin(CE,0)
    
44. #define CE_H                 s3c2410_gpio_setpin(CE,1)
    
45. #define SCK_OUT                s3c2410_gpio_cfgpin(SCK,SCK_OUTP)
    
46. #define SCK_UP                 s3c2410_gpio_pullup(SCK,1)
    
47. #define SCK_L                s3c2410_gpio_setpin(SCK,0)
    
48. #define SCK_H                 s3c2410_gpio_setpin(SCK,1)
    
49. #define MISO_IN                s3c2410_gpio_cfgpin(MISO,MISO_INP)
    
50. #define MISO_UP         s3c2410_gpio_pullup(MISO,1)
    
51. #define MISO_STU        s3c2410_gpio_getpin(MISO)
    
52. #define IRQ_IN                s3c2410_gpio_cfgpin(IRQ,IRQ_INP)
    
53. #define IRQ_UP                s3c2410_gpio_pullup(IRQ,1)
    
54. #define IRQ_L                s3c2410_gpio_setpin(IRQ,0)
    
55. #define IRQ_H                s3c2410_gpio_setpin(IRQ,1)
    
56. #define MOSI_OUT        s3c2410_gpio_cfgpin(MOSI,MOSI_OUTP)
    
57. #define MOSI_UP         s3c2410_gpio_pullup(MOSI,1)
    
58. #define MOSI_L                s3c2410_gpio_setpin(MOSI,0)
    
59. #define MOSI_H                s3c2410_gpio_setpin(MOSI,1)
    
60. #define CSN_OUT                s3c2410_gpio_cfgpin(CSN,CSN_OUTP)
    
61. #define CSN_UP                 s3c2410_gpio_pullup(CSN,1)
    
62. #define CSN_L                s3c2410_gpio_setpin(CSN,0)
    
63. #define CSN_H                 s3c2410_gpio_setpin(CSN,1)
    
64. 
    
65. #define TX_ADR_WIDTH         5
    
66. #define RX_ADR_WIDTH         5
    
67. #define TX_PLOAD_WIDTH         32
    
68. #define RX_PLOAD_WIDTH         32
    
69. uint8 const TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};
    
70. uint8 const RX_ADDRESS[RX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};
    
71. 
    
72. #define READ_REG                0x00
    
73. #define WRITE_REG                 0x20
    
74. #define RD_RX_PLOAD         0x61
    
75. #define WR_TX_PLOAD         0xA0
    
76. #define FLUSH_TX                 0xE1
    
77. #define FLUSH_RX                 0xE2
    
78. #define REUSE_TX_PL         0xE3
    
79. #define NOP                         0xFF
    
80. 
    
81. #define CONFIG                         0x00
    
82. #define EN_AA                         0x01
    
83. #define EN_RXADDR                 0x02
    
84. #define SETUP_AW                 0x03
    
85. #define SETUP_RETR                 0x04
    
86. #define RF_CH                         0x05
    
87. #define RF_SETUP                 0x06
    
88. #define STATUS                         0x07
    
89. #define OBSERVE_TX                 0x08
    
90. #define CD                                 0x09
    
91. #define RX_ADDR_P0                 0x0A
    
92. #define RX_ADDR_p1                 0x0B
    
93. #define RX_ADDR_P2                 0x0C
    
94. #define RX_ADDR_P3                 0x0D
    
95. #define RX_ADDR_P4                 0x0E
    
96. #define RX_ADDR_P5                 0x0F
    
97. #define TX_ADDR                 0x10
    
98. #define RX_PW_P0                 0x11
    
99. #define RX_PW_P1                 0x12
    
100. #define RX_PW_P2                 0x13
     
101. #define RX_PW_P3                0x14
     
102. #define RX_PW_P4                0x15
     
103. #define RX_PW_P5                 0x16
     
104. #define FIFO_STATUS         0x17
     
105. 
     
106. uint8 init_NRF24L01(void);
     
107. uint8 SPI_RW(uint8 tmp);
     
108. uint8 SPI_Read(uint8 reg);
     
109. void SetRX_Mode(void);
     
110. void SetTX_Mode(void);
     
111. uint8 SPI_RW_Reg(uint8 reg,uint8 value);
     
112. uint8 SPI_Read_Buf(uint8 reg,uint8 *pBuf,uint8 uchars);
     
113. uint8 SPI_Write_Buf(uint8 reg,uint8 *pBuf,uint8 uchars);
     
114. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
     
115. void nRF24L01_TxPacket(unsigned char *tx_buf);
     
116. 
     
117. uint8 opencount = 0;
     
118. uint8 sta;
     
119. #define RX_DR         6
     
120. #define TX_DS         5
     
121. #define MAX_RT          4
     
122. 
     
123. uint8 init_NRF24L01(void)
     
124. {
     
125.         MISO_UP;
     
126.         CE_OUT;
     
127.         CSN_OUT;
     
128.         SCK_OUT;
     
129.         MOSI_OUT;
     
130.         MISO_IN;
     
131.         IRQ_IN;
     
132.         udelay(500);
     
133.         CE_L;
     
134.         ndelay(60);
     
135.         CSN_H;
     
136.         ndelay(60);
     
137.         SCK_L;
     
138.         ndelay(60);
     
139.         SPI_Write_Buf(WRITE_REG + TX_ADDR,TX_ADDRESS,TX_ADR_WIDTH);
     
140.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0,RX_ADDRESS,RX_ADR_WIDTH);
     
141.         SPI_RW_Reg(WRITE_REG + EN_AA,0x00);
     
142.         SPI_RW_Reg(WRITE_REG + EN_RXADDR,0x01);
     
143.         SPI_RW_Reg(WRITE_REG + RF_CH,0);
     
144.         SPI_RW_Reg(WRITE_REG + RX_PW_P0,RX_PLOAD_WIDTH);
     
145.         SPI_RW_Reg(WRITE_REG + RF_SETUP,0x07);
     
146.         SPI_RW_Reg(WRITE_REG + CONFIG,0x0f);
     
147.         mdelay(1000);
     
148. //        nRF24L01_TxPacket(TxBuf);
     
149. //        SPI_RW_Reg(WRITE_REG + STATUS,0xff);
     
150. //        printk("test 1\n");
     
151.         mdelay(1000);
     
152.         return 1;
     
153. }
     
154. 
     
155. uint8 SPI_RW(uint8 tmp)
     
156. {
     
157.         uint8 bit_ctr;
     
158.         for(bit_ctr = 0;bit_ctr < 8;bit_ctr++)
     
159.         {
     
160.                 if(tmp&0x80)
     
161.                         MOSI_H;
     
162.                 else
     
163.                         MOSI_L;
     
164.                 tmp<<=1;
     
165.                 SCK_H;
     
166.                 ndelay(60);
     
167.                 tmp |= MISO_STU;
     
168.                 SCK_L;
     
169.                 ndelay(60);
     
170.         }
     
171.         return(tmp);
     
172. }
     
173. 
     
174. uint8 SPI_Read(uint8 reg)
     
175. {
     
176.         uint8 reg_val;
     
177.         CSN_L;
     
178.         ndelay(60);
     
179.         SPI_RW(reg);
     
180.         reg_val = SPI_RW(0);
     
181.         CSN_H;
     
182.         ndelay(60);
     
183.         return reg_val;
     
184. }
     
185. 
     
186. uint8 SPI_RW_Reg(uint8 reg,uint8 value)
     
187. {
     
188.         uint8 status;
     
189.         CSN_L;
     
190.         ndelay(60);
     
191.         status = SPI_RW(reg);
     
192.         SPI_RW(value);
     
193.         CSN_H;
     
194.         ndelay(60);
     
195.         return(status);
     
196. }
     
197. 
     
198. uint8 SPI_Read_Buf(uint8 reg,uint8 *pBuf,uint8 uchars)
     
199. {
     
200.         uint8 status ,uint8_ctr;
     
201. 
     
202.         CSN_L;
     
203.         ndelay(60);
     
204.         status = SPI_RW(reg);
     
205.        
     
206.         for(uint8_ctr = 0;uint8_ctr < uchars;uint8_ctr++)
     
207.         {
     
208.                 pBuf[uint8_ctr] = SPI_RW(0);
     
209.                 ndelay(20);
     
210.         }
     
211.        
     
212.         CSN_H;
     
213.         ndelay(60);;
     
214.         return (status);
     
215. }
     
216. 
     
217. uint8 SPI_Write_Buf(uint8 reg,uint8 *pBuf,uint8 uchars)
     
218. {
     
219.         uint8 status,uint8_ctr;
     
220.        
     
221.         CSN_L;
     
222.         ndelay(60);
     
223.         status = SPI_RW(reg);
     
224.         ndelay(60);
     
225.         for(uint8_ctr = 0;uint8_ctr < uchars;uint8_ctr++)
     
226.         {
     
227.                 SPI_RW(*pBuf++);
     
228.                 ndelay(20);
     
229.         }
     
230.         CSN_H;
     
231.         ndelay(60);
     
232.         return status;
     
233. }
     
234. 
     
235. void SetRX_Mode(void)
     
236. {
     
237.         CE_L;
     
238.         ndelay(60);
     
239. //        SPI_Write_Buf(WRITE_REG + RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);
     
240. //        SPI_RW_Reg(WRITE_REG + EN_AA,0x01);
     
241. //        SPI_RW_Reg(WRITE_REG + EN_RXADDR,0x01);
     
242. //        SPI_RW_Reg(WRITE_REG + RF_CH,40);
     
243. //        SPI_RW_Reg(WRITE_REG + RX_PW_P0,TX_PLOAD_WIDTH);
     
244. //        SPI_RW_Reg(WRITE_REG + RF_SETUP,0x07);
     
245. //        SPI_RW_Reg(WRITE_REG + CONFIG,0x0f);
     
246.         CE_H;
     
247.         udelay(131);
     
248. }
     
249. 
     
250. void SetTX_Mode(void)
     
251. {
     
252.         udelay(100);
     
253.         CE_L;
     
254.         CSN_H;
     
255.         SCK_L;
     
256.         SPI_Write_Buf(WRITE_REG + TX_ADDR,TX_ADDRESS,TX_ADR_WIDTH);
     
257.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);
     
258.         SPI_Write_Buf(WR_TX_PLOAD,TxBuf,TX_PLOAD_WIDTH);
     
259.         SPI_RW_Reg(WRITE_REG + EN_AA,0x00);//0x01
     
260.         SPI_RW_Reg(WRITE_REG + EN_RXADDR,0x01);//0x01
     
261.         SPI_RW_Reg(WRITE_REG + SETUP_RETR,0x00);//0x1a
     
262.         SPI_RW_Reg(WRITE_REG + RF_CH,0);
     
263.         SPI_RW_Reg(WRITE_REG + RX_PW_P0,RX_PLOAD_WIDTH);
     
264.         SPI_RW_Reg(WRITE_REG + RF_SETUP,0x07);
     
265.         SPI_RW_Reg(WRITE_REG + CONFIG,0x0e);
     
266. //        CE_H;
     
267.         udelay(1000);
     
268. }
     
269. 
     
270. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
     
271. {
     
272.         unsigned char revale = 0;
     
273.         sta = SPI_Read(STATUS);
     
274.         if(sta&(1<<RX_DR))
     
275. //        if(RX_DR == 1)
     
276.         {
     
277.                 CE_L;
     
278.                 udelay(50);
     
279.                 SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);
     
280.                 revale = 1;
     
281.         }
     
282.         SPI_RW_Reg(WRITE_REG + STATUS,sta);
     
283.         return revale;
     
284. }
     
285. 
     
286. void nRF24L01_TxPacket(unsigned char* tx_buf)
     
287. {
     
288.         CE_L;
     
289.         ndelay(60);
     
290.         SPI_Write_Buf(WRITE_REG + RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);
     
291.         SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);
     
292.         SPI_RW_Reg(WRITE_REG + CONFIG,0x0e);
     
293.         CE_H;
     
294.         printk("==%x=%x== ",SPI_RW(STATUS),SPI_RW(FIFO_STATUS));
     
295.         udelay(10);
     
296. }
     
297. 
     
298. static ssize_t nrf24l01_write(struct file *filp,const char *buffer,size_t count,loff_t* ppos)
     
299. {
     
300.         int n1 = 0;
     
301.         int n2 = 0;
     
302. 
     
303.         if(copy_from_user(&TxBuf,buffer,count))
     
304.         {
     
305.                 printk("Can't Send Data！ --%d\n",count);
     
306.                 return -EFAULT;
     
307.         }
     
308.         nRF24L01_TxPacket(TxBuf);
     
309.         n1 = SPI_RW( STATUS);
     
310.         n2 = SPI_RW(FIFO_STATUS);
     
311.     printk(" %x- %x ",n1,n2);
     
312. //        SPI_RW_Reg(FLUSH_TX,0x00);
     
313.         SPI_RW_Reg(WRITE_REG + STATUS,0xff);
     
314. 
     
315.         return 0;
     
316. }
     
317. 
     
318. static ssize_t nrf24l01_read(struct file* filp,char* buffer,size_t count,loff_t *ppos)
     
319. {
     
320.         int ret = -1;
     
321. 
     
322.         SetRX_Mode();
     
323.         mdelay(100);
     
324.         nRF24L01_RxPacket(TxBuf);
     
325. //        ret = copy_to_user(buffer,TxBuf,count);
     
326.         SPI_RW_Reg(WRITE_REG + STATUS,0xff);
     
327. //        if(ret > 0) return -EFAULT;
     
328. //        else return 0;       
     
329.         return 10;
     
330. }
     
331. 
     
332. static int nrf24l01_open(struct inode* node,struct file *file)
     
333. {
     
334.         uint8 flag = 0;
     
335.         if(opencount == 1)
     
336.                 return -EBUSY;
     
337.         flag = init_NRF24L01();
     
338.         mdelay(100);
     
339.         if(flag == 0)
     
340.         {
     
341.                 printk("unable to open device \n");
     
342.                 return -1;
     
343.         }
     
344.         else
     
345.         {
     
346.                 opencount++;
     
347.                 printk("device opened ！\n");
     
348.                 return 0;
     
349.         }
     
350. }
     
351. 
     
352. static int nrf24l01_release(struct inode* node,struct file* file)
     
353. {
     
354.         opencount--;
     
355.         printk(DEVICE_NAME"release！\n");
     
356.         return 0;
     
357. }
     
358.        
     
359. static struct file_operations nrf24l01_fops = {
     
360.         .owner = THIS_MODULE,
     
361.         .open = nrf24l01_open,
     
362.         .write = nrf24l01_write,
     
363.         .read = nrf24l01_read,
     
364.         .release = nrf24l01_release,
     
365. };
     
366. 
     
367. static int __init nrf24l01_init(void)
     
368. {
     
369.         int ret;
     
370.        
     
371.         printk("Initial driver for NRF24L01 .....\n");
     
372.         ret = register_chrdev(NRF24L01_MAJOR,DEVICE_NAME,&nrf24l01_fops);
     
373.         mdelay(10);
     
374.         if(ret < 0)
     
375.         {
     
376.                 printk(DEVICE_NAME" can't register major number \n");
     
377.                 return ret;
     
378.         }
     
379.         else
     
380.         {
     
381.                 printk(DEVICE_NAME "register success \n");
     
382.                 devfs_mk_cdev(MKDEV(NRF24L01_MAJOR, 0), S_IFCHR | S_IRUSR | S_IWUSR |S_IRGRP, DEVICE_NAME);
     
383. 
     
384.                 return 0;
     
385.         }
     
386. }
     
387. 
     
388. static void __exit nrf24l01_exit(void)
     
389. {
     
390.         devfs_remove(DEVICE_NAME);
     
391.         unregister_chrdev(NRF24L01_MAJOR,DEVICE_NAME);
     
392.         printk("NRF24L01 unregister success \n");
     
393. }
     
394. 
     
395. module_init(nrf24l01_init);
     
396. module_exit(nrf24l01_exit);
     
397. 
     

复制代码

本人小白，刚开始学习嵌入式，硬件功底不好，现在这里也米有仪器，也不能检测，都困惑了好几天了，请高手来指点一下吧

要要示波器看相关的引脚才能调试呢 网上的代码需要根据实际的情况进行移植才能使用

不错，下载下来看看。

看一下是否真的驱动起来了，还是你发送的数据格式有错，还是时序上有问题，你可以用示波器看一下波形