前言
5 W- j& y% ^3 v, U2 O: x& dSTM32下NRF24L01实现无线传输


一、原理图
$ r) ]. m. Q' k6 E& U& q1.STM32F103C8T6
6 m+ N4 |$ K) ~7 F4 c& x  y1 ~

  t) t; T' ~7 u" S% m
/ O% Z6 l1 @) j! n8 d7 \" v4 p2.NRF24L01
1 Z5 N+ _5 \1 v0 \

" Y/ x; ]9 E9 r" U: e
! O: ~. F; S* E, u9 UNRF24L01是 nordic 的无线通信芯片，它具有以下特点：


& ]4 x$ O8 k4 L8 d1） 2.4G 全球开放的 ISM 频段（2.400 - 2.4835GHz），免许可证使用；
+ I: i  g$ `6 X0 M2）最高工作速率 2Mbps，高校的 GFSK 调制，抗干扰能力强；
3） 125 个可选的频道，满足多点通信和调频通信的需要；
4）内置 CRC 检错和点对多点的通信地址控制；
5）低工作电压（1.9~3.6V），待机模式下状态为 26uA；掉电模式下为 900nA；
; P. m, v8 [7 A/ M+ b+ C) `# e6）可设置自动应答，确保数据可靠传输；
& W, U7 G; ?+ A& e7）工作于EnhancedShockBurst 具有Automatic packet handling,Auto packet transaction handling ，可以实现点对点或是 1 对 6 的无线通信，速度可以达到 2M（bps），具有可选的内置包应答机制，极大的降低丢包率。
; l0 O' l( g: S3 ^8）通过 SPI 总线与单片机进行交互，最大通信速率为10Mbps；


# G  B% h, k; r$ n; i) V二、Keil代码
1.SPI_NRF2401.C

1. <font face="微软雅黑" size="3">#include "Struct.h"
   
2. 
   ( E) y" u5 {2 P0 |* z
3. /******************************************************************************
   9 F9 u1 n1 e6 h+ b  |, b) C
4.                                                         宏定义
   
5. *******************************************************************************/
   % l0 @3 s( d/ j* k
6. #define NRF_CE_GPIO                GPIOC               
   
7. #define NRF_CE_Pin                GPIO_Pin_14        
   
8. #define NRF_CSN_GPIO        GPIOC               
   ) C) `" L- @0 a  }$ |) T: F* R4 l9 [
9. #define NRF_CSN_Pin                GPIO_Pin_13        
   : U+ X8 h- j+ i7 P: c
10. #define NRF_IRQ_GPIO        GPIOC
    
11. #define NRF_IRQ_Pin                GPIO_Pin_15
    % A1 _  v# x$ C) J
12. 
    
13. #define NRF_CE_H                   NRF_CE_GPIO ->BSRR = NRF_CE_Pin  //CE高电平
    
14. #define NRF_CE_L                   NRF_CE_GPIO ->BRR  = NRF_CE_Pin  //CE低电平
    
15. #define NRF_CSN_H                  NRF_CSN_GPIO->BSRR = NRF_CSN_Pin //CSN高电平
    
16. #define NRF_CSN_L                  NRF_CSN_GPIO->BRR  = NRF_CSN_Pin //CSN高电平
    
17. #define        NRF_IRQ_Read        NRF_IRQ_GPIO->IDR  & NRF_IRQ_Pin //IRQ读数据
    
18. /******************************************************************************
    / E) z  h# n& K8 ]$ q2 x# r
19.                                                         变量定义
    
20. *******************************************************************************/
    3 H7 X% h5 x' v) X! a6 P
21. uint8_t NRF24L01_RXDATA[32];//nrf24l01接收到的数据
    3 j5 P- `( Z2 u: m4 o
22. uint8_t NRF24L01_TXDATA[32];//nrf24l01需要发送的数据
    
23. static uint8_t TX_ADDRESS[5]= {0x1A,0x2A,0x3A,0x4A,0x5A};//本地地址
    
24. static uint8_t RX_ADDRESS[5]= {0x1A,0x2A,0x3A,0x4A,0x5A};//接收地址
    1 \( Z# }5 e. o8 C' T0 E" K
25. static uint16_t Nrf_Erro=0;
    ; G; W7 R  F3 m
26. 
    2 \: K* ?  D, {
27. /******************************************************************************
    
28. 函数原型:        void SPI2_Init(void)
    
29. 功　　能:        初始化SPI总线
    
30. *******************************************************************************/
    ' y. y: p( V! q
31. void SPI2_Init(void)
    
32. {
    ' @; q: X2 A4 P% k6 ~! [& e4 l5 p
33.         SPI_InitTypeDef SPI_InitStructure;
    
34.         GPIO_InitTypeDef GPIO_InitStructure;
    0 n1 t7 W. `: g
35.         EXTI_InitTypeDef EXTI_InitStructure;
    7 x3 Y# n( G2 K- n: w/ H
36.         
    
37.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
    
38.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
    
39.         //配置SCK,MISO,MOSI引脚  
    
40.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
    7 w( ]+ m2 x* y& r
41.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    % N$ s! z# Z) n" G! |& C
42.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用功能
    
43.         GPIO_Init(GPIOB, &GPIO_InitStructure);
    
44.         //配置CE引脚
    , B/ ^! P1 s* A  A
45.         GPIO_InitStructure.GPIO_Pin = NRF_CE_Pin;
    % H9 U( m0 ~& r3 t+ W
46.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    , X% |4 H, ~+ ~3 E9 _) |% j
47.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推挽输出
    
48.         GPIO_Init(NRF_CE_GPIO, &GPIO_InitStructure);
    * l# `. M* R# k: {$ D
49.         //配置CSN引脚
    8 T* s+ d* A9 S7 _
50.         GPIO_InitStructure.GPIO_Pin = NRF_CSN_Pin;
    / d, _/ Z! `9 K
51.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    6 x( z2 R% [* M6 Q. v$ `! z
52.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推挽输出
    - k. @% ~2 l/ [! e  I
53.         GPIO_Init(NRF_CSN_GPIO, &GPIO_InitStructure);        
    # M7 c# }+ Z0 g8 j. f- w6 a* q) M9 @
54.         //配置IRQ引脚
    
55.         GPIO_InitStructure.GPIO_Pin = NRF_IRQ_Pin;
    
56.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
57.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入
    - g& ~1 ~2 }  o: @, E
58.         GPIO_Init(NRF_IRQ_GPIO, &GPIO_InitStructure);        
    $ o8 k& O0 U9 @6 O- l' D
59.         
    
60.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource15);
    
61.     EXTI_InitStructure.EXTI_Line=EXTI_Line15;
    
62.     EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;//外部中断
    
63.     EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling;//下降沿触发
    
64.     EXTI_InitStructure.EXTI_LineCmd=ENABLE;
    9 q5 \7 }" t6 @; w) u$ m
65.     EXTI_Init(&EXTI_InitStructure);
    
66.         
    * m- V( C6 L( K% j1 S! y* v
67.         NRF_CSN_H;        //禁止NRF器件
    / H. x1 P0 K7 ]' C! K0 N$ A$ L
68.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //双线全双工
    * R7 I1 s  B+ H. A$ i- J! C0 i
69.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master; //主模式
    ) |! o3 N% B$ }! C( F' E6 s
70.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //数据大小8位
    
71.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; //时钟极性，空闲时为低
    
72.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; //第1个边沿有效，上升沿为采样时刻
    
73.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;  //NSS信号由软件产生
    + J) a/ Q; H5 b
74.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; //8分频，9MHz
    6 H3 V  Q% O- e. n) M3 x9 u( T) }
75.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //高位在前
    
76.         SPI_InitStructure.SPI_CRCPolynomial = 7;
    
77.         SPI_Init(SPI2, &SPI_InitStructure);
    
78.            
    
79.         SPI_Cmd(SPI2, ENABLE);//使能 SPI1
    
80.         
    # c$ A) [% O* @, E, z0 n+ v
81. //        PrintString("\r\n SPI2     初始化完成！");
    
82. }
    : ~* P/ l4 e6 H4 H# R
83. /******************************************************************************
    
84. 函数原型:        uint8_t SPI_RW(uint8_t data)
    4 q# [; o/ \) c9 x0 g7 R0 A+ U
85. 功　　能:        SPI总线读写
    
86. 返 回 值：        返回SPI总线读取数据
    % j; c* k. e0 X  U/ t. Y; k
87. *******************************************************************************/
    
88. uint8_t SPI_RW(uint8_t data)
    " ~: G5 J; p' P% T) o
89. {
    
90.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET);//当SPI发送缓冲器非空时等待  
    
91.         SPI_I2S_SendData(SPI2, data);//通过SPI总线发送一字节数据
    
92.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);//当SPI接收缓冲器为空时等待
    
93.         return SPI_I2S_ReceiveData(SPI2);
    3 x0 g# H+ u* V$ p8 P: m% Y
94. }
    
95. 
    
96. /******************************************************************************
    9 x& q9 f1 P0 \  _5 W) ]( y
97. 函数原型：        uint8_t NRF_Write_Reg(uint8_t reg, uint8_t value)
    
98. 功    能：        NRF写寄存器
    
99. 返 回 值：        NRF写寄存器返回值
    / h. I  r: N1 e. b* v: @
100. *******************************************************************************/
     
101. uint8_t NRF_Write_Reg(uint8_t reg, uint8_t value)
     2 i" D1 B9 C* F; D4 i
102. {
     
103.         uint8_t status;
     : H& h7 \- m, s. p" i# g
104.         NRF_CSN_L;                //选通NRF器件
     ' A* N' k& m. Y, g+ M+ \$ J1 v
105.         status = SPI_RW(reg);//写寄存器地址
     
106.         SPI_RW(value);        //写数据
     ( _1 Y$ r* y+ e' H% A
107.         NRF_CSN_H;                //禁止NRF器件
     % y1 c" p" U. j' d! n
108.         return         status;
     
109. }
     
110. 
     6 \3 T& Q9 x9 m8 l, |) ?
111. /******************************************************************************
     * ?  F+ g) c% B+ }* a' S6 r
112. 函数原型：        uint8_t NRF_Read_Reg(uint8_t reg)
     ; m5 v6 z. Q4 R# f' f6 y
113. 功    能：        NRF读寄存器
     
114. 返 回 值：        寄存器数据
     
115. *******************************************************************************/
     & p; E" }3 R6 ?/ |0 L
116. uint8_t NRF_Read_Reg(uint8_t reg)
     1 @' m2 V: o5 o. n; e
117. {
     " H2 F: ~- a3 I! @
118.         uint8_t reg_val;
     
119.         NRF_CSN_L;                //选通NRF器件
     ( m/ a- Y1 t; F# w
120.         SPI_RW(reg);        //写寄存器地址
     6 p: N! L1 `; p# \
121.         reg_val = SPI_RW(0);//读取该寄存器返回数据
     
122.         NRF_CSN_H;                //禁止NRF器件
     
123.     return         reg_val;
     
124. }
     5 L5 C) l& H1 p" z
125. 
     " b9 y  z' x4 X( j; z
126. /******************************************************************************
     
127. 函数原型：        uint8_t NRF_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
     7 N* ~9 E. s, T% O' {! K( u, X6 }
128. 功    能：        NRF写缓冲区
     & m' j8 v( }* z: Z8 e  k
129. 返 回 值：        NRF写缓冲区返回值
     
130. *******************************************************************************/
     
131. uint8_t NRF_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
     
132. {
     
133.         uint8_t i;
     
134.         uint8_t status;
     2 b1 h4 u6 Z& B! S4 n4 y' o$ v9 x
135.         NRF_CSN_L;        //选通NRF器件
     
136.         status = SPI_RW(reg);//写寄存器地址
     
137.         for(i=0; i<uchars; i++)
     . v# L- M, G+ m( g
138.         {
     ) ], u. R+ G. e. Q, O
139.                 SPI_RW(pBuf[i]);//写数据
     
140.         }
     4 Q' s; C6 x3 _9 y# P
141.         NRF_CSN_H;        //禁止NRF器件
     # H( m" O3 ]0 I& e! B* C2 H6 E* e
142.     return         status;        
     ; L: J! f! C+ m6 L4 n0 B2 j
143. }
     5 e# Q! B1 `) O* r2 Q" U3 c$ _
144. 
     * y, W2 e, V* U
145. /******************************************************************************
     $ T( z( s3 {& y7 T  k; T* e6 I
146. 函数原型：        uint8_t NRF_Read_Buff(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
     
147. 功    能：        NRF读缓冲区
     
148. 返 回 值：        缓冲区数据
     $ ?* O% G: S2 V% m9 q# Q& _- O( A
149. *******************************************************************************/
     6 G9 |! R/ u6 z3 e& a4 e( r
150. uint8_t NRF_Read_Buff(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
     
151. {
     
152.         uint8_t i;
     
153.         uint8_t status;
     
154.         NRF_CSN_L;        //选通NRF器件
     2 U! Q1 i; f6 ]# G
155.         status = SPI_RW(reg);//写寄存器地址
     $ R# y" W3 p7 q2 s3 p
156.         for(i=0; i<uchars; i++)
     ' l. n  q# G2 }) C& r: d
157.         {
     
158.                 pBuf[i] = SPI_RW(0);//读取返回数据        
     
159.         }
     
160.         NRF_CSN_H;        //禁止NRF器件
     
161.     return         status;
     
162. }
     
163. 
     
164. /******************************************************************************
     - v% p! A% a; z+ q
165. 函数原型：        void NRF24L01_Check(void)
     + B& A, H; O: R$ r# }
166. 功    能：        检查NRF器件是否正常
     
167. *******************************************************************************/
     
168. void NRF24L01_Check(void)
     0 U6 [. }4 x0 `: P% I
169. {
     
170.         uint8_t buf[5];
     
171.         uint8_t i;
     
172.         //写入5个字节的地址
     ( Y' M9 h. X) E
173.         NRF_Write_Buf(NRF_WRITE_REG+TX_ADDR,TX_ADDRESS,5);
     
174.         //读出写入的地址
     
175.         NRF_Read_Buff(TX_ADDR,buf,5);
     
176.         //比较
     
177.         for(i=0;i<5;i++)
     ( ^( p9 g5 {# x5 b# J
178.         {
     
179.                 if(buf[i]!=TX_ADDRESS[i])
     ) z& @- j3 i# D3 M8 I# B
180.                         break;
     
181.         }
     
182. //        if(i==5)
     % i; G* t) t( G$ p
183. //                PrintString("\r\n NRF24L01 初始化成功！");
     
184. //        else
     
185. //                PrintString("\r\n NRF24L01 初始化失败！");
     ! i1 G6 d3 G. a$ T8 m
186. }
     
187. 
     
188. /******************************************************************************
     
189. 函数原型：        static void NRF24L01_Set_TX(void)
     & z' k2 P( q' q  |/ N$ M
190. 功    能：        将NRF24L01设置为发送模式
     " N. J5 K0 U6 H- _
191. *******************************************************************************/
     
192. static void NRF24L01_Set_TX(void)
     
193. {
     
194.         NRF_CE_L;
     
195.         NRF_Write_Reg(NRF_WRITE_REG + CONFIG,0x0E);//发送
     
196.         NRF_CE_H;
     
197. }
     6 x, ^; d0 M( Q0 i) u9 a+ x
198. 
     , k4 f0 x, [" B/ `! x5 n, `
199. /******************************************************************************
     1 _" a/ }6 v% m& v; ?
200. 函数原型：        static void NRF24L01_Set_RX(void)
       k5 @, t2 T) b+ Q# R/ }0 ^
201. 功    能：        将NRF24L01设置为接收模式
     , o( k  z" Y: C# _
202. *******************************************************************************/
     
203. static void NRF24L01_Set_RX(void)
     6 }3 {8 W7 _2 s  R0 U# l
204. {
     , S. b. O. Q5 B! c
205.         NRF_CE_L;
     
206.         NRF_Write_Reg(NRF_WRITE_REG + CONFIG,0x0F);//接收
     ) I/ Z+ [! t5 w. B
207.         NRF_CE_H;
     
208. }
     
209. 
     6 i0 V  R. c. k9 A3 }2 ]. _
210. /******************************************************************************
     7 G( B5 G8 @+ y, Z4 n
211. 函数原型：        void NRF_Send_TX(uint8_t * tx_buf, uint8_t len)
     
212. 功    能：        NRF2401发送数据包
     
213. *******************************************************************************/
     
214. void NRF_Send_TX(uint8_t * tx_buf, uint8_t len)
     
215. {        
     4 o6 X2 K- [2 p; l4 r
216.         NRF24L01_Set_TX();
     
217.         NRF_CE_L;//进入待机模式1        
     
218.         NRF_Write_Buf(WR_TX_PLOAD, tx_buf, len);//装载数据
     
219.         NRF_CE_H;//设置CE为高，启动发射。CE高电平持续时间最小为10us
     
220. }
     
221. /******************************************************************************
     " l2 e& I% [; }# o( u  b8 q' |4 c2 R* o
222. 函数原型：        void NRF24L01_Init(uint8_t Chanal,uint8_t Mode)
     4 A5 J& x2 [* @- W+ W9 c
223. 功    能：        NRF24L01初始化
     
224. 参    数：        Chanal，RF通道
     
225. *******************************************************************************/
     . T4 p5 K3 P1 J1 o8 @
226. void NRF24L01_Init(uint8_t Chanal,uint8_t Mode)
     
227. {
     0 J8 l, f) g4 G* }( v# K# @6 g: O
228.         NRF_CE_L;
     ; u. F4 n" {' I
229.                
     
230.         NRF_Write_Reg(FLUSH_TX,0xff);//清空发送缓冲区
       i0 ^+ G# d$ @- g/ m" ?' s6 W
231.         NRF_Write_Reg(FLUSH_RX,0xff);//清空接收缓冲区
     & R: X3 x4 N& B# E" b  U* b8 G
232.         NRF_Write_Buf(NRF_WRITE_REG + TX_ADDR,   TX_ADDRESS,5); //写TX节点地址         
     - S0 k2 z' n* T# r/ N  m
233.         NRF_Write_Buf(NRF_WRITE_REG + RX_ADDR_P0,RX_ADDRESS,5);        //写RX节点地址
     " F7 {2 y& P+ M+ z
234. 
     
235.         NRF_Write_Reg(NRF_WRITE_REG + EN_AA,     0x01); //使能通道0的自动应答
     5 j( a  Q* F5 f- n# ^0 v  p/ L8 r  r( x
236.         NRF_Write_Reg(NRF_WRITE_REG + EN_RXADDR, 0x01);        //使能通道0的接收地址
     % U* ]7 K9 |- n3 p0 D* T2 S
237.         NRF_Write_Reg(NRF_WRITE_REG + SETUP_RETR,0x1a);        //设置自动重发间隔时间:500us;最大自动重发次数:10次
     
238.         NRF_Write_Reg(NRF_WRITE_REG + RF_CH,   Chanal);        //设置RF通道为CHANAL
     . s/ K2 x6 u: B8 ^% x8 g
239.         NRF_Write_Reg(NRF_WRITE_REG + RX_PW_P0,    32);        //设置通道0的有效数据宽度
     
240.         NRF_Write_Reg(NRF_WRITE_REG + RF_SETUP,  0x0f); //设置TX发射参数,0db增益,2Mbps,低噪声增益开启
     8 S9 D( `# {9 J- R0 v9 {
241.         
     6 d; k3 [, h$ Z+ Y- I
242.         if(Mode==TX)
     
243.                 NRF_Write_Reg(NRF_WRITE_REG + CONFIG,0x0E);//发送
     
244.         else if(Mode==RX)
     
245.                 NRF_Write_Reg(NRF_WRITE_REG + CONFIG,0x0F);//接收
     
246.         
     ; b( Y2 s9 c$ v+ |
247.         NRF_CE_H;
     
248. }
     
249. 
     
250. /******************************************************************************
     
251. 函数原型：        static void NRF24L01_Analyse(void)
     
252. 功    能：        分析NRF24L01收到的数据帧
     
253. *******************************************************************************/
     
254. static void NRF24L01_Analyse(void)
     
255. {
     
256.         uint8_t sum = 0,i;
     7 c5 ?- g: a( Y' H3 R7 E$ v
257.         uint8_t len = NRF24L01_RXDATA[3] + 5;
     ; K8 j$ I- c# _
258.         //uint8_t i=0;
     
259.         for(i=3;i<len;i++)
     3 R5 f3 f# G1 S/ U( i- d. t
260.                 sum ^= NRF24L01_RXDATA[i];
     . A' w) m( I, o, Z
261.         if( sum!=NRF24L01_RXDATA[len] )        return;        //数据校验
     9 D3 }" s- {3 P2 ~; q; v: Q
262.         if( NRF24L01_RXDATA[0] != '[font=微软雅黑][size=3]2.SPI_NRF24L01.h[/size][/font]
     1 ~  b% E6 y  e% h
263. [code]<font face="微软雅黑" size="3">#ifndef _SPI_NRF24L01_H_
     
264. #define _SPI_NRF24L01_H_
     & c! W% h* ^( `3 {* U
265. #include "stm32f10x.h"
     
266. 
     " B* x1 j5 O: c3 }
267. /******************************************************************************
     
268.                                                         宏定义
     
269. *******************************************************************************/
     
270. #define TX        1
     % r( Y" p! @1 U
271. #define RX        2
     
272. 
     
273. #define RX_DR        6        //接收数据中断.当接收到有效数据后置一。写‘1’清除中断。
     ! j! A5 V: z' F( U5 V8 u& a
274. #define TX_DS        5        //数据发送完成中断。当数据发送完成后产生中断。如果工作在自动应答模式下，只有当接收到应答信号后此位置一。写‘1’清除中断。
     
275. #define MAX_RT        4        //达到最多次重发中断。写‘1’清除中断。如果MAX_RT中断产生则必须清除后系统才能进行通讯。
     
276. #define TX_FULL 0        //TX FIFO寄存器满标志。   1:TX FIFO  寄存器满   0: TX FIFO 寄存器未满, 有可用空间。
     
277. 
     : l6 H$ M  O% e$ U, H6 k
278. /******************************************************************************
     
279.                                                         全局变量声明
     
280. *******************************************************************************/
     
281. extern         uint8_t NRF24L01_RXDATA[32];//nrf24l01接收到的数据
     
282. extern         uint8_t NRF24L01_TXDATA[32];//nrf24l01需要发送的数据
     
283. 
     * j- G, W$ c1 `/ }5 h5 l; D- V
284. /******************************************************************************
     
285.                                                         全局函数声明
     
286. *******************************************************************************/
     ; x% O4 W2 {* V. g
287. void SPI2_Init(void);
     " e, Y: n/ D' U! W
288. void NRF24L01_IRQ(void);
     . Y. s; @3 p- l0 g* u7 {; D* j
289. void NRF24L01_Check(void);
     
290. void NRF24L01_Init(uint8_t Chanal,uint8_t Mode);
     
291. void NRF_Send_TX(uint8_t * tx_buf, uint8_t len);
     6 x; r5 I2 p% ]0 s: L* W
292. void Nrf_Connect(void);
     
293. 
     
294. uint8_t NRF_Read_Reg(uint8_t reg);
     : f! D- y9 n  C! K. C) B
295. uint8_t NRF_Write_Reg(uint8_t reg, uint8_t value);
     
296. uint8_t NRF_Read_Buff(uint8_t reg, uint8_t *pBuf, uint8_t uchars);
     3 _# [2 b; L" c6 g
297. 
     8 h7 D8 D. }$ z7 B4 ~) ?" g9 ]4 n9 d6 |& F
298. /******************************************************************************
     % G) [/ }# ~1 d7 [
299.                                                         NRF24L01寄存器指令
     0 c' A/ ^7 F9 f& c
300. *******************************************************************************/
     5 O/ W  C9 G7 ~4 d
301. #define NRF_READ_REG    0x00          // 读寄存器指令
     2 u% J$ a* I+ T* t+ s
302. #define NRF_WRITE_REG   0x20         // 写寄存器指令
       Y* i2 h! W1 [6 _: a$ h. U6 ^
303. #define ACTIVATE                0x50          // follow with 0x73 to activate feature register
     
304. #define R_RX_PL_WID           0x60        // 读接收缓冲区的长度
     4 c, Z& o& }2 x" F" G0 m
305. #define RD_RX_PLOAD     0x61          // 读取接收数据指令
     
306. #define WR_TX_PLOAD     0xA0          // 写待发数据指令
     
307. #define W_ACK_PAYLOAD        0xA8        // Used in RX mode.
     
308. #define FLUSH_TX        0xE1         // 冲洗发送 FIFO指令
       {1 c( q2 b$ v0 `% O
309. #define FLUSH_RX        0xE2          // 冲洗接收 FIFO指令
     8 C/ V- R$ @9 o) M; x( r
310. #define REUSE_TX_PL     0xE3          // 定义重复装载数据指令
     
311. #define NOP             0xFF          // 保留
     
312. /******************************************************************************
     
313.                                                         NRF24L01寄存器地址
     
314. *******************************************************************************/
     " J5 n  N9 m) V- c9 X
315. #define CONFIG          0x00          // 配置收发状态，CRC校验模式以及收发状态响应方式
     
316. #define EN_AA           0x01          // 自动应答功能设置
     
317. #define EN_RXADDR       0x02          // 可用信道设置
     
318. #define SETUP_AW        0x03          // 收发地址宽度设置
     1 m/ @, u  x3 v1 S7 v
319. #define SETUP_RETR      0x04          // 自动重发功能设置
     4 W2 \! n4 i. [1 `4 H
320. #define RF_CH           0x05          // 工作频率设置
     / q3 n2 Y: K$ H
321. #define RF_SETUP        0x06          // 发射速率、功耗功能设置
     
322. #define NRFRegSTATUS    0x07          // 状态寄存器
     
323. #define OBSERVE_TX      0x08          // 发送监测功能
     , W9 s% j+ ?3 C2 k1 Y9 f
324. #define CD              0x09          // 地址检测           
     ( F+ ?4 \* w1 x
325. #define RX_ADDR_P0      0x0A          // 频道0接收数据地址
     : F1 m( O5 T* V1 N! K5 a
326. #define RX_ADDR_P1      0x0B          // 频道1接收数据地址
     ; |; Q% X9 T# `0 k; N4 N
327. #define RX_ADDR_P2      0x0C          // 频道2接收数据地址
     
328. #define RX_ADDR_P3      0x0D          // 频道3接收数据地址
     
329. #define RX_ADDR_P4      0x0E          // 频道4接收数据地址
     
330. #define RX_ADDR_P5      0x0F          // 频道5接收数据地址
     ' [0 @. W- l0 f; z/ {9 L) l' c2 S, b
331. #define TX_ADDR         0x10          // 发送地址寄存器
     
332. #define RX_PW_P0        0x11          // 接收频道0接收数据长度
     & j3 e- n: x* B  c
333. #define RX_PW_P1        0x12          // 接收频道1接收数据长度
     1 F) u  p6 H3 E$ K/ m6 y
334. #define RX_PW_P2        0x13          // 接收频道2接收数据长度
     $ C3 Y; o3 {$ p2 @# E. \; W' v6 d
335. #define RX_PW_P3        0x14          // 接收频道3接收数据长度
     
336. #define RX_PW_P4        0x15          // 接收频道4接收数据长度
     ! U0 z+ K6 @- _8 F* X( d0 {0 w3 _- x
337. #define RX_PW_P5        0x16          // 接收频道5接收数据长度
       X5 S- M# F, X7 s% L
338. #define FIFO_STATUS     0x17          // FIFO栈入栈出状态寄存器设置
     
339. 
     
340. #define DYNPD                    0x1C          // per pipe DPL control
     
341. #define FEATURE                    0x1D          // “Feature” register address
     
342.          
     
343. #endif
     
344. </font>

复制代码

3.Struct.h
* @, L9 u) V6 a6 ]5 g- G  L

1. <font face="微软雅黑" size="3">#ifndef _STRUCT_H_
   
2. #define _STRUCT_H_
   
3. 
   7 V4 o8 |0 A  u
4. #include "stm32f10x.h"
   
5. #include "Led.h"
   
6. #include "SPI_NRF24L01.h"
   & A5 u& q+ @+ g; f1 N  y1 E3 a* o
7. #include "Uart.h"
   
8. 
   
9. #endif
   2 T: x$ b- s7 r/ g7 X0 A
10. </font>

复制代码

4.main.c

1. <font face="微软雅黑" size="3">#include "Struct.h"
   4 \: Z5 v' |/ P$ \. G; r* f
2. 
   
3. int main(void)
   
4. {
   ) ]. K0 r1 A- a1 h6 c5 Z
5.   SPI2_Init();  //SPI2初始化
   
6.         NRF24L01_Init(35,TX);//2401选择35通道，发送模式
   
7.         NRF24L01_Check();//检测2401是否正常
   4 O  r7 X4 `/ T: n& i8 |9 x4 T
8.         PrintString("\r\n HEELO QST! \r\n");
   
9.         }
   4 j9 X9 ?' o% Y: n1 q
10. </font>

复制代码

" c- r- I+ G9 p' I  q: n1 g
总结
3 u. c, y' }# |( Q, x以上就是今天要讲的内容，本文仅仅简单介绍了基于STM32F103C8T6在Keil下编程实现NRF24L01实现无线传输的原理图和代码。

)        return;        //数据校验
        if( NRF24L01_RXDATA[1] != 'M' )        return;        //数据校验
        if( NRF24L01_RXDATA[2] != '>' )        return;        //MWC发送给上位机的标志
) ^0 N6 M( l0 t! Q) b0 p//        LEDGreen_ON;
  @* u0 L  v+ b- p! H//        if( NRF24L01_RXDATA[4] == MSP_FLY_DATA )//功能桢标志
//        {
//                Battery_Fly =( (uint16_t)(NRF24L01_RXDATA[6])  << 8 ) | NRF24L01_RXDATA[5];        
  c% p) c) `4 Q. r8 ^+ d3 V# L//                THROTTLE1  = ( (uint16_t)(NRF24L01_RXDATA[8])  << 8 ) | NRF24L01_RXDATA[7];
//                THROTTLE2  = ( (uint16_t)(NRF24L01_RXDATA[10]) << 8 ) | NRF24L01_RXDATA[9];        
* `3 u+ d, c- G//                THROTTLE3  = ( (uint16_t)(NRF24L01_RXDATA[12]) << 8 ) | NRF24L01_RXDATA[11];        
& N4 C* C$ U* C7 ?, |//                THROTTLE4  = ( (uint16_t)(NRF24L01_RXDATA[14]) << 8 ) | NRF24L01_RXDATA[13];        
//                pid[0].kp = NRF24L01_RXDATA[15];
( ^- Z& e/ f. X6 c; t//                pid[0].ki = NRF24L01_RXDATA[16];
8 T* c  A& Q  A" @* |3 C//                pid[0].kd = NRF24L01_RXDATA[17];
& L7 C# s; ^! ]: C//               
//                pid[1].kp = NRF24L01_RXDATA[18];
6 n* h4 |' x+ }+ u+ T  ]. j//                pid[1].ki = NRF24L01_RXDATA[19];
//                pid[1].kd = NRF24L01_RXDATA[20];
8 x  b" L) e' h2 _0 o% U7 D
( p# R2 ~/ P4 c; [1 f: h4 T: D. `//                pid[2].kp = NRF24L01_RXDATA[21];
//                pid[2].ki = NRF24L01_RXDATA[22];
8 z& T# q5 |. Y( a# g8 z//                pid[2].kd = NRF24L01_RXDATA[23];
; g3 t# S: F4 G1 g: `: w//               
//                for(i=3;i<10;i++)
- a9 h7 P& w$ T% }: ~9 t//                {
//                        pid.kp=0;
( A/ d/ i; t7 R6 ?" o' W//                        pid.ki=0;
//                        pid.kd=0;
//                }
9 O' n( Z/ T* y7 Q* L& @! _! e' [1 \//        }
//        else if( NRF24L01_RXDATA[4] == MSP_RAW_IMU || NRF24L01_RXDATA[4] == MSP_ATTITUDE )//功能桢标志
/ W1 ^/ M! r9 P8 A//                Uart_Send(NRF24L01_RXDATA,len+1);
}
8 u8 T& _. J8 Q7 z
/******************************************************************************
5 k, c! {: [9 ?- t9 s函数原型：        void NRF24L01_IRQ(void)
功    能：        NRF24L01中断
8 H, U2 j+ G9 u6 z: g*******************************************************************************/
void NRF24L01_IRQ(void)
{
0 F, _3 L8 X' S( ]) i- ?        uint8_t status = NRF_Read_Reg(NRF_READ_REG + NRFRegSTATUS);
4 J: w; D  P. f$ e        
        if(status & (1<<RX_DR))//接收中断
/ [! i1 ?+ g6 a4 W        {
6 q$ Z- l% Z* @; S% G) E/ X) u                uint8_t rx_len = NRF_Read_Reg(R_RX_PL_WID);//收到数据长度
* M# O! P/ [" w/ G' B) m                if(rx_len==32)
                {
                        NRF_Read_Buff(RD_RX_PLOAD,NRF24L01_RXDATA,rx_len);//读取接收FIFO数据
                        Nrf_Erro = 0;
                }
                else
! O& i4 F9 [5 U! a4 z- |; i                {
                        NRF_Write_Reg(FLUSH_RX,0xff);//清空接收缓冲区
                }
+ i; f0 C9 U2 h4 {) t        }
        if(status & (1<<MAX_RT))//达到最多次重发中断
2 g2 e. M# f% F: ~# P  P/ L        {
: O4 N& b& N- j" X                if(status & (1<<TX_FULL))//TX FIFO 溢出
# A( n0 w' F2 d  o: c8 l; N- E  B( E2 z                {
4 S' l+ G& ]  Z( j: B8 t                        NRF_Write_Reg(FLUSH_TX,0xff);//清空发送缓冲区
                }
        }
3 K, i( O( {" u9 D: f4 U        if(status & (1<<TX_DS))//发送完成
        {
4 ^% _- W4 j/ |" E: l- {( c' I/ P                NRF24L01_Set_RX();//设置Nrf2401为接收模式
        }
        NRF_Write_Reg(NRF_WRITE_REG + NRFRegSTATUS, status);//清除中断标志位
. {- A, c# V0 b/ [  {}

+ e4 k) h3 C6 P+ m/******************************************************************************
, _% p" n- y! h9 S& ]. Y7 Q. q函数原型：        void Nrf_Connect(void)
# k6 |# r* o5 l* I: ]) b# u/ E功    能：        NRF24L01连接函数
*******************************************************************************/
* k$ `  B& w& @7 D6 `9 Ovoid Nrf_Connect(void)//500HZ
, u* [3 ~9 L5 P- }) p9 t* Q9 Z+ w7 A& L{
        Nrf_Erro++;
0 U- c5 F+ Q! k7 d$ z        if(Nrf_Erro==1)
        {
  B, I% E! w/ g- z# g6 G                NRF24L01_Analyse();//分析NRF24L01收到的数据帧
        }
        if(Nrf_Erro%50==0)//0.1s未接收nrf数据 ，试图连接飞控
3 }0 U2 _2 s) T" }4 r        {        
                NRF24L01_IRQ();//清除中断标志位
        }
" c6 [/ n2 E1 s$ \) G2 z        if(Nrf_Erro>=500)//1s未接收nrf数据 ,关闭绿色LED指示灯
4 f& Y+ R( b; r3 v% _' P& g. O# h/ a        {        
! g( `2 ]8 n( n  \" m  f8 I//                LEDGreen_OFF;
                Nrf_Erro = 1;
//                Battery_Fly = 0;
        }
}
& l- `: R2 K; z</font>[/code]2.SPI_NRF24L01.h
  ~) T: Y7 |& ^& W+ r$ n1 {

1. <font face="微软雅黑" size="3">#ifndef _SPI_NRF24L01_H_
   
2. #define _SPI_NRF24L01_H_
   ; L+ [& {# b$ E) ?
3. #include "stm32f10x.h"
   
4. 
   
5. /******************************************************************************
   2 f/ Y* r0 g- O% M, u: W
6.                                                         宏定义
   $ E) @  i* Z7 i3 T. B
7. *******************************************************************************/
   , `) U9 v, M3 R0 N/ W  ]
8. #define TX        1
   
9. #define RX        2
   , b+ Q( j1 W/ q, I$ s
10. 
    
11. #define RX_DR        6        //接收数据中断.当接收到有效数据后置一。写‘1’清除中断。
    , p! x" m) {& _+ m$ P6 i2 v
12. #define TX_DS        5        //数据发送完成中断。当数据发送完成后产生中断。如果工作在自动应答模式下，只有当接收到应答信号后此位置一。写‘1’清除中断。
    ' N( J: e3 a9 M; j3 U! H2 I
13. #define MAX_RT        4        //达到最多次重发中断。写‘1’清除中断。如果MAX_RT中断产生则必须清除后系统才能进行通讯。
    8 ?6 `1 p6 X. y& j
14. #define TX_FULL 0        //TX FIFO寄存器满标志。   1:TX FIFO  寄存器满   0: TX FIFO 寄存器未满, 有可用空间。
    , V0 u3 ]& Y, N+ V( u
15. 
    # o% H& q% A% ^$ N5 p' I$ Q
16. /******************************************************************************
    ! a" [- E+ t: Q' H4 P& y
17.                                                         全局变量声明
    
18. *******************************************************************************/
    
19. extern         uint8_t NRF24L01_RXDATA[32];//nrf24l01接收到的数据
    
20. extern         uint8_t NRF24L01_TXDATA[32];//nrf24l01需要发送的数据
    
21. 
    
22. /******************************************************************************
    8 b% m: S$ V5 D2 s' k+ Y
23.                                                         全局函数声明
    
24. *******************************************************************************/
    ) F( S* _, k  j- }( `
25. void SPI2_Init(void);
      r+ Y. D) z6 s
26. void NRF24L01_IRQ(void);
    
27. void NRF24L01_Check(void);
    
28. void NRF24L01_Init(uint8_t Chanal,uint8_t Mode);
    8 |' V, y" O" [1 k$ S$ [* d# C
29. void NRF_Send_TX(uint8_t * tx_buf, uint8_t len);
    
30. void Nrf_Connect(void);
    " L" \/ R$ K' a4 P6 m! }) \8 D
31. 
    
32. uint8_t NRF_Read_Reg(uint8_t reg);
    
33. uint8_t NRF_Write_Reg(uint8_t reg, uint8_t value);
    
34. uint8_t NRF_Read_Buff(uint8_t reg, uint8_t *pBuf, uint8_t uchars);
    
35. 
    ( T8 t- j- T; V! N
36. /******************************************************************************
    
37.                                                         NRF24L01寄存器指令
    
38. *******************************************************************************/
    ( K' I) n* a# X3 v  ~$ @" R6 Q
39. #define NRF_READ_REG    0x00          // 读寄存器指令
    
40. #define NRF_WRITE_REG   0x20         // 写寄存器指令
    
41. #define ACTIVATE                0x50          // follow with 0x73 to activate feature register
    7 |9 B2 Z" l, V$ m( ~) n- l
42. #define R_RX_PL_WID           0x60        // 读接收缓冲区的长度
    
43. #define RD_RX_PLOAD     0x61          // 读取接收数据指令
    
44. #define WR_TX_PLOAD     0xA0          // 写待发数据指令
    : I* ~% U3 I0 e. y) r
45. #define W_ACK_PAYLOAD        0xA8        // Used in RX mode.
      J# ]) |: o4 r$ w9 S1 d, B* g7 H' z
46. #define FLUSH_TX        0xE1         // 冲洗发送 FIFO指令
    
47. #define FLUSH_RX        0xE2          // 冲洗接收 FIFO指令
    5 O, R2 D, p! B; d- B% T9 |
48. #define REUSE_TX_PL     0xE3          // 定义重复装载数据指令
    , L$ T2 F$ u( v2 O% j
49. #define NOP             0xFF          // 保留
    ! w: N! P3 n& [: ], P) P& P6 |
50. /******************************************************************************
      u! i" F' q6 X6 a& E# A/ J
51.                                                         NRF24L01寄存器地址
    1 x) B/ A+ O, M4 }1 |6 _
52. *******************************************************************************/
    
53. #define CONFIG          0x00          // 配置收发状态，CRC校验模式以及收发状态响应方式
    
54. #define EN_AA           0x01          // 自动应答功能设置
    + A+ s. B6 \+ D. W4 ^0 ]. y
55. #define EN_RXADDR       0x02          // 可用信道设置
    
56. #define SETUP_AW        0x03          // 收发地址宽度设置
    
57. #define SETUP_RETR      0x04          // 自动重发功能设置
    0 d' w* J7 b( v; L, u: \
58. #define RF_CH           0x05          // 工作频率设置
    - e3 p* N7 g& ]2 d( d4 z) {
59. #define RF_SETUP        0x06          // 发射速率、功耗功能设置
    8 V# h0 W1 J3 X: B! K9 X3 O
60. #define NRFRegSTATUS    0x07          // 状态寄存器
    
61. #define OBSERVE_TX      0x08          // 发送监测功能
    
62. #define CD              0x09          // 地址检测           
    
63. #define RX_ADDR_P0      0x0A          // 频道0接收数据地址
    ! b' q& O: n  R& e7 i; v; Q
64. #define RX_ADDR_P1      0x0B          // 频道1接收数据地址
    ' x3 }' U! b2 Q/ a% _* t# i, g. ]
65. #define RX_ADDR_P2      0x0C          // 频道2接收数据地址
    2 `4 u1 }3 `3 U, M5 ~- W
66. #define RX_ADDR_P3      0x0D          // 频道3接收数据地址
    ' z4 [  O: q6 C3 c
67. #define RX_ADDR_P4      0x0E          // 频道4接收数据地址
    9 n7 Z- C- X# M: [, d6 Q/ ^' e
68. #define RX_ADDR_P5      0x0F          // 频道5接收数据地址
    
69. #define TX_ADDR         0x10          // 发送地址寄存器
    9 X+ x5 F! a+ O
70. #define RX_PW_P0        0x11          // 接收频道0接收数据长度
    
71. #define RX_PW_P1        0x12          // 接收频道1接收数据长度
    
72. #define RX_PW_P2        0x13          // 接收频道2接收数据长度
    
73. #define RX_PW_P3        0x14          // 接收频道3接收数据长度
    7 z, h  z# w2 A7 I; [
74. #define RX_PW_P4        0x15          // 接收频道4接收数据长度
    
75. #define RX_PW_P5        0x16          // 接收频道5接收数据长度
    
76. #define FIFO_STATUS     0x17          // FIFO栈入栈出状态寄存器设置
    ; w: o* z9 J6 x$ E& U
77. 
    
78. #define DYNPD                    0x1C          // per pipe DPL control
    9 O% ^. W0 n* J6 l% Y
79. #define FEATURE                    0x1D          // “Feature” register address
    - @6 s/ d9 N' M: k- z
80.          
    1 E- B) {# a4 L+ _, L. s, X% E
81. #endif
    
82. </font>

复制代码

3.Struct.h

1. <font face="微软雅黑" size="3">#ifndef _STRUCT_H_
   1 g9 {9 }' R- w
2. #define _STRUCT_H_
   
3. 
   
4. #include "stm32f10x.h"
   0 T# K3 h/ p2 u; O
5. #include "Led.h"
   9 A  `# L. P7 I& m$ m; w
6. #include "SPI_NRF24L01.h"
   8 L& ^; w( |5 O
7. #include "Uart.h"
   / l' R. P; S! ^7 g( j, C
8. 
   4 m% D+ J. @) c5 a+ ]
9. #endif
   
10. </font>

复制代码

4.main.c
0 e$ O' N  J. C

1. <font face="微软雅黑" size="3">#include "Struct.h"
   
2. 
     ^9 K* }; o3 ]% m4 l
3. int main(void)
   ) D8 m# A  l% e5 @7 B
4. {
   
5.   SPI2_Init();  //SPI2初始化
   
6.         NRF24L01_Init(35,TX);//2401选择35通道，发送模式
   ; N' a; ~1 |3 c9 l3 O5 f* F
7.         NRF24L01_Check();//检测2401是否正常
   ( n, r! A5 Z/ R
8.         PrintString("\r\n HEELO QST! \r\n");
   
9.         }
   " r0 r$ b- F" G$ {9 P4 N
10. </font>

复制代码

; K! Y% g0 P  I7 B总结
以上就是今天要讲的内容，本文仅仅简单介绍了基于STM32F103C8T6在Keil下编程实现NRF24L01实现无线传输的原理图和代码。
, d5 E  r7 Q0 f3 e9 u
6 H5 r6 [: s+ h