硬件随机数实验
本章，我们将介绍STM32MP157的硬件随机数发生器。我们使用KEY0按键来获取硬件随机数，并且将获取到的随机数值通过串口打印出来。同时，使用LED0指示程序运行状态。

20.1 随机数发生器简介
STM32MP157自带了硬件随机数发生器（RNG），其中RNG1给A7内核使用，RNG2给M4内核使用。RNG处理器是一个以连续模拟噪声为基础的随机数发生器，在主机读数时提供一个32位的随机数。
; ^# p4 `# w& t! {+ d- X20.1.1 RNG框图
$ W+ Y; R2 n4 k' J/ _, C# l下面先来学习RNG框图，通过学习RNG框图会有一个很好的整体掌握，同时对之后的编程也会有一个清晰的思路。STM32MP157的随机数发生器框图如下图所示：


5 w" O5 t: y- F
2 D& `; h* Y. {, N# k/ Z图20.1.1. 1随机数发生器(RNG)框图
随机数发生器有2个时钟域：AHB时钟域和RNG时钟域。AHB 时钟用于为 AHB 存储寄存器和调节组件提供时钟信号，RNG 时钟用于噪声源采样。如果 RNG_CR 寄存器中的 CED 位设置为“0”了，即启用时钟错误检测，那么 RNG 时钟频率 必须大于 AHB 时钟频率的32 分之一，否则时钟检查器会指示时钟错误，RNG 将停止生成随机数。在配置时钟时，注意此范围。
RNG时钟域时钟为rng_clk，rng_clk由RCC_RNG2CKSELR寄存器的RNG2SRC[1:0]位选择具体的时钟源，具体选择关系为：
" p  s; f: L" ?6 A# H$ p0 s3 g1 d0x0: csi_ker_ck
0x1: pll4_r_ck
0x2: lse_ck clock
$ A  b8 t- n' g; |' C1 x1 k1 |0 S0x3: lsi_ck
  \2 Z$ @; C) w. A/ S+ P默认情况下STM32CubeMX会选择0x0: csi_ker_ck（4 MHz）作为rng_clk的时钟源，最大可通过PLL4配置为48MHz：


  M, [: g  ]5 d8 \
图20.1.1. 2 RNG2默认采用CSI作为时钟源
. V3 ^+ L+ X# A: I. K' a1 N) hAHB时钟域的时钟来自AHB3（最大为209MHz），用于访问相关寄存器等，通过RCC_MC_AHB3ENSETR的RNG2EN位（bit6）使能。可见，4MHz小于209/32，如果开启时钟错误检测，注意配置RNG2的时钟范围。
. U2 s0 ]+ `+ Q- j' O
% r! _$ j2 N4 N# Y
" o, D7 Y. n( @9 ~
3 b5 [, M2 ]6 R$ V图20.1.1. 3 RNG时钟
! X2 T8 l7 O" k& B& C, E* z8 T6 y. {RCC_RNG2CKSELR和RCC_MC_AHB3ENSETR这两个寄存器我们就不做介绍了，大家参考手册。从RNG框图整体上知道，RNG有两个输入和一个输出。具体如下表：
" Q- X, Y" L9 X/ s0 U7 U

' ?5 L9 A& F5 i/ B# }
& _0 W7 N+ m3 g表20.1.1. 1 RNG内部输入/输出信号
: Q3 f% D/ z( M2 sSTM32MP157的随机数发生器（RNG）采用模拟电路实现，由内部两个模拟噪声源产生种子，经过采样和归一化处理，再经过线性移位寄存器和判断逻辑，最终输出到RNG_DR，生成32 位随机数。
每个模拟噪声源由3个环形振荡器组成，振荡器产生的输出经过异或运算产生种子，经过采样归一化处理后，输出到RNG内部的线性移位寄存器。采样频率由rng_clk时钟提供，因此，随机数质量与 HCLK 频率无关。当将大量种子引入线性移位寄存器后，经过判断逻辑，最终输出到数据寄存器 (RNG_DR)。
, g' }. m7 @5 R同时，系统会监视模拟种子和专用时钟 rng_clk，当种子上出现异常序列，或rng_clk时钟频率过低时，可以由RNG_SR寄存器的对应位读取到，如果设置了中断，则在检测到错误时，还可以产生中断。
9 ?! [" G/ F4 u, l: c$ A20.1.2 RNG寄存器
' e+ k$ p7 u, s6 s7 j1.RNG控制寄存器（RNG_CR）
RNG控制寄存器描述如下图所示：

6 B- T2 ]# b# o6 k

+ d, n) v- b* r" r图20.1.2. 1 RNG_CR寄存器
9 \7 G. U" j8 I# p0 y3 v该寄存器我们只关心RNGEN位，该位用于使能随机数发生器，所以必须设置为1。
- }8 i& }1 z& N" o$ E1 D+ c2. RNG状态寄存器（RNG_SR）
2 o& U2 k! C8 y7 k( D4 |/ gRNG状态寄存器描述如下图所示：
8 h! x$ J3 g) Z# `0 W8 `' R. E: N

1 u! n* S/ y, N4 h- S
) g; A5 H, H$ b& Y* ?6 W图20.1.2. 2 RNG_SR寄存器
6 M" i( v: U7 q5 V8 u/ b该寄存器我们仅关心最低位（DRDY位），该位用于表示RNG_DR寄存器包含的随机数数据是否有效，如果该位为1，则说明RNG_DR的数据是有效的，可以读取出来了。读RNG_DR后，该位自动清零。
! C7 I6 j9 H% w. d) u6 \8 y3. RNG数据寄存器（RNG_DR）
RNG数据寄存器描述如下图所示：



& g' q1 L- o) ~) k' C6 k. m图20.1.2. 3 RNG_DR寄存器
RNG_DR寄存器是只读寄存器，我们可以读取该寄存器获得32位随机数值。此寄存器在最多216个AHB时钟周期后，又可以提供新的随机数值。
- d$ C5 r1 \: ^- s
20.1.3 RNG的HAL库驱动
RNG在HAL库中的驱动代码在stm32mp1xx_hal_rng.c文件（及其头文件）中。
1.HAL_RNG_Init函数
  o" o' q! Q  R0 c4 y) `, U3 {6 PRNG的初始化函数，其声明如下：

1. HAL_StatusTypeDef HAL_RNG_Init(RNG_HandleTypeDef *hrng);
   
2. ●函数描述：
   
3.         用于初始化RNG。
   ; s, W# F3 ~9 Z( J5 G% @3 L# v% V, K
4. ●函数形参：
   
5.         形参1是RNG_HandleTypeDef结构体类型指针变量，其定义如下：
   ) M8 g( D0 I# N7 G, z# U$ X
6. typedef struct
   6 y# c! b0 m% q
7. {
   9 ]9 u  c% Y+ ?- B4 G
8.   RNG_TypeDef                   *Instance;    /* RNG基地址 */
   
9.   RNG_InitTypeDef               Init;         /* RNG初始化配置结构体 */
   
10.   HAL_LockTypeDef               Lock;         /* RNG锁设置 */
    + m, f% j" n) z' c! q8 ?  r
11.   __IO HAL_RNG_StateTypeDef   State;        /* RNG设备访问状态 */
    
12.   __IO  uint32_t                ErrorCode;    /* RNG错误代码 */
    ) h4 L% k. K1 s6 ?
13.   uint32_t                      RandomNumber; /* RNG最后生成的随机数 */
    
14. } RNG_HandleTypeDef;
    
15.         1）Instance：指向RNG寄存器基地址。
    , u$ f* G9 d, U! a; t+ u
16.         2）Init：是的RNG初始化结构体，其结构体类型RTC_InitTypeDef定义如下：
    
17. typedef struct
    / K; W  c7 @( ]$ S  J$ |5 n
18. {
    " \3 L* c  O6 i+ f" ^
19.   uint32_t            ClockErrorDetection; /* CED时钟错误检测 */
    9 P& e  f" \1 a9 l+ a. Y/ {4 w
20. } RNG_InitTypeDef;

复制代码

# S( B) s+ a- f3）Lock：用于配置锁状态。
4）State：RNG设备访问状态。
5）ErrorCode ：RNG错误代码
6）RandomNumber ：该变量存储RNG最后生成的随机数
, x- t  i5 c* v! ]
●函数返回值：
. N' K/ f  _% w6 b6 F7 UHAL_StatusTypeDef枚举类型的值。
2. HAL_RNG_GenerateRandomNumber函数
HAL_RNG_GenerateRandomNumber是RNG生成随机数函数。其声明如下：
HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber(RNG_HandleTypeDef *hrng,
" ~) a  R2 I  X' p( Guint32_t *random32bit);
●函数描述：
6 h9 X0 A9 T3 U$ B  G! j1 w+ g该函数用于RNG生成随机数。
●函数形参：
形参1是RNG_HandleTypeDef结构体类型指针变量，即RNG的句柄。
* [% d  f- w" e  D形参2是uint32_t类型指针变量，随机32位指针，生成随机变量。
" v" G, p3 A+ R5 v2 Z, b: F" s8 D$ Y●函数返回值：
$ Z5 p  o" C) e9 U' X0 o3 |HAL_StatusTypeDef枚举类型的值。
% p: U- {' w/ r) g0 p
20.2 硬件设计
3 I  E8 m/ }5 V1.例程功能
# ~. w% K$ x6 b: y: O  e4 D本实验使用STM32MP157自带的硬件随机数生成器（RNG），获取随机数，并通过串口打印出来。按KEY0可以获取一次随机数。同时程序自动获取0~9范围内的随机数，显示在屏幕上。LED0闪烁用于提示程序正在运行。
" j6 k5 ^' ~( b+ M2.硬件资源
9 V$ P' ]" K/ w8 L1）LED灯：LED0
/ [% M) Q, ], [2）独立按键 KEY0
% v" d3 R: F. |: B' E$ E8 _3）串口4
- r7 r1 d! ]4 {0 x; s3 a5 b& E4）RNG（硬件随机数生成器）
9 d: G. \$ _- J/ x7 zLED0 KEY0 UART4_TX UART4_RX
PI0 PG3 PG11 PB2
% e* {; F5 P, \0 Z表20.2. 1 硬件资源
5 l) J5 g% J( w3.原理图
RNG属于STM32MP157内部资源，通过软件设置好就可以了。

( W- v( ~7 Q( @9 c& H/ W% n; I20.3 软件设计
本实验配置好的实验工程已经放到了开发板光盘中，路径为：开发板光盘A-基础资料\1、程序源码\11、M4 CubeIDE裸机驱动例程\CubeIDE_project\ 13 RNG。
20.3.1 程序流程图
下面看看本实验的程序流程图：
' E; W; ]* B6 V0 R% `/ a# j; A
) l6 h9 g4 h* A0 f
: Y' @8 k: y% R" u9 B
0 e1 @3 o$ F; G$ A5 Q$ f0 Y图20.3.1. 1硬件随机数实验程序流程图
3 R* `% o% U  u# V
20.3.2 软件配置
1.新建和配置工程
  f' j; m5 [( X3 ]; v% i  h本节实验可以在前面的串口通信实验的基础上实现，因为用到串口UART4，也可以重新新建一个新的工程。这里新建工程RNG，然后配置串口UART4和按键KEY0以及LED0，具体的配置步骤我们前面的实验章节都有介绍过，如果不记得配置步骤，大家可以回顾前面相关的实验章节。本节实验中，LED和按键只用到LED0和KEY0，其它LED和按键没有用到，如果直接使用前面BSP文件夹里的led.c、led.h、ket.h和key.c文件的话，可以直接将其他LED和按键也一起配置了。
" z! [  V2 Z6 U$ _2 Z9 B（1）GPIO配置
" h2 C9 y) b# n1 QLED0和KEY0配置如下：



$ f: M- ?& F& }# q- o图20.3.2. 1 LE0和KEY0配置
! c; i1 V: p' hUART4配置如下：


/ o+ }3 v+ [# h' y$ |7 o. ^
图20.3.2. 2 UART4配置
（2）NVIC配置：
0 n+ q; r4 f8 X  @6 _3 Q  _UART4参数使用默认配置：
+ T/ O4 l8 B& _- W& l6 a


图20.3.2. 3 UART4参数配置
我们使用串口中断，先开启串口全局中断，



图20.3.2. 4 开启UART4全局中断
串口中断优先级配置如下：



, P: O: p6 ?( ~4 E图20.3.2. 5 配置UART4中断优先级
$ N( ]$ N/ L& H+ ~下面，我们直接配置RNG2：
（3）配置RNG2
) k4 H7 y1 w! t2 s: w+ X如果不知道RNG在哪里，可以直接搜索RNG2：



图20.3.2. 6 查找RNG2
; i: r* f2 ?7 j4 e5 {( d在SecurityRNG2下找到RNG2的配置，按照如下图配置，先勾选Cortex-M4，再选择Activated，即激活随机数发生器。其它配置保持默认，实际上RNG没有其它参数需要配置的。这里，我们不开启时钟错误检测：


  f4 J5 Z0 m. r/ r# Y
/ {8 N& z' D$ X* H; b( m7 E图20.3.2. 7 配置RNG2
/ a6 {4 Y% w! K: h! W（4）配置时钟
; ~1 R; ?8 N' i- bRRNG2时钟默认采用CSI的时钟，其它时钟也可以保持默认配置。这里就保持和前面一样的配置，配置PCLK1最大为104.5MHz：
3 F9 @2 H1 \2 M( U. l" d( a' o


0 @, t1 f, S" m; V/ D4 \图20.3.2. 8 配置时钟
（5）配置生成独立的.c和.h文件

. R! C/ u6 e) L8 ?" L5 z

图20.3.2. 9配置生成独立的文件
# C  ]) i- _1 `0 L; \# k9 b* z2. 生成工程
以上的配置检查无误后，按下键盘的“Ctrl+S”组合键保存配置并生成工程。将前面按键实验用到的BSP文件夹拷贝到本工程的Src目录下，只留下按键和LED相关的代码：
  `2 r# H: w& h9 S; S" E

1 r' M3 Y9 T: T; L% k
4 i/ s2 A3 b% G8 B# s( s: z* o图20.3.2. 10生成工程
3 c( O% |0 o3 K; I+ X3. 添加用户代码
上一步操作中，我们已经将BSP文件夹拷贝到了工程中，因为本节实验只用到LED0和KEY0相关的代码，所以将其它LED1和按键的代码注释掉。当然，也可以在STM32CubeMX上将LED1和其它按键也一起配置了，这样就不需要注释这些代码了，或者也可以自己重新手动编写这部分代码。
( S- C9 s/ H8 ]6 k（1）key.h、key.c、led.c和led.h的代码比较简单，这里就不列出来了，大家可以直接参考本工程中的代码。
（2）串口相关的代码可直接参考前面串口通信实验章节部分，这里就不再列出来了。
3 n4 V3 _8 F' I: J（3）RNG2初始化代码已经在rng.c文件中生成了，代码比较简单，如下：

1. #include "rng.h"
   
2. 
   
3. RNG_HandleTypeDef hrng2; /* RNG2句柄 */
   & P# s0 K. k2 ~) {$ `9 p- B
4. 
   2 f' k" \4 s' y7 o  r6 ?/ Y; e7 N' s
5. /**
   ' ]" f1 C9 R( \; W
6. * @brief       RNG底层驱动，初始化RNG2
   . K0 i' {( h2 H; K
7. * @note        此函数会被HAL_RNG_Init()调用
   3 U. ?# `8 c; ~6 x" t3 ]% g( R  h
8. * @param       hrng:RNG句柄
   
9. * @retval      无
   
10. */
    * X, i* x) z0 @7 C1 R1 ~3 W1 `
11. void MX_RNG2_Init(void)
    6 M, U! H5 N. A- C0 ]- I; g% f
12. {
    , F7 E6 w# W. q/ [: I  y. Y
13.   hrng2.Instance = RNG2; /* RNG2 */
    " c& u- ?+ P2 a4 z0 e- i
14.   hrng2.Init.ClockErrorDetection = RNG_CED_DISABLE; /* 关闭时钟错误检查 */
    : e2 D; }3 L2 G8 {1 J- c3 S$ a1 z9 N
15.   if (HAL_RNG_Init(&hrng2) != HAL_OK) /* 初始化RNG2 */
    
16.   {
      P' p# H" |& Q0 m' n/ K2 F
17.     Error_Handler();
    - E$ ]! L' \1 r6 O- m
18.   }
    1 o" K7 w  ^. X' j. P
19. 
    6 u& _& S5 a3 A& D9 {" D, u- t) D
20. }
    
21. /**
    
22. * @brief       RNG底层驱动，时钟源设置和使能
    / q' D  Q& n  {. _. `7 u
23. * @note        此函数会被HAL_RNG_Init()调用
    
24. * @param       hrng:RNG2句柄
    
25. * @retval      无
    $ b" Y' [9 q  I
26. */
    
27. void HAL_RNG_MspInit(RNG_HandleTypeDef* rngHandle)
    
28. {
    ! W9 e/ I* F, c
29.   RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
    
30.   if(rngHandle->Instance==RNG2)
    
31.   {
    
32.   if(IS_ENGINEERING_BOOT_MODE())
    # B9 U& z& O$ @
33.   {
    ) p( M8 o* s- X6 ~  R, E8 F$ r
34.       /* 外设外RNG2 */
    ( K# Z. H; H& l, s! [
35.     PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RNG2;
    : Z# g* Z( z5 S, W1 o
36.     /* 时钟源设置为CSI */
    
37.     PeriphClkInit.Rng2ClockSelection = RCC_RNG2CLKSOURCE_CSI;
    
38.     /* 初始化RCC扩展外设时钟，也就是RNG2时钟 */
    6 r3 C6 [1 B3 X% p! ?* B/ {9 c; m$ I3 e
39.     if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
    / H; E$ @1 h) V9 r  M
40.     {
    
41.       Error_Handler();
    
42.     }
    " T8 @& W0 w* D
43.   }
    
44.     __HAL_RCC_RNG2_CLK_ENABLE(); /* 使能RNG2时钟 */
    0 y! j' Z: O$ J
45.   }
    
46. }
    9 [7 Y" Y% U) a4 z
47. /**
    
48. * @brief       RNG底层驱动反初始化函数
    
49. * @note        如果需要，可以调用此函数
    
50. * @param       hrng:RNG句柄
    
51. * @retval      无
    2 u8 T# e1 a9 Y: N' O
52. */
    
53. void HAL_RNG_MspDeInit(RNG_HandleTypeDef* rngHandle)
    
54. {
    
55.   if(rngHandle->Instance==RNG2)
    7 x+ Y# I  ]6 O- S6 `8 B) Y$ b
56.   {
    
57.     __HAL_RCC_RNG2_CLK_DISABLE();/* 关闭RNG2时钟，即关闭RNG2 */
    + a# C0 Z3 b. @5 ?8 K: y, l; v
58.   }
    
59. }
    
60.         （4）手动添加获取随机数的代码
    
61.         在rng.c文件中添加如下代码：
    ! s: ]' D0 ^" c* p- q6 K
62. /* USER CODE BEGIN 1 */
    1 O3 E$ [/ g' t+ E) y. F9 x$ Z
63. /**
    1 [& ~1 _$ \* ]; f& ?7 O
64. * @brief       得到随机数
    * o9 X7 l) d8 ^- j5 S. u: k
65. * @param       无
    
66. * @retval      获取到的随机数(32bit)
    
67. */
    
68. uint32_t rng_get_random_num(void)
    3 A9 e* m2 a3 V7 h# J
69. {
    . B% L# O( A- a- X
70.     uint32_t randomnum;
    , v5 V* t* s8 ]( O
71.     HAL_RNG_GenerateRandomNumber(&hrng2, &randomnum);
    
72.     return randomnum;
    
73. }
    3 b! l4 w7 ^# M9 M2 ]! e) ~
74. 
    6 @: b7 _: {7 x  v4 t: g6 M9 Z
75. /**
    
76. * @brief       得到某个范围内的随机数
    
77. * @param       min,max: 最小,最大值.
    + O, ^3 a6 O2 Y* V1 V
78. * @retval      得到的随机数(rval),满足:min<=rval<=max
    
79. */
    1 [6 F) o5 G9 p8 Z, R- L% L1 k: E  t
80. int rng_get_random_range(int min, int max)
    # [- v* m7 G+ v" m# J# G' i% I
81. {
    ! z& B# P! e: ~
82.     uint32_t randomnum;
    
83.     HAL_RNG_GenerateRandomNumber(&hrng2, &randomnum);
    0 }, u+ a/ a9 I/ S% z! c# I2 R
84.     return randomnum%(max-min+1) + min;
    ! X' K# S! F7 K! K, h, b
85. }
    ; ^2 J5 I2 x% X
86. /* USER CODE END 1 */

复制代码

以上代码比较简单，主要是通过HAL库中的HAL_RNG_GenerateRandomNumber函数获取随机数。rng_get_random_num函数主要是获取随机数，rng_get_random_range主要是返回某个范围内的随机数。
（5）修改main.c文件

1. #include "main.h"
   
2. #include "rng.h"
   ( ]8 h: X1 J8 b
3. #include "usart.h"
   
4. #include "gpio.h"
   , I) {1 g8 |8 o) X
5. 
   & R6 J. z) o; U/ ~
6. /* USER CODE BEGIN Includes */
   ) X5 v  m: f6 m: O& ?
7. #include "./BSP/Include/led.h"
   5 w  C( b6 `! c+ O4 h5 V
8. #include "./BSP/Include/key.h"
     K/ k/ e9 N! B6 J8 J6 s
9. /* USER CODE END Includes */
   
10. 
    ) F0 m- q# |& U4 |4 d6 q2 Q
11. void SystemClock_Config(void);
    7 \. d/ j5 ], n  K' H; F$ ?
12. 
    
13. int main(void)
    1 i: T' J$ U" h8 m/ d) N6 |* _
14. {
    
15.   HAL_Init();
    
16.   if(IS_ENGINEERING_BOOT_MODE())
    ( L( l) f% C: f! ^0 O! P! o. L
17.   {
    
18.     SystemClock_Config();
    3 Y) I3 ^) j2 [2 K' o  F) m2 K
19.   }
      t9 W" d' `, E! ~! S
20.   MX_GPIO_Init();
    - X. R1 q7 L, m7 R# n! b7 f) F
21.   MX_RNG2_Init();
    
22.   MX_UART4_Init();
    " C9 n0 F0 e1 w4 V: q
23.   /* USER CODE BEGIN 2 */
    * M' g" ?  g9 m8 S
24.   /* printf("请输入字符，并按下回车键结束\r\n"); */
    ! q! T. l7 x( V) I+ j7 B, b& L3 i
25.       HAL_UART_Receive_IT(&huart4,&RxBuffer,1);/* 以中断方式接收函数 */
    0 J: f  i7 s4 w6 e% e, A: E  ~( n
26.   /* USER CODE END 2 */
    
27.   while (1)
    + X3 |# w% h* I
28.   {
    . b0 x2 K. r* d) w5 g$ L/ _. U" W
29.     /* USER CODE BEGIN 3 */
    : U, M' K% T" D( w6 u/ ^
30.       uint32_t random;
    
31.       uint8_t t = 0, key;
    0 y7 M& c0 H6 s0 _. n9 M
32.       key = key_scan(0);
    - ]$ @( _; t  j3 O' r
33.       if (key == KEY0_PRES)
    6 d2 M& D- s  x& o" }$ B
34.           {
    
35.              random = rng_get_random_num();
    4 W1 X6 G7 ?& f$ U. j
36.              printf("Random Num:%lu\r\n", random);
    - L+ \/ v0 @% g( T; g
37.            }
    9 A# r. p8 Q4 a; M( O+ Y
38.        if ((t % 20) == 0)
    3 G- w& D1 T2 w' `8 n
39.            {
    
40.              t = 0;
    
41.              LED0_TOGGLE();                    /* 每200ms,翻转一次LED0 */
    
42.              random = rng_get_random_range(0, 9);/* 取[0,9]区间的随机数 */
    
43.              printf("Random Num[0-9]:%lu\r\n", random);
    
44.             }
    
45.               HAL_Delay(10);
    
46.               t++;
    ' ~" o% X( E+ S6 S; ^+ d- k; }
47.   }
    
48.   /* USER CODE END 3 */
    - Z; h! M# O4 G- s" Z
49. }

复制代码

以上代码中，每隔200ms会自动打印一次[0,9]区间的随机数，同时LED0会翻转一次。如果有按键按下，那么串口就会打印获取到的随机数。

20.4 编译和测试
编译无报错，测试结果如下：


  n$ N, \7 e3 h+ c: n, d) Y4 F
, b2 @  J/ ^) `- z7 w图20.4. 1测试结果
& _  v# l4 s3 g8 L————————————————
版权声明：正点原子


3 B8 }$ ~1 O1 M7 X! K$ ]0 _8 W; R, I% n