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

0 r5 N7 l2 d7 Z7 @; H, H首先是初始化SPI接口，这个非常简单：
1 |: |* ^6 U& n1 J& H

1. SPI_HandleTypeDef g_spi_handle;
   
2. 
   ; J- c  u, |) s: Q+ ]
3. uint8_t SPI2_PD3_PC2_PC3_Read_Write_Byte(uint8_t txdata)
   
4. {
   
5.   uint8_t rxdata;
   
6.   HAL_SPI_TransmitReceive(&g_spi_handle , &txdata , &rxdata , 1 , 1000);
   * t5 N4 I" j+ b& f' |4 e
7.   return rxdata;
   
8. }
   0 x7 j+ c* n1 l
9. 
   
10. void SPI2_PD3_PC2_PC3_Init(void)
    : S% `% D% r# ?: \
11. {
    ; |. ~- M' w) f% b/ J
12.   GPIO_InitTypeDef gpio_init_struct = {0};
    ! o3 u' C  }6 C) n& I" f5 T% \
13.   RCC_PeriphCLKInitTypeDef rcc_periph_clk_init = {0};
    
14. 
    0 ?; \9 B/ w6 p1 H+ j) f
15.   __HAL_RCC_SPI2_CLK_ENABLE();
    8 k* M4 N, m3 n. t+ b" I. E
16.   __HAL_RCC_GPIOC_CLK_ENABLE();
    6 F6 m) L9 J5 f# R' m! n
17.   __HAL_RCC_GPIOD_CLK_ENABLE();
    & g( x- i1 k1 f% n0 i
18. 
    
19.   rcc_periph_clk_init.PeriphClockSelection = RCC_PERIPHCLK_SPI23;
    
20.   rcc_periph_clk_init.Spi23ClockSelection = RCC_SPI23CLKSOURCE_PLL1Q;
    4 Y& f6 a: T4 z2 O% ~. X, d: \; H
21.   HAL_RCCEx_PeriphCLKConfig(&rcc_periph_clk_init);
    
22. 
    
23.   gpio_init_struct.Mode = GPIO_MODE_AF_PP;
    8 c2 S* q8 B4 Q8 A7 Q) }
24.   gpio_init_struct.Pull = GPIO_PULLUP;
    6 p' o8 L( U2 ?2 a8 T2 G4 u+ h: h
25.   gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
26. 
    
27.   gpio_init_struct.Pin = GPIO_PIN_3;
    
28.   gpio_init_struct.Alternate = GPIO_AF5_SPI2;
    ) e7 Q* k2 Q# k
29.   HAL_GPIO_Init(GPIOD , &gpio_init_struct);
    
30. 
    ) R" {. k+ c% z8 {! w! b
31.   gpio_init_struct.Pin = GPIO_PIN_2;
    5 r: @- `0 [. p; h0 W: h4 G
32.   gpio_init_struct.Alternate = GPIO_AF5_SPI2;
    
33.   HAL_GPIO_Init(GPIOC , &gpio_init_struct);
    
34. 
    
35.   gpio_init_struct.Pin = GPIO_PIN_3;
    5 i9 F9 O' s% t  E8 p. B
36.   gpio_init_struct.Alternate = GPIO_AF5_SPI2;
    
37.   HAL_GPIO_Init(GPIOC , &gpio_init_struct);
    
38. 
    0 i" J+ u( E2 \0 V9 y) t
39.   g_spi_handle.Instance = SPI2;
    
40.   g_spi_handle.Init.Mode = SPI_MODE_MASTER;
    
41.   g_spi_handle.Init.Direction = SPI_DIRECTION_2LINES;
    ; A- s0 m& ?9 |  n
42.   g_spi_handle.Init.DataSize = SPI_DATASIZE_8BIT;
    
43.   g_spi_handle.Init.CLKPolarity = SPI_POLARITY_LOW;
    , O, I5 ^! l5 D$ l2 J; }2 B
44.   g_spi_handle.Init.CLKPhase = SPI_PHASE_1EDGE;
    0 p# Y* Z8 j3 X3 R7 j
45.   g_spi_handle.Init.NSS = SPI_NSS_SOFT;  
    
46.   g_spi_handle.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    # ]6 U! W5 f2 O+ C* S
47.   g_spi_handle.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
    
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;
    " ]1 X' K' M, v/ u
51.   g_spi_handle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    
52.   g_spi_handle.Init.CRCPolynomial = 7;
    
53.   HAL_SPI_Init(&g_spi_handle);
    
54. 
    2 d/ _3 }( }- |# r0 j
55.   __HAL_SPI_ENABLE(&g_spi_handle);
    / W  C, H) `7 h
56.   SPI2_PD3_PC2_PC3_Read_Write_Byte(0Xff);
      U: p& M, y6 P
57. }

复制代码

这里需要注意的是，H7R7的SPI接口时钟要设置为128分频或者256分频，因为SPI123三个接口的时钟直接挂在PLLQ上，分频太少的话，波形变形的程度使得NRF24L01无法识别，进而无法进行任何通信，然后就是时钟信号空闲时为低，第一个沿变开始传输数据，这个也是NRF24L01芯片的特性，不遵循这个设置无法进行通信。

# f3 F- {2 m' v* A) D1 a/ Z0 @4 dNRF24L01还需要用CS CE IRQ三个脚，其中CS脚是片选，需要在传输数据时进行控制，CE脚常高表示使能，IRQ脚是发送时会用到：
0 `1 r6 q4 _: C& o" d/ C  K: p

1. #define NRF24L01_CS_GPIO_PORT                              GPIOM
   ! w# ]# \% l) [7 @1 t3 [  j, @* f
2. #define NRF24L01_CS_GPIO_PIN                            GPIO_PIN_13
   8 V# j* Z% q8 @3 X; n
3. #define NRF24L01_CS_GPIO_CLK_ENABLE                            __HAL_RCC_GPIOM_CLK_ENABLE();
   
4. #define NRF24L01_CS_HIGH                                                HAL_GPIO_WritePin(NRF24L01_CS_GPIO_PORT , NRF24L01_CS_GPIO_PIN , GPIO_PIN_SET);
   ; n2 x# Y" F& f6 i& x
5. #define NRF24L01_CS_LOW                             HAL_GPIO_WritePin(NRF24L01_CS_GPIO_PORT , NRF24L01_CS_GPIO_PIN , GPIO_PIN_RESET);
   & O1 t' J9 ]( N# k
6. 
   ( B" m% I$ U, I, ]  ]
7. #define NRF24L01_CE_GPIO_PORT                                 GPIOM
   
8. #define NRF24L01_CE_GPIO_PIN                                  GPIO_PIN_14
   
9. #define NRF24L01_CE_GPIO_CLK_ENABLE                            __HAL_RCC_GPIOM_CLK_ENABLE();
   
10. #define NRF24L01_CE_HIGH                                                HAL_GPIO_WritePin(NRF24L01_CE_GPIO_PORT , NRF24L01_CE_GPIO_PIN , GPIO_PIN_SET);
    1 A" f' _: _3 S  e! u" X" ~
11. #define NRF24L01_CE_LOW                                HAL_GPIO_WritePin(NRF24L01_CE_GPIO_PORT , NRF24L01_CE_GPIO_PIN , GPIO_PIN_RESET);
    0 T3 V' o4 F- p% a1 C
12. 
    
13. #define NRF24L01_IRQ_GPIO_PORT                                 GPIOF
    
14. #define NRF24L01_IRQ_GPIO_PIN                                  GPIO_PIN_2
    ' m) w: T  M" @- W  S$ o% q
15. #define NRF24L01_IRQ_GPIO_CLK_ENABLE                        __HAL_RCC_GPIOF_CLK_ENABLE();
    
16. #define NRF24L01_IRQ_READ()                                            HAL_GPIO_ReadPin(NRF24L01_IRQ_GPIO_PORT , NRF24L01_IRQ_GPIO_PIN)
    
17. 
    
18. void NRF24L01_GPIO_Init(void)
    
19. {
    ) e6 ~! \  R7 B" L" a8 U! J
20.     GPIO_InitTypeDef gpio_init_struct;
    8 |1 w+ W' v2 k
21.     NRF24L01_CS_GPIO_CLK_ENABLE;
    
22.     NRF24L01_CE_GPIO_CLK_ENABLE;
    $ o3 ^5 |( ]- u6 I- |8 [8 F  A* i
23.     NRF24L01_IRQ_GPIO_CLK_ENABLE;
    $ O. c6 g+ {3 C& y( n
24.    
    ) J. U" `$ ?0 D/ u- q
25.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;
    
26.     gpio_init_struct.Pull = GPIO_PULLUP;
    
27.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
      O' y; }7 {; f% ]
28.    
    8 E  ?: k) `/ {
29.     gpio_init_struct.Pin = NRF24L01_CS_GPIO_PIN;
    * a; u/ ^8 j6 ~. O6 |
30.     HAL_GPIO_Init(NRF24L01_CS_GPIO_PORT , &gpio_init_struct);
    ! h3 K7 {- s$ s! E6 J, [
31.    
    
32.     gpio_init_struct.Pin = NRF24L01_CE_GPIO_PIN;
    ) ]. b3 [2 v2 @$ u
33.     HAL_GPIO_Init(NRF24L01_CE_GPIO_PORT , &gpio_init_struct);
    
34.    
    
35.     gpio_init_struct.Mode = GPIO_MODE_INPUT;
    4 \' |9 w! ]# {
36.     gpio_init_struct.Pin = NRF24L01_IRQ_GPIO_PIN;
    
37.     HAL_GPIO_Init(NRF24L01_IRQ_GPIO_PORT , &gpio_init_struct);
    9 W. j" w  u2 H5 I* }. d" s6 |
38.    
    
39.     NRF24L01_CE_LOW;
    
40.     NRF24L01_CS_HIGH;
    
41. }

复制代码

/ @. S. T7 J: |: i4 b
& l4 O0 j& G: }. m9 m) Y& }NRF24L01有五个寄存器是可以用来检测器件是否正常工作的：

1. uint8_t NRF24L01_Check(void)
   * _  D4 H3 U6 X- O9 f
2. {
   ' m' |5 L1 I: s+ f5 v
3.     uint8_t buf[5] = {0xa5 , 0xa5 , 0xa5 , 0xa5 , 0xa5};
   7 U3 A6 k  L" }+ g
4.     uint8_t i;
   
5.     NRF24L01_Write_Buf(NRF_WRITE_REG + TX_ADDR , buf , 5);
   1 Y5 Q, K6 x* M7 C4 u) L
6.     NRF24L01_Read_Buf(TX_ADDR , buf , 5);
   
7.     for(i = 0 ; i < 5 ; i++)
   7 z/ `( Q; h4 ~" w7 g) I
8.         if(buf[i] != 0XA5)
   ) J. F, N- g9 b+ I' q: p
9.             break;                                    
   
10.     if(i!=5)
    
11.         return 1;
    4 [# @, b. D$ p  {$ M& G9 S" N
12.     return 0;
    
13. }

复制代码

NRF24L01模块在同一时间只能设置为只接收或者只发送模式，属于半双工器件，要实现全双工收发需要两个模块：
/ _! J) Z. e1 }+ g5 D& `5 u

1. void NRF24L01_RX_Mode(void)
   % ]& f9 Q/ f% d4 a5 Q$ l, u/ r
2. {
   6 O! j, s2 _' E# y/ i7 `
3.     NRF24L01_CE_LOW;
   . j5 C; H: P9 f. {8 A/ l( T. z
4.     NRF24L01_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(uint8_t*)RX_ADDRESS,RX_ADR_WIDTH);
   5 {- m' L! d4 ]' ?1 H& b
5.    
   
6.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);  
   ) ~0 {+ Z8 c! @" X% s5 P' s
7.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01);
   / n1 A) w; K' B( v0 V) _$ y
8.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_CH,40);
   ( R) ^  n/ i- x6 M
9.     NRF24L01_Write_Reg(NRF_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);
   
10.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);
    ) j- u* W1 a1 }+ O. i0 ^0 `
11.     NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG, 0x0f);
    
12.     NRF24L01_CE_HIGH;
    
13. }
    
14. 
    
15. void NRF24L01_TX_Mode(void)
    0 e" c: S. U, Y3 A
16. {                                                         
    
17.     NRF24L01_CE_LOW;
    ) \: U: ~6 z2 C+ A$ w
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);
    . N* b& N. U, D4 F
20. 
    ; N3 F# E/ ?/ \) z9 ]! _  L
21.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);
    
22.     NRF24L01_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01);
    ; E; R$ ^# Q: k
23.     NRF24L01_Write_Reg(NRF_WRITE_REG+SETUP_RETR,0x1a);
    ; R  T# h8 e& H- P
24.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_CH,40);
    * F0 S) G6 R5 y5 r( z4 F
25.     NRF24L01_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);
    
26.     NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG,0x0e);
    * q1 x2 n/ a3 k! b9 x3 n' I, f/ i
27.     NRF24L01_CE_HIGH;
    
28. }
    
29. 
    
30. uint8_t NRF24L01_RxPacket(uint8_t *rxbuf)
    & `" h  p" C: X) |# V0 A/ H
31. {
    
32.     uint8_t sta;                                          
    
33.     sta = NRF24L01_Read_Reg(STATUS);
    # e& Z) A7 o( x. m- t/ ?5 z+ Q
34. 
    
35.     NRF24L01_Write_Reg(NRF_WRITE_REG + STATUS , sta);
    
36.    
    
37.     if(sta & RX_OK)
    
38.     {
    7 c3 {# t8 }; V7 E& L& F
39.         printf("sta = 0x%x RX_OK.\n" , sta);
    7 l$ V! F1 }: T: p+ e7 J
40.         NRF24L01_Read_Buf(RD_RX_PLOAD , rxbuf , RX_PLOAD_WIDTH);
    
41.         NRF24L01_Write_Reg(FLUSH_RX , 0xff);
    : A5 k+ A7 U! F1 D
42.         return 0;
    
43.     }      
    : ?) n3 c; o1 z  I/ }! n
44.     return 1;
    
45. }   
    ! e' y7 S. I4 r" U% y
46. 
    ' q6 E/ i- S! O+ |$ g. B
47. uint8_t NRF24L01_TxPacket(uint8_t *txbuf)
    
48. {
    ' v; ?, t# `; X6 {( ^1 ?$ Z# V
49.     uint8_t sta;
    ! w4 a& a/ a) [' L1 Z
50.     NRF24L01_CE_LOW;
    
51.   NRF24L01_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);
    
52.      NRF24L01_CE_HIGH;
    
53.     while(NRF24L01_IRQ_READ() != 0);
    ' b3 U9 D) ?1 h3 k% i
54.     sta = NRF24L01_Read_Reg(STATUS);
    ' B  p  D9 `3 C9 M. S: t, q
55.     NRF24L01_Write_Reg(NRF_WRITE_REG+STATUS,sta);
    
56.     if(sta&MAX_TX)
    
57.     {
    ( Z4 ?, N5 T4 ^# }( K6 `
58.         NRF24L01_Write_Reg(FLUSH_TX,0xff);
    : E' d" ]6 ^/ _8 F0 k
59.         return MAX_TX;
    ! M- m# q; ?; P* v
60.     }
    
61.     if(sta&TX_OK)
    7 K' F' _) X$ R% W/ _0 s4 X
62.     {
    " h3 W4 V: \* m) S( T. g
63.         return TX_OK;
    # k, |" J4 ?6 x. t+ h
64.     }
    
65.     return 0xff;
    
66. }

复制代码

9 T% o. q6 T/ L: X) t7 U2 x我这里在主界面创建一个flexButton用于控制NRF24L01模块发送一行数据：


, {+ h" N4 k9 e看看发送效果，按下fb之后，H7R7开发板会通过NRF24L01模块发送一行字符串，另一个设置了相同接收地址的NRF24L01开发板就会收到这个字符串：
9 H1 `# U$ M% }3 V# _
/ L0 z0 J7 q# Z$ Y( P然后是接收，接收就更简单了，只需要设置模块为接收模式后，在Tick事件回调函数调用即可：
+ ~# _* O  k, V9 k1 f$ Y
; [' o* G4 b+ r& ^8 a% ~

补上一张H7R7开发板和NRF24L01接收机开发板（STM32F103R）的合照


" Z% S1 I* [% M