正点原子H7R7开发板上面的NRF24L01接口是可以接一个NRF24L01模块的，原子论坛也提供了例程可供参考，但是是适配给原子自家的NRF24L01模块的，使用第三方模块厂出品的NRF24L01模块程序需要做一些细微调整，无法直接通用。

" Z8 E2 y1 k0 @3 ^+ S4 X* r首先是初始化SPI接口，这个非常简单：

1. SPI_HandleTypeDef g_spi_handle;
   + W$ `7 b& |) X
2. 
   ' {# X( @  u  t
3. uint8_t SPI2_PD3_PC2_PC3_Read_Write_Byte(uint8_t txdata)
   
4. {
   
5.   uint8_t rxdata;
   2 K- t3 M; X) h+ E
6.   HAL_SPI_TransmitReceive(&g_spi_handle , &txdata , &rxdata , 1 , 1000);
   . w9 q+ [5 `+ ]3 `, H' J6 i9 U; b
7.   return rxdata;
   
8. }
   ; C9 z0 ?5 z$ J6 _) H
9. 
   
10. void SPI2_PD3_PC2_PC3_Init(void)
    
11. {
    
12.   GPIO_InitTypeDef gpio_init_struct = {0};
    
13.   RCC_PeriphCLKInitTypeDef rcc_periph_clk_init = {0};
    
14. 
    
15.   __HAL_RCC_SPI2_CLK_ENABLE();
    
16.   __HAL_RCC_GPIOC_CLK_ENABLE();
    % D* M& {; R3 o- q8 @1 F; G. X
17.   __HAL_RCC_GPIOD_CLK_ENABLE();
    
18. 
    
19.   rcc_periph_clk_init.PeriphClockSelection = RCC_PERIPHCLK_SPI23;
    
20.   rcc_periph_clk_init.Spi23ClockSelection = RCC_SPI23CLKSOURCE_PLL1Q;
    $ R& d$ ?' C( K% V/ n& G5 U
21.   HAL_RCCEx_PeriphCLKConfig(&rcc_periph_clk_init);
    ' l5 {  r$ B, ]
22. 
    
23.   gpio_init_struct.Mode = GPIO_MODE_AF_PP;
    ) M4 L0 L8 D. R( F$ k1 w0 {
24.   gpio_init_struct.Pull = GPIO_PULLUP;
    ' k( L* u3 ?8 v5 T5 Z5 J7 a+ B" A
25.   gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    & [2 p! z: }9 I% L* Z
26. 
      L, `; t( V- `" ~
27.   gpio_init_struct.Pin = GPIO_PIN_3;
    . w( P6 K, u+ F4 `) p+ g" f
28.   gpio_init_struct.Alternate = GPIO_AF5_SPI2;
    6 D5 k8 Q, [1 r" ]$ m, e: f) Z* |
29.   HAL_GPIO_Init(GPIOD , &gpio_init_struct);
    
30. 
    6 r0 E& O" D3 j
31.   gpio_init_struct.Pin = GPIO_PIN_2;
    
32.   gpio_init_struct.Alternate = GPIO_AF5_SPI2;
    
33.   HAL_GPIO_Init(GPIOC , &gpio_init_struct);
    $ w( [' ^9 q+ h
34. 
      ]7 Y7 M  M7 l3 @8 L& K/ |
35.   gpio_init_struct.Pin = GPIO_PIN_3;
    + d  [. k# ~5 ?: p
36.   gpio_init_struct.Alternate = GPIO_AF5_SPI2;
    
37.   HAL_GPIO_Init(GPIOC , &gpio_init_struct);
    $ Z2 D) ?! |" @, S: q' [9 }: S
38. 
    / i% L; ?2 H8 h  o
39.   g_spi_handle.Instance = SPI2;
    + D% K0 w$ F" V+ `# _% r* F
40.   g_spi_handle.Init.Mode = SPI_MODE_MASTER;
    
41.   g_spi_handle.Init.Direction = SPI_DIRECTION_2LINES;
    
42.   g_spi_handle.Init.DataSize = SPI_DATASIZE_8BIT;
    
43.   g_spi_handle.Init.CLKPolarity = SPI_POLARITY_LOW;
    7 o( ]6 @1 r- Q& J
44.   g_spi_handle.Init.CLKPhase = SPI_PHASE_1EDGE;
    & f5 E4 {) Q9 q$ y9 Y1 g
45.   g_spi_handle.Init.NSS = SPI_NSS_SOFT;  
    " e) K% v: `9 D8 U7 `  E& S  E% V- h
46.   g_spi_handle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    
47.   g_spi_handle.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
    " J. X2 z5 @* _6 E+ Z4 w
48.   g_spi_handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    
49.   g_spi_handle.Init.FirstBit = SPI_FIRSTBIT_MSB;
    
50.   g_spi_handle.Init.TIMode = SPI_TIMODE_DISABLE;
    
51.   g_spi_handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    , [1 [: f5 Y' S4 Q
52.   g_spi_handle.Init.CRCPolynomial = 7;
    
53.   HAL_SPI_Init(&g_spi_handle);
    + k- c' Z7 z4 Q7 ]5 j
54. 
    
55.   __HAL_SPI_ENABLE(&g_spi_handle);
    
56.   SPI2_PD3_PC2_PC3_Read_Write_Byte(0Xff);
    ) p, z9 P6 o& F! q& [0 G% ]
57. }

复制代码

这里需要注意的是，H7R7的SPI接口时钟要设置为128分频或者256分频，因为SPI123三个接口的时钟直接挂在PLLQ上，分频太少的话，波形变形的程度使得NRF24L01无法识别，进而无法进行任何通信，然后就是时钟信号空闲时为低，第一个沿变开始传输数据，这个也是NRF24L01芯片的特性，不遵循这个设置无法进行通信。
0 b$ P& L, m# L$ X. K
) x5 A* L* }& \. UNRF24L01还需要用CS CE IRQ三个脚，其中CS脚是片选，需要在传输数据时进行控制，CE脚常高表示使能，IRQ脚是发送时会用到：

1. #define NRF24L01_CS_GPIO_PORT                              GPIOM
   5 ^) p$ @6 c8 h1 Q( }# v$ j6 `
2. #define NRF24L01_CS_GPIO_PIN                            GPIO_PIN_13
   8 S& S/ D5 K% l5 V. t0 ?2 d, U3 e
3. #define NRF24L01_CS_GPIO_CLK_ENABLE                            __HAL_RCC_GPIOM_CLK_ENABLE();
   $ g; ~$ j& r0 d7 }
4. #define NRF24L01_CS_HIGH                                                HAL_GPIO_WritePin(NRF24L01_CS_GPIO_PORT , NRF24L01_CS_GPIO_PIN , GPIO_PIN_SET);
   
5. #define NRF24L01_CS_LOW                             HAL_GPIO_WritePin(NRF24L01_CS_GPIO_PORT , NRF24L01_CS_GPIO_PIN , GPIO_PIN_RESET);
   . c; @) m0 O4 s' m1 M8 d& }5 g: G; P
6. 
   ; C* S4 z) P* y  i* z
7. #define NRF24L01_CE_GPIO_PORT                                 GPIOM
   
8. #define NRF24L01_CE_GPIO_PIN                                  GPIO_PIN_14
   1 J" R, u2 a3 @
9. #define NRF24L01_CE_GPIO_CLK_ENABLE                            __HAL_RCC_GPIOM_CLK_ENABLE();
   ! b- ?' G. K4 H6 D
10. #define NRF24L01_CE_HIGH                                                HAL_GPIO_WritePin(NRF24L01_CE_GPIO_PORT , NRF24L01_CE_GPIO_PIN , GPIO_PIN_SET);
    
11. #define NRF24L01_CE_LOW                                HAL_GPIO_WritePin(NRF24L01_CE_GPIO_PORT , NRF24L01_CE_GPIO_PIN , GPIO_PIN_RESET);
    3 G- X. {7 n5 _4 n# l
12. 
    8 k2 Q1 C0 n5 ]; `  q4 G2 B3 y
13. #define NRF24L01_IRQ_GPIO_PORT                                 GPIOF
    1 i- }' l8 P1 m
14. #define NRF24L01_IRQ_GPIO_PIN                                  GPIO_PIN_2
    
15. #define NRF24L01_IRQ_GPIO_CLK_ENABLE                        __HAL_RCC_GPIOF_CLK_ENABLE();
    ( ^* @$ o; W# S% t7 s: ?' K7 b
16. #define NRF24L01_IRQ_READ()                                            HAL_GPIO_ReadPin(NRF24L01_IRQ_GPIO_PORT , NRF24L01_IRQ_GPIO_PIN)
    7 ~9 T* v" P, x
17. 
    9 h  v' F1 ?9 Y- Z& H1 D6 x
18. void NRF24L01_GPIO_Init(void)
    ( ]# c+ N& e& n+ {" x6 K4 W
19. {
    
20.     GPIO_InitTypeDef gpio_init_struct;
    - ]  C. z# M' o2 W8 @* V0 x
21.     NRF24L01_CS_GPIO_CLK_ENABLE;
    
22.     NRF24L01_CE_GPIO_CLK_ENABLE;
    
23.     NRF24L01_IRQ_GPIO_CLK_ENABLE;
    
24.    
    5 W8 m6 m& {1 X: }9 i' ^5 _/ T! J5 l
25.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;
    
26.     gpio_init_struct.Pull = GPIO_PULLUP;
    , X; _6 n3 b; T4 Q/ Y+ |
27.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
    
28.    
      O+ P5 `* L: p: R6 ?- D
29.     gpio_init_struct.Pin = NRF24L01_CS_GPIO_PIN;
    7 D7 y4 f  R9 Q2 J1 q' P2 f
30.     HAL_GPIO_Init(NRF24L01_CS_GPIO_PORT , &gpio_init_struct);
    
31.    
    # a) b7 \% \0 O* q
32.     gpio_init_struct.Pin = NRF24L01_CE_GPIO_PIN;
    1 A% n$ U/ R/ ^+ a% `# a
33.     HAL_GPIO_Init(NRF24L01_CE_GPIO_PORT , &gpio_init_struct);
    9 [4 p" @3 F4 b8 F
34.    
    
35.     gpio_init_struct.Mode = GPIO_MODE_INPUT;
    4 m! `/ k# F' G# j8 L: @7 t
36.     gpio_init_struct.Pin = NRF24L01_IRQ_GPIO_PIN;
    
37.     HAL_GPIO_Init(NRF24L01_IRQ_GPIO_PORT , &gpio_init_struct);
    
38.    
    $ i. I5 A! Q! m1 l# L) @
39.     NRF24L01_CE_LOW;
    5 r+ f4 |' r3 f! l7 a6 b; D
40.     NRF24L01_CS_HIGH;
    ! W- |5 W/ w" H+ S! o% _/ N
41. }

复制代码

NRF24L01有五个寄存器是可以用来检测器件是否正常工作的：

1. uint8_t NRF24L01_Check(void)
   
2. {
   
3.     uint8_t buf[5] = {0xa5 , 0xa5 , 0xa5 , 0xa5 , 0xa5};
   
4.     uint8_t i;
   
5.     NRF24L01_Write_Buf(NRF_WRITE_REG + TX_ADDR , buf , 5);
   
6.     NRF24L01_Read_Buf(TX_ADDR , buf , 5);
   - Q; \$ A4 R8 ^. h7 `
7.     for(i = 0 ; i < 5 ; i++)
   
8.         if(buf[i] != 0XA5)
   
9.             break;                                    
   
10.     if(i!=5)
    
11.         return 1;
    . O% o, C! V  E( x/ \
12.     return 0;
    - c+ E  U8 }/ M& U$ o
13. }

复制代码

' S# T  w- G& \NRF24L01模块在同一时间只能设置为只接收或者只发送模式，属于半双工器件，要实现全双工收发需要两个模块：
' n" N6 O2 U) o- I* G4 v  t4 U. K

1. void NRF24L01_RX_Mode(void)
   
2. {
   
3.     NRF24L01_CE_LOW;
   
4.     NRF24L01_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(uint8_t*)RX_ADDRESS,RX_ADR_WIDTH);
   
5.    
   # L7 ?/ F' W1 G& o' D( E1 I
6.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);  
   ' W, E6 l6 p0 a
7.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01);
   & D8 d' M+ `9 c+ V6 B
8.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_CH,40);
   
9.     NRF24L01_Write_Reg(NRF_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);
   
10.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);
    $ h9 Q, `; k6 n- ~
11.     NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG, 0x0f);
    3 U, q  D. P- P, I! V
12.     NRF24L01_CE_HIGH;
    
13. }
    
14. 
    ' R, L$ z! s- x  ]; L% A2 K1 J
15. void NRF24L01_TX_Mode(void)
    & t) u+ L3 L: g% n! Y# Z
16. {                                                         
    5 g. h! \5 ]9 g4 v
17.     NRF24L01_CE_LOW;
    7 \2 @  c) O7 K# t2 D
18.     NRF24L01_Write_Buf(NRF_WRITE_REG+TX_ADDR,(uint8_t*)TX_ADDRESS,TX_ADR_WIDTH);
    
19.     NRF24L01_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(uint8_t*)RX_ADDRESS,RX_ADR_WIDTH);
    
20. 
    
21.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);
    
22.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01);
    4 u) V( K% ]" e3 o; O+ E
23.     NRF24L01_Write_Reg(NRF_WRITE_REG+SETUP_RETR,0x1a);
    
24.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_CH,40);
    # C& z2 n# g: s- h" F: n* ]
25.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);
    5 w: L( y; N/ \" n2 V
26.     NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG,0x0e);
    
27.     NRF24L01_CE_HIGH;
    
28. }
    
29. 
    , s( D) [: y: c3 r" T) H  ?6 _
30. uint8_t NRF24L01_RxPacket(uint8_t *rxbuf)
    
31. {
    & U- n4 u9 ]$ B- B; u# u, F0 O
32.     uint8_t sta;                                          
    % A0 R1 t* }  k; W  z
33.     sta = NRF24L01_Read_Reg(STATUS);
    1 ]% G( e6 z& a, S
34. 
    2 b3 h2 ]6 X6 e0 @) t
35.     NRF24L01_Write_Reg(NRF_WRITE_REG + STATUS , sta);
    - Y3 _5 f% S) q3 _
36.    
    " k* O# i' G5 ?, Y5 z/ |. y; }
37.     if(sta & RX_OK)
    
38.     {
    
39.         printf("sta = 0x%x RX_OK.\n" , sta);
    
40.         NRF24L01_Read_Buf(RD_RX_PLOAD , rxbuf , RX_PLOAD_WIDTH);
    
41.         NRF24L01_Write_Reg(FLUSH_RX , 0xff);
    ( e5 P# f- t! G6 m5 c* W- Q
42.         return 0;
    
43.     }      
    
44.     return 1;
    
45. }   
    
46. 
    " `5 n7 k8 g4 [) m) m/ n
47. uint8_t NRF24L01_TxPacket(uint8_t *txbuf)
    
48. {
    
49.     uint8_t sta;
    - p9 g5 d8 l- Y
50.     NRF24L01_CE_LOW;
    8 C( Y4 k) I1 K, R: }/ Y6 P
51.   NRF24L01_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);
    / `  Y4 n! L: Q
52.      NRF24L01_CE_HIGH;
    $ `+ T# N! |5 Y) O0 q/ }
53.     while(NRF24L01_IRQ_READ() != 0);
    $ ]& O0 h+ `, Y8 a6 ~1 G
54.     sta = NRF24L01_Read_Reg(STATUS);
    5 N& Q$ c; t; }7 H, T
55.     NRF24L01_Write_Reg(NRF_WRITE_REG+STATUS,sta);
    
56.     if(sta&MAX_TX)
    
57.     {
    
58.         NRF24L01_Write_Reg(FLUSH_TX,0xff);
    1 F1 g9 e$ {7 @
59.         return MAX_TX;
    
60.     }
    ' P1 e8 A% Q! c; _' ?
61.     if(sta&TX_OK)
    
62.     {
    4 ~7 q6 U# s$ i6 j. ?7 z
63.         return TX_OK;
    
64.     }
    : q2 c' W" D' s, D) u. L0 ~
65.     return 0xff;
    
66. }

复制代码

; a) W' \7 g( ~  z! {我这里在主界面创建一个flexButton用于控制NRF24L01模块发送一行数据：
, K+ R& v6 n& ~8 `: \6 y6 d5 ]( R

  q" x9 a% q7 ^" C7 f) X( Q看看发送效果，按下fb之后，H7R7开发板会通过NRF24L01模块发送一行字符串，另一个设置了相同接收地址的NRF24L01开发板就会收到这个字符串：

$ y6 m0 }; ?2 X9 G- ?然后是接收，接收就更简单了，只需要设置模块为接收模式后，在Tick事件回调函数调用即可：
5 Y. K3 E7 o3 b; ?6 ]4 n: c! f

补上一张H7R7开发板和NRF24L01接收机开发板（STM32F103R）的合照
( R0 ]3 i! D8 Q2 P5 R

- Y( m" ]0 t5 M