nrf24l01驱动

自己写的多通道的

1. #include "nRF24L01Drv.h"
2. #include "USART.h"
3. #include "stdio.h"
4. #include "config.h"
5. #include <intrins.h>
6. #include "spi.h"
8. /**
9. * 1.改多路方法：
10. * NUM_USED_PIPE 改为使用的路数， RX_ADDRESS 分别指定 RX的地址，
11. * RX_PLOAD_WIDTH 改为每一路的PAYLOAD
12. * NRF24L01_RxPacket 里面知道是哪一路在接收
13. *
14. *
15. * 2. 发送时自动将CONFIG 备份，然后切换TX后再切换回去
16. *   并且备份RX_ADDR_P0
17. *
18. * 3. 通道0，1 支持40位地址写入， 但是通道2，3，4，5只支持1位写入，其他地址与1通道相同
19. *
20. * 4. NRF24L01_TxPacket 支持写入TX_PLOAD_WIDTH 个字节
21. *
22. * 5. NRF24L01_RxPacket 第一个参数是PIPE_NUMBER, 第二个参数是 读入的 buffer
23. *
24. *
25. * **/
26. #define NUM_USED_PIPE 3
28. const u8 TX_ADDRESS[TX_ADR_WIDTH] = {0x35, 0x30, 0x30, 0x30, 0x35};
29. const u8 RX_ADDRESS[6][RX_ADR_WIDTH] = {{0x33, 0x30, 0x30, 0x30, 0x33}, {0x34, 0x30, 0x30, 0x30, 0x33}, {0x35, 0x00, 0x00, 0x00, 0x00}};
30. u8 RX_PLOAD_WIDTH[6] = {0x02, 0x02, 0x02, 0x00, 0x00, 0x00};
32. u8 SPI_RW(u8 tr_data)
33. {
34.         u16 bit_ctr;
35.         for (bit_ctr = 0; bit_ctr < 8; bit_ctr ) // output 8-bit
36.         {
37.                 NRF_MOSI = (tr_data & 0x80); // output 'uchar', MSB to MOSI
38.                 tr_data = (tr_data << 1);         // shift next bit into MSB..
39.                 NRF_SCK = 1;                                 // Set SCK high..
40.                 tr_data |= NRF_MISO;                 // capture current MISO bit
41.                 NRF_SCK = 0;                                 // ..then set SCK low again
42.         }
43.         return (tr_data); // return read uchar
44. }
46. /*********************************************/
47. /* 函数功能：给24L01的寄存器写值（一个字节） */
48. /* 入口参数：reg   要写的寄存器地址          */
49. /*           value 给寄存器写的值            */
50. /* 出口参数：status 状态值                   */
51. /*********************************************/
52. u8 NRF24L01_RW_Reg(u8 reg, u8 value)
53. {
54.         u16 status;
56.         NRF_CSN = 0;                  // CSN low, init SPI transaction
57.         status = SPI_RW(reg); // select register
58.         SPI_RW(value);                  // ..and write value to it..
59.         NRF_CSN = 1;                  // CSN high again
61.         return (status); // return nRF24L01 status uchar
62. }
63. /*************************************************/
64. /* 函数功能：读24L01的寄存器值 （一个字节）      */
65. /* 入口参数：reg  要读的寄存器地址               */
66. /* 出口参数：value 读出寄存器的值                */
67. /*************************************************/
68. u8 NRF24L01_Read_Reg(u8 reg)
69. {
70.         u8 reg_val;
72.         NRF_CSN = 0;                        // CSN low, initialize SPI communication...
73.         SPI_RW(reg);                        // Select register to read from..
74.         reg_val = SPI_RW(0xFF); // ..then read registervalue
75.         NRF_CSN = 1;                        // CSN high, terminate SPI communication
77.         return (reg_val); // return register value
78. }
79. /*********************************************/
80. /* 函数功能：读24L01的寄存器值（多个字节）   */
81. /* 入口参数：reg   寄存器地址                */
82. /*           *pBuf 读出寄存器值的存放数组    */
83. /*           len   数组字节长度              */
84. /* 出口参数：status 状态值                   */
85. /*********************************************/
86. u8 NRF24L01_Read_Buf(u8 reg, u8 *pBuf, u8 len)
87. {
88.         u16 status, uchar_ctr;
90.         NRF_CSN = 0;                  // Set CSN low, init SPI tranaction
91.         status = SPI_RW(reg); // Select register to write to and read status uchar
93.         for (uchar_ctr = 0; uchar_ctr < len; uchar_ctr )
94.                 pBuf[uchar_ctr] = SPI_RW(0xFF); //
96.         NRF_CSN = 1;
98.         return (status); // return nRF24L01 status uchar
99. }
100. /**********************************************/
101. /* 函数功能：给24L01的寄存器写值（多个字节）  */
102. /* 入口参数：reg  要写的寄存器地址            */
103. /*           *pBuf 值的存放数组               */
104. /*           len   数组字节长度               */
105. /**********************************************/
106. u8 NRF24L01_Write_Buf(u8 reg, u8 *pBuf, u8 len)
107. {
108.         u8 status, u8_ctr;
109.         NRF_CSN = 0;
110.         status = SPI_RW(reg); //发送寄存器值(位置),并读取状态值
111.         for (u8_ctr = 0; u8_ctr < len; u8_ctr )
112.                 SPI_RW(*pBuf ); //写入数据
113.         NRF_CSN = 1;
114.         return status; //返回读到的状态值
115. }
117. /*********************************************/
118. /* 函数功能：24L01接收数据                   */
119. /* 入口参数：rxbuf 接收数据数组              */
120. /* 返回值： 1   成功收到数据                 */
121. /*          0   没有收到数据                 */
122. /*********************************************/
123. u8 NRF24L01_RxPacket(u8 *pipe_num, u8 *rxbuf)
124. {
125.         u8 fifo_state;
126.         u8 state;
127.         u8 i;
128.         unsigned char revale = 0;
130.         fifo_state = NRF24L01_Read_Reg(FIFO_STATUS); //读取状态寄存器的值
131.         state = NRF24L01_Read_Reg(STATUS);                         //清除TX_DS或MAX_RT中断标志
132.         //TX1_write2buff(state);
133.         if (!(fifo_state & _BV(RX_EMPTY))) //接收到数据
134.         {
135.                 NRF_CSN = 0;
136.                 i = SPI_RW(RF24_NOP); // IRQ收发完成中断响应，16位CRC，主发送
137.                 *pipe_num = (i >> RX_P_NO) & 0x07;
138.                 NRF_CSN = 1;
139.                 NRF_CE = 0;                                                                                                                  //SPI使能
140.                 NRF24L01_Read_Buf(RD_RX_PLOAD, rxbuf, RX_PLOAD_WIDTH[*pipe_num]); // read receive payload from RX_FIFO buffer
141.                                                                                                                                                   //   NRF24L01_RW_Reg(FLUSH_RX,0xff);//清除RX FIFO寄存器
142.                 NRF24L01_RW_Reg(WRITE_REG STATUS, state);                                                  //清除TX_DS或MAX_RT中断标志
143.                 NRF24L01_RW_Reg(FLUSH_RX, 0xFF);                                                                  //清除TX_DS或MAX_RT中断标志
144.                 revale = RX_PLOAD_WIDTH[*pipe_num];
145.         }
146.         NRF_CE = 1;
148.         return revale; //没收到任何数据
149. }
150. /**********************************************/
151. /* 函数功能：设置24L01为发送模式              */
152. /* 入口参数：txbuf  发送数据数组              */
153. /* 返回值； 0x10    达到最大重发次数，发送失败*/
154. /*          0x20    成功发送完成              */
155. /*          0xff    发送失败                  */
156. /**********************************************/
157. u8 NRF24L01_TxPacket(u8 *txbuf)
158. {
159.         u8 state;
160.         u8 config;
162.         NRF_CE = 0; //StandBy I模式
163.         config = NRF24L01_Read_Reg(CONFIG);
165.         NRF24L01_Read_Buf(RX_ADDR_P0, RX_ADDRESS[0], RX_ADR_WIDTH);                          // 备份 RX_ADDRESS[0]
166.         NRF24L01_Write_Buf(WRITE_REG RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
167.         NRF24L01_Write_Buf(WR_TX_PLOAD, txbuf, TX_PLOAD_WIDTH);                                  // 装载数据
168.         NRF24L01_RW_Reg(WRITE_REG CONFIG, config & ~_BV(0));                                  // 设置为PTX
169.         NRF_CE = 1;
170.         //置高CE，激发数据发送
171.         while (NRF_IRQ == 1)
172.         {
173.                 ;
174.         }                                                                                        //等待发送完成
175.         state = NRF24L01_Read_Reg(STATUS);                        //读取状态寄存器的值
176.         NRF24L01_RW_Reg(WRITE_REG STATUS, state); //清除TX_DS或MAX_RT中断标志
177.         if (state & MAX_TX)                                                        //达到最大重发次数
178.         {
179.                 NRF24L01_RW_Reg(FLUSH_TX, 0xff); //清除TX FIFO寄存器
180.                 return MAX_TX;
181.         }
183.         NRF24L01_Write_Buf(WRITE_REG RX_ADDR_P0, RX_ADDRESS[0], RX_ADR_WIDTH);
184.         NRF24L01_RW_Reg(WRITE_REG CONFIG, config); //改回PRX
185.         if (state & TX_OK)                                                         //发送完成
186.         {
187.                 return TX_OK;
188.         }
189.         return 0xff; //发送失败
190. }
191. /********************************************/
192. /* 函数功能：检测24L01是否存在              */
193. /* 返回值；  0  存在                        */
194. /*           1  不存在                      */
195. /********************************************/
196. u8 NRF24L01_Check(void)
197. {
198.         u8 check_in_buf[5] = {0x11, 0x22, 0x33, 0x44, 0x55};
199.         u8 check_out_buf[20] = {0x00};
201.         NRF_CE = 0;
203.         NRF24L01_Write_Buf(WRITE_REG TX_ADDR, check_in_buf, 5);
204.         NRF24L01_Read_Buf(READ_REG TX_ADDR, check_out_buf, 5);
206.         if ((check_out_buf[0] == 0x11) &&
207.                 (check_out_buf[1] == 0x22) &&
208.                 (check_out_buf[2] == 0x33) &&
209.                 (check_out_buf[3] == 0x44) &&
210.                 (check_out_buf[4] == 0x55))
211.                 return 0;
213.         return 1;
214. }
216. void NRF24L01_RT_Init(void)
217. {
218.         u8 i = 0;
220.         NRF_SCK = 0;
222.         NRF_CE = 0; // chip enable
224.         NRF24L01_Write_Buf(WRITE_REG TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);
226.         NRF24L01_RW_Reg(WRITE_REG CONFIG, 0x0B);           //0x20
227. ……………………