B* A& m% ?' i( y

资源篇

' Q' {1 A% _  ]; T: t' q6 i

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

( L2 I' L& l. z" K# GSTM32G474资源介绍：

9 {# t& D8 G: e; ~; z

+ b; J! X) g2 P

STM32G474开发板实物图：

4 v1 ?  K* E% f3 c' j" D2 x( n

▲ 开发板实物图

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

0 b/ k- o, [" N* U& ?

实战篇

" i1 f' t! x, ]3 N9 G+ |) ^

! x. A4 I  |. {3 r

测试内容：

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

1. LED和GPIO测试1

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

▲ 引脚配置

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

7 C! R* f7 K# {

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

- h; |( r. Y+ N4 T( S- @! w

代码：

2 T: h# u% \* P# e" `

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

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

2. VCP虚拟串口测试1

( i9 H" D. Y- k! |: M% z* `& S

（1） 原理：

MCU与stlik连接

6 E4 g9 Q% r6 {! S$ U; l

虚拟串口连接MCU的LPUART1
. X1 n; I/ F3 k& H8 w  J' J0 ?

（2） 配置工程：

相关代码：

  y3 T( L3 T6 [2 I5 T  j4 ~

9 s" L7 V$ H7 Z# H' s; Y6 e/ o

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

; j% v! N& B  j# B! ^( L0 K

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

& o5 P% v5 X3 P; }8 R

3．FPU性能测试1

原理：

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

步骤：

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

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

+ _. h, @+ `" p1 O( Q

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

1. 
   + @( e( l6 a2 j+ F
2. /**
   ' n( O" f1 q$ g1 ~
3.   * @name  DoubleD
   ) a7 c7 F9 V9 L- l0 e" C
4.   * @brief 双精度乘除法.
   & M$ c3 b6 b. ?7 g" k  q8 v  M
5.   * @param angle：起始值，times：计算次数，
   
6. *mod：1除法0乘法
   + W# t' T, @6 Y7 @7 ?1 q# a. J& ^- W
7.   */
   ( `' i2 z0 K+ R
8. void DoubleD(double angle,uint32_t times,uint8_t mode)
   % n/ z" l" S7 D: R- Z7 \2 j8 }& F
9. {
   
10.     uint32_t i;
    
11.     double result;
    2 V" k, i& Y; S2 G
12.     if(mode)//除法
    
13.     {
    , ]; v8 ^, k- s7 g, O
14.         for(i=0;i<times;i++)
    - J; x# }9 P$ ~3 j0 S+ U: ^
15.         {
    4 c5 I$ k$ k! `+ l7 L/ \8 l# |
16.             result = angle/PI;
    
17.             angle += 0.00001f;
    $ N3 ~4 T0 c* w$ H
18.         }        
    4 W$ p) K9 u) F  ^% V* y
19.     }
    
20.     else//乘法
    
21.     {
    
22.         for(i=0;i<times;i++)
    
23.         {
    : W( w; i0 D% L. m+ C# g2 N
24.             result = angle*PI;
    
25.             angle += 0.00001f;
    5 N+ g! ?( y/ e& z! y) n9 K, Z
26.         }
    
27.     }
    
28. }

复制代码

( I4 o6 K- }% w1 a4 r% m, I

# {, {2 I' v" C& {

1. 
   . x  _' ^' p. {% t& z  m* L
2. /**
   
3.   * @name  FloatXFloat
   
4.   * @brief 单精度乘除法.
   4 G! t2 f2 M/ e! E# f, H5 b2 ]
5. * @param angle：起始值，times：计算次数，*mod：1除法0乘法
   
6.   */
   
7. void FloatXFloat(float angle,uint32_t times,uint8_t mode)
   . D: K+ ?! D' ?) ^- w
8. {
   , U2 w  }8 _3 z. M- D/ W9 f- t
9.     uint32_t i;
   5 ^" _4 O4 O8 S, D
10.     float result;
    $ W* ~% N1 {. q9 K
11.     if(mode)//除法
    2 z2 @7 j( m1 y0 C4 W/ o& a
12.     {
    ) Q2 q# _7 G+ F" U% k% d) t
13.         for(i=0;i<times;i++)
    " h* [. b  Y; I( J
14.         {
    , G: j' ~0 f8 k6 \  ]
15.             result = angle/PI;
    
16.             angle += 0.00001f;
    
17.         }        
    $ G4 u# F3 W+ G/ C' b9 B* a
18.     }
    
19.     else//乘法
      W1 d# Y4 @" N3 L
20.     {
    
21.         for(i=0;i<times;i++)
    7 V6 E, H5 H' v- Z. v3 u! o3 c6 S
22.         {
    & D* n7 G) X' V/ {
23.             result = angle*PI;
    ' _6 j: ]) D) {( ^
24.             angle += 0.00001f;
    
25.         }
    
26.     }
    # m4 v9 Y/ a# X, L% s% Z8 h9 ~
27. }
    

复制代码

& G* S. V7 _+ t* l$ w" _/ v$ `

主函数
1 N9 y& M7 y5 A0 R/ J

1. 
   0 q  u! R2 h2 k! n6 D) p) I
2. int main(void)
   
3. {
   
4.   /* USER CODE BEGIN 1 */
   
5.   /* USER CODE END 1 */
   
6.   /* MCU Configuration--------------------------------------------------------*
   + U0 {7 o6 \( S! g3 l
7.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   + i% {& H2 e3 Q5 W7 b! S
8.   HAL_Init();
   
9.   /* USER CODE BEGIN Init */
   5 P5 q; D7 @0 V- D3 R' w0 N0 Q& @
10.   /* USER CODE END Init */
    
11.   /* Configure the system clock */
    
12.   SystemClock_Config();
    : e) i4 U0 [/ {9 D
13.   /* USER CODE BEGIN SysInit */
    
14.   /* USER CODE END SysInit */
    
15.   /* Initialize all configured peripherals */
    
16.   MX_GPIO_Init();
    
17.   MX_USART1_UART_Init();
    - `2 U2 x& J5 x4 {; m
18.   MX_LPUART1_UART_Init();
    
19.   /* USER CODE BEGIN 2 */
    
20.   HAL_Init();
    
21.   /* USER CODE END 2 */
    * m' O# {* L. k, u. `( J
22. /* Infinite loop */
    
23.   /* USER CODE BEGIN WHILE */
    
24.   while (1)
    
25.   {
    
26.     /* USER CODE END WHILE */
    , `% T. F1 z; ?8 p+ r: f
27.     /* USER CODE BEGIN 3 */
    - g& T7 v/ S9 [. j1 `
28.     printf("---------------NOT USER FPU----------------------\n");
    
29.     //-------------------测试单精度乘法----------------------------------------
    2 A# |6 Q0 F4 `& t- \
30.     start_tim = HAL_GetTick();   
    
31.     //乘法
    / Z1 b! u* ]. K8 B( R* c, Y/ q. J+ l
32.     FloatXFloat(PI/6,TIMES,0);      
    0 v  ]9 G* U2 `4 Y& ?
33.     end_tim = HAL_GetTick();
    
34.     if(end_tim > start_tim)
    + P  f8 O- c8 ?" i5 Z7 k
35.     {
    5 [+ L) W5 W( \& p* }. K6 x
36.         tim_cnt = end_tim - start_tim;
      w7 d0 W% w( v9 N7 f* L
37.     }
    & q  Q* j6 z6 K8 e- Q+ ^/ ^
38.     else
    
39.     {
    $ T: N& d! o4 o  h% G% y- p! |
40.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
41.     }
    / a( l5 x$ o. ]" v7 o, n7 N
42.     printf("单精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间  
    
43.     //-----------------测试单精度除法-------------------------------------------
    % D8 d/ {! x) I
44.     start_tim = HAL_GetTick();
    # L) B( U0 K2 G! k
45.     //除法
    + u; m  X5 M, v) o$ a, C) m$ P% O
46.     FloatXFloat(PI/6,TIMES,1);
    1 R& R+ k7 V1 w  Y
47.     end_tim = HAL_GetTick();
    
48.     if(end_tim > start_tim)
    
49.     {
    
50.         tim_cnt = end_tim - start_tim;
    
51.     }
    " o2 W! d* _& \' z1 U
52.     else
    . T9 M/ l/ X9 O6 O8 l
53.     {
    
54.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
55.     }
    ) A: L: C- \# {+ [  j7 z- Q
56.     printf("单精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    4 S. M7 [2 U% Q' E5 \0 Z
57.     //-----------------测试双精度乘法-------------------------------------------
    
58.     start_tim = HAL_GetTick();
    
59.     //乘法
    1 x' ?+ X4 v# G' T
60.     DoubleD(PI/6,TIMES,1);
    , ^! j3 w  e: O: R$ E2 j$ H
61.     end_tim = HAL_GetTick();
    
62.     if(end_tim > start_tim)
    ; k* F/ V$ z  m
63.     {
    # T) Q8 J) P- F" ?
64.         tim_cnt = end_tim - start_tim;
    : q# m# t: y1 ^- c2 r7 s: I2 S
65.     }
    
66.     else
    
67.     {
    
68.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
69.     }
    
70.     printf("双精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间     
    
71.     //-----------------测试双精度除法-------------------------------------------
    
72.     start_tim = HAL_GetTick();
    ; W' |- ?" T4 t5 j9 a
73.     //除法
    2 j7 b# o$ ?/ j5 b. W
74.     DoubleD(PI/6,TIMES,1);
    
75. 
    , o# B$ K! ?& I2 `2 z  b& I
76.     end_tim = HAL_GetTick();
    
77.     if(end_tim > start_tim)
    ; u. [1 D( X* D5 Y/ N
78.     {
    
79.         tim_cnt = end_tim - start_tim;
      [* A7 D, H# R
80.     }
    & D: O, t9 ]3 E- e: S$ m
81.     else
    
82.     {
    " p# ~, z7 n$ _7 r( e
83.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
84.     }
    9 |6 a) |: }4 E8 M
85.     printf("双精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    
86. 
    ! g0 F" s; t3 x2 s# P
87. 
    
88.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    ) i/ p7 d6 _3 o4 A% s* k
89.     HAL_Delay(500);
    ' M  j6 K" H0 j
90.   }
    
91.   /* USER CODE END 3 */
    
92. }

复制代码

测试结果：

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

) m2 E- n( W$ @3 r; z! o  y- i

（1）没有打开FPU

) z5 Y: @  k- K) }7 r9 F0 N- ?& w/ ^

（2）打开FPU

& B- t, ~' Z* `

数据比较

/ E' [# I4 }% c) ^+ f, u	打开FPU(ms)	关闭FPU(ms)	比例
单精度乘法	1	9	9
单精度除法	3	13	4.3
双精度乘法	17	16	0.9
双精度乘法	21	21	1

7 r$ g9 |  z) V7 C

得出结论：

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

4. DSP测试1

) {, ?# t" q  N5 B: c0 x3 }

原理：

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。

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

减价宏定义ARM_MATH_CM4。

* y0 v( i4 c' q4 O2 D

测试主要代码：

运算函数：

1. 
   $ G$ Q) K( W  |4 Y; |
2. //sin cos测试
   & R% i2 H; j' W3 ?7 {* R
3. //angle:起始角度
   
4. //times:运算次数
   
5. //mode:0,不使用DSP库;1,使用DSP库
   
6. //返回值：0,成功;0XFF,出错
   ' m- y! }5 R. k1 ~) {& O
7. uint8_t sin_cos_test(float angle,uint32_t times,uint8_t mode)
   7 P  A% e8 m4 c
8. {
   ! y5 Z& z, b: {
9.     float sinx,cosx;
   1 n8 G# P: y& \
10.     float result;
    
11.     uint32_t i=0;
    
12.     if(mode==0)
    
13.     {
    
14.         for(i=0;i<times;i++)
    
15.         {
    
16.             cosx=cosf(angle);  //不使用DSP优化的sin，cos函数
    # O6 O4 b; H2 c1 c9 Y4 H+ `
17.             sinx=sinf(angle);
    
18.             result=sinx*sinx+cosx*cosx;//计算结果应该等于1  
    
19.             result=fabsf(result-1.0f);//对比与1的差值
    
20.             if(result>DELTA)
    4 \  u3 ]/ W% j) g' |
21.             {
    
22.                 return 0XFF;      //判断失败
    
23.             }
      b8 B1 S3 P; P
24.             angle+=0.001f;         //角度自增
    1 {5 D$ a0 x, J, \
25.         }
    ; t" S. k- p! {! u5 [3 {/ o
26.     }
    
27.     else
    
28.     {
    : e8 u8 |2 Y$ ]( L" Y7 g+ }7 q
29.         for(i=0;i<times;i++)
    ( C7 s0 h- Y$ e! D
30.         {
    
31.             cosx=arm_cos_f32(angle);//使用DSP优化的sin，cos函数
    & b( F. q$ i* x) B6 V
32.             sinx=arm_sin_f32(angle);
    ) [" _( j* f2 O
33.             result=sinx*sinx+cosx*cosx; //计算结果应该等于1  
    ; z" G0 ]7 a: r7 Z7 s, H- D, `& ?
34.             result=fabsf(result-1.0f);    //对比与1的差值
    
35.             if(result>DELTA)
    ' ]3 d+ q4 J/ I5 T3 _4 A
36.             {
    / J$ p$ E+ z+ p# n% j$ ^
37.                 return 0XFF;//判断失败
    
38.             }
    : U' S: R1 x1 q: t
39.             angle+=0.001f;                //角度自增
    
40.         }
    3 v! ?# l/ x8 t' f7 k0 N/ }
41.     }
    
42.     return 0;//任务完成
    ! ^( }" d; G: M7 ^4 k
43. }

复制代码

% c& }. B  o% @2 y/ D

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

/ C, u: d* @& K/ T( }. m

主函数

1. 
   
2. /**
   6 e1 f% I  a' G, c( F4 p5 J
3.   * @brief  The application entry point.
   
4.   * @retval int
   : s& D# H4 M' r- O
5.   */
   2 F; o  ^$ z4 X9 R( v; U: m6 [
6. int main(void)
   
7. {
   
8.   /* USER CODE BEGIN 1 */
   , @$ N) w2 d1 {0 u9 C) l4 O$ s/ j
9.   /* USER CODE END 1 */
   7 H  h; D: P9 i1 Z+ ?& I7 p( c. Q
10.   /* MCU Configuration--------------------------------------------------------*/
    
11.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    + ~3 R, J: d( o7 i
12.   HAL_Init();
    
13.   /* USER CODE BEGIN Init */
    
14.   /* USER CODE END Init */
    
15.   /* Configure the system clock */
    , |% d1 S6 t; ^# m/ z/ @8 ]; I
16.   SystemClock_Config();
      h0 _+ Q3 y0 N* V1 B6 u+ f8 R) g. [% ?
17.   /* USER CODE BEGIN SysInit */
    
18.   /* USER CODE END SysInit */
    0 a1 I5 d6 J' }( s- i& |: {
19.   /* Initialize all configured peripherals */
    
20.   MX_GPIO_Init();
    / z! {& v0 F* n! H
21.   MX_USART1_UART_Init();
    5 M" _  A8 r3 B
22.   MX_LPUART1_UART_Init();
    7 }6 G: o! G  x, \" b
23.   /* USER CODE BEGIN 2 */
    + d2 O* G4 i0 G
24.   HAL_Init();
    % h. l, D; U. R+ K0 W- b5 ]/ Q
25.   /* USER CODE END 2 */
    
26.   /* Infinite loop */
    
27.   /* USER CODE BEGIN WHILE */
    5 J, B0 ^9 ]4 S/ t
28.   while (1)
    
29.   {
    
30.     /* USER CODE END WHILE */
    ) u( P! g7 Z: j7 N
31.     /* USER CODE BEGIN 3 */
    
32.      //使用DSP优化
    ! J' V- C  D, p2 e9 k
33.     start_tim = HAL_GetTick();
    
34.     status = sin_cos_test(PI/6,200000,1);
    ; E$ Y9 n/ Z; o2 @; `3 j
35.     end_tim = HAL_GetTick();
    6 b  O9 I2 R8 r! x* @! i& s/ M
36.     if(end_tim > start_tim)
    & p" Z' U1 ?8 J! `* L
37.     {
    
38.         tim_cnt = end_tim - start_tim;
    ' w$ l5 L" ?& Q% l) i3 B
39.     }
    , d7 f( W4 X* K2 T) n
40.     else
    
41.     {
    
42.         tim_cnt = 0xffffffff - start_tim + end_tim;
    $ W8 i5 @. x7 w" S$ _
43.     }
    
44.     if(status==0)
    
45.     {
    & X8 U; j& e' X2 J4 S( L, U% _
46.         printf("USER DSP-- %d ms\r\n",tim_cnt);    //显示运行时间  
    ) d- v  g4 q) {  v
47.     }      
    * F9 O1 U3 E9 w. \; u# ^4 _1 J( x
48.     else
    
49.     {
    
50.         printf("USER DSP ERROR\n");    //显示当前运行情况   
    * |& `; C! Q: ^
51.     }      
    ( d+ d# F& B0 [0 x# X0 I; P" s7 S+ h
52.     //不使用DSP优化        
    
53.     start_tim = HAL_GetTick();
    
54.     status = sin_cos_test(PI/6,200000,0);
    : b  m6 _) T7 b5 @  Q) H
55.     end_tim = HAL_GetTick();
    
56.     if(end_tim > start_tim)
    
57.     {
    
58.         tim_cnt = end_tim - start_tim;
    : h6 S3 U, _! N- Y: P' `0 p6 o
59.     }
    
60.     else
    , X& f9 M/ h( H
61.     {
    ) \% n& A; Y  a* {# M
62.         tim_cnt = 0xffffffff - start_tim + end_tim;
    8 G( K) \. Q7 a6 J& K4 j6 c' c
63.     }   
    
64. 
    
65.     if(status==0)
    5 C5 |# J$ A" d% v4 O) ^
66.     {
    
67.         printf("NOT USER DSP-- %d-ms\r\n",tim_cnt);    //显示运行时间  
    
68.     }      
    & \4 B/ z( S' Y  ]
69.     else
    ; E. c6 K$ m0 C
70.     {
    * q, W$ M' R, u
71.         printf("NOT USER DSP ERROR\n");    //显示当前运行情况   
    # v! G$ p7 W+ @
72.     }   
    1 D% m* T+ \# g
73.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    3 J* t( S4 l- u3 ?$ {
74.     HAL_Delay(500);

复制代码

# z4 ?# d2 z, k) [

参数：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倍。

2 A! H, f/ j- Q! o8 Q5 `4 O

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

7 R% S- h! g+ t7 o

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

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

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