概述

    直接存储器访问（DMA)用于在外设与存储器之间以及存储器与存储器之间提供高速数据传输。可以在无需任何CPU操作的情况下通过DMA快速传输传输。这样节省的CPU资源可供其它操作使用。

    DMA允许在后台执行数据传输，无需Cortex-MO处理器干预。在此操作过程中，主处理器可以执行其它任务，仅当整个数据块需要处理时，才会中断主处理器。这样即使传输大量数据也不会对系统性能造成太大影响。

    DMA主要用于为不同的外设模块实现集中数据缓冲存储（通常在系统SRAM中）。与分布式解决方案（其中每个外设都需要实现自己的本地数据存储）相比，DMA解决方案在硅片成本和功耗方面的成本较低。

    根据使用的产品型号的不同，有一个或两个DMA模块。

    STM32F0XX DMA控制器总共有5个通道用于DMA1,每个通道都专门管理来自一个或多个外设的存储器访问请求。它具有一个仲裁器，用于处理不同的DMA请求的优先级。

    本篇文章主要介绍如何使用STM32CubeMX实现串口DMA读取，并且打印出去。

( c, u  O5 f2 S/ D" c* S* P

3 w) e- H8 |; ~, D/ L- M  h! y

硬件准备

    首先需要准备一个开发板，这里我准备的是NUCLEO-F030R8的开发板：  

  

3 Z8 S& o+ ~* ^) ~

选择芯片型号

       使用STM32CUBEMX选择芯片stm32f030r8，如下所示：

配置时钟源

    HSE与LSE分别为外部高速时钟和低速时钟，在本文中使用内置的时钟源，故都选择Disable选项，如下所示：

, j- ~8 v% D1 y* E1 n& }: f5 }

配置时钟树

    STM32F0的最高主频到48M，所以配置48即可：

: h  a' c9 I; a  }( M8 M. p

串口配置

    本次实验使用的串口1进行串口通信，波特率配置为115200。

    配置DMA

9 e. X' k/ `( d' |2 P) e, B

    中断

: G# t0 {7 D& A( {

$ V8 q' n. w0 U

生成工程设置

    注意在生产工程设置中不能出现中文，不然会报错。

代码生成设置

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

生成代码

8 F7 b) K4 Q  T: T7 N
/ S, h+ [1 _, g3 [6 |+ s3 B

配置keil

% E5 e3 [" B! @& @( \$ J/ Q# r8 ]

8 ~% q% `) c  y/ h# ?. e

    在main.c中，添加头文件，若不添加会出现 identifier "FILE" is undefined报错。
) K+ b/ W% H( A) @

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "stdio.h"
   : X( K, O+ T( C9 K* \6 G
4. 
   * O/ B) N; O2 |4 a* P5 c. S8 L3 [, m
5. /* USER CODE END Includes */

复制代码

    变量定义：

1. /* USER CODE BEGIN PV */
   
2. 
   
3. #define BUFFERSIZE 255           //可以接收的最大字符个数      
   & g. W# s. m0 I% Y% k' v  I
4. 
   
5. uint8_t ReceiveBuff[BUFFERSIZE]; //接收缓冲区
   2 Z* y! G' T$ ~% \& [
6. 
   
7. uint8_t recv_end_flag = 0,Rx_len;//接收完成中断标志，接收到字符长度
   
8. 
   
9. /* USER CODE END PV */

复制代码

) s& n# b, S7 E$ F

    函数声明和串口重定向：

1. /* USER CODE BEGIN PFP */
   
2. 
   - `8 h" H; A, h% b4 s4 T+ \
3. void uart1_data(void);                                        //接收函数
   
4. 
   . O) G7 ?% u3 I0 m+ ~! u
5. #ifdef __GNUC__                                                                        //串口重定向
   
6. 
   
7. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   / U; c8 Q6 y0 C' a! b- T% {9 E9 r* S: q3 |( b
8. 
   
9. #else
   
10. 
    
11. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    1 l& z3 s% r1 S$ E( D
12. 
    
13. #endif
    
14. 
    
15. PUTCHAR_PROTOTYPE
    5 h2 M. {. G& O2 M* _: q/ ?
16. 
    
17. {
    : e5 [7 g, M5 Q$ j( ^
18. 
    
19.     HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
    . `; g# g! S! d' s
20. 
    . B; N% l5 W! ~, Q4 F' O5 I
21.     return ch;
    & Z& q) F6 h  U& k* ~  }& A1 a/ d
22. 
    9 s; ^: {. D, P8 ~+ w- C' t' w7 W8 C
23. }
    
24. 
    
25. /* USER CODE END PFP */

复制代码

  V* v, d7 |  m

    开启串口IDLE中断：

1.   /* USER CODE BEGIN 2 */
   9 o& f/ I8 j0 c
2. 
   8 P5 X2 q/ p  o7 p$ I  c
3.         printf("串口1DMA例程\r\n");
   
4. 
   + E/ B" H; h; X$ h5 S3 n
5.   __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);//使能串口1 IDLE中断
   
6. 
   
7.   /* USER CODE END 2 */

复制代码

    主循环：

1. /* USER CODE BEGIN WHILE */
   + `: N2 V9 B0 y% Y+ \! {
2. 
   " @$ c1 P/ G3 @- F: e
3.   while (1)
   + I/ i. M1 C0 K7 R/ ^" @
4. 
   
5.   {
   % t5 f$ Z; m6 J9 i+ K
6. 
   
7.     /* USER CODE END WHILE */
   
8. 
   & M0 [" ^3 ?" {' d) I2 \
9.                 uart1_data();//串口数据处理
   8 }0 B& ^1 X8 F. O5 d. B5 O. C0 M$ {
10. 
      v" |5 @" V6 O4 R) v9 }
11.     /* USER CODE BEGIN 3 */
    
12. 
    
13.   }
    
14. 
    % Y+ R6 b& e2 ]! m6 s, X6 [
15.   /* USER CODE END 3 */

复制代码

' B: k* [* r1 T

    串口DMA获取：

1. /* USER CODE BEGIN 4 */
   
2. 
   
3. void uart1_data(void)
   
4. 
   
5. {
   
6. 
   
7.         if(recv_end_flag ==1)//接收完成标志
   
8. 
   . y* Z3 l8 l4 m) e/ [6 _, f' [; p# p
9.         {
   
10. 
    
11.                 printf("数据长度=%d\r\n",Rx_len);//打印接收到的数据长度
    
12. 
    
13.                 printf("数据内容:");
    . O; g+ I6 ]1 h* b. D& W6 q
14. 
    2 b/ l% e7 a" ]8 I$ Q$ {- m
15.                 for(int i=0;i<Rx_len;i++)
    
16. 
    
17.                 {
    6 {+ |- Y: F9 Q% {
18. 
    9 `* U( s. k- g
19.                         printf("%c",ReceiveBuff[i]);//向串口打印接收到的数据
    & y! M6 X4 R0 A: J
20. 
    
21.             }
    + T6 W0 N7 n' q  ]1 C4 l0 e$ ]' m, J
22. 
    2 x0 A1 B4 ~6 s+ C3 q& s
23.     printf("\r\n");         
    1 V4 n# y  \. O+ Y7 g  L
24. 
    3 Z3 o- ~! ?; z4 h
25.     for(int i = 0; i < Rx_len ; i++) //清空接收缓存区
    3 S( @" r% ^6 I: M7 E
26. 
    ; n6 l" l/ g0 z* k+ z) M4 Z6 s1 g
27.     ReceiveBuff[i]=0;//置0
    
28. 
    6 d1 O- p% y" t/ Q/ R( ^, z
29.     Rx_len=0;//接收数据长度清零
    0 E3 Q: N3 N& e, h. [8 U
30. 
    
31.     recv_end_flag=0;//接收标志位清零
    
32. 
    " N7 ~# Y+ j/ C
33.     }
    
34. 
    # v7 }  l8 v6 K5 U2 W: z
35.     //开启下一次接收
    
36. 
    
37.     HAL_UART_Receive_DMA(&huart1,(uint8_t*)ReceiveBuff,BUFFERSIZE);
    3 ?' Y) U1 K7 s7 [" Y. [; _" z
38. 
    1 a/ E# F7 L! q7 d8 b" Y, N
39. }
    
40. 
    4 A7 s2 k; y1 ~0 m1 `
41. /* USER CODE END 4 */
    9 T9 S' B3 R  m7 m
42. 
    

复制代码

    #include "stm32f0xx_it.c"文件中断外部变量引用：

1. /* USER CODE BEGIN 0 */
   . M( b9 A; y$ Q  X$ I3 g4 Q
2. 
   * F- o5 E8 t! L2 L& K
3. #define BUFFERSIZE 255        //可接收的最大数据量
   & s* s- I6 I4 ?4 s7 }4 x
4. 
   ! |5 c: N2 R/ _3 w. k- G
5. extern uint8_t recv_end_flag,Rx_len,bootfirst;
   % q+ |# d. P2 N" y
6. 
   4 ?8 [* U3 R6 k1 J& K
7. /* USER CODE END 0 */

复制代码

    串口1中断函数：

1. /**
   
2. 
   ( [$ p" L5 B' C
3.   * @brief This function handles USART1 global interrupt.
   1 h+ ?7 ~% D0 r$ ^8 R3 b
4. 
   * z( E7 J: ^+ ^5 u' y
5.   */
   
6. 
   
7. void USART1_IRQHandler(void)
   
8. 
   7 }" W/ a0 }( ]  N" x( K7 M4 ^
9. {
   9 P+ \8 _' i, o5 ?7 x
10. 
    8 h8 X/ t+ p* J- ~' P+ |
11.   /* USER CODE BEGIN USART1_IRQn 0 */
    $ A1 S) r: Z! V' b7 j
12. 
    - a1 J& g  C' ^; {$ j' ]! {
13. 
    ; s& N4 j( t/ P3 n
14. 
    # y6 g4 A0 h) T, ]% {) P& ]
15.   /* USER CODE END USART1_IRQn 0 */
    7 \; s( m, {; B1 _% [, v% w7 P
16. 
    
17.   HAL_UART_IRQHandler(&huart1);
    
18. 
    
19.   /* USER CODE BEGIN USART1_IRQn 1 */
    7 I, J3 Z& e2 D4 \
20. 
    
21.         uint32_t temp;
    
22. 
    5 D- ]) [( c9 l" C4 ?4 T5 l
23.         if(USART1 == huart1.Instance)//判断是否为串口1中断
    
24. 
    - z- v' p1 i4 D7 T1 Z$ g/ `
25.         {      
    2 o7 m7 B+ }3 c
26. 
      s/ p2 H5 X; D7 d
27.                 if(RESET != __HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))//如果为串口1
    1 N9 k% n- n" R9 T
28. 
    
29.                 {
    
30. 
    1 G3 I7 u" z% P- ~( i
31.                         __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除中断标志
    
32. 
    
33.       HAL_UART_DMAStop(&huart1);//停止DMA接收
    
34. 
    
35.       temp  = __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//获取DMA当前还有多少未填充
    1 v) U0 x1 H8 i7 q, M9 L
36. 
    % _# {0 G8 a6 x4 k5 `- [2 E
37.       Rx_len =  BUFFERSIZE - temp; //计算串口接收到的数据个数
    ' R# {" G9 Q  o/ _7 V4 d
38. 
    
39.       recv_end_flag = 1;
    # _% v" u% w9 m7 s5 |) T4 n) ~
40. 
    ; O2 j" ^4 E( ~1 a
41.      }
    5 i" v9 ]+ [5 [
42. 
    
43.         }       
    
44. 
    ; Z, a! w9 `5 Y+ M  O* w+ V3 e
45.   /* USER CODE END USART1_IRQn 1 */
    $ |6 i( J8 F* S! t( w+ J
46. 
    4 C8 g0 ?* K5 D1 f) l& q$ E8 y
47. }

复制代码

演示效果

转载自：记帖

如有侵权请联系删除

& \$ E; I6 F7 f; w
- `  m  N6 ~: v0 N. D( s