概述
' Z' ?" `& r8 }+ K' `本篇文章主要介绍如何使用STM32CubeMX移植到雅特力AT32F403AVGT7，并通过双串口输出打印。
2 ]4 B0 k2 O+ _/ V+ }直接存储器访问（DMA)用于在外设与存储器之间以及存储器与存储器之间提供高速数据传输。可以在无需任何CPU操作的情况下通过DMA快速传输传输。这样节省的CPU资源可供其它操作使用。
9 i, ~- l( a2 J! ?7 _
DMA允许在后台执行数据传输，无需Cortex-M3处理器干预。在此操作过程中，主处理器可以执行其它任务，仅当整个数据块需要处理时，才会中断主处理器。这样即使传输大量数据也不会对系统性能造成太大影响。
$ c, P! L/ E  A. _/ n5 \9 k
DMA主要用于为不同的外设模块实现集中数据缓冲存储（通常在系统SRAM中）。与分布式解决方案（其中每个外设都需要实现自己的本地数据存储）相比，DMA解决方案在硅片成本和功耗方面的成本较低。
! s7 p& |+ O/ _. i7 n/ _
! L0 y; a' u* k4 X" B根据使用的产品型号的不同，有一个或两个DMA模块。
# }5 ~! C' i; ~$ \% r
本篇文章主要介绍如何使用STM32CubeMX实现串口DMA读取，并且打印出去。
, N6 H; h- S- P1 |5 J
, |! {* R9 f! [, H& J; n
+ T- [2 W- X7 G. y" H
硬件准备
% f5 g, S6 b  X& z! D. S, U首先需要准备一个开发板，这里我准备的是雅特力AT32F403AVGT7的开发板：


7 i3 E' y8 @1 j5 Z
0 x; ~1 V* r( L. l, f, {* Z选择芯片型号
4 b$ ?4 I2 j( Z; {* o雅特力AT32F403AVGT7兼容STM32F103系列，故选取STM32f103VG进行开发。
6 Y! u  Q1 W6 N0 w/ b3 i% |. ]
; F8 {" \# Q; i: x  I0 S0 @! f

配置时钟源
HSE与LSE分别为外部高速时钟和低速时钟，在本文中使用内置的时钟源，故都选择Disable选项，如下所示：
8 b$ n# @$ s2 }. t$ }
. N0 w) y( V  g& B
5 a. b. W9 y) x4 V* M
配置时钟树
$ W2 L* b- B* n雅特力AT32F403AVGT7最高频率到240M，但是STM32F1的最高主频到72M，同时使用不使用外部晶振时候，最高速度只能到64M，所以配置64即可：

. x& R/ C% A( f8 ]
2 l% L+ |, k, |* q' z* G5 p
串口配置
4 W! x2 M- S# A5 o! U本次实验使用的串口2，串口3进行串口通信，波特率配置为115200。
# g8 S9 v& o! V5 h
4 }% [9 H2 g8 b' ~  r- e5 c



配置DMA
在DMA 设置中,Mode有两种模式，一种是普通模式(Normal)，使用一次发送语句就发一次，另一种是循环模式(Circula)，使用一次发送会一直发送。这里接收选择循环模式。





中断
. V5 Q# r% q# I  X在中断设置里打开串口2,3的中断。
) h  Y% S- e: y" H& X
( ]$ A- K  ?+ A' d0 f

生成工程设置
* S  |, i4 b6 }% F3 F注意在生产工程设置中不能出现中文，不然会报错。



代码生成设置
最后设置生成独立的初始化文件


. `' F' B3 s" ?: ?1 O
/ B$ [8 w, p) R2 S1 b生成代码
5 L5 G: ]* {# v

8 A) E/ c/ Q: |, n8 S9 t
代码编写
: f  S  d# ?3 h0 ]# R4 ]- N6 s! k在main.c中，添加头文件，若不添加会出现 identifier “FILE” is undefined报错。

8 h8 p4 d- B8 a! a

1. /* USER CODE BEGIN Includes */
   
2. #include "stdio.h"
   3 r2 ^% ?8 H: B5 K% q
3. /* USER CODE END Includes */

复制代码

+ n! @& f. H* v. z$ t变量定义 ，在main.c中添加。
6 a! X& c. i+ m

1. /* USER CODE BEGIN PV */
   
2. #define BUFFERSIZE_usart2 1000           //可以接收的最大字符个数      
   ! M, y- v  y3 N$ f- }% t  h; n
3. uint8_t ReceiveBuff_usart2[BUFFERSIZE_usart2]; //接收缓冲区
   ; v- b( ]# `! O$ v
4. uint8_t recv_end_flag_usart2 = 0,Rx_len_usart2;//接收完成中断标志，接收到字符长度
   
5. 
   , \& }4 w3 ~" m' @# j4 d; ~
6. #define BUFFERSIZE_usart3 1000           //可以接收的最大字符个数      
   ' V! ~3 p% T, t; b
7. uint8_t ReceiveBuff_usart3[BUFFERSIZE_usart3]; //接收缓冲区
   
8. uint8_t recv_end_flag_usart3 = 0,Rx_len_usart3;//接收完成中断标志，接收到字符长度
   
9. int f1_u1 = 0;
   + {1 B4 [, S* P8 ]( {
10. /* USER CODE END PV */

复制代码

  Q) [+ a% A0 {函数声明和串口重定向，这里使用串口3进行打印，在main.c中添加。
4 e# [) V, a" q4 ^# x& Q& ^
& e( E( r/ l7 F3 J

1. /* USER CODE BEGIN PFP */
   4 M9 U; F8 k+ \- f+ Z
2. void uart2_data(void);                                        //接收函数
   5 Z0 M! v- C- J1 b3 A' n6 S
3. void uart3_data(void);                                        //接收函数
   / K$ U8 L$ x' H  W
4. #ifdef __GNUC__                                                                        //串口重定向
   
5. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   
6. #else
   
7. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   8 ?( M" Q" G# T+ A3 D
8. #endif
   : G6 _, N7 ~' M+ c3 H4 e) }0 z
9. PUTCHAR_PROTOTYPE
   " S' J( W  C1 K
10. {
    1 E8 M3 k9 w0 s9 e3 k* Y% Z
11.     HAL_UART_Transmit(&huart3 , (uint8_t *)&ch, 1, 0xFFFF);
    
12.     return ch;
    
13. }
    
14. /* USER CODE END PFP */

复制代码

开启串口IDLE中断，在main.c中添加。
6 F" d% N7 W% Z5 k/ M/ y1 \

1.   /* USER CODE BEGIN 2 */
   ( C6 k1 n6 }; u5 o) R8 V
2.   __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);//使能串口2 IDLE中断
   
3.         __HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);//使能串口2 IDLE中断
   2 Y! o; u1 U6 ?0 Y! I
4.                 printf("双串口DMA接收例程\r\n");
   
5.   /* USER CODE END 2 *

复制代码

; |% H, F3 k8 I5 B2 F* w$ }2 R串口DMA获取，在main.c中添加。
7 y3 x1 C, z+ i0 C6 [

1. void uart2_data(void)
   
2. {
   
3.         if(recv_end_flag_usart2 ==1)//接收完成标志
     q* E/ i. y, F  E# G$ ?( G5 I1 l
4.         {
   6 u2 p3 q/ ~0 B7 O9 ^* b3 g
5.                 printf("串口2数据长度=%d\r\n",Rx_len_usart2);//打印接收到的数据长度
   
6.                 printf("串口2数据内容:");
   . `# H  ~, x9 C" R
7.                 for(int i=0;i<Rx_len_usart2;i++)
     z- a: z8 a0 u0 ?. `
8.                 {
   * p) G) G- P9 u5 k0 W
9.                         printf("%c",ReceiveBuff_usart2<i>);//向串口打印接收到的数据
   7 I+ y3 u# u3 {2 Q1 P8 o  k' \
10.             }
    " y6 D& K8 l! o- s9 l! G  |, S! J$ m
11.     printf("\r\n");         
    % \' k) M( f8 y% J% b" ^; G, P
12.     for(int i = 0; i < Rx_len_usart2 ; i++) //清空接收缓存区
    ) c4 V: E! G" {3 u1 h
13.     ReceiveBuff_usart2<i>=0;//置0
    
14.     Rx_len_usart2=0;//接收数据长度清零
    ( z4 b: E  h" t3 _; Y. p
15.     recv_end_flag_usart2=0;//接收标志位清零
    : w. B/ v' K+ {  a/ |* s
16.     }
    
17.                             //开启下一次接收
    
18.     HAL_UART_Receive_DMA(&huart2,(uint8_t*)ReceiveBuff_usart2,BUFFERSIZE_usart2);
    
19. }
    
20. void uart3_data(void)
    
21. {
    
22.         if(recv_end_flag_usart3 ==1)//接收完成标志
    9 h. d% y. i8 |- A+ k
23.         {
    ; K8 T, Z! w) s: m
24.                 printf("串口3数据长度=%d\r\n",Rx_len_usart3);//打印接收到的数据长度
    # N* G5 y9 d7 ?1 ^* g& }* T
25.                 printf("串口3数据内容:");
    2 E& H- _6 |7 ?9 p, h
26.                 for(int i=0;i<Rx_len_usart3;i++)
    
27.                 {
    
28.                         printf("%c",ReceiveBuff_usart3<i>);//向串口打印接收到的数据
    
29.             }
    9 O! Y5 C& k3 k( D4 X# i7 |2 ~
30.     printf("\r\n");         
    
31.     for(int i = 0; i < Rx_len_usart3 ; i++) //清空接收缓存区
    
32.     ReceiveBuff_usart3<i>=0;//置0
    
33.     Rx_len_usart3=0;//接收数据长度清零
    # F0 \1 D, _* q5 h! E. y- B
34.     recv_end_flag_usart3=0;//接收标志位清零
    + h# {1 x( k( Y7 _9 P
35.     }
    
36.                             //开启下一次接收
    & O3 F# v7 V' M" p4 }% n8 E5 e
37.     HAL_UART_Receive_DMA(&huart3,(uint8_t*)ReceiveBuff_usart3,BUFFERSIZE_usart3);
    
38. }</i></i></i></i>

复制代码

主循环，在main.c中添加。
% {# b% Q0 ]4 h3 N
1 w' V! W, b8 U" ]) M* U

1.   /* USER CODE BEGIN WHILE */
   
2.   while (1)
   
3.   {
   : ~/ z- b' a: ?. A, L$ e. n
4.     /* USER CODE END WHILE */
   9 q7 X% B4 U& G4 P$ z  S
5.                 uart2_data();
   9 y* V8 I* c6 X/ C' |
6.                 uart3_data();
   ( {$ [+ I3 n5 y6 U" N& x
7.     /* USER CODE BEGIN 3 */
   ( C% x) l2 C3 @8 Q1 o
8.   }
   2 l) `+ }- Q6 S- ?* ]  l
9.   /* USER CODE END 3 *

复制代码

中断外部变量引用，在stm32f0xx_it.c中添加。
9 q2 s- u3 A! B+ W+ _

1. /* USER CODE BEGIN 0 */
   
2. #define BUFFERSIZE_usart2 255        //可接收的最大数据量
   + ^/ x, z% k( A4 j% J% t" ~
3. extern uint8_t recv_end_flag_usart2,Rx_len_usart2;
   
4. 
   * G% N7 f' m. m: L0 B; R
5. 
   
6. #define BUFFERSIZE_usart3 255        //可接收的最大数据量
   " f% b3 P) @$ Q+ |1 V7 \' O
7. extern uint8_t recv_end_flag_usart3,Rx_len_usart3;
   
8. /* USER CODE END 0 */

复制代码

3 _: q) M9 I. E3 j串口2,3中断函数，在stm32f0xx_it.c中添加。
- p; m- u) O4 Y' ~; l
) J$ |  v; y5 f2 d

1. /**
   ! E. B( d% h) B* N; x' b# V2 a
2.   * @brief This function handles USART2 global interrupt.
   
3.   */
   
4. void USART2_IRQHandler(void)
   
5. {
   
6.   /* USER CODE BEGIN USART2_IRQn 0 */
   
7. 
   * q! ~" Z7 A" q0 H, H
8.   /* USER CODE END USART2_IRQn 0 */
   5 t+ q0 Z: S3 {. a, S& y) r' s
9.   HAL_UART_IRQHandler(&huart2);
   " h$ ^: e- W: C: Q/ Q
10.   /* USER CODE BEGIN USART2_IRQn 1 */
    ( U* ~+ x1 j6 {* Q% p6 U
11.                 uint32_t temp_usart2;
    
12.         if(USART2 == huart2.Instance)//判断是否为串口2中断
    ; r8 Z& R/ J; E/ i& K
13. 
    7 V- y) |& q! K1 Y7 N
14.         {      
    
15.                 if(RESET != __HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE))//如果为串口2
    
16.                 {
    8 m# L- H$ G, k- r7 r
17.                         __HAL_UART_CLEAR_IDLEFLAG(&huart2);//清除中断标志
    5 O# @% M" {8 b$ Y5 C2 l+ v
18.       HAL_UART_DMAStop(&huart2);//停止DMA接收
    
19.                      temp_usart2  = __HAL_DMA_GET_COUNTER(&hdma_usart2_rx);//获取DMA当前还有多少未填充
    
20.                       Rx_len_usart2 =  BUFFERSIZE_usart2 - temp_usart2; //计算串口接收到的数据个数
    2 h3 e5 o' @# s/ D9 D. o1 M0 ?
21.                       recv_end_flag_usart2 = 1;
    
22.              }
    " ^7 t3 T: u: D) j' h
23.         }
    + f. Y/ D" V$ k& B
24.   /* USER CODE END USART2_IRQn 1 */
    8 H; ~& t) K$ H, M* G3 C
25. }
    , Z' c5 F- W0 r- t; L1 K/ u8 S6 [0 s
26. 
    $ i( y' F; `$ [6 g; ]  `
27. /**
    9 g4 c2 v7 f# k3 k0 ?0 q
28.   * @brief This function handles USART3 global interrupt.
    . G# d3 J- v2 T) j$ J1 R
29.   */
    % g4 _2 O2 p7 |1 a) {
30. void USART3_IRQHandler(void)
    
31. {
    ) F3 l3 Z# Q8 v5 k0 K' _% u
32.   /* USER CODE BEGIN USART3_IRQn 0 */
    
33. 
    
34.   /* USER CODE END USART3_IRQn 0 */
    2 i7 @6 I" R6 ~0 ]
35.   HAL_UART_IRQHandler(&huart3);
    
36.   /* USER CODE BEGIN USART3_IRQn 1 */
    
37.         uint32_t temp_usart3;
    - |! X# D+ g0 W* x4 M5 f2 |
38.         if(USART3 == huart3.Instance)//判断是否为串口3中断
      f. q3 J. t5 V: ?# \/ z
39. 
    : S; h# Y3 ~, ?, q
40.         {      
    / O' E4 x  j% C# O7 p& f
41.                 if(RESET != __HAL_UART_GET_FLAG(&huart3,UART_FLAG_IDLE))//如果为串口3
    7 }1 Y. v9 U* K/ ?, U7 g
42.                 {
    2 J# W" C( x% _# U# H0 Y
43.                         __HAL_UART_CLEAR_IDLEFLAG(&huart3);//清除中断标志
    
44.       HAL_UART_DMAStop(&huart3);//停止DMA接收
    
45.                      temp_usart3  = __HAL_DMA_GET_COUNTER(&hdma_usart3_rx);//获取DMA当前还有多少未填充
    6 {1 f8 D2 B- S" c
46.                       Rx_len_usart3 =  BUFFERSIZE_usart3 - temp_usart3; //计算串口接收到的数据个数
    ! \. x9 E/ y+ Q6 w$ |
47.                       recv_end_flag_usart3 = 1;
    ) Z. t6 [: w- u6 |5 w9 p3 c
48.              }
    
49.         }
    $ R" O" f; _4 }
50.   /* USER CODE END USART3_IRQn 1 */
    " S" U: f5 }7 \8 ^  S) H
51. }
    9 W7 ]; D1 i1 g" C7 _

复制代码

0 S5 Z/ U* |. w( F, w结果演示
+ O' d1 `9 I# ]& z8 O开机会显示双串口DMA接收例程。
* l9 {2 I8 k9 I+ f0 c串口2发送数据会在串口3中打印，但是会显示接收的是串口2。
) y) O+ u# h* U3 j' P' f1 B串口3发送数据会在串口3中打印，但是会显示接收的是串口3。
0 g$ F* A6 J( B1 U5 ?/ G, q


, M9 v2 ?( T/ @3 V. P" j0 [$ D5 \
! }# |) A! D' V! S
& E9 F: j8 X' l" A3 M