' D- H4 Y2 h. [7 C1 C2 d& ?

资源篇

! I# E% l: X+ p8 K7 ^

0 z$ e+ y6 \8 ~

外观还是一如既往的靓，简洁美观。板子搭载的是M4内核，速度快，高达170M主频，和数学运算加速器CORDIC大大提高运算能力， 输入电压范围1.71~3.6V，512Flash，128的SRAM，1个用户LED，一个用户按键，32.768khz的外部低速晶振，外接24M的高速晶振，Micro-AB连接器，Arduino™ Uno V3连接器可扩与Arduino™ Uno V3连接，板载STLINK_V3仿真调试器，调试器的主控是STM32F723，下载速度得到的很大的提高。

2 u$ A2 g& f0 q/ i# _# L! H- JSTM32G474资源介绍：

! }" u% T6 H2 N% M0 T6 s2 N

9 e. p; {9 |2 |7 c0 j

STM32G474开发板实物图：

▲ 开发板实物图

开发板分为上下两部分，上半部分为ST-LINK-V3仿真器，可以给开发板进行调试和程序下载。下半部分是G474的最小系统板：全IO引出，兼容流行的Arduino扩展口如下图所示。值得一提的是：上半部分的ST-LINK是可以通过断开跳帽之后可以单独作为调试器使用。

: q: S7 M8 [! h5 }

实战篇

* d) t# ~+ Z2 `3 ?! U" v

测试内容：

• IO测试
• 虚拟串口VCP测试
• FPU测试
• DSP测试
  

1. LED和GPIO测试1

(1) 原理：短按一下按键，LED点亮，再短按一下按键LED熄灭。(2) 步骤：使用CubeCubeMx生成工程。

▲ 引脚配置

时钟配置：外接24M晶振，高达170M主频

; u4 X& R" U9 S# Z

生成工程，固件包版本V1.1.0。

/ N3 k9 ?6 L4 F

代码：

结果：短按一下按键，LED点亮，再短按一下按键LED熄灭。

结论：使用MX配置简单快速。

2. VCP虚拟串口测试1

5 W: M, B) ^9 |$ c

（1） 原理：

MCU与stlik连接

# m! g7 W' ]8 e; G) A$ L" f

虚拟串口连接MCU的LPUART1
: {% W# m0 a  W7 r

（2） 配置工程：

相关代码：

3 C( h- u' E. g% }$ g

（3）结果：如下所示，按一次按键就打印一个“OK”，LED一亮灭交替。

结论：这个功能在我们调试的时候十分方便，节省了很多的资源和时间。

9 z, ~( S$ p  g; ~( I

3．FPU性能测试1

原理：

FPU浮点运算单元，如果CPU上没有FPU进行浮点运算的话必须按照IEEE标准进行运算十分的耗时，相较之下具有FPU的处理器在计算浮点运算是非常快的，G474Nucleo板载FPU运算加速器，运算性能非常出色，我们可以通过简单的测试来测一下板子的FPU的性能，可以通过计算使用FPU时单精度的乘除法使用的时间和没有使用FPU时消耗的时间进行比较来得出结论，其中时间的计数我们使用的是systick定时器。
( f* l9 u5 m' P! O  X" t

6 D  k2 c8 K) X8 X7 K) i

步骤：

首先我们要学会打开硬件FPU，我们要设置 CPACR寄存器，其中在SystemInit函数中已经写好怎么配置，如下图：

我们只需要添加宏定义__FPU_PRESENT =1 ，_FPU_USED=1就可以了，而默认已经定义了__FPU_PRESENT =1，我们还需要添加_FPU_USED=1，在target 的Code Generation 选single Precision 就行了，如下图。

  u7 N$ G2 Y5 B

  g. h; H" M+ i1 t& W

相关代码如下：双精度和单精度计算函数

1. 
   
2. /**
   
3.   * @name  DoubleD
   
4.   * @brief 双精度乘除法.
   
5.   * @param angle：起始值，times：计算次数，
   4 C; r1 i1 R- k! j4 Y
6. *mod：1除法0乘法
   4 ~5 _* l( B0 B2 d
7.   */
   
8. void DoubleD(double angle,uint32_t times,uint8_t mode)
   - A, f4 u8 d4 X9 i( ]
9. {
   ( j0 q/ C7 L. s" R. t. E
10.     uint32_t i;
    ! j1 A: _# D$ [* w% F
11.     double result;
    
12.     if(mode)//除法
    
13.     {
    
14.         for(i=0;i<times;i++)
    
15.         {
    
16.             result = angle/PI;
    
17.             angle += 0.00001f;
    7 S3 X. R! N( d5 _% q2 i/ L
18.         }        
    ! N! ^+ o. f' _' o+ I" L
19.     }
    
20.     else//乘法
    
21.     {
    
22.         for(i=0;i<times;i++)
    
23.         {
    
24.             result = angle*PI;
    + y. N. J6 T3 p! v: R
25.             angle += 0.00001f;
    
26.         }
    
27.     }
    
28. }

复制代码

1. 
   4 W/ D2 P* G! o
2. /**
   9 k3 {& D( `# k% P* e$ f3 C
3.   * @name  FloatXFloat
   
4.   * @brief 单精度乘除法.
   ! \/ \* d. |. c+ F$ d' D
5. * @param angle：起始值，times：计算次数，*mod：1除法0乘法
   3 m' D( d6 ~# k3 H, b
6.   */
   8 T2 }+ x: T/ E0 |
7. void FloatXFloat(float angle,uint32_t times,uint8_t mode)
   
8. {
   
9.     uint32_t i;
   9 U$ a8 t" j" p
10.     float result;
    & O1 h% D" O- C  g  T
11.     if(mode)//除法
    8 Z+ Z# r1 ?1 z+ Q- n' j3 _2 X
12.     {
    / D! u9 e7 t, F, K# [: h# L
13.         for(i=0;i<times;i++)
    
14.         {
    
15.             result = angle/PI;
      ]: z7 L) n- A# n4 V
16.             angle += 0.00001f;
    * @0 D9 ]2 v& l' i) U. Y
17.         }        
    0 N" t8 _& u' \/ P0 f
18.     }
    
19.     else//乘法
    
20.     {
    
21.         for(i=0;i<times;i++)
    6 M/ B% n# u! d9 Z/ q5 k
22.         {
    ! r4 B1 g& D, E1 i7 x* A
23.             result = angle*PI;
    
24.             angle += 0.00001f;
    % x$ m+ L' {3 w" g
25.         }
    ) j% R; D' C# Z/ u( K( C
26.     }
    & ]4 \1 U: E/ \! {: U  \9 O
27. }
    ! k& p  }. Y( ]) k

复制代码

5 L- O5 O6 t6 `  y; }- i

主函数
) }" v* T& ^9 B: u- O2 L% q

1. 
   
2. int main(void)
     f4 _& ]$ s- A+ t. o+ \/ p4 G! z* [9 G, t: s
3. {
   / `; w0 C. |, u( @3 f7 K
4.   /* USER CODE BEGIN 1 */
   4 p' B0 N# G2 T( T
5.   /* USER CODE END 1 */
   * ?& D  E/ Z3 V0 S2 e8 L
6.   /* MCU Configuration--------------------------------------------------------*
   / n) k9 M$ H; o# z, n2 [/ U
7.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
8.   HAL_Init();
   
9.   /* USER CODE BEGIN Init */
   
10.   /* USER CODE END Init */
    1 b5 w( L- |! @7 P& G% g
11.   /* Configure the system clock */
    
12.   SystemClock_Config();
    ' V; T3 ^6 n% T- Y2 k
13.   /* USER CODE BEGIN SysInit */
    
14.   /* USER CODE END SysInit */
    
15.   /* Initialize all configured peripherals */
    
16.   MX_GPIO_Init();
    
17.   MX_USART1_UART_Init();
    
18.   MX_LPUART1_UART_Init();
    : F( V! \2 o+ |8 D
19.   /* USER CODE BEGIN 2 */
    
20.   HAL_Init();
    
21.   /* USER CODE END 2 */
    
22. /* Infinite loop */
    
23.   /* USER CODE BEGIN WHILE */
    - W! R6 Y9 N- V# m/ I) o7 u! }
24.   while (1)
    $ N. N( V. c2 V3 z, o
25.   {
    
26.     /* USER CODE END WHILE */
    . n, e" o' H) ~$ a' `6 O
27.     /* USER CODE BEGIN 3 */
    3 l8 E, l0 H5 e% a3 d$ y( X
28.     printf("---------------NOT USER FPU----------------------\n");
    / S6 ~$ Q8 T$ a" d3 \  k+ |
29.     //-------------------测试单精度乘法----------------------------------------
    5 P3 w: O; k& U; |
30.     start_tim = HAL_GetTick();   
    
31.     //乘法
    : k' l9 Y# c  t* e
32.     FloatXFloat(PI/6,TIMES,0);      
    
33.     end_tim = HAL_GetTick();
    
34.     if(end_tim > start_tim)
    
35.     {
    6 |7 y& L6 i1 f
36.         tim_cnt = end_tim - start_tim;
    4 J3 S! Y9 s% D% q) _5 g0 L
37.     }
    
38.     else
    
39.     {
    . Y  J# I; e- q' U! j
40.         tim_cnt = 0xffffffff - start_tim + end_tim;
    ; A0 K5 b4 C" e% m5 O( k2 A" Z
41.     }
    & `" K) C2 o+ z
42.     printf("单精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间  
    
43.     //-----------------测试单精度除法-------------------------------------------
    ! |& M+ A( ~+ N; H- h  T
44.     start_tim = HAL_GetTick();
    $ Y  I* {$ P9 n  J* @
45.     //除法
    # z' s" R! [: `9 p, P+ \
46.     FloatXFloat(PI/6,TIMES,1);
    6 ^( [4 P; G4 @' a
47.     end_tim = HAL_GetTick();
    . \- B$ J; V' J. ]6 A: F3 f
48.     if(end_tim > start_tim)
    . |5 O1 N8 k; u- t. Z
49.     {
    - v" O( q4 [/ k/ u  x2 J9 V; p- W
50.         tim_cnt = end_tim - start_tim;
    , [' d; ^8 g6 W' N, J7 F$ k- e
51.     }
    
52.     else
    
53.     {
    
54.         tim_cnt = 0xffffffff - start_tim + end_tim;
    ) s% R; R) u; W. E- U# U
55.     }
    
56.     printf("单精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    . }+ U/ J* `* s5 K: n4 {
57.     //-----------------测试双精度乘法-------------------------------------------
    
58.     start_tim = HAL_GetTick();
    & O2 G6 a: _$ Z; y  ?1 P& X) `( M% |
59.     //乘法
    + v- ]( e5 p5 R, l# p
60.     DoubleD(PI/6,TIMES,1);
    3 I$ `" w8 c& P6 S  j4 w. E  K# [
61.     end_tim = HAL_GetTick();
    ( c5 y1 }0 `" {/ {% }
62.     if(end_tim > start_tim)
    
63.     {
    
64.         tim_cnt = end_tim - start_tim;
    
65.     }
    
66.     else
    / Q$ ^& Z* M; B+ y( _
67.     {
    . i/ Y& ]( ?& H3 Z. J& g5 I1 ]% W# ^" u
68.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
69.     }
    
70.     printf("双精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间     
    
71.     //-----------------测试双精度除法-------------------------------------------
    
72.     start_tim = HAL_GetTick();
    ' U$ {  a. T+ z$ U. R( O  ]  j8 ~, b
73.     //除法
    8 J0 n) D  t4 }2 ~' ^  T
74.     DoubleD(PI/6,TIMES,1);
    0 Q3 a; u( K0 u/ }* o; d% K6 }
75. 
    
76.     end_tim = HAL_GetTick();
    
77.     if(end_tim > start_tim)
    
78.     {
    
79.         tim_cnt = end_tim - start_tim;
    / D! q  h! n9 n$ g0 f/ Y
80.     }
    # S  Y1 Y* _3 A: \: `4 x+ g, P, R  z- R
81.     else
    
82.     {
    4 K( ]0 f5 A" g& `% ^$ X2 c
83.         tim_cnt = 0xffffffff - start_tim + end_tim;
    - V5 t, N: e- V) h% M0 V) y. v1 U
84.     }
    , P4 `' e- o! ~' q5 E- m
85.     printf("双精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    
86. 
    
87. 
    : \/ t9 y, U. T- X3 P0 D
88.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    
89.     HAL_Delay(500);
    + l. l5 t1 q" z6 o- z! p
90.   }
    7 }: n# g  V' A. [# h
91.   /* USER CODE END 3 */
    ( k% C' R9 G9 j3 R( X4 b% y
92. }

复制代码

* ^8 a1 C: m9 s+ B! |9 ~  z4 r: D
& I- O$ K- P* E, ]3 D* T

: i# Z7 z' H& u% n1 ]1 p

测试结果：

条件：输入参数angle：起始值 = π/6，times：计算次数 = 20000(两万)，mod：乘除法时。

* D2 J7 j& |0 c( p* {

（1）没有打开FPU

  E6 _/ ^6 {# y( H8 Y. p% p9 _% e. x

（2）打开FPU

; n+ }8 v: s4 ?& N

数据比较

1 z0 E. P9 [7 W7 D- q1 N2 S	打开FPU(ms)	关闭FPU(ms)	比例
单精度乘法	1	9	9
单精度除法	3	13	4.3
双精度乘法	17	16	0.9
双精度乘法	21	21	1

得出结论：

打开FPU和没有打开FPU在浮点计算性能上有明显的提高，测试中可以看出在单精度乘法上性能上比较明显，速度大概是没有打开FPU的9倍左右，单精度除法则提升没有那么高4.3倍左右，在双精度上的运算则没有起到作用，耗时基本相同，所以FPU在单精度上计算速度上比较快对于双精度计算则不起作用。

/ o# P& P, R7 d

4. DSP测试1

, V2 e! h3 U$ q+ T

原理：

M4内核除了集成硬件FPU外，还带有DSP指令，还有相应的加速单元增加了数据的处理能力和运算速度，ST还提供了DSP算法相关的库 ，大大的提高了我们开发速度和效率 ，为了展示DSP的性能，我使用ST提供的标准库数学运算的运算速度和使用DSP库的提供的数学函数的运算速度比较，参考原子的比较方式，现在我们用过sin（x）² +cos（x）² = 1 这个运算，首先我们以x为变量，x从π/6开始，每次累加0.001，累加200000次，每次的结果的误差不能大于0.00005的运算时间进行比较，可以得到使用DSP和不使用DSP运算速度上的差别。

步骤：

在原来的工程上加入DSP库的头文件和源文件，并包含头文件路径，还要打开硬件FPU，添加宏定义,添加头文件和lib。

2 ]0 f( x) S/ n7 U# B; z! h

打开FPU，在target 的Code Generation 选singlePrecision。

减价宏定义ARM_MATH_CM4。

9 ^% R8 \8 H  v. ?0 {

测试主要代码：

运算函数：

1. 
   
2. //sin cos测试
   1 L( Y) Y4 C- m5 R3 w
3. //angle:起始角度
   . {) l3 [( X' J4 r# O  V; z7 k  b
4. //times:运算次数
   $ t! F: K, y1 W; T" h$ A+ Y+ h7 j
5. //mode:0,不使用DSP库;1,使用DSP库
   $ i0 _4 O2 M. ~9 j; A; s% B6 n- Y
6. //返回值：0,成功;0XFF,出错
   
7. uint8_t sin_cos_test(float angle,uint32_t times,uint8_t mode)
   ! p% W9 F" d- H% F4 ?/ c, v
8. {
   
9.     float sinx,cosx;
   
10.     float result;
    
11.     uint32_t i=0;
    
12.     if(mode==0)
    
13.     {
    . H5 ]  ^4 Z# X& F( n, C+ L
14.         for(i=0;i<times;i++)
    
15.         {
    # T9 t1 L% f' Z* O  [
16.             cosx=cosf(angle);  //不使用DSP优化的sin，cos函数
    
17.             sinx=sinf(angle);
    5 @4 c2 H; n+ i# F
18.             result=sinx*sinx+cosx*cosx;//计算结果应该等于1  
    ! E1 K: T9 v% G  ~5 d. G0 u
19.             result=fabsf(result-1.0f);//对比与1的差值
    
20.             if(result>DELTA)
    % ?' q9 w5 o9 {% V  A( {
21.             {
    ' q6 M# G8 |# d: a( y
22.                 return 0XFF;      //判断失败
    
23.             }
    
24.             angle+=0.001f;         //角度自增
    % d5 R# _6 [% q, S% b$ l
25.         }
    
26.     }
    5 v, W% ~' N" M( X0 [- {$ N; q
27.     else
    - H  L: q5 H' K+ ~: z( g3 X
28.     {
    
29.         for(i=0;i<times;i++)
    + X; C) f) |$ {. [! w: T
30.         {
    7 k8 i9 \3 V; N+ S  p5 u9 g
31.             cosx=arm_cos_f32(angle);//使用DSP优化的sin，cos函数
    ) E4 E3 n6 }7 @' k8 `5 A! v
32.             sinx=arm_sin_f32(angle);
    
33.             result=sinx*sinx+cosx*cosx; //计算结果应该等于1  
    
34.             result=fabsf(result-1.0f);    //对比与1的差值
    
35.             if(result>DELTA)
    
36.             {
    * z9 ^' ?2 W- L0 C2 `
37.                 return 0XFF;//判断失败
    
38.             }
    
39.             angle+=0.001f;                //角度自增
    
40.         }
    ) P7 D( B  A  I
41.     }
    
42.     return 0;//任务完成
    4 b; A$ p- [! a, r3 j' q+ |
43. }

复制代码

' H& q3 ~, o4 o. `* _7 P8 j: s

函数中当输入参数mode为1时使用DSP库提供的arm_cos_f32和arm_sin_f32计算sin（x）² +cos（x）² = 1，输入参数angle为其实角度，计算一次增加0.001,输入的参数timers是要计算的次数，计算的次数越多越消耗时间，对硬件的资源要求就越高，mode为1时则使用st标准库提供的sin，cos函数，所以通过两者的比较得出那种方式比较节省时间。

' \  A, X0 D5 _* E  }1 v

主函数

1. 
   ! J1 j) J/ `( u" |0 `* M
2. /**
   # R+ Z* |+ |7 l  W% S
3.   * @brief  The application entry point.
   
4.   * @retval int
   
5.   */
   * N/ M9 v8 p, r9 }+ Y% W- I4 K( ^
6. int main(void)
   ) K" K6 ^# m$ j: ^* U  y5 e3 x
7. {
   ( U2 a% j3 t  i- P. W
8.   /* USER CODE BEGIN 1 */
   
9.   /* USER CODE END 1 */
   
10.   /* MCU Configuration--------------------------------------------------------*/
      \2 D6 g4 m! J7 s9 D
11.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    4 k: b5 X. A  ]  b6 D  u
12.   HAL_Init();
      t* ~6 |* P' N. F
13.   /* USER CODE BEGIN Init */
    
14.   /* USER CODE END Init */
    & f( U( t5 ]/ G) h  s7 ^3 D& T# W! U
15.   /* Configure the system clock */
    
16.   SystemClock_Config();
    
17.   /* USER CODE BEGIN SysInit */
    6 P" n. C# ]5 N) l
18.   /* USER CODE END SysInit */
    ) [) k; m7 b1 j5 X  X
19.   /* Initialize all configured peripherals */
    
20.   MX_GPIO_Init();
    8 f9 @+ \5 C  c# V# e
21.   MX_USART1_UART_Init();
    $ A$ q! F  N: u, }+ E7 y$ d) y9 j
22.   MX_LPUART1_UART_Init();
    - c/ Q' v5 e+ y; Q# K
23.   /* USER CODE BEGIN 2 */
    # X" ~% w8 e  U5 E, ^" I
24.   HAL_Init();
    9 o9 {- u* X" n
25.   /* USER CODE END 2 */
    8 Y$ T6 D. _0 ?) }& g7 J0 `  |3 j
26.   /* Infinite loop */
    
27.   /* USER CODE BEGIN WHILE */
    ) @4 p8 j8 j: E5 I: L" M/ Z
28.   while (1)
      t$ O0 m- U) X/ A1 O( B
29.   {
    
30.     /* USER CODE END WHILE */
    
31.     /* USER CODE BEGIN 3 */
    
32.      //使用DSP优化
    
33.     start_tim = HAL_GetTick();
    & o# r$ y$ G5 B' I5 e5 o( H0 s8 X
34.     status = sin_cos_test(PI/6,200000,1);
    . s. [* @, y! m3 l9 t7 t
35.     end_tim = HAL_GetTick();
    
36.     if(end_tim > start_tim)
    $ y: E( k! H! j0 q
37.     {
    5 K- ^( A# ]0 }1 ]0 r7 T
38.         tim_cnt = end_tim - start_tim;
    
39.     }
    
40.     else
    ' n3 E/ L4 U- q/ O
41.     {
    ) ~2 w9 W7 ]9 ^( n( @
42.         tim_cnt = 0xffffffff - start_tim + end_tim;
    % ?# k$ d6 P1 `* n  _( I" m6 b
43.     }
    # Z. Y  x4 a7 K' h4 g
44.     if(status==0)
    0 X- T; f/ U$ F  G! J  I* }' x
45.     {
    
46.         printf("USER DSP-- %d ms\r\n",tim_cnt);    //显示运行时间  
    
47.     }      
    # o& s% a5 _; z7 |7 G
48.     else
    ( q2 m# @; r6 O5 y2 I
49.     {
    
50.         printf("USER DSP ERROR\n");    //显示当前运行情况   
    4 m4 r7 B; H2 X% l. v- i' G- f  l9 l
51.     }      
    
52.     //不使用DSP优化        
    0 f# J, ?; K0 i3 |
53.     start_tim = HAL_GetTick();
    ; s& J: B6 _" X/ U
54.     status = sin_cos_test(PI/6,200000,0);
    ; j# W+ x2 V$ Y7 B; Z1 u
55.     end_tim = HAL_GetTick();
    
56.     if(end_tim > start_tim)
    # e0 }' V/ C& z0 z0 p
57.     {
    : w+ f5 T9 z# m) U7 ]
58.         tim_cnt = end_tim - start_tim;
    
59.     }
      v9 h3 u2 x" f" Q
60.     else
    
61.     {
    
62.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
63.     }   
    
64. 
    
65.     if(status==0)
    
66.     {
    ' E$ H" a) I' f6 p% D( e: K/ B
67.         printf("NOT USER DSP-- %d-ms\r\n",tim_cnt);    //显示运行时间  
    
68.     }      
    
69.     else
    . e2 s5 X6 _( Z
70.     {
    # s; J; @( u2 M9 r6 O/ Q) x
71.         printf("NOT USER DSP ERROR\n");    //显示当前运行情况   
    
72.     }   
    9 j6 X9 d$ }5 `( B9 e
73.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    
74.     HAL_Delay(500);

复制代码

参数：angle : 起始角度 = π/6 ; times : 运算次数 = 10 000（1万）;

结果如下图：使用DSP是8ms，没有使用DSP是12ms；12/8= 1.5倍。

参数：angle : 起始角度 = π/6 ; times : 运算次数 = 100 000（10万）;

结果如下图：使用DSP是86ms，没有使用DSP是129ms；129/86= 1.5倍。

参数：angle : 起始角度 = π/6 ; times : 运算次数 = 200000（20万）;

结果如下图：使用DSP是172ms，没有使用DSP是258ms；258/172= 1.5倍。

) n* K- O/ v% u, s

总结：在单精度数学运算方面使用DSP加数的效果还是比较明显的，平均来说是没有说使用DSP的15倍。

# K2 |2 Y; l0 ^$ y% K2 ^' ~

板子的原理图在哪里找的啊？

goodgft 发表于 2021-8-20 09:07
板子的原理图在哪里找的啊？

MB1367-G474RE-C04 Board schematic

MB1367-G474RE-C05 Board schematic