: z" b. K6 g+ Y) C

资源篇

& p4 c5 W: M9 ]: L% \

5 v* G+ t8 f; \- ]

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

0 m- K; }7 K" ?' KSTM32G474资源介绍：

STM32G474开发板实物图：

▲ 开发板实物图

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

2 y; _+ |5 O: T, m) k9 \$ N4 r) T

实战篇

& V6 L( s$ u/ v- d, o

测试内容：

• IO测试
• 虚拟串口VCP测试
• FPU测试
• DSP测试
  + q% y; s4 }8 B+ W

1. LED和GPIO测试1

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

▲ 引脚配置

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

$ h2 U7 m; k* k9 Y

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

5 H$ v. d7 N$ ~

代码：

% i/ s) j. e9 @: k

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

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

2. VCP虚拟串口测试1

（1） 原理：

MCU与stlik连接

虚拟串口连接MCU的LPUART1
# T) i1 \5 [8 W9 A  A8 n

（2） 配置工程：

相关代码：

; L5 {( F' t7 K8 X9 K

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

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

3．FPU性能测试1

  D: r, T+ p! p8 Y4 C+ G5 X

原理：

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

步骤：

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

% o/ I. q- h7 k/ w

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

* w$ e* E7 f, u' D

% B7 {- i. W% T3 k( v* N

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

1. 
   
2. /**
   * @. T6 O% J, l; @- F" q5 t
3.   * @name  DoubleD
   + B* I+ L' J% D$ l: H% B$ Q
4.   * @brief 双精度乘除法.
   
5.   * @param angle：起始值，times：计算次数，
   0 p. H3 W3 v/ e' y
6. *mod：1除法0乘法
   
7.   */
   
8. void DoubleD(double angle,uint32_t times,uint8_t mode)
   - z& J! h) P' U6 C1 U
9. {
   
10.     uint32_t i;
    0 Y1 N& E2 w8 X9 j# j' n5 \# \
11.     double result;
    . b4 I; s8 M' Q0 L* N  A. o
12.     if(mode)//除法
    
13.     {
    
14.         for(i=0;i<times;i++)
    8 r, @1 G/ h# ^: u& Q% F
15.         {
    
16.             result = angle/PI;
    " M/ l. }7 }7 N0 L7 _
17.             angle += 0.00001f;
    4 F- b3 M& [( R% z: F
18.         }        
    " A" ]. \5 F7 i1 u( |
19.     }
    
20.     else//乘法
    0 q" }2 L. i2 Z. ~
21.     {
    
22.         for(i=0;i<times;i++)
    8 d0 s/ Z' c$ Q1 b9 I# R# v
23.         {
    
24.             result = angle*PI;
    
25.             angle += 0.00001f;
    
26.         }
    7 u  F: P+ C9 m  I- W4 L% Y
27.     }
    
28. }

复制代码

+ p" ^" p: K6 D* H+ ~; j/ g+ ?

" b! b% Y7 t* j, y0 e/ H6 G

1. 
   
2. /**
   
3.   * @name  FloatXFloat
   3 N" n8 C) d1 g; u' x2 t+ y
4.   * @brief 单精度乘除法.
   + L3 c1 k; @5 D# q$ V! Q8 |
5. * @param angle：起始值，times：计算次数，*mod：1除法0乘法
   $ }2 M  z5 O$ K$ H% {- \/ u) M
6.   */
   
7. void FloatXFloat(float angle,uint32_t times,uint8_t mode)
   3 X7 M+ k& Q9 k2 p# A6 G* ?
8. {
   ; N+ g/ X2 c7 J  d9 g$ q
9.     uint32_t i;
   
10.     float result;
    / N* x; r% w, ^: e3 k
11.     if(mode)//除法
    
12.     {
    1 Q7 H$ q. ~: F3 v9 x0 c
13.         for(i=0;i<times;i++)
    3 L4 U+ h. v  r' k) n  \2 T+ N
14.         {
    
15.             result = angle/PI;
    
16.             angle += 0.00001f;
    7 I, d: [5 ^% _2 q
17.         }        
    * Q; d6 h( L, ]
18.     }
    
19.     else//乘法
    
20.     {
    
21.         for(i=0;i<times;i++)
    
22.         {
    
23.             result = angle*PI;
    
24.             angle += 0.00001f;
    % ?& E8 x# i* J! w. h0 M5 B
25.         }
    
26.     }
    
27. }
    ; G' X& C0 K% y

复制代码

' J" T; o6 n2 E/ k

主函数
/ b8 V: r3 c8 R; }; d8 Q. b" M

1. 
   
2. int main(void)
   
3. {
   - r; y* f, k. V2 }1 u) @6 @7 n
4.   /* USER CODE BEGIN 1 */
   
5.   /* USER CODE END 1 */
   
6.   /* MCU Configuration--------------------------------------------------------*
   
7.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
8.   HAL_Init();
   6 ~4 Z# X. s  O. ?! c, @- Q& y+ m
9.   /* USER CODE BEGIN Init */
   
10.   /* USER CODE END Init */
    
11.   /* Configure the system clock */
    
12.   SystemClock_Config();
    * E3 _& b" ]/ Y9 |+ d8 t; I
13.   /* USER CODE BEGIN SysInit */
    / m$ R* k5 S% f% e) ^& s
14.   /* USER CODE END SysInit */
    
15.   /* Initialize all configured peripherals */
    
16.   MX_GPIO_Init();
    
17.   MX_USART1_UART_Init();
    
18.   MX_LPUART1_UART_Init();
    
19.   /* USER CODE BEGIN 2 */
    9 n1 \) J; v3 `8 t
20.   HAL_Init();
    . \; d8 N; d5 T7 ^: B  g" q. J
21.   /* USER CODE END 2 */
    
22. /* Infinite loop */
    
23.   /* USER CODE BEGIN WHILE */
    
24.   while (1)
    1 b% `, v. t* F2 G% J  }! `( k
25.   {
    
26.     /* USER CODE END WHILE */
    
27.     /* USER CODE BEGIN 3 */
    3 t" E; ^2 N$ w7 M( E7 n& B
28.     printf("---------------NOT USER FPU----------------------\n");
    7 \+ D& V0 L; T% a
29.     //-------------------测试单精度乘法----------------------------------------
    
30.     start_tim = HAL_GetTick();   
    
31.     //乘法
    . B7 c/ Z( Y! `. I; \8 G- C
32.     FloatXFloat(PI/6,TIMES,0);      
    8 X8 g/ `+ y5 `5 l
33.     end_tim = HAL_GetTick();
    
34.     if(end_tim > start_tim)
    - i+ n  z3 g) K1 V
35.     {
    
36.         tim_cnt = end_tim - start_tim;
    
37.     }
    . t0 r# f4 H& \; P+ z
38.     else
    ; z( R1 t+ c4 ~: S0 @& N' E8 E  i
39.     {
    / P0 Q3 D2 U" O0 u
40.         tim_cnt = 0xffffffff - start_tim + end_tim;
    $ X: }# u" k% u
41.     }
    
42.     printf("单精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间  
    8 m. a3 p* T6 u) ^% ~9 N
43.     //-----------------测试单精度除法-------------------------------------------
    
44.     start_tim = HAL_GetTick();
    
45.     //除法
    
46.     FloatXFloat(PI/6,TIMES,1);
    
47.     end_tim = HAL_GetTick();
    : f; {' Y$ H: `) W$ M# b. W) t; N
48.     if(end_tim > start_tim)
    % v2 T' U5 F( T# p8 B  S5 [
49.     {
    2 U; d2 T, t  d. U) L
50.         tim_cnt = end_tim - start_tim;
    6 e9 V' K; N3 U* p- q
51.     }
    - F9 V: S/ B' K) Y& ]" r
52.     else
    3 a7 k5 B$ x1 _( o8 U% d
53.     {
    
54.         tim_cnt = 0xffffffff - start_tim + end_tim;
    4 a5 n$ Q+ @+ |+ ]' g* f9 Q# H
55.     }
    
56.     printf("单精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    
57.     //-----------------测试双精度乘法-------------------------------------------
    % y6 F: |4 I+ ^/ V
58.     start_tim = HAL_GetTick();
    ' d8 j% d' p! F9 [8 f
59.     //乘法
    
60.     DoubleD(PI/6,TIMES,1);
    2 G% q7 D% m3 o. |
61.     end_tim = HAL_GetTick();
    % P6 ~' |4 M1 G2 C8 ]7 x6 l* n( a) J
62.     if(end_tim > start_tim)
    
63.     {
    ( c( o( k  F1 u# Z+ K" T
64.         tim_cnt = end_tim - start_tim;
    
65.     }
    
66.     else
    0 |4 q+ T# ?& h  q' H, \. K
67.     {
    
68.         tim_cnt = 0xffffffff - start_tim + end_tim;
    8 G2 [, I- W  r1 f: w4 {
69.     }
    6 P* G5 c% C& G% n
70.     printf("双精度乘法-- %d ms\r\n",tim_cnt);    //显示运行时间     
    
71.     //-----------------测试双精度除法-------------------------------------------
    
72.     start_tim = HAL_GetTick();
    
73.     //除法
    6 ^3 k- O5 p+ O
74.     DoubleD(PI/6,TIMES,1);
    
75. 
    
76.     end_tim = HAL_GetTick();
    
77.     if(end_tim > start_tim)
    
78.     {
    4 R/ [5 M7 a5 P; e! G
79.         tim_cnt = end_tim - start_tim;
    4 I/ j! h7 p7 H" s8 o
80.     }
    ) |! r! d; k7 o+ D/ x7 {6 _
81.     else
    
82.     {
    
83.         tim_cnt = 0xffffffff - start_tim + end_tim;
    - {5 U, O% P, R6 V. E* ]1 _
84.     }
    
85.     printf("双精度除法-- %d ms\r\n",tim_cnt);    //显示运行时间
    
86. 
    
87. 
    
88.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    
89.     HAL_Delay(500);
    $ Y/ s. P5 x) }& @! J
90.   }
    
91.   /* USER CODE END 3 */
    . Q: W, h7 ^: H0 A
92. }

复制代码

* F$ l) Q  G9 {5 Q8 s  E% X; @

测试结果：
! f9 D' l( G8 y) ^7 R0 w& \

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

（1）没有打开FPU

3 a' Y2 j4 @# X+ {; W+ V

（2）打开FPU

数据比较

	打开FPU(ms)	关闭FPU(ms)	比例
单精度乘法	1	9	9
单精度除法	3	13	4.3
双精度乘法	17	16	0.9
双精度乘法	21	21	1

; A2 d$ ]* O& N$ v# |) s5 D8 z

得出结论：

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

/ h: O( I# R7 l* |) o

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。

4 _# Z" W4 t4 W

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

减价宏定义ARM_MATH_CM4。

6 c" o  y- \3 _& ?2 {2 b9 T

测试主要代码：

运算函数：

1. 
   ' ~8 d9 |1 ?; x; `8 s2 f+ Y
2. //sin cos测试
   
3. //angle:起始角度
   + P: Q8 x; I7 c: O4 o/ F3 n; c
4. //times:运算次数
   
5. //mode:0,不使用DSP库;1,使用DSP库
     x9 {' W: y3 y; w- D
6. //返回值：0,成功;0XFF,出错
   
7. uint8_t sin_cos_test(float angle,uint32_t times,uint8_t mode)
   
8. {
   * v0 F1 d, M2 ^( _3 h% Q' n$ E
9.     float sinx,cosx;
   - P6 b$ W1 I6 V7 s0 e$ _
10.     float result;
    
11.     uint32_t i=0;
    
12.     if(mode==0)
    1 `9 U, r/ x4 V2 s
13.     {
    ' `4 i( r" Z+ K' I$ D& }
14.         for(i=0;i<times;i++)
    + F7 R3 s7 S* ?
15.         {
    ! T. [; t" h; o) ?
16.             cosx=cosf(angle);  //不使用DSP优化的sin，cos函数
    
17.             sinx=sinf(angle);
    , _/ K- u. \3 `# V9 h4 M* F
18.             result=sinx*sinx+cosx*cosx;//计算结果应该等于1  
      [/ i; A$ ^+ t, Q, B8 c% |
19.             result=fabsf(result-1.0f);//对比与1的差值
    : D+ n7 k, K7 |* E! y/ J- A0 ]# s
20.             if(result>DELTA)
    
21.             {
    
22.                 return 0XFF;      //判断失败
    
23.             }
    
24.             angle+=0.001f;         //角度自增
    % `1 J, z" U& [2 S& p6 T
25.         }
    , k5 R* K/ ]& n, g
26.     }
    1 Z( t+ `& C) d  ]
27.     else
    
28.     {
    , `, D+ k8 h' Y8 J; g
29.         for(i=0;i<times;i++)
    / Z: i8 g/ G, |% ?$ Q$ y+ a
30.         {
    & [/ I. B8 \% ]- I" Q5 u8 Y; _$ J
31.             cosx=arm_cos_f32(angle);//使用DSP优化的sin，cos函数
    0 }* f. W; |0 L0 f6 d# q: ^# _
32.             sinx=arm_sin_f32(angle);
    
33.             result=sinx*sinx+cosx*cosx; //计算结果应该等于1  
    
34.             result=fabsf(result-1.0f);    //对比与1的差值
    5 R1 q: L; o: k6 U+ ^! y
35.             if(result>DELTA)
    
36.             {
    ) G# \0 N. z7 A& S2 i
37.                 return 0XFF;//判断失败
    " g* V) d: @, M- b  c
38.             }
    2 E0 T+ L1 H6 Q/ |4 |/ i; |
39.             angle+=0.001f;                //角度自增
    4 p% x3 l' @5 J2 f* U8 ~: H
40.         }
    ' `4 x8 p( }; E) ?9 y0 `. a+ x
41.     }
    
42.     return 0;//任务完成
    
43. }

复制代码

% y# O$ Q. k% M, R

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

主函数

1. 
   * C8 u: T8 }* w
2. /**
   8 O2 O$ i$ J: F8 n/ j
3.   * @brief  The application entry point.
   + f) p9 [' ^4 R& W; y# d- E2 t
4.   * @retval int
   
5.   */
   : V6 |3 h, h! {8 ]' A/ m3 Y( h
6. int main(void)
   2 X& z9 z  s: J* U( K1 D, H
7. {
   : w) ~/ k) d$ I) s0 ^
8.   /* USER CODE BEGIN 1 */
   # ^/ j+ M# x5 e  w4 |# Q
9.   /* USER CODE END 1 */
   6 |4 X9 Q4 ~# M8 l1 u8 D
10.   /* MCU Configuration--------------------------------------------------------*/
    
11.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
12.   HAL_Init();
    1 u/ R: ~) P. T; V( t: H
13.   /* USER CODE BEGIN Init */
    
14.   /* USER CODE END Init */
    
15.   /* Configure the system clock */
    
16.   SystemClock_Config();
    ' ?) ?, `! J( O/ K: a' _  e
17.   /* USER CODE BEGIN SysInit */
    + x: f; ?% K# N4 f. p
18.   /* USER CODE END SysInit */
    & m0 ~: Y, p; ]) }+ p  d* @
19.   /* Initialize all configured peripherals */
    , U  d" M$ _7 W$ ^1 \
20.   MX_GPIO_Init();
    
21.   MX_USART1_UART_Init();
    " R( P% Z, A" P. x9 A: M% d& {& W, T9 {
22.   MX_LPUART1_UART_Init();
    
23.   /* USER CODE BEGIN 2 */
    ! z. k- c" L7 c3 ^9 {
24.   HAL_Init();
    
25.   /* USER CODE END 2 */
    0 @3 T" {0 f7 `6 a
26.   /* Infinite loop */
    ; L9 o% {) o( J5 s! r* B1 o. }
27.   /* USER CODE BEGIN WHILE */
    * L; ]4 p8 c4 h9 |7 M; J
28.   while (1)
    
29.   {
    
30.     /* USER CODE END WHILE */
    0 V4 a# k- Y! [) ]0 I( h
31.     /* USER CODE BEGIN 3 */
    
32.      //使用DSP优化
    
33.     start_tim = HAL_GetTick();
    
34.     status = sin_cos_test(PI/6,200000,1);
      @% P/ Q0 A; l" ]8 a
35.     end_tim = HAL_GetTick();
    9 F# Q" K! Y+ t+ k; a+ c) s4 `
36.     if(end_tim > start_tim)
    
37.     {
    
38.         tim_cnt = end_tim - start_tim;
    
39.     }
    
40.     else
    
41.     {
    8 ?8 d1 A( [1 ]% D0 S. O0 v- u% _
42.         tim_cnt = 0xffffffff - start_tim + end_tim;
    + F& o* b. [4 l' c+ ~
43.     }
    
44.     if(status==0)
    9 A0 \  \  P2 t' M- G0 u
45.     {
    ; n0 y$ Z. Y# z! T" i, M
46.         printf("USER DSP-- %d ms\r\n",tim_cnt);    //显示运行时间  
    
47.     }      
    ! r( }. N" X0 O* j( _
48.     else
    & |; S: E: }" Z. y# j
49.     {
    " u1 b2 Y! B0 x* k6 E) j* D* P  I9 @
50.         printf("USER DSP ERROR\n");    //显示当前运行情况   
    8 q& z: L" X# E8 ]* C" f
51.     }      
    
52.     //不使用DSP优化        
    
53.     start_tim = HAL_GetTick();
    
54.     status = sin_cos_test(PI/6,200000,0);
    
55.     end_tim = HAL_GetTick();
    9 `3 z- o' I' @5 L8 k  K; P
56.     if(end_tim > start_tim)
    
57.     {
    
58.         tim_cnt = end_tim - start_tim;
    , [. F/ ^5 a* b5 D
59.     }
    
60.     else
    ; |1 J+ X8 }) Q1 L7 n$ W8 @1 a# D
61.     {
    # r+ a3 n  i$ c/ r$ |
62.         tim_cnt = 0xffffffff - start_tim + end_tim;
    
63.     }   
    7 Z$ {" e+ Z& B$ x6 u# q
64. 
    0 ~8 D* A( c; n" p* u% g$ n* \/ k
65.     if(status==0)
    ; V# p  `! H* _5 x7 C" B1 s- K9 h4 l7 t
66.     {
    
67.         printf("NOT USER DSP-- %d-ms\r\n",tim_cnt);    //显示运行时间  
    
68.     }      
    
69.     else
    
70.     {
    
71.         printf("NOT USER DSP ERROR\n");    //显示当前运行情况   
    : O8 C) t4 ]! [/ J* M/ F0 T; y, ~' Y
72.     }   
    $ @1 a7 T7 n/ p0 h! g/ c" r
73.     HAL_GPIO_TogglePin(USER_LED_GPIO_Port,USER_LED_Pin);      
    
74.     HAL_Delay(500);

复制代码

! l4 Q9 J) M' I! P% W- Q0 c7 A6 m2 r

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

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

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

1 C5 w, {2 z5 _2 m3 S

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

7 O' m) d$ F# Z4 Z5 r- W) E! g

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

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

# q5 \3 Y6 V4 M* Z6 g# n

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

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