1 s- Q3 a6 C& I, q) h! Z5 J

资源篇

8 V5 D* J( B# e* P* y2 M; N1 u

外观还是一如既往的靓，简洁美观。板子搭载的是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，下载速度得到的很大的提高。

& y: M9 l- z7 c3 \STM32G474资源介绍：

7 r. e6 H, g# I. j

STM32G474开发板实物图：

1 S% u+ k4 f8 ^- g

▲ 开发板实物图

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

6 o6 _2 Z  w$ m+ Y# D& Z

实战篇

测试内容：

• IO测试
• 虚拟串口VCP测试
• FPU测试
• DSP测试
  + E  G. q. a' [6 y7 t

1. LED和GPIO测试1

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

▲ 引脚配置

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

+ Q2 m( s2 z5 x. w

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

. a8 F6 q; D& l1 f' a

7 q7 [  S) y/ L! L* N* Z

代码：

: U; R! ^/ [3 S

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

8 f' D% Y* K) M4 ?9 i" e# l# `' I

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

2. VCP虚拟串口测试1

0 Y/ I" }7 M: M" ]: j

（1） 原理：

MCU与stlik连接

/ @, @5 `+ {0 R5 ]  p

虚拟串口连接MCU的LPUART1

（2） 配置工程：

相关代码：

6 ^' t) ^1 o& m! f8 Y  _. P

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

* J7 s$ |$ X' ^. F) h0 Z$ ?

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

3．FPU性能测试1

原理：

FPU浮点运算单元，如果CPU上没有FPU进行浮点运算的话必须按照IEEE标准进行运算十分的耗时，相较之下具有FPU的处理器在计算浮点运算是非常快的，G474Nucleo板载FPU运算加速器，运算性能非常出色，我们可以通过简单的测试来测一下板子的FPU的性能，可以通过计算使用FPU时单精度的乘除法使用的时间和没有使用FPU时消耗的时间进行比较来得出结论，其中时间的计数我们使用的是systick定时器。
- @8 N9 E# f6 ~* w% O- r+ P

; ?% a+ p0 [) O# m

步骤：

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

. i+ p6 T9 o, O

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

相关代码如下：双精度和单精度计算函数
/ {9 d: A7 r$ u; x4 L& t' P+ J, F

1. 
   
2. /**
   ; D% n) d4 T& c/ n
3.   * @name  DoubleD
   2 E- J8 j$ \0 B8 Y- E" M* l
4.   * @brief 双精度乘除法.
   
5.   * @param angle：起始值，times：计算次数，
   
6. *mod：1除法0乘法
   
7.   */
   1 ^+ j+ H0 t2 C! X: n
8. void DoubleD(double angle,uint32_t times,uint8_t mode)
   8 b5 @2 o* m5 b$ `0 B
9. {
   
10.     uint32_t i;
    / t0 w/ q5 `/ C
11.     double result;
    
12.     if(mode)//除法
    3 d: _% ^+ h- e. o/ h! S+ K
13.     {
    - Q( s9 a& L- O# B" ]
14.         for(i=0;i<times;i++)
      W, W% }5 q, z
15.         {
    
16.             result = angle/PI;
    
17.             angle += 0.00001f;
    
18.         }        
    
19.     }
    
20.     else//乘法
    * m/ L2 B7 r. Q( `
21.     {
    
22.         for(i=0;i<times;i++)
    
23.         {
    ' N0 F5 X, w# W) ^+ ^/ r
24.             result = angle*PI;
    # F8 ~5 D4 N% u" R0 B
25.             angle += 0.00001f;
    3 ]8 a0 ?2 a# v4 a8 a
26.         }
    
27.     }
    ' k2 M2 D, ~6 G0 s; W* z
28. }

复制代码

0 i8 N0 R" ~+ y; W. y0 w

, _2 B: q1 {. V1 ?  g* @$ N7 I

8 e/ n5 I8 I' r% C" E

1. 
   
2. /**
   
3.   * @name  FloatXFloat
     k$ ~5 }* ]' [: _8 n: D
4.   * @brief 单精度乘除法.
   0 G- U% Q* l* L: ?2 m5 B
5. * @param angle：起始值，times：计算次数，*mod：1除法0乘法
   ; I: H6 U: j+ i5 \! n6 Q/ c7 k
6.   */
   
7. void FloatXFloat(float angle,uint32_t times,uint8_t mode)
   5 d, X$ l; s6 _* \" o: _
8. {
   
9.     uint32_t i;
   9 v6 L, d% K& H: Q. b+ k/ v
10.     float result;
    
11.     if(mode)//除法
    5 m3 p3 u' M: s
12.     {
    
13.         for(i=0;i<times;i++)
    & C/ _. A8 n0 G8 F) D0 ~& N" E" D
14.         {
    
15.             result = angle/PI;
    ) N2 ^: }& ], a( @
16.             angle += 0.00001f;
    , V, V  P* e; O/ F+ p
17.         }        
    ! K7 d, f& d$ ]- m; n$ u8 ]& m
18.     }
    2 U9 @6 C! p, ?# l, m
19.     else//乘法
    . V: L0 r, Y% \% n9 r2 C8 i
20.     {
    
21.         for(i=0;i<times;i++)
    
22.         {
    
23.             result = angle*PI;
    
24.             angle += 0.00001f;
    
25.         }
    
26.     }
    ' B% v) ^, e3 ~" \8 m. b: o
27. }
    

复制代码

5 J# k3 P% a; t

1 M& \" Z. f. _) T, R

主函数
* m. `: {6 R& T+ N% y+ B

1. 
   & O, a+ o( x0 T' C! Z
2. int main(void)
   
3. {
   
4.   /* USER CODE BEGIN 1 */
   
5.   /* USER CODE END 1 */
   
6.   /* MCU Configuration--------------------------------------------------------*
   5 L8 W3 P+ t) q' t5 k
7.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   ! e) D/ D" V: ^6 I( H
8.   HAL_Init();
   * {1 f4 I3 {3 l5 Z7 U! J
9.   /* USER CODE BEGIN Init */
   
10.   /* USER CODE END Init */
    
11.   /* Configure the system clock */
    
12.   SystemClock_Config();
    4 z6 `' n, x" V7 {! u6 d
13.   /* USER CODE BEGIN SysInit */
    
14.   /* USER CODE END SysInit */
    " T) w+ {# l5 n
15.   /* Initialize all configured peripherals */
    
16.   MX_GPIO_Init();
    
17.   MX_USART1_UART_Init();
    % O6 n  B! d/ j: v* C8 D  M. P
18.   MX_LPUART1_UART_Init();
    ; w  l! V: z$ V: [
19.   /* USER CODE BEGIN 2 */
    
20.   HAL_Init();
    
21.   /* USER CODE END 2 */
    # B- \- B! Q' i' A
22. /* Infinite loop */
      C7 W  j' V" K5 G  y8 x
23.   /* USER CODE BEGIN WHILE */
    
24.   while (1)
    ; t, e2 i) B6 o4 m
25.   {
    & e) x) Y8 s' ]3 w8 i
26.     /* USER CODE END WHILE */
    
27.     /* USER CODE BEGIN 3 */
    " D- w+ `4 H/ r5 m( x! a6 Q4 F1 }
28.     printf("---------------NOT USER FPU----------------------\n");
    . I. |. X0 `$ Q, ~1 S
29.     //-------------------测试单精度乘法----------------------------------------
    ' a3 U! Z) _, H" t6 X8 I0 H
30.     start_tim = HAL_GetTick();   
    4 K, U. w2 {& h' B) a
31.     //乘法
    
32.     FloatXFloat(PI/6,TIMES,0);      
    
33.     end_tim = HAL_GetTick();
    % T4 C; |8 N% z5 l- e
34.     if(end_tim > start_tim)
    
35.     {
    : ^. x9 r( Y/ l  ~
36.         tim_cnt = end_tim - start_tim;
    
37.     }
    ! S- e  A! I! K) j2 _& u* c. Y
38.     else
    8 w" u5 a% {; E- i' s. t( L% V# A
39.     {
    5 a* F# ]4 j: B
40.         tim_cnt = 0xffffffff - start_tim + end_tim;
    : g% E3 L$ R: p3 _9 o" J$ Q8 w
41.     }
    * {% Z& ]6 S4 s( n) G# x. A
42.     printf("单精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间  
    
43.     //-----------------测试单精度除法-------------------------------------------
    
44.     start_tim = HAL_GetTick();
    
45.     //除法
    
46.     FloatXFloat(PI/6,TIMES,1);
    ! r1 u! e4 Z3 U/ ]
47.     end_tim = HAL_GetTick();
    
48.     if(end_tim > start_tim)
    4 u4 j" I6 }. X& [, m9 G
49.     {
    
50.         tim_cnt = end_tim - start_tim;
    / i$ s( U# H; U' _- e
51.     }
    
52.     else
    
53.     {
    ( H5 t7 v6 A7 _4 r# W+ L
54.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
55.     }
    " f( s) }/ n1 p  P
56.     printf("单精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    # D  g! i- E/ \! ~5 h
57.     //-----------------测试双精度乘法-------------------------------------------
    : M; @0 j- i  v+ I. @! y' ^
58.     start_tim = HAL_GetTick();
    * v! O, Y6 g, z" t9 M" H
59.     //乘法
    " m* {) |" P$ }# K
60.     DoubleD(PI/6,TIMES,1);
    ; @, g4 ^- y* q0 V
61.     end_tim = HAL_GetTick();
    + m0 j  U1 A. r2 q. L9 u
62.     if(end_tim > start_tim)
    
63.     {
    $ w6 m/ `$ Q3 m; B2 ~2 u% {
64.         tim_cnt = end_tim - start_tim;
    1 N4 v0 x9 a- P+ J0 F; D
65.     }
    3 Z& ^. M5 p9 |* }
66.     else
    4 @- [" X' k5 G. I/ m" p& R
67.     {
    0 w' P& O$ N& ~! b
68.         tim_cnt = 0xffffffff - start_tim + end_tim;
    + [7 D0 b/ s6 q+ o: B* h% W
69.     }
    
70.     printf("双精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间     
    2 }: l) U. l+ `% c4 @9 T
71.     //-----------------测试双精度除法-------------------------------------------
    
72.     start_tim = HAL_GetTick();
    
73.     //除法
    ' @& u) |6 q  Y1 ]: k
74.     DoubleD(PI/6,TIMES,1);
    3 A1 k. ^( |% A" d0 x: S
75. 
    
76.     end_tim = HAL_GetTick();
    ' L2 |2 }: {7 b0 V4 L
77.     if(end_tim > start_tim)
    
78.     {
    ' b/ M+ j* R) n
79.         tim_cnt = end_tim - start_tim;
    
80.     }
    
81.     else
    0 ], B; n+ I6 m  `
82.     {
    
83.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
84.     }
    . v. L8 k/ D% W. w" M, ?+ T
85.     printf("双精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    % I% T. ^$ g) q5 j9 Y
86. 
    0 \7 d. t4 ~' R$ R3 Y4 p* s0 _
87. 
    + V- s, \! ^. q0 o/ U9 b8 g/ a
88.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    
89.     HAL_Delay(500);
    
90.   }
    4 R% ^% x5 @5 S/ ]/ p; _
91.   /* USER CODE END 3 */
    
92. }

复制代码

测试结果：
5 J) j# Y7 I+ g2 F) ^" c% c( P

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

+ ]6 y. Z" c4 j' b

（1）没有打开FPU

9 W3 m& Q2 G" S3 n- k4 E! R& r

（2）打开FPU

/ b3 k) A* [3 ]: c

数据比较

1 e5 o( j6 O4 v. c	打开FPU(ms)	关闭FPU(ms)	比例
单精度乘法	1	9	9
单精度除法	3	13	4.3
双精度乘法	17	16	0.9
双精度乘法	21	21	1

* T7 g: \/ C5 c' ~0 U

得出结论：

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

2 g5 X' y) ]! ~

4. DSP测试1

原理：

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。

! z* ^8 ]3 O% |4 j

5 W& c& H3 e, c& x2 r  v7 |

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

9 d5 s1 B' P/ p% W  M

减价宏定义ARM_MATH_CM4。

% [+ ^- Y1 z! m; T

测试主要代码：

运算函数：

1. 
   - {% I- u' g, J* U) ^
2. //sin cos测试
   
3. //angle:起始角度
   & z$ A( A/ s* h2 q
4. //times:运算次数
   
5. //mode:0,不使用DSP库;1,使用DSP库
   ) Y/ s$ n( f3 A3 D% F/ R
6. //返回值：0,成功;0XFF,出错
   
7. uint8_t sin_cos_test(float angle,uint32_t times,uint8_t mode)
   2 j8 r& ?- F7 f; W# v9 M- u3 ~. R
8. {
   
9.     float sinx,cosx;
   
10.     float result;
    
11.     uint32_t i=0;
    
12.     if(mode==0)
    
13.     {
    
14.         for(i=0;i<times;i++)
    
15.         {
    3 u2 F5 a& Q8 g8 |4 _
16.             cosx=cosf(angle);  //不使用DSP优化的sin，cos函数
    
17.             sinx=sinf(angle);
    : r2 H: |; g/ ^3 B
18.             result=sinx*sinx+cosx*cosx;//计算结果应该等于1  
    7 q2 K. _0 A7 ^0 U, d# @
19.             result=fabsf(result-1.0f);//对比与1的差值
    $ b- x* |# V# N" h5 h
20.             if(result>DELTA)
    . F' V) H1 \# o) M1 }8 c
21.             {
    
22.                 return 0XFF;      //判断失败
    
23.             }
    ! o. G) a9 ?2 S5 \# e6 }
24.             angle+=0.001f;         //角度自增
    
25.         }
    1 \2 l' |5 v5 t+ y, H" `
26.     }
    8 b9 ]; M: C7 t0 O" b0 d
27.     else
    
28.     {
    + a9 K/ y6 R/ a4 m0 F6 w: E% J
29.         for(i=0;i<times;i++)
    2 M& U" d/ a" i
30.         {
    
31.             cosx=arm_cos_f32(angle);//使用DSP优化的sin，cos函数
    % D% K4 S+ r9 x! e, n4 Z% w6 ]6 q
32.             sinx=arm_sin_f32(angle);
    
33.             result=sinx*sinx+cosx*cosx; //计算结果应该等于1  
    ( n, T$ g) V9 v) U
34.             result=fabsf(result-1.0f);    //对比与1的差值
    % D% Z/ [: x2 L0 w0 w  |
35.             if(result>DELTA)
    
36.             {
    
37.                 return 0XFF;//判断失败
    
38.             }
    
39.             angle+=0.001f;                //角度自增
    
40.         }
    , j9 t: B6 u0 m) I8 F7 a- J
41.     }
    & R% K* X* \' g1 `7 f& \" Q3 c
42.     return 0;//任务完成
    # h7 e' @4 w. A& a* @  m; H
43. }

复制代码

' z, }0 A) X$ w+ e

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

7 `5 I& G* T0 M! M

主函数

1. 
   7 e8 A6 c' z1 |
2. /**
   0 i3 l6 x7 z- [3 {7 J2 U) @6 U
3.   * @brief  The application entry point.
   
4.   * @retval int
   . f$ g3 }  b: m  ]8 u
5.   */
   # O1 |" _& v4 a: @4 I2 Z
6. int main(void)
   / B2 A0 B' E+ [$ y8 y" p. u/ ^
7. {
   
8.   /* USER CODE BEGIN 1 */
     u6 }" ^) M  U4 s4 G
9.   /* USER CODE END 1 */
   6 w7 y9 y+ f- ^
10.   /* MCU Configuration--------------------------------------------------------*/
    1 U6 G* p5 Z( j
11.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    8 }8 ?" |: r" m3 r2 j; n
12.   HAL_Init();
    
13.   /* USER CODE BEGIN Init */
    + v* R0 p/ I  d" k2 E! H
14.   /* USER CODE END Init */
    6 s6 J! z# \' X9 N8 N. ^3 C
15.   /* Configure the system clock */
      e  P7 @9 o, ]; D
16.   SystemClock_Config();
    8 {& T8 o. y( a6 L: I
17.   /* USER CODE BEGIN SysInit */
    
18.   /* USER CODE END SysInit */
    
19.   /* Initialize all configured peripherals */
    
20.   MX_GPIO_Init();
    
21.   MX_USART1_UART_Init();
    ; z- R# ^* I; V. C. [8 F
22.   MX_LPUART1_UART_Init();
    
23.   /* USER CODE BEGIN 2 */
    0 A. @" E3 j# M
24.   HAL_Init();
    
25.   /* USER CODE END 2 */
    
26.   /* Infinite loop */
    
27.   /* USER CODE BEGIN WHILE */
    " F7 K* s1 ]1 B6 ]; N/ S
28.   while (1)
    4 P; q4 r" w. M$ k- t0 J4 [8 S
29.   {
    4 q5 V# T- ?# p7 L3 B6 k
30.     /* USER CODE END WHILE */
    : r1 ]6 [# u) b, P
31.     /* USER CODE BEGIN 3 */
    
32.      //使用DSP优化
    
33.     start_tim = HAL_GetTick();
    + T3 a+ m5 d/ L! s7 H8 j1 [
34.     status = sin_cos_test(PI/6,200000,1);
    3 V* a/ ~% k6 P( E
35.     end_tim = HAL_GetTick();
      L% Y; O1 }" g4 j" b' b/ ?( O
36.     if(end_tim > start_tim)
    5 M) y+ C% l( I$ c
37.     {
    
38.         tim_cnt = end_tim - start_tim;
    
39.     }
    6 ]8 q% w( d  z! h' `
40.     else
      C0 D* _+ o# P) S! ^, e1 o
41.     {
    1 S5 W3 l# u  x% p4 y* K* j
42.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
43.     }
    
44.     if(status==0)
    / @; y# O/ |( ^: l
45.     {
    " E' M- K, E- n1 u6 L
46.         printf("USER DSP-- %d ms\r\n",tim_cnt);    //显示运行时间  
    + Z& w! x* [& y
47.     }      
    
48.     else
    
49.     {
      {7 c9 _7 ~/ y
50.         printf("USER DSP ERROR\n");    //显示当前运行情况   
    5 P! o0 {: g2 ?
51.     }      
      a! H. m6 O5 W! `1 L
52.     //不使用DSP优化        
    
53.     start_tim = HAL_GetTick();
    
54.     status = sin_cos_test(PI/6,200000,0);
    % r1 t+ l. q, ?" g( s9 P. S
55.     end_tim = HAL_GetTick();
    4 I" s1 t2 `6 a1 c& o
56.     if(end_tim > start_tim)
    # {( l% v; }: M, V* ?1 }
57.     {
      D; Y" N$ @+ w9 O- I+ n
58.         tim_cnt = end_tim - start_tim;
    
59.     }
    
60.     else
    % M6 n* P& \  l) K1 X  f5 i
61.     {
    
62.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
63.     }   
    
64. 
    
65.     if(status==0)
    
66.     {
    
67.         printf("NOT USER DSP-- %d-ms\r\n",tim_cnt);    //显示运行时间  
    " u, ~! b! C3 T4 v) j! z
68.     }      
    
69.     else
    
70.     {
    - |$ a' n9 c7 T" }$ [! A. n1 u
71.         printf("NOT USER DSP ERROR\n");    //显示当前运行情况   
    ! u' R/ q0 q2 g$ y5 `3 A: d1 ]
72.     }   
    
73.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    ; a( C0 Q5 w  W  x- X
74.     HAL_Delay(500);

复制代码

参数：angle : 起始角度 = π/6 ; times : 运算次数 = 10 000（1万）;
6 _5 F) @+ ]$ p& M  R. b

+ x' H4 p% A9 C3 v, D0 {3 f: H; }$ v  u

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

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

. O5 M0 S8 w& L$ E

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

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

) |9 v- K. ?9 o; j- }' c# J

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

. W- A( A0 }7 D

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

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