无线通信实验
本章，我们将介绍如何使用2.4G无线模块NRF24L01实现无线通信。将使用两块STM32开发板，一块用于发送，一块用于接收，从而实现无线数据传输，并把数据显示在LCD上。

41.1 SPI&NRF24L01无线模块介绍
41.1.1 NRF24L01简介
NRF24L01无线模块，采用的芯片是NRF24L01+。该芯片是由NORDIC公司生产，并且集成NORDIC自家的Enhance ShortBurst协议，主要特点如下：
5 N3 z9 Z  o. }. X  s- B6 _1）2.4G全球开放的ISM频段，免许可证使用
2）最高工作速率2Mbps，高效的GFSK调制，抗干扰能力强
3）126个可选的频道，满足多点通信和调频通信的需要
: N- y: k7 b/ [3 _4）6个数据通道可支持点对多点的通信地址控制
1 n# Q7 u8 L6 i1 q" T5）低工作电压（1.9~3.6V）
+ H% L* D- P7 l$ M6）硬件CRC和自动处理字头
7）可设置自动应答，确保数据可靠传输
0 q9 q7 l& f; N' @0 o; K$ R由于高速信号是由芯片内部的射频协议处理后进行无线高速通信，对MCU的时钟频率要求不高，只需要对NRF24L01某些寄存器进行配置即可。芯片与外部MCU是通过SPI通信接口进行数据通信，并且最大的SPI速度可达10MHz。
这个芯片是NRF24L01的升级版。相比NRF24L01，升级版支持250k，1M，2M三种传输速率；支持更多种功率配置，根据不同应用有效节省功耗；稳定性及可靠性更高。
0 `) `4 b5 _7 F) s/ h7 z该模块的外形和引脚图如图41.1.1.1所示：
$ |& b+ }* H4 Q  E


+ B/ ^8 F) r1 U: w图41.1.1.1 NRF24L01无线模块外形和引脚图
模块VCC脚的电压范围为1.9~3.6V，建议不要超过3.6V，否则可能烧坏模块，一般用3.3V电压比较合适。除了VCC和GND脚，其他引脚都可以和5V单片机的IO口直连，正是因为其兼容5V单片机的IO，所以使用上具有很大优势。
具体引脚介绍如表41.1.1.1所示。
3 M% T8 {  i- _模块引脚 GND VCC CE CSN SCK MOSI MISO IRQ
/ X* E1 S, G7 A功能说明 地线 3.3V电源线 使能端 片选 时钟 数据输出 数据输入 中断
0 |# L( W+ O# ?! h* p表41.1.1.1 引脚介绍表
引脚部分主要分为电源相关的VCC和GND，SPI通信接口相关的CSN/SCK/MOSI/MISO，模式选择相关的CE，中断相关的IRQ。CE引脚会与CONFIG寄存器共同控制NRF24L01进入某个工作模式。IRQ引脚会在寄存器的配置下生效，当收到数据、成功发送数据或达到最大重发次数时，IRQ引脚会变为低电平。
+ p1 k9 `% Y+ b7 B/ z" PSPI通信接口将会在41.1.4小节进行讲解。
3 P& G: m1 d9 ^( [" ]; L. y6 tNRF24L01的Enhance ShockBurstTM模式具体表现在自动应答和重发机制，发送端要求接收端在接收到数据后要有应答信号，便于发送端检测有无数据丢失，一旦有数据丢失，则通过重发功能将丢失的数据恢复，这个过程无需MCU。Enhance ShockBurstTM模式可以通过EN_AA寄存器进行配置。
接下来看一下Enhanced ShockBurstTM模式下NRF24L01通信图，如图41.1.1.2所示：


3 h, P7 f' q1 J; ]
图41.1.1.2 NRF24L01通信图
这里我们抽离PTX6和PRX出来，分析一下通信过程。
. `2 o3 m7 i4 p" x( I2 aPTX6作为发送端，它就需要设置发送地址，可以看到TX_ADDR为0x7878787878，PRX作为接收端，它使能接收通道0并设置接收通道0接收地址0x7878787878。通信时，发送端发送数据接收端接收到数据并记录TX地址接收端以TX地址为目的地址发送应答信号发送端会以通道0接收应答信号。
NRF24L01规定：发送端中的数据通道0是用来接收接收端发送的应答信号，所以数据通道0的接收地址要与发送地址要相同才能确保收到正确的应答信号，这里十分重要，必须要在相关寄存器中配置正确。
41.1.2 NRF24L01工作模式介绍
NRF24L01作为无线通信模块，功耗问题十分重要，有数据发送与空闲状态下能耗肯定是需要调整，所以设计者给芯片设计了多种工作模块，如表41.1.2.1所示：

- E5 v$ K# ~5 w( A5 e* K

NRF24L01工作模式是由CE引脚和CONFIG寄存器的PWR_UP位和PRIM_RX位共同控制。CE引脚在前面也说到是模式控制线，而PWR_UP位是上电位，PRIM_RX位可以理解为配置身份位(TX or RX)。可以看到发送模式有两种，待机模式也有两种，功耗上各不相同，没有标红的发送模式和待机模式I是官方推荐使用，更加节能，但是本实验用到的模式就是上表中标红色部分，因为标红的的模式使用起来更加方便。单看发送模式，使用官方推荐的发送模式，你要发送三级TX_FIFO数据需要产生三个边沿信号（CE从高电平变为低电平）。而我们使用的发送模式，从CE引脚的操作上看，只需要拉高，就可以把所有TX_FIFO里的数据发送完成。
NRF24L01的发送和接收都有三级FIFO，每一级FIFO就有32个字节。发送和接收都是对FIFO进行操作，并且最大操作的数据量就是一级FIFO即32字节。发送时，只需要把数据存进TX_FIFO并按照发送模式下的操作（参考NRF24L01工作模式表中的发送模式）即可让NRF24L01启动发射，这个发射过程就包括：无线系统上电，启动内部16MHz时钟，无线发送数据打包，高速发送数据。接收时，也是通过读取RX_FIFO里的内容。
' N3 b; k2 t* |& @+ ~41.1.3 NRF24L01寄存器
& a, H! S1 ^8 ?. Z6 `) H8 {在这里简单介绍一下本实验用到的NRF24L01比较重要的寄存器。
3 H" U3 L! G$ F* p  B) f配置寄存器（CONFIG）
寄存器地址0x01，复位值为0x80，用来配置NRF24L01工作状态以及中断相关，描述如图41.1.2.1所示：



图41.1.2.1 配置寄存器图
需要配置成发送模式，可以把该寄存器赋值为0x0E，如果配置成接收模式，可以把该寄存器赋值为0x0F。无论是发送模式还是接收模式，都使能16位CRC以及使能接收中断、发送中断和最大重发次数中断，这里发送端和接收端配置需要一致。
: i1 x$ l. ^& F. {自动应答功能寄存器（EN_AA）
, r0 {  o. H& }3 r寄存器地址0x01，复位值为0x3F，用来设置通道0~5的自动应答功能，描述如图41.1.2.3所示：

/ J; Y! R9 C) ]. m2 ~2 o3 B

图41.1.2.3 自动应答功能寄存器图
4 D1 s8 w# q! [( ]' P' [4 o) D; _本实验，接收端是以数据通道0作为接收通道，并且前面也提及Enhanced ShockBurstTM模式的自动应答流程，接收端接收到数据后，需要回复应答信号，通过该寄存器ENAA_P0置1即可实现。另外，使能自动应答也相当于配置成Enhanced模式，所以发送端也需要进行自动应答允许。
接收地址允许寄存器（EN_RXADDR）
寄存器地址0x02，复位值为0x03，用于使能接收通道0~5，描述如图41.1.2.4所示：


' @, q" d6 s; e4 Y/ ?+ n
图41.1.2.4 接收地址允许寄存器图
前面也说到接收端使用的是通道0进行接收数据，所以ERX_P0需要置1处理。同样的，发送端也需要使能数据通道0来接收应答信号。
地址宽度设置寄存器（SETUP_AW）
5 A1 `) ]; {) {" p$ m, G寄存器地址0x03，复位值为0x03，对接收/发送地址宽度设置位，描述如图41.1.2.5所示：
( C; F7 F5 ^, J2 k9 E% _3 u


图41.1.2.5 地址宽度设置寄存器图
本实验中，无论是发送地址还是接收地址都是使用5字节，也就是默认设置便是使用5字节宽度的地址。
自动重发配置寄存器（SETUP_RETR）
寄存器地址0x04，复位值为0x00，对发送端的自动重发数值和延时进行设置，描述如图41.1.2.6所示：
1 z6 V! Z3 k( i& I3 j参数 位 描述
ADR 7:4 自动重发延时：
4 N: r$ p( ]  f7 q' ~3 h0000~111186 us + 250 * (ARD + 1) us
* v! _5 p/ m+ h: KARC 3:0 自动重发计数
# E/ Y" K5 J# o0000~1111自动重发次数。0代表禁止
图41.1.2.6 自动重发配置寄存器图
1 d6 d8 C5 `0 x% B本实验中，直接对该寄存器写入0x1A，即自动重发间隔时间为586us，最大自动重发次数为10次。在使能了MAX_RT中断时，连续重发10次还是发送失败的时候，IRQ中断引脚就会拉低。
射频频率设置寄存器（RF_CH）
寄存器地址0x05，复位值为0x05，对NRF24L01的频段进行设置，描述如图41.1.2.7所示：



图41.1.2.7 射频频率设置寄存器图
频率计算公式：2400 + RF_CH（MHz）
本实验中，直接对该寄存器写入40即射频频率为2440MHz。通信双方该寄存器必须配置一样才能通信成功。
( ~6 \/ w: T$ N. U3 l  ?发射参数设置寄存器（RF_SETUP）
. @# l! r1 J7 o5 o; Q: ?9 J9 \寄存器地址0x06，复位值为0x0E，对NRF24L01的发射功率、无线速率进行设置，描述如图41.1.2.8所示：
# X/ m1 ^- T3 L8 f5 Q2 X2 ^! S2 `


图41.1.2.8 发射参数设置寄存器图
本实验中，直接对该寄存器写入0x0F即射频输出功率为0dBm增益，传输速率为2MHz。发送端和接收端该寄存器的配置需一样。功率越小耗电越少，同等条件下，传输距离越小，这里我们设置射频部分功耗为最大，当然大家可以根据实际应用而选择对应的功率配置。
状态寄存器（STATUS）
$ L& u  i8 D% P5 r! J. G3 k5 x' l地址0x07，复位值为0x0E，反应NRF24L01当前工作状态，描述如图41.1.2.2所示：
/ i2 m2 F* o% N. b. `3 x( `( B& r5 q
: |/ P: y$ \4 N, z' m/ t

图41.1.2.2 状态寄存器图
) l4 Q' O; ]+ }0 G) }) e5 i该寄存器作为查询作用，作为发送端，发送完数据后，可以查询一下TX_DS位状态便知是否成功发送数据，发送数据异常时，也可以通过查询MAX_RT位状态获知是否达到最大重发次数。作为接收端，就可以通过查询RX_OK位状态获知是否接收到数据。我们查询相关位后都需要将该位置1清除中断。
( N7 S, ~7 X% T. {5 a+ m此外，我们还用到设置接收通道0地址寄存器RX_ADDR_P0(0x0A)和发送地址设置寄存器TX_ADDR(0x10)以及接收通道0有效数据看度设置寄存器RX_PW_P0(0x11)，由于这三个寄存器比较简单，所以这里就不列出来了。
% i& E7 l" E* A41.1.4 SPI接口简介
& I3 V# _; f2 u7 F3 t0 e; zSPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。
/ Z0 _- d* s1 E4 O" G8 `. gSPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，现在越来越多的芯片集成了这种通信协议，STM32H750也有SPI接口，其框图如图41.1.3.1所示：

! _+ Q5 m+ j! u

图41.1.3.1 STM32H750的SPI框图
3 y( x8 h! H& a  g8 K, S5 |图中我们挑出了4处和我们本章例程相关的位置进行重点介绍，其中①处是SPI的对外信号，一般由4根信号线组成（MCK是I2S用的，不属于SPI信号线）：
MISO（SDI）： 主设备数据输入，从设备数据输出。
MOSI（SDO）：主设备数据输出，从设备数据输入。
( r7 E; c* D: x; |# cSCK（CK）：时钟信号，由主设备产生。
SS（WS）：从设备片选信号（也称CS），由主设备控制。
图中②处是SPI的时钟生成器，将来自spi_ker_ck的时钟进行分频输出，最终产生SCK信号，并驱动RX/TX移位寄存器接收/发送数据。SPI1/2/3的spi_ker_ck时通过RCC_D2CCIP1R寄存器的SPI123SEL[2:0]设置，默认为0，则spi_ker_ck来自pll1_q_ck，为200Mhz。
图中③处重点由：TX移位寄存器、RX移位寄存器等组成，分别用于发送数据和接收数据，
TxFIFO用于发送数据，RxFIFO用于接收数据，我们可以设置FIFO大小为1，这样写入TXDR的数据就可以直接输出到TX移位寄存器，在SCK时钟的驱动下，输出到MOSI脚。同理，当FIFO大小为1时，RX移位寄存器接收到的数据，也会直接输出给RXDR寄存器。
图中④处是SPI的一堆控制寄存器，用于设置SPI的各种工作情况（或模式），该区域由spi_pclk时钟驱动。一般我们需要合理的设置这些寄存器，SPI才可以正常使用。
SPI总线有四种工作模式，如表41.1.3.1所示：


% w1 ^' l$ G9 [' K6 }
3 E3 a1 Q0 U- b: A+ `表41.1.3.1 SPI四种工作模式
其中CPOL和CPHA分别控制SCK的时钟极性和相位时钟，可以通过相关寄存器设置。 不同时钟/相位下的总线数据传输时序如图41.1.3.2所示：
6 `* L: H+ Y! `0 K. _3 e* v
! A' g5 x( c& h. _1 O3 M5 \

图41.1.3.2 不同时钟相位下的总线传输时序（CPHA=0/1）
SPI在驱动不同的器件时，必须注意其支持的工作模式，需要设置合适的SPI工作模式，才可以正常通信。
对于STM32H7来说，SPI的MSB和LSB是可以配置的，通过SPI_CFG2的LSBFIRST位进行控制，当该位为1时，表示LSB在前；当该位为0时，表示MSB在前；
7 V/ H% _( o; \( K, b& a& tSTM32H7的SPI功能很强大，SPI时钟最高可以到133Mhz，支持DMA，可以配置为SPI协议或者I2S协议（支持全双工I2S）。
本章，我们将使用STM32H750的SPI来驱动NRF24L01无线模块。这里对SPI我们只简单介绍一下SPI的使用，STM32H750的SPI详细介绍请参考《STM32H7xx考手册》第2180页，第50章。
# H  E/ N, }0 k9 N* N. OSPI主模式配置步骤
1）配置相关引脚的复用功能，使能SPI2时钟。
我们要用SPI2，第一步就要使能SPI2的时钟，SPI2的时钟通过APB1LENR的第14位来设置。其次要设置SPI2的相关引脚为复用(AF5)输出，这样才会连接到SPI2上。这里我们使用的是PB13、14、15这3个（SCK.、MISO、MOSI，CS使用软件管理方式），所以设置这三个为复用IO，复用功能为AF5。
& s( c; t" B$ b( O3 v) t2）设置SPI2的波特率和数据格式。
: g% C8 a, e% s8 ]1 D# C2 D- ?这一步通过SPI2_CFG1来设置，SPI2的波特率（就是SCK的频率，最大133Mhz）通过SPI2_CFG1寄存器的MBR[2:0]来设置，可以设置为spi_ker_ck的2~256分频。而数据格式通过SPI2_CFG1寄存器的DSIZE[4:0]位设置，数据长度等于DSIZE[4:0]+1，比如，我们要设置为8位数据格式，则设置DSIZE[4:0]=7即可。
0 c, s! A2 P: G! n: m' g# U3 ?3）设置SPI2工作模式。
这一步通过SPI2_CFG2来设置，我们设置SPI2为主机模式，全双工，然后通过CPOL和CPHA位来设置SCK时钟极性及采样方式。并设置SPI2的SS（即CS）控制方式为软件控制。
! e. n) q1 B! ]) T8 m4 K5 n4）使能SPI2。
通过SPI2_CR1的bit0来设置，以启动SPI2，在启动之后，我们就可以开始SPI通讯了。
5 p8 W. B' O+ X: ~; `2 e! N% N41.2 硬件设计
例程功能
开机的时候先检测NRF24L01模块是否存在，在检测到NRF24L01模块之后，根据KEY0和KEY1的设置来决定模块的工作模式。在设定好工作模式之后，就会不停的发送/接收数据，同时在LCD上面显示相关信息。LED0闪烁用于提示程序正在运行。
7 E0 Y! T1 w7 U- T硬件资源
( W: `+ k, W- b9 d1 e- O/ ^: Z1）LED灯 LED0 – PB4
2 ) 独立按键
6 U# R- y6 T* oKEY0 – PA1
, [; y' R! x4 W: d/ F( \KEY1 – PA15
7 N8 b* z2 Z" i' d3）2.4G无线模块 NRF24L01模块
4）正点原子2.8/3.5/4.3/7/10寸TFTLCD模块(仅限MCU屏，16位8080并口驱动)
% @' G' [0 l7 b5）串口1(PA9/PA10连接在板载USB转串口芯片CH340上面)
$ B6 L5 q7 p& \" R, x6）SPI2（连接在PB13/PB14/PB15上）
原理图
NRF24L01模块与STM32的连接关系，如下图所示：


' J6 F6 [+ C$ T
1 \" k4 c' ~9 F图41.2.1 NRF24L01模块接口与STM32连接原理图
这里NRF24L01使用的是SPI2，连接在PB13/PB14/PB15上。注意：NRF_IRQ和GBC_LED共用了PC3，所以，他们不能同时使用，需要分时复用。
由于无线通信实验是双向的，所以至少要有两个模块同时能工作，这里我们使用2套开发板来向大家演示。
41.3 程序设计
NRF24L01配置步骤
1）SPI参数初始化(工作模式、数据时钟极性、时钟相位等)。
HAL库通过调用SPI初始化函数HAL_SPI_Init完成对SPI参数初始化，详见例程源码。
注意：该函数会调用：HAL_SPI_MspInit函数来完成对SPI底层的初始化，包括：SPI及GPIO时钟使能、GPIO模式设置等。
# ~- `3 F& y$ ^- O% Z2）使能SPI时钟和配置相关引脚的复用功能以及NRF24L01的其他相关管脚。
7 L- N' D0 ?0 W: h$ C' p本实验用到SPI2，使用PB13、PB14和PB15作为SPI_SCK、SPI_MISO和SPI_MOSI，以及NRF24L01的CE、CSN和IRQ分别对应PC0，PE0和PC3，因此需要先使能SPI2、GPIOC和GPIOE时钟。参考代码如下：
__HAL_RCC_GPIOx_CLK_ENABLE(); /* 使能GPIOx时钟，x=A……K /
__HAL_RCC_SPI2_CLK_ENABLE (); / 使能SPI时钟 */
GPIO模式设置通过调用HAL_GPIO_Init函数实现，详见本例程源码。
" X6 d+ \# x! u3 a3）使能SPI
通过__HAL_SPI_ENABLE函数使能SPI，便可进行数据传输。
1 @) _4 I( \, m9 A4）SPI传输数据
通过HAL_SPI_Transmit函数进行发送数据。
通过HAL_SPI_Receive函数进行接收数据。
5 @. A& ?' r% A: a7 U7 U5 z也可以通过HAL_SPI_TransmitReceive函数进行发送与接收操作。
5）编写NRF24L01的读写函数
基于SPI的读写函数的基础上，编写NRF24L01的读写函数。
* ^9 z/ x) q" k2 R- @6）编写NRF24L01接收模式与发送模式函数
通过查看寄存器，编写配置NRF24L01接收和发送模式的函数。
41.3.1 程序流程图

. ]. |) n. j) ^" y; G

- I9 ^6 f3 Y, a2 W! f9 J图41.3.1.1无线通信实验程序流程图
41.3.2 程序解析

SPI驱动代码
- x$ K) X8 F# J. E) V- L& g这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。SPI驱动源码包括两个文件：spi.c和spi.h。
* P, r) X8 ~5 A- _/ B  U首先介绍的是spi.h文件，具体定义如下：
9 I  y4 N: T  L3 n9 \

1. /* SPI2 引脚 定义 */
   % u* J& o* M: c& ?
2. #define SPI2_SCK_GPIO_PORT                    GPIOB
   
3. #define SPI2_SCK_GPIO_PIN                      GPIO_PIN_13
   
4. #define SPI2_SCK_GPIO_AF                       GPIO_AF5_SPI2
   
5. #define SPI2_SCK_GPIO_CLK_ENABLE()      
   ; f1 S( Y/ c3 r* \5 L
6. do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   /* PB口时钟使能 */
   
7. 
   
8. #define SPI2_MISO_GPIO_PORT                   GPIOB
   9 q- A2 ]9 k$ |/ l8 T2 v0 i7 ]
9. #define SPI2_MISO_GPIO_PIN                    GPIO_PIN_14
   
10. #define SPI2_MISO_GPIO_AF                     GPIO_AF5_SPI2
    $ G7 d' Y. Z( q0 V
11. #define SPI2_MISO_GPIO_CLK_ENABLE()     
      c. g, G9 w! }( u! |! o
12. do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   /* PB口时钟使能 */
    
13. 
    - q, e- u9 b& r, E, t& Y; h
14. #define SPI2_MOSI_GPIO_PORT                   GPIOB
    3 k5 I! B' b2 @' {  e8 Y: I
15. #define SPI2_MOSI_GPIO_PIN                     GPIO_PIN_15
    - b6 A" w/ K. X  s
16. #define SPI2_MOSI_GPIO_AF                       GPIO_AF5_SPI2
    - l  T* L5 ?) {0 x
17. #define SPI2_MOSI_GPIO_CLK_ENABLE()     
    
18. do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   /* PB口时钟使能 */
    
19. 
    
20. /* SPI2相关定义 */
    - Q. Y& u* s8 g% F  k/ R
21. #define SPI2_SPI                                  SPI2
    
22. #define SPI2_SPI_CLK_ENABLE()           
    ; v' _" F: F! \9 \
23. do{ __HAL_RCC_SPI2_CLK_ENABLE(); }while(0)    /* SPI2时钟使能 */
    . S0 `$ |& {- w! w
24. 上面的宏定义是SPI2的接口（PB13\PB14\PB15）的相关宏定义。
    
25. 下面介绍spi.c文件，首先是SPI初始化相关函数，具体如下：
    9 e' \' k% X# J: Y0 L& v$ t4 b. Z
26. SPI_HandleTypeDef g_spi_handle;  /* SPI句柄 */
    $ [* m# q$ R5 p0 O. @
27. /**
    
28. * @brief             SPI初始化代码
    
29. *   @note            主机模式,8位数据,禁止硬件片选
    : s+ A7 n" j. ]( W& y" S( A0 \6 G1 x
30. * @param             无
    
31. * @retval            无
    1 ?( U' `" [( C0 r  ?5 k' E% _
32. */
    
33. void spi2_init(void)
    
34. {
    
35. g_spi_handle.Instance = SPI2;                 /* SP2 */
    ! w' d; {3 o, V0 |7 S& n
36. /* 设置SPI工作模式，设置为主模式 */
    + e. {/ U: z$ P. L, K
37. g_spi_handle.Init.Mode = SPI_MODE_MASTER;  
    
38. /* 设置SPI单向或者双向的数据模式:SPI设置为双线模式 */
    3 c% r3 ]/ q! E) B
39. g_spi_handle.Init.Direction = SPI_DIRECTION_2LINES;   
    , g- E8 z  m- o
40. /* 设置SPI的数据大小:SPI发送接收8位帧结构 */                  
    + {" ?8 D5 y# o" e: s
41. g_spi_handle.Init.DataSize = SPI_DATASIZE_8BIT;   
    6 J% R( H% F& y
42. /* 串行同步时钟的空闲状态为高电平 */                     
    
43.     g_spi_handle.Init.CLKPolarity = SPI_POLARITY_HIGH;                     
      }- A# C: ~! Z/ E& W! R0 f. c) a
44.     /* 串行同步时钟的第二个跳变沿（上升或下降）数据被采样 */
    
45. g_spi_handle.Init.CLKPhase = SPI_PHASE_2EDGE;     
    
46. /* NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制 */                     
    ' x! R; Y* ^8 G# k& t
47.     g_spi_handle.Init.NSS = SPI_NSS_SOFT;        
    # A; V5 v3 B1 f% ?" q
48. g_spi_handle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;  /* NSS信号脉冲失能 */
    
49. /* SPI主模式IO状态保持使能 */
    
50. g_spi_handle.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;  
    8 z$ d- I+ R7 x5 r, ]% s! X; _
51. /* 定义波特率预分频的值:波特率预分频值为256 */
    3 P; I# }9 M5 P9 ]
52. g_spi_handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;  
    & V* G% S( \& X1 y: y7 O# }
53. /* 指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始 */
    
54. g_spi_handle.Init.FirstBit = SPI_FIRSTBIT_MSB;        
    & K1 ~/ S9 G! k9 _* D( z
55.   /* 关闭TI模式 */                 
    
56. g_spi_handle.Init.TIMode = SPI_TIMODE_DISABLE;      
    + b% x' E2 n6 z$ F, I2 _
57. /* 关闭硬件CRC校验 */
    
58.     g_spi_handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;   
    * F5 a, `5 ?+ `6 N
59.     g_spi_handle.Init.CRCPolynomial = 7;            /* CRC值计算的多项式 */
    
60.     HAL_SPI_Init(&g_spi_handle);
    
61. 
    , }8 T/ I& t( n, E- a
62.     __HAL_SPI_ENABLE(&g_spi_handle);                 /* 使能SPI2 */
    " C9 e2 z3 Q+ i  {5 q
63.     spi2_read_write_byte(0Xff);                       /* 启动传输 */
    
64. }
    $ H# s* y3 G% n: L
65. 
    
66. /**
    
67. * @brief             SPI底层驱动，时钟使能，引脚配置
    4 S$ Y  @& j7 Y( w4 L6 q
68. * @param             hspi:SPI句柄
    7 e7 e0 K, p9 d  C8 _8 w
69. * @note               此函数会被HAL_SPI_Init()调用
    : O6 r( L9 e3 F3 n( c( u1 v
70. * @retval            无
    
71. */
    
72. void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
    
73. {
    
74.     GPIO_InitTypeDef gpio_init_struct;
    : A' h) U2 S- M3 L
75.     RCC_PeriphCLKInitTypeDef rcc_periph_clk_init;
    
76. 
    
77.     SPI2_SPI_CLK_ENABLE();                   /* SPI2时钟使能 */
    7 o1 o9 q- u3 e/ G0 ^: V
78.     SPI2_SCK_GPIO_CLK_ENABLE();             /* SPI2_SCK脚时钟使能 */
    
79.     SPI2_MISO_GPIO_CLK_ENABLE();            /* SPI2_MISO脚时钟使能 */
    
80.     SPI2_MOSI_GPIO_CLK_ENABLE();            /* SPI2_MOSI脚时钟使能 */
    
81. 
    
82. /* 设置SPI2的时钟源 */
    
83. rcc_periph_clk_init.PeriphClockSelection = RCC_PERIPHCLK_SPI2;
    
84. /* SPI2时钟源使用PLL1Q */
    
85.     rcc_periph_clk_init.Spi123ClockSelection = RCC_SPI123CLKSOURCE_PLL;
    7 f0 j$ Z8 I$ V$ c2 a' g' [- k
86.     HAL_RCCEx_PeriphCLKConfig(&rcc_periph_clk_init);
    
87. 
    ( P3 X" u# |* K6 G
88.     gpio_init_struct.Pin = SPI2_SCK_GPIO_PIN;
    
89.     gpio_init_struct.Mode = GPIO_MODE_AF_PP;                        /* 复用推挽输出 */
    
90.     gpio_init_struct.Pull = GPIO_PULLUP;                             /* 上拉 */
    
91.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;           /* 高速 */
    
92.     gpio_init_struct.Alternate = SPI2_SCK_GPIO_AF;                 /* 复用 */
    
93.     HAL_GPIO_Init(SPI2_SCK_GPIO_PORT, &gpio_init_struct);        /* 初始化SCK引脚 */
    
94. 
    * }  K6 |( E. U* C/ R$ W
95.     gpio_init_struct.Pin = SPI2_MISO_GPIO_PIN;
    7 D, _. J/ z4 m" w
96.     gpio_init_struct.Alternate = SPI2_MISO_GPIO_AF;                 /* 复用 */
    
97.     HAL_GPIO_Init(SPI2_MISO_GPIO_PORT, &gpio_init_struct);        /* 初始化MISO引脚 */
    
98. 
    
99.     gpio_init_struct.Pin = SPI2_MOSI_GPIO_PIN;
    
100.     gpio_init_struct.Alternate = SPI2_MOSI_GPIO_AF;                 /* 复用 */
     
101.     HAL_GPIO_Init(SPI2_MOSI_GPIO_PORT, &gpio_init_struct);        /* 初始化MOSI引脚 */
     ) R! a5 U2 ^9 O3 P1 |
102. }
     
103. 上面介绍的是SPI2初始化函数（SPI2_Init）和SPI初始化回调函数HAL_SPI_MspInit。
     
104. 最后介绍的是SPI2速度设置函数和SPI2读写一个字节数据函数，具体如下：
     
105. /**
     . A4 ^5 |* {9 {; A7 u; W
106. * @brief            SPI2速度设置函数
     # l0 W& h2 B  C; i2 n0 _
107. *   @note            SPI2时钟选择来自pll1_q_ck, 为240Mhz
     ! |- p% {% I: v
108. *                    SPI速度 = spi_ker_ck / 2^(speed + 1)
     
109. * @param             speed: SPI2时钟分频系数,SPI_BAUDRATEPRESCALER_2
     ! x* A$ [( V: ?2 a9 b4 m) m
110. ~SPI_BAUDRATEPRESCALER_256
     
111. * @retval            无
     8 ^3 I4 f5 }* \( V8 I5 G: w9 s
112. */
     9 \3 D1 E+ W5 d) ?% P1 y; B: e
113. void spi2_set_speed(uint32_t speed)
     ' J* o4 z) B' X/ c5 A- U
114. {
     
115.     assert_param(IS_SPI_BAUDRATE_PRESCALER(speed));        /* 判断有效性 */
     4 Y& c+ m! q! K
116.     __HAL_SPI_DISABLE(&g_spi_handle);                       /* 关闭SPI */
     
117.     g_spi_handle.Instance->CFG1 &= ~(0X7 << 28);         /* 位30-28清零，用来设置波特率*/
     ! k# T! Y" o/ k1 ?8 B
118.     g_spi_handle.Instance->CFG1 |= speed;                   /* 设置SPI速度 */
     6 h3 [* {. @: w6 i5 G
119.     __HAL_SPI_ENABLE(&g_spi_handle);                         /* 使能SPI */
       q' F& B9 l9 W6 C3 X# P
120. }
     
121. /**
     / u4 J9 Y. @& f* |5 A1 C2 Y6 e' x/ v
122. * @brief             SPI2读写一个字节数据
     
123. * @param             txdata: 要发送的数据(1字节)
     
124. * @retval             接收到的数据(1字节)
     
125. */
     
126. uint8_t spi2_read_write_byte(uint8_t txdata)
     : B! h$ A  C6 `! @
127. {
     7 F9 R! P5 s- Z* l$ q) l% X
128.     uint8_t rxdata;
     
129.     HAL_SPI_TransmitReceive(&g_spi_handle,&txdata,&rxdata, 1, 1000);
     0 ~* S& g" A  |- k
130.     return rxdata;    /* 返回收到的数据 */
     9 S  j' {  x. R0 c% _
131. }

复制代码

6 |1 J/ h' e0 N- G! o8 S6 r其中，spi2_set_speed函数用于设置SPI2的传输速度也就是波特率，SPI2的传输速度是通过SPI2->CFG1寄存器的位30-28来设置。形参speed是SPI2时钟分频系数，取值范围是：SPI_BAUDRATEPRESCALER_2~SPI_BAUDRATEPRESCALER_256。
' J1 h* [1 X1 w8 n% k2 @2 \* Y而spi2_read_write_byte函数主要是通过调用HAL库中SPI发送接收函数HAL_SPI_TransmitReceive来实现数据的发送和接收。
2. NRF24L01驱动代码
这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。NRF24L01驱动源码包括两个文件：nrf24l01.c和nrf24l01.h。
我们要在spi.c文件中封装好的函数的基础上进行调用，实现nrf24l01的发送与接收。下面先看一下nrf24l01.h文件中定义的信息，其代码如下：
* y$ n1 ^# d5 v/* NRF24L01 操作引脚 定义(不包含SPI_SCK/MISO/MISO等三根线) */

1. #define NRF24L01_CE_GPIO_PORT                           GPIOC
   
2. #define NRF24L01_CE_GPIO_PIN                            GPIO_PIN_0
   ( d% z6 X4 M3 X' w
3. #define NRF24L01_CE_GPIO_CLK_ENABLE()      
   
4. do{ __HAL_RCC_GPIOC_CLK_ENABLE(); }while(0)   /* PC口时钟使能 */
   # Q# }; k% W& f, r
5. 
   / c- W' X! e- f- `% K
6. #define NRF24L01_CSN_GPIO_PORT                    GPIOE
   & T9 Y: `+ ~' @+ g# v
7. #define NRF24L01_CSN_GPIO_PIN                      GPIO_PIN_0
   
8. #define NRF24L01_CSN_GPIO_CLK_ENABLE()     
   
9. do{ __HAL_RCC_GPIOE_CLK_ENABLE(); }while(0)   /* PE口时钟使能 */
   1 Y7 I8 J+ {: n4 F3 L5 [  h, {
10. 
    * `4 N- o) t: x1 M; m/ ^9 q+ @
11. #define NRF24L01_IRQ_GPIO_PORT                     GPIOC
    
12. #define NRF24L01_IRQ_GPIO_PIN                      GPIO_PIN_3
    
13. #define NRF24L01_IRQ_GPIO_CLK_ENABLE()     
    
14. do{ __HAL_RCC_GPIOC_CLK_ENABLE(); }while(0)   /* PC口时钟使能 */
    
15. /* 24L01操作线 */
    3 I2 e+ L5 P- n3 c) Y$ J
16. #define NRF24L01_CE(x)    do{ x ? \
    
17. HAL_GPIO_WritePin(NRF24L01_CE_GPIO_PORT,NRF24L01_CE_GPIO_PIN,GPIO_PIN_SET):\
    
18. HAL_GPIO_WritePin(NRF24L01_CE_GPIO_PORT,NRF24L01_CE_GPIO_PIN,GPIO_PIN_RESET);\
    
19.                                  }while(0)       /* 24L01模式选择信号 */
    * M3 P+ @7 m* j, a
20. 
    # Z1 A, ]  i9 `: \, d
21. #define NRF24L01_CSN(x)   do{ x ? \
    / I% Y- ]2 C% S# M/ b% [
22. HAL_GPIO_WritePin(NRF24L01_CSN_GPIO_PORT,NRF24L01_CSN_GPIO_PIN,GPIO_PIN_SET):\
    5 X! @- |& I* a$ }7 w( @' c* ?$ y
23. HAL_GPIO_WritePin(NRF24L01_CSN_GPIO_PORT,
    5 `8 Y$ \5 b' t1 Q
24. NRF24L01_CSN_GPIO_PIN,GPIO_PIN_RESET);\
    
25.                                  }while(0)       /* 24L01片选信号 */
    . ]0 v, L. J' t8 q& H/ v
26. 
    
27. #define NRF24L01_IRQ      HAL_GPIO_ReadPin(NRF24L01_IRQ_GPIO_PORT,
    
28. NRF24L01_IRQ_GPIO_PIN) /* IRQ主机数据输入 */
    
29. 以上除了有NRF24L01的引脚定义及引脚操作函数，此外还有一些NRF24L01寄存器操作命令以及其寄存器地址，由于篇幅太大，所以这里就不列出来了，大家可以去看一下工程文件。
    % K" s8 F# y4 L0 `8 D) R
30. 下面看一下NRF24L01的初始化函数，其定义如下：
    
31. /**
    
32. * @brief             针对NRF24L01修改SPI2驱动
    9 q0 W2 R9 W7 I$ E( G8 A" W7 A
33. * @param              无
    $ i6 U6 x/ @7 N6 Y( v! r8 x
34. * @retval            无
    % @$ N: S/ F$ J# v: @( I
35. */
    ( E: m  p9 T) ^2 M. W
36. void nrf24l01_spi_init(void)
    
37. {
    & J) N0 A; O! g( S; Q
38. __HAL_SPI_DISABLE(&g_spi_handle);   /* 先关闭SPI2 */
    - c: n- ^& p( U
39. /* 串行同步时钟的空闲状态为低电平 */
    + R8 P3 N1 c5 g5 z& ?
40. g_spi_handle.Init.CLKPolarity = SPI_POLARITY_LOW;
    
41. /* 串行同步时钟的第1个跳变沿（上升或下降）数据被采样 */
    
42.     g_spi_handle.Init.CLKPhase = SPI_PHASE_1EDGE;     
    
43.     HAL_SPI_Init(&g_spi_handle);
    
44.     __HAL_SPI_ENABLE(&g_spi_handle);    /* 使能SPI2 */
    
45. }
    3 h2 s8 ^" z5 K' d
46. 
    3 n8 N2 i3 M2 V8 h
47. /**
    
48. * @brief             初始化24L01的IO口
    # {1 z; E1 k0 W7 _' Y) \' s
49. *   @note            将SPI2模式改成SCK空闲低电平,及SPI 模式0
    % Z) }' C5 t" P: y; X0 N$ N- F% G
50. * @param             无
    
51. * @retval            无
    
52. */
    % o3 @0 ?2 o$ F6 V+ ^
53. void nrf24l01_init(void)
    
54. {
    
55. GPIO_InitTypeDef gpio_init_struct;
    / n6 r) p( T0 a. d2 X* k- a0 `
56. 
    
57.     NRF24L01_CE_GPIO_CLK_ENABLE();           /* CE脚时钟使能 */
    
58.     NRF24L01_CSN_GPIO_CLK_ENABLE();         /* CSN脚时钟使能 */
    
59.     NRF24L01_IRQ_GPIO_CLK_ENABLE();         /* IRQ脚时钟使能 */
    / Z8 }2 Q- B. ~# S$ I" B
60. 
    
61.     gpio_init_struct.Pin = NRF24L01_CE_GPIO_PIN;
    9 L8 h" m8 ]2 Y+ R0 z% ?
62.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;                       /* 推挽输出 */
    + w& m/ Z% }5 A; Z, d
63.     gpio_init_struct.Pull = GPIO_PULLUP;                                 /* 上拉 */
    
64.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;               /* 高速 */
    3 F+ T$ o, G* W+ P7 R
65.     HAL_GPIO_Init(NRF24L01_CE_GPIO_PORT, &gpio_init_struct);         /* 初始化CE引脚 */
    
66. 
    
67.     gpio_init_struct.Pin = NRF24L01_CSN_GPIO_PIN;
    $ I9 O6 L4 C7 c) g! ^. x# ^0 k
68.     HAL_GPIO_Init(NRF24L01_CSN_GPIO_PORT, &gpio_init_struct);        /* 初始化CS引脚 */
    
69. 
    6 Y- @! ~% U/ C0 x' O5 E2 F
70.     gpio_init_struct.Pin = NRF24L01_IRQ_GPIO_PIN;
    ( q. Z! H3 F/ t5 \5 R- x
71.     gpio_init_struct.Mode = GPIO_MODE_INPUT;                            /* 输入 */
    
72.     gpio_init_struct.Pull = GPIO_PULLUP;                                 /* 上拉 */
    
73.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;               /* 高速 */
    ; g' ?9 \4 N2 i- g
74.     HAL_GPIO_Init(NRF24L01_IRQ_GPIO_PORT, &gpio_init_struct);        /* 初始化CE引脚 */
    
75. 
    7 k2 q9 c+ o0 n7 b9 g& u* Y8 C
76.     spi2_init();                          /* 初始化SPI2 */
    
77.     nrf24l01_spi_init();                /* 针对NRF的特点修改SPI的设置 */
    
78.     NRF24L01_CE(0);                      /* 使能24L01 */
    
79.     NRF24L01_CSN(1);                    /* SPI片选取消 */
    
80. }

复制代码

在初始化函数中，我们主要对该模块用到的管脚进行配置以及从初始化工作以及需要调用spi.c文件中的spi_init函数对SPI1的引脚进行初始化。现在让我们看一下 NRF24L01的工作时序图见下图41.3.2.1所示。

4 X  n8 }. t1 x
$ d0 r, w1 C; a) _! `
* Y9 Z$ j/ I$ @0 I2 V+ o' H图41.3.2.1 NRF24L01的工作时序图
大家可以比对一下前面章节的SPI工作时序图，符合工作模式1的时序，即在奇数边沿上升沿进行数据的采集。所以我们调用nrf24l01_spi_init函数针对NRF的特点修改SPI的设置。该函数就是将SPI的工作模式配置成串行同步时钟空闲状态为低电平，在奇数边沿数据被采集，也就是前面SPI实验章节中SPI的工作模式0。看看工作时序图的某些标号意义，Cn代表指令位，Sn代表状态寄存器位，Dn代表数据位。
下面介绍一下NRF24L01的读写函数，其代码如下：
2 I0 @! M# b  B) P3 E( \

1. /**
   $ O$ s3 c# M8 C) w% b% N3 F+ P4 A
2. * @brief             NRF24L01写寄存器
   
3. * @param             reg   : 寄存器地址
   8 `; B# M! t% p$ W
4. * @param             value : 写入寄存器的值
   
5. * @retval            状态寄存器值
   
6. */
   
7. static uint8_t nrf24l01_write_reg(uint8_t reg, uint8_t value)
   1 `+ Y4 R+ n9 B8 k; B3 O
8. {
   3 i5 N  z2 K9 y5 i! ?
9.     uint8_t status;
   9 e' B. U2 y9 z4 t1 e" E  n/ P( d" N
10.     NRF24L01_CSN(0);                               /* 使能SPI传输 */
    & b( _" U( r" o
11.     status = spi2_read_write_byte(reg);        /* 发送寄存器号 */
    
12.     spi2_read_write_byte(value);         /* 写入寄存器的值 */
    
13.     NRF24L01_CSN(1);                               /* 禁止SPI传输 */
    
14.     return status;                                 /* 返回状态值 */
    . R  P5 p4 w. F. L
15. }
    
16. 
    
17. /**
    & \7 m/ A8 t8 w+ s: C1 e3 F
18. * @brief             NRF24L01读寄存器
    
19. * @param             reg   : 寄存器地址
    : Z* r0 d( x- ~/ J# k: h" S
20. * @retval            读取到的寄存器值;
    2 W  Y7 j- Z" o# f# ~, i
21. */
    
22. static uint8_t nrf24l01_read_reg(uint8_t reg)
    
23. {
    
24.     uint8_t reg_val;
    ' w5 n; |1 p2 ?5 t+ G" f
25.     NRF24L01_CSN(0);                                    /* 使能SPI传输 */
    
26.     spi2_read_write_byte(reg);                        /* 发送寄存器号 */
    
27.     reg_val = spi2_read_write_byte(0XFF);   /* 读取寄存器内容 */
    
28.     NRF24L01_CSN(1);                                    /* 禁止SPI传输 */
    
29.     return reg_val;                                     /* 返回状态值 */
    
30. }
    3 l; A7 b/ [" T. g6 @# e+ J
31. 
    
32. /**
    
33. * @brief             在指定位置读出指定长度的数据
    
34. * @param               reg   : 寄存器地址
    , M( q9 n( K1 B9 U" V# t5 U
35. * @param               pbuf  : 数据指针
    
36. * @param               len   : 数据长度
    
37. * @retval              状态寄存器值
    
38. */
    
39. static uint8_t nrf24l01_read_buf(uint8_t reg, uint8_t *pbuf, uint8_t len)
    : L5 O7 u1 k' K, L: P
40. {
    ; y8 }. {2 c% N0 H& q. v: c
41.     uint8_t status, i;
    ) S  }) Y% q6 b( X5 n/ z: t5 z
42.     NRF24L01_CSN(0);     /* 使能SPI传输 */
    
43. status = spi2_read_write_byte(reg);         /* 发送寄存器值(位置),并读取状态值 */
    ' V, `, b6 E' t/ k$ x% ?; M7 P% H
44. 
    2 e9 c: F6 K# v+ O4 _
45.     for (i = 0; i < len; i++)
    
46.     {
    
47.         pbuf<i> = spi2_read_write_byte(0XFF);  /* 读出数据 */
    4 n- s0 Z& H" f3 m# k
48. }
    ' L" A1 s' W2 L6 ]5 ^% Y
49. 
    0 N% \6 l* n6 ?4 N6 T- A
50.     NRF24L01_CSN(1);    /* 关闭SPI传输 */
    
51.     return status;      /* 返回读到的状态值 */
    
52. }
    
53. 
    " l" Z+ L. }. Y% Q
54. /**
    
55. * @brief             在指定位置写指定长度的数据
    
56. * @param              reg   : 寄存器地址
    
57. * @param               pbuf  : 数据指针
    ; R  Z: s! ?$ g
58. * @param               len   : 数据长度
    3 m/ G8 V3 }% B1 j9 p
59. * @retval              状态寄存器值
    ) y2 j0 p5 B3 E$ F. G& i
60. */
    ' g$ E: v* f% [  O% o, i( g
61. static uint8_t nrf24l01_write_buf(uint8_t reg, uint8_t *pbuf, uint8_t len)
    
62. {
    
63.     uint8_t status, i;
      J( p6 {6 r& S6 \
64.     NRF24L01_CSN(0);                               /* 使能SPI传输 */
    
65. status = spi2_read_write_byte(reg);        /* 发送寄存器值(位置),并读取状态值 */
    
66. 
    & R- F# J) E( T
67.     for (i = 0; i < len; i++)
    2 b& K' T/ r% \' G4 W
68.     {
    
69.         spi2_read_write_byte(*pbuf++);          /* 写入数据 */
    / M0 P4 y& ~' J6 k% `2 i. e
70. }
    ( f% s8 D0 @2 M
71. 
    7 D4 N$ @0 F1 y+ d
72.     NRF24L01_CSN(1);    /* 关闭SPI传输 */
    
73.     return status;      /* 返回读到的状态值 */
      j3 y+ B2 z; `' u
74. }
    : B7 Q$ E1 ]! e' Q; i5 k: c
75. </i>

复制代码

以上是NRF24L01的写寄存器函数和读寄存器函数，以及扩展的函数：在指定位置写入指定长度的数据函数和指定位置读取指定长度的数据函数。
4 Y. ^% A  s% `5 m" i6 S先讲一下NRF24L01读写寄存器函数实现的具体过程：
先拉低片选线→发送寄存器号→发送数据/接收数据→拉高片选线。
这里提及一下SPI的相关知识：SPI是通过移位寄存器进行数据传输，所以发一字节数据就会收到一个字节数据。那么发数据就可以直接发送数据，接收数据只需要发送0xFF，寄存器会返回要读取的数据。
在指定位置写入指定长度的数据函数和在指定位置读取指定长度的数据函数的实现方式也是通过调用SPI的读写一字节函数实现，这里跟写寄存器和读寄存器函数的实现差不多，这里就不做展开了。
7 t1 q* f  D9 q3 Z/ A/ ^3 a+ {下面看一下这两种模式的初始化过程：
% I, R0 s, X! i# w! p- Z2 URx模式初始化过程：
8 @1 @) x* q+ W$ A6 W  c6 q1）写Rx节点的地址
# C7 H/ N  T  A9 N! i( \) T2）使能通道x自动应答
) M, \& u4 V/ p2 D; c7 Z% o3）使能通道x接收地址
4）设置通信频率
5）选择通道x的有效数据宽度
6）配置发射参数（发射功率、无线速率）
7）配置NRF24L01的基本参数以及切换工作模式
其代码如下：
* K' U% ^  C  Q  u9 H
( s9 p! f( x+ ?! e3 v: W; g

1. /**
   
2. * @brief            NRF24L01进入接收模式
   8 v* N" I' |! C& _3 r
3. *   @note            设置RX地址,写RX数据宽度,选择RF频道,波特率和LNA HCURR
   
4. *                      当CE变高后,即进入RX模式,并可以接收数据了
   
5. * @param               无
   3 o5 A2 ?2 e' t/ d
6. * @retval              无
   
7. */
   + v& G6 {. W7 N. y7 z: [' R
8. void nrf24l01_rx_mode(void)
   # r) [( C2 _: T2 f6 m! j% U; E+ X
9. {
   7 L9 r7 ^' `# m9 Y0 H8 Z) v+ Q
10.     NRF24L01_CE(0);
    " J. d9 ?, q' y% e! y% G3 a  ^& H
11.     nrf24l01_write_buf(NRF_WRITE_REG + RX_ADDR_P0, (uint8_t *)RX_ADDRESS, RX_ADR_WIDTH);/* 写RX节点地址 */
    * X: s& M- x3 s. u5 `8 e2 z- R
12. 
    
13.     nrf24l01_write_reg(NRF_WRITE_REG + EN_AA, 0x01);      /* 使能通道0的自动应答 */
    0 X7 T  F- D" R5 {
14.     nrf24l01_write_reg(NRF_WRITE_REG + EN_RXADDR, 0x01); /* 使能通道0的接收地址 */
    ! A# s; a4 P2 k  h0 H6 c7 b
15. nrf24l01_write_reg(NRF_WRITE_REG + RF_CH, 40);        /* 设置RF通信频率 */
    
16. /*选择通道0的有效数据宽度*/
    
17. nrf24l01_write_reg(NRF_WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH);
    1 [) ?+ d1 [( N0 V$ N0 q
18. /*设置TX发射参数,0db增益,2Mbps,低噪声增益开启*/
    + \! W& T, p" _! b( f& @6 ^
19. nrf24l01_write_reg(NRF_WRITE_REG + RF_SETUP, 0x0f);
    
20. /* 配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式 */
    
21.     nrf24l01_write_reg(NRF_WRITE_REG + CONFIG, 0x0f);      
    
22.     NRF24L01_CE(1); /* CE为高,进入接收模式 */
    
23. }
    : T8 f# o1 I0 ~- u, M6 |
24. Tx模式初始化过程：
    " D1 N5 [$ h9 ^* B+ Q- q
25. 1）写Tx节点的地址
    ; M* e2 `9 k3 W+ g
26. 2）写Rx节点的地址，主要为了使能硬件的自动应答
    
27. 3）使能通道x的自动应答
    
28. 4）使能通道x接收地址
    
29. 5）配置自动重发次数
    
30. 6）配置通信频率
    7 R1 J* q/ x! P
31. 7）选择通道x的有效数据宽度
    # j6 x! a  @0 ?1 `5 Z
32. 8）配置发射参数（发射功率、无线速率）
    
33. 9）配置NRF24L01的基本参数以及切换工作模式
    ; x/ I# q+ j0 i/ N
34. 其代码如下：
    
35. /**
    ( o1 C; E% {5 w; J9 B  M, M
36. * @brief             NRF24L01进入发送模式
    
37. *   @note            设置TX地址,写TX数据宽度,设置RX自动应答的地址,填充TX发送数据,选择RF频 道,波特率和PWR_UP,CRC使能
    # p+ S4 q/ C0 l- `. S' K1 @
38. *                      当CE变高后,即进入TX模式,并可以发送数据了, CE为高大于10us,则启动发送.
    
39. * @param             无
    
40. * @retval             无
    
41. */
    
42. void nrf24l01_tx_mode(void)
    3 c& \7 o0 ]+ f. x& t( H6 j' P
43. {
    
44.     NRF24L01_CE(0);
      R7 X% {$ Z2 f& O
45.     nrf24l01_write_buf(NRF_WRITE_REG + TX_ADDR, (uint8_t *)TX_ADDRESS,          TX_ADR_WIDTH);   /* 写TX节点地址 */
    2 r: u2 f0 b  F, x4 U3 k& p# ~
46.     nrf24l01_write_buf(NRF_WRITE_REG + RX_ADDR_P0, (uint8_t *)RX_ADDRESS,     RX_ADR_WIDTH);    /* 设置RX节点地址,主要为了使能ACK */
    
47. 
    
48.     nrf24l01_write_reg(NRF_WRITE_REG + EN_AA, 0x01);       /* 使能通道0的自动应答 */
    
49. nrf24l01_write_reg(NRF_WRITE_REG + EN_RXADDR, 0x01);  /* 使能通道0的接收地址 */
    
50. /* 设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次 */
    " H: n/ B1 q( e/ r6 P
51.     nrf24l01_write_reg(NRF_WRITE_REG + SETUP_RETR, 0x1a);   
    
52. nrf24l01_write_reg(NRF_WRITE_REG + RF_CH, 40);         /* 设置RF通道为40 */
    5 S; ~0 U6 v* Y& _# j% R$ j
53. /* 设置TX发射参数,0db增益,2Mbps,低噪声增益开启 */
    
54. nrf24l01_write_reg(NRF_WRITE_REG + RF_SETUP, 0x0f);     
    : d$ ]% A9 I5 o& l
55. /* 配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开启所有中断 */
    
56.     nrf24l01_write_reg(NRF_WRITE_REG + CONFIG, 0x0e);      
    
57.     NRF24L01_CE(1); /* CE为高,10us后启动发送 */
    
58. }

复制代码

% T  E; @9 P+ }以上就是两种模式的配置，看过完整代码的，会发现TX_ADDR和RX_ADDR两个地址是一样的，跟前面说法一致，我们必须保持地址的匹配才能通信成功。以上代码中的发送函数都有一个特点，并不是单纯发送寄存器地址，而是操作指令+寄存器地址，这一点需要记得。NRF24L01的操作指令也有好几个，它是配合寄存器完成特定的操作，其定义如下：

& {' l/ d4 X  Q

1. /* NRF24L01寄存器操作命令 */
   * c, k/ u7 L1 L. y( Y: g
2. #define NRF_READ_REG           0x00           /* 读配置寄存器,低5位为寄存器地址 */
   ' g5 y: v1 k2 f. d; F
3. #define NRF_WRITE_REG          0x20          /* 写配置寄存器,低5位为寄存器地址 */
   
4. #define RD_RX_PLOAD           0x61          /* 读RX有效数据,1~32字节 */
     E' O: X. C! E4 {/ f) ]$ V
5. #define WR_TX_PLOAD            0xA0          /* 写TX有效数据,1~32字节 */
   
6. #define FLUSH_TX              0xE1          /* 清除TX FIFO寄存器.发射模式下用 */
   
7. #define FLUSH_RX             0xE2            /* 清除RX FIFO寄存器.接收模式下用 */
   # v3 ^" ?( ^5 q7 I! K! {
8. #define REUSE_TX_PL           0xE3            /* 重新使用上一包数据,CE为高,数据包被不断发送. */
   3 S! q& ]$ O4 B9 y: l1 N
9. #define NOP                    0xFF            /* 空操作,可以用来读状态寄存器 */
   
10. 经过上面的发送或者接收模式初始化步骤后，NRF24L01就可以准备启动发送数据或者等待接收数据了。
    / s/ {# A* y/ |  H  Y
11. 下面来看一下启动NRF24L01发送一次数据的函数，其定义如下：
    7 ?/ j+ H. c) V! f: O; {$ A
12. /**
    ' d+ P& x0 R( F+ R
13. * @brief             启动NRF24L01发送一次数据(数据长度 = TX_PLOAD_WIDTH)
    
14. * @param             ptxbuf : 待发送数据首地址
    
15. * @retval            发送完成状态
    
16. *   @arg             0    : 发送成功
    
17. *   @arg             1    : 达到最大发送次数,失败
    
18. *   @arg             0XFF : 其他错误
    
19. */
    
20. uint8_t nrf24l01_tx_packet(uint8_t *ptxbuf)
    4 W; h: m' K# k9 Z* `. u
21. {
    
22.     uint8_t sta;
    . b3 q! A7 }3 c# F8 j
23.     uint8_t rval = 0XFF;
    
24. 
    
25. NRF24L01_CE(0);
    " r* j5 `3 B3 t' p% x
26. /* 写数据到TX BUF  TX_PLOAD_WIDTH个字节 */
    
27.     nrf24l01_write_buf(WR_TX_PLOAD, ptxbuf, TX_PLOAD_WIDTH);   
    
28.     NRF24L01_CE(1); /* 启动发送 */
    
29. 
    8 D! c0 a1 e' H+ z5 t. e  f. s
30.     while (NRF24L01_IRQ != 0);          /* 等待发送完成 */
    
31. 
    
32.     sta = nrf24l01_read_reg(STATUS);   /* 读取状态寄存器的值 */
    . x' \. k" N0 W
33.     nrf24l01_write_reg(NRF_WRITE_REG + STATUS, sta);/*清除TX_DS或MAX_RT中断标志*/
    % H( ^9 S0 N0 e5 j
34. 
    
35.     if (sta & MAX_TX)   /* 达到最大重发次数 */
    
36.     {
    * w; U( [& V  l2 @
37.         nrf24l01_write_reg(FLUSH_TX, 0xff); /* 清除TX FIFO寄存器 */
    ( k7 Z2 T, z7 \' q: K
38.         rval = 1;
    
39.     }
    : F+ k: u1 E! c8 J9 `
40. 
    
41.     if (sta & TX_OK)        /* 发送完成 */
    
42.     {
    ' q. f: P3 y: A4 }
43.         rval = 0;          /* 标记发送成功 */
    
44.     }
    0 n6 H1 l9 h" C- u2 m! M7 K
45.     return rval;          /* 返回结果 */
    
46. }

复制代码

$ N  G1 n5 F; U8 c9 h! W在这里启动发送数据函数中，具体实现很简单，拉低片选信号→向发送数据寄存器写入数据→拉高片选信号。这里说明一下，在发送完寄存器号后都会返回一个status值，返回的这个值就是前面介绍的STATUS寄存器的内容。在这个基础上就可以知道数据是否发送完成以及现在的状态。
然后介绍一下NRF24L01接收一次数据函数，其定义如下：

1. /**
   , h! N: y1 k) q% x: R
2. * @brief       启动NRF24L01接收一次数据(数据长度 = RX_PLOAD_WIDTH)
   " Y8 D/ O+ G6 s9 X
3. * @param       prxbuf : 接收数据缓冲区首地址
   : }1 [" l9 c# B+ e: V
4. * @retval      接收完成状态
   $ |4 z- T/ V* Y( C
5. *   @arg       0 : 接收成功
   
6. *   @arg       1 : 失败
   
7. */
   
8. uint8_t nrf24l01_rx_packet(uint8_t *prxbuf)
   
9. {
   ' t5 T. g4 t3 f9 N! F, |
10.     uint8_t sta;
    0 i. W* w4 D$ E; @6 C. }8 L
11.     uint8_t rval = 1;
    * K8 Y  X* B$ n0 X/ E5 O' R% ?# W
12. 
    ' Q. ?5 [/ ]* ]3 r' {3 [. a5 L
13.     sta = nrf24l01_read_reg(STATUS); /* 读取状态寄存器的值 */
    / q0 e  G9 D  u6 O9 r9 A$ K) p) e5 Y
14.     nrf24l01_write_reg(NRF_WRITE_REG + STATUS, sta);/*清除TX_DS或MAX_RT中断标志*/
    
15. 
    
16.     if (sta & RX_OK)                /* 接收到数据 */
    
17.     {
    
18.         nrf24l01_read_buf(RD_RX_PLOAD, prxbuf, RX_PLOAD_WIDTH); /* 读取数据 */
    5 _# @+ X/ G* M" j, l% ~8 x
19.         nrf24l01_write_reg(FLUSH_RX, 0xff); /* 清除RX FIFO寄存器 */
    ' P6 Z0 h2 y  q: `  |
20.         rval = 0;                   /* 标记接收完成 */
    
21.     }
    
22.     return rval;                    /* 返回结果 */
    % P7 f# Z4 U) s2 K- n/ q; r
23. }
    # p' p' o! k4 T& }' O+ o  g' A1 m( d% l

复制代码

: f( _2 L+ y3 \3 ]0 c) J在启动接收的过程中，首先需要判断当前NRF24L01的状态，往后才是真正的读取数据，清除接收寄存器的缓冲，完成数据的接收。这里需要注意的是我们通过RX_PLOAD_WIDTH和TX_PLOAD_WIDTH决定了接收和发送的数据宽度，这也决定每次发送和接收的有效字节数。NRF24L01每次最多传输32个字节，再多的字节传输则需要多次传输。通信双方的发送和接收数据宽度必须一致才能正常通信。
3. main.c代码
在main.c里编写如下代码：
" [/ C5 Z' D# ]! w1 o' m
/ l7 K1 j' e% }

1. int main(void)
   
2. {
   
3.     uint8_t key, mode;
   ' C0 S3 s7 W6 u, D5 N
4.     uint16_t t = 0;
   
5.     uint8_t tmp_buf[33];
   + n$ F) g! x3 d  B
6. 
   
7.     sys_cache_enable();                            /* 打开L1-Cache */
   3 K9 ^* S. f7 v
8.     HAL_Init();                                      /* 初始化HAL库 */
   
9.     sys_stm32_clock_init(240, 2, 2, 4);         /* 设置时钟, 480Mhz */
   9 H& e( s' Q2 l
10.     delay_init(480);                                /* 延时初始化 */
    + m. j1 p6 A! m  P9 R! z
11.     usart_init(115200);                            /* 串口初始化为115200 */
    - a2 J% S; S$ Z6 u: J
12.     mpu_memory_protection();                      /* 保护相关存储区域 */
    
13.     led_init();                                             /* 初始化LED */
    8 ]7 s. [, ?2 d/ d
14.     lcd_init();                                           /* 初始化LCD */
    
15.     key_init();                                           /* 初始化按键 */
    
16.     nrf24l01_init();                                     /* 初始化NRF24L01 */
    & {% H8 M$ d$ m! d
17. 
    
18.     lcd_show_string(30, 50, 200, 16, 16, "STM32", RED);
    
19.     lcd_show_string(30, 70, 200, 16, 16, "NRF24L01 TEST", RED);
    
20.     lcd_show_string(30, 90, 200, 16, 16, "ATOM@ALIENTEK", RED);
    ; x. q: t! Q9 O9 @
21. 
    4 f. ^7 a( C# u5 l3 H4 ]  O2 N
22.     while (nrf24l01_check())           /* 检查NRF24L01是否在线 */
    # o) W; u" w8 t  F* f; ^+ c! v
23.     {
    7 Y( u7 b+ A$ A8 k" j3 i4 [( K
24.         lcd_show_string(30, 130, 200, 16, 16, "NRF24L01 Error", RED);
    ; {( p6 R* u8 r+ K
25.         delay_ms(200);
    
26.         lcd_fill(30, 130, 239, 130 + 16, WHITE);
    
27.         delay_ms(200);
    6 v- i6 K* S0 L
28.     }
    ! i: ?: b7 Y: I: e+ D7 n, u% m2 g
29. lcd_show_string(30, 130, 200, 16, 16, "NRF24L01 OK", RED);
    
30. 
    
31.     while (1)   /* 提醒用户选择模式 */
    & h6 J: o4 L. m2 v
32.     {
    
33.         key = key_scan(0);
    : {& _% G* o& `0 g7 ?. M, M
34. 
    
35.         if (key == KEY0_PRES)
    
36.         {
    $ j2 n( R$ l: h+ Z5 B! u
37.             mode = 0;   /* 接收模式 */
    
38.             break;
      k! ]& H0 |# `7 Y# B/ _, H
39.         }
    
40.         else if (key == KEY1_PRES)
    $ B& e0 b8 ^3 \- y
41.         {
    
42.             mode = 1;   /* 发送模式 */
    # S* z! G2 P$ _" A
43.             break;
    ) {4 v/ ]7 f4 e& b$ Y/ J0 l  J7 L8 e5 I
44.         }
    % l; B# e; v1 ]
45. 
    $ E/ y4 R7 s. x- M# l6 J8 C
46.         t++;
      d; g* l! g) J) e4 e9 |
47.         if (t == 100)   /* 显示提示信息 */
    
48.         {
    7 V3 i* {0 O, _* z
49.             lcd_show_string(10, 150, 230, 16, 16,
    / Q5 f( c5 w) @, L: o( R1 d" B* v" I
50. "KEY0:RX_Mode  KEY1:TX_Mode", RED);
    ( x" m* j" B9 Z- \1 P
51.         }
    
52.         if (t == 200)   /* 关闭提示信息 */
    9 A  X* M) d. j: z# T2 k; }7 h
53.         {
    1 G2 f. U0 W0 v- ]+ n' y
54.             lcd_fill(10, 150, 230, 150 + 16, WHITE);
    
55.             t = 0;
    
56.         }
    
57.         delay_ms(5);
    " M4 V* n, l+ {$ E( z3 C
58.     }
      a, s- u4 h4 U/ {$ f
59.     lcd_fill(10, 150, 240, 166, WHITE);     /* 清空上面的显示 */
    ( k8 H9 j, M, {8 ]! q2 |0 `% h9 J5 |
60. 
    
61.     if (mode == 0)  /* RX模式 */
    : B5 H! k7 e) m; x" u5 S$ q9 U7 E5 _6 N
62.     {
    7 {0 y) {* b' Y4 }- H; m/ g
63.         lcd_show_string(30, 150, 200, 16, 16, "NRF24L01 RX_Mode", BLUE);
    
64.         lcd_show_string(30, 170, 200, 16, 16, "Received DATA:", BLUE);
    2 w+ N: l4 c0 _
65.         nrf24l01_rx_mode();     /* 进入RX模式 */
    
66. 
    
67.         while (1)
    3 X6 u2 |) G7 I
68.         {
    
69.             if (nrf24l01_rx_packet(tmp_buf) == 0)   /* 一旦接收到信息,则显示出来. */
    
70.             {
    
71.                 tmp_buf[32] = 0;/* 加入字符串结束符 */
    , \& g# ~( `* V1 i" D
72.                 lcd_show_string(0,190,lcddev.width-1,32,16,(char*)tmp_buf, BLUE);
    
73.             }
    
74.             else delay_us(100);
    2 i7 S7 v# Z% D; E3 o3 V
75. 
    
76.             t++;
    
77.             if (t == 10000)     /* 大约1s钟改变一次状态 */
    
78.             {
    
79.                 t = 0;
    
80.                 LED0_TOGGLE();
    6 o5 X" ]7 Z1 D* y1 W2 |
81.             }
      j& @+ f+ \4 F3 H
82.         }
    
83.     }
    
84.     else    /* TX模式 */
    
85.     {
    / |5 V+ I. i5 E/ D& f" J
86.         lcd_show_string(30, 150, 200, 16, 16, "NRF24L01 TX_Mode", BLUE);
    # q& ~# U7 r5 ?4 {5 J! Q9 E  B3 S
87.         nrf24l01_tx_mode();   /* 进入TX模式 */
    4 K9 o6 C9 w) }
88.         mode = ' ';             /* 从空格键开始发送 */
    : P( b' M3 Q; L% j+ Z9 G/ |. w$ F
89. 
    ' I) v) L0 Y  {2 v$ @
90.         while (1)
    
91.         {
    
92.             if (nrf24l01_tx_packet(tmp_buf) == 0)   /* 发送成功 */
    3 h) }% w% S/ I0 _
93.             {
    
94.                 lcd_show_string(30, 170, 239, 32, 16, "Sended DATA:", BLUE);
    ( Y2 G) A9 H+ g
95.                 lcd_show_string(0,190,lcddev.width-1,32,16,(char*)tmp_buf, BLUE);
    
96.                 key = mode;
    1 C. l% b2 K6 a- T- t5 Q/ n  v
97. 
    
98.                 for (t = 0; t < 32; t++)
    
99.                 {
    4 `- @  `1 a5 {  M* D
100.                     key++;
     
101.                     if (key > ('~'))
     
102. key = ' ';
     + [1 C9 l- U  K0 {/ Z+ T5 r
103.                     tmp_buf[t] = key;
     ' J# J0 F# X& h1 M9 O3 i4 j
104.                 }
     & M/ @! E  `* c* ]
105. 
     2 _/ f$ \! ?2 ]- s0 G
106.                 mode++;
     
107.                 if (mode > '~')
     
108. mode = ' ';
     
109.                 tmp_buf[32] = 0; /* 加入结束符 */
     ' `) L( O4 e( r" P5 m: @  n" f4 c2 a" M
110.             }
     1 g, V" m0 |  W% ]  ~: e. q) |
111.             else
     
112.             {
     
113.                 lcd_fill(0, 170, lcddev.width, 170 + 16 * 3, WHITE);/* 清空显示 */
     : [! w, _: g+ \- g8 h
114.                 lcd_show_string(30,170,lcddev.width-1,32,16, "Send Failed ",BLUE);
     / a' [8 R" A" x! c  L
115.             }
     / A. K% C6 Z' F) d* {  M
116. 
     : @) j' n0 S& @1 `* t( ]6 t+ t
117.             LED0_TOGGLE();
     
118.             delay_ms(200);
     
119.         };
     & r, I. p+ |# V$ T: W: c
120.     }
     ' n! M% L3 d' }: M$ w
121. }

复制代码

程序运行时先通过nrf24l01_cheak函数检测NRF24L01是否存在，如果存在，则让用户选择发送模式还是接收模式，在确定模式之后，设置NRF24L01的工作模式，然后执行相对应的数据发送/接收处理。

41.4 下载验证
将程序下载到开发板后，可以看到LCD显示的内容如图41.4.1所示：

- X5 ]1 L- p9 H9 p) M
; G% I: Z" g+ u2 C( k5 w
图41.4.1 选择工作模式界面
通过KEY0和KEY1来选择NRF24L01模块所要进入的工作模式，我们两个开发板一个选择发送模式，一个选择接收模式就可以了。
设置好的通信界面如图41.4.2和图41.4.3所示：

4 _( M; m' N$ G% c6 [1 w

$ P/ x2 v. X) B" F+ ]' N图41.4.2 开发板A通信界面（发送）
; f5 g9 H& |/ P  N5 Q8 W1 p5 F
( N/ o0 A7 L% o/ O% q5 p
4 F" `, G7 W+ O
# u$ A) {" S9 r5 g* z图41.4.3 开发板B通信界面（接收）
图41.4.2来自于开发板A，工作在发送模式。图41.4.3来自于开发板B，工作在接收模式，A发送，B接收。发送和接收图片的数据不一样，是因为我们拍照的时间不一样导致的。大家看到收发数据是一致，那就说明实验成功。
! Q- A2 V& u/ _————————————————
版权声明：正点原子

+ W7 T, y8 h# S  L" `/ [# [