周末有时间，测试了一下STM32F103的DMA串口收发程序，基于CubeMX的，结果却是令人大失所望。

我在去年，测试了一下【中断模式】的，结果是速度超快。
- @8 }( p) o* \速度115200bps和1Mbps，双向同时收发100万字符无差错。 2Mbps，单方向100万字符无差错。
详情请见：  STM32基于CubeMX的高速串口收发程序（中断模式）

那时就有网友，问我为什么不用DMA模式，我也认为DMA的好处多多，只是没有时间验证一下。
现在，我得到的结果是，DMA模式用在UART这种低速外设上面，可能性能并不好，不如中断模式的。
3 ]  R6 d& `+ {- }请网友们给看一看，希望我的代码有问题。
先说我的测试结果吧：
STM32F103C8T6 Bluepill板，MCU时钟72MHz，用CubeMX配置出DMA模式的两个串口收发。
8 g" D0 [% P; L$ ?7 m0 G+ N- J+ T添加少量代码，就做成了两个串口互相收发。 与上面说的中断模式的用法一样。
7 U6 J9 E' `9 @! z3 [8 k  w结果是，115200波特率，以10ms间隔发送接收40个字符，单方向正常，双方向同时收发就丢失数据。
如果时间间隔放到200ms，双方向同时收发，也能正常了。
5 e! `) X& ?7 r6 [0 ?
: G& X" B+ I  N$ I& T下面，看看我用的代码：
CubeMX的配置过程，就不累叙了，附件里面有配置文件。
$ O. r4 S7 k7 H7 G

1. //main.c 添加的代码：
   ) C" X% J) b5 J& x3 e/ B& K4 c8 L
2. 
   
3. //变量：
   
4. #define DMA_RX_BUFFER_SIZE            128
   ! C8 J5 x) N+ H
5. uint8_t UART1_Rx_Buffer[DMA_RX_BUFFER_SIZE] = {0};
   6 S" T  ~/ \9 W
6. uint8_t UART2_Rx_Buffer[DMA_RX_BUFFER_SIZE] = {0};
   9 \- Y8 I* A* T" `$ N
7. 
   
8. uint8_t recv_end_flag1 = 0;
   2 X$ {! t  _) t4 F2 Z5 i
9. uint8_t rx_len1 = 0;
   ; g) ?  G$ B0 p6 E
10. uint8_t recv_end_flag2 = 0;
    
11. uint8_t rx_len2 = 0;
    5 s) R) n% B2 U" K
12. 
    1 ^0 L1 h+ J( K. p
13. 。。。
    ' ]9 p+ e* P6 f
14. 
    % b) x7 Q# y$ i7 A/ D% _! {( i. d
15. //初始化
    2 o: X$ \; J2 C) W5 d2 H" b2 N
16.   __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
17.   __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
    
18.   
    
19.   HAL_UART_Receive_DMA(&huart1, UART1_Rx_Buffer, DMA_RX_BUFFER_SIZE);
    7 y3 G( w% Y* \
20.   HAL_UART_Receive_DMA(&huart2, UART2_Rx_Buffer, DMA_RX_BUFFER_SIZE);
    
21. 
    , A9 q5 g! I0 V6 w& m. }
22.   。。。
    " G9 }; z1 Q' l4 ]2 ~
23.   
    5 L9 q% q" j8 U! [, @
24. //main（）
    
25.     if(recv_end_flag1 ==1){     //UART1 Rx, UART2 Tx
    : q% ^5 k" F# u" |. Y
26. 
    . W+ Y- G  f" J2 Y' y, S" j
27.       HAL_UART_Transmit_DMA(&huart2,UART1_Rx_Buffer,rx_len1);
    * ^) [5 t0 ]" q
28. 
    & y3 S; h4 B" P1 K+ H1 [5 s
29.       rx_len1=0;
    + }0 K3 O# Y8 x6 L
30. 
    4 [) Y5 ~: u# d3 |% f) Q
31.       recv_end_flag1=0;
    
32. 
    9 N6 J6 X6 B- W; q/ Q, y
33.       HAL_UART_Receive_DMA(&huart1,UART1_Rx_Buffer,DMA_RX_BUFFER_SIZE);
    
34.     }
    3 T' h/ p& r; {) h2 z. I
35.    
    
36.     if(recv_end_flag2 ==1){    //UART2 Rx, UART1 Tx
    
37. 
    . O* q: I( {/ f4 h* B8 g6 i8 i
38.       HAL_UART_Transmit_DMA(&huart1,UART2_Rx_Buffer,rx_len2);
    - E2 L7 r, V6 E- ]" z
39. 
      u- e9 Z0 W* i2 b" D2 C
40.       rx_len2=0;
    
41. 
    " E' F1 q4 w2 \7 I# j: u
42.       recv_end_flag2=0;
    
43. 
    & V: T: C0 B. r3 t! e- `
44.       HAL_UART_Receive_DMA(&huart2,UART2_Rx_Buffer,DMA_RX_BUFFER_SIZE);
    & n' j: F3 p+ Z
45.     }
    ( i% n% c: u: t9 Z
46.    
    
47.    
    
48.    
    1 o7 K- D; V8 u7 q2 m4 c, C/ _
49.    
    
50.    
    
51. //stm32f1xx_it.c 中断服务程序里面修改的代码：
    
52. 
    
53. extern uint8_t recv_end_flag1;
    
54. extern uint8_t rx_len1;
    " z4 }4 S% ^- i- C7 s3 E
55. extern uint8_t recv_end_flag2;
    : U8 L+ O3 Y2 N# T! [  D
56. extern uint8_t rx_len2;
    
57. 
    
58. #define BUFFER_SIZE 128
    , e" D. k2 M5 s* f0 a. M0 e. j8 n# ?
59. 
    
60. void USART1_IRQHandler(void)
    
61. {
    # i+ `( ^% Q% o" e# D" N3 {% Y
62.   /* USER CODE BEGIN USART1_IRQn 0 */
    8 e; n- Q7 h) _/ T* I" G7 O
63.     uint32_t tmp_flag = 0;
    
64.     uint32_t temp;
    
65. 
    3 o, X/ E, L6 ]7 E" N( H
66.   /* USER CODE END USART1_IRQn 0 */   
    
67.   HAL_UART_IRQHandler(&huart1);
    $ G7 ^2 k* \  c; k- ~
68.   /* USER CODE BEGIN USART1_IRQn 1 */
    / P9 K! G: ~% X. A! B
69. 
    
70.   tmp_flag =  __HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE);
      \7 w! g# m( v
71. 
    ( j# q5 h7 z0 r" e' `6 Y
72.   if((tmp_flag != RESET)){
    
73. 
    4 v6 n2 U' h9 U$ C9 u: Y
74.     __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
75. 
    
76.     HAL_UART_DMAStop(&huart1);
    
77. 
    " O$ U4 t% O4 r& P
78.     temp  = hdma_usart1_rx.Instance->CNDTR;
    
79. 
    2 c: G' g7 A% K$ e/ i! G
80.     rx_len1 =  BUFFER_SIZE - temp;
    
81. 
    / \  F% w/ N1 D" u/ v
82.     recv_end_flag1 = 1;
    " v4 |* F' A% x* M5 B) s
83.   }
    
84.   /* USER CODE END USART1_IRQn 1 */
    
85. }
    
86. 
    
87. 
    / q8 z: i* k8 u) p& d% q" V
88. /**
      O8 T3 ]& f. M2 F! N( k5 n' G
89. * @brief This function handles USART2 global interrupt.
    
90. */
    
91. void USART2_IRQHandler(void)
    % {9 I! E# ?8 |' E% p( B
92. {
    ) ?6 i# h# l! F3 L$ [
93.   /* USER CODE BEGIN USART1_IRQn 0 */
    7 x4 e5 O! o2 U6 ~
94.     uint32_t tmp_flag = 0;
    ; l% ?: |. ^) [6 ~7 p' L  j7 Q
95.     uint32_t temp;
    0 Y: x- @! w9 C# V
96. 
    
97.   /* USER CODE END USART1_IRQn 0 */   
    
98.   HAL_UART_IRQHandler(&huart2);
    
99.   /* USER CODE BEGIN USART1_IRQn 1 */
      ]8 k8 K/ b' Q* E  I, F
100. 
     
101.   tmp_flag =  __HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE);
     
102. 
     ' R) d7 U# v8 @" y. C$ c' {: O
103.   if((tmp_flag != RESET)){
     
104. 
     * @& ^' X2 B. S
105.     __HAL_UART_CLEAR_IDLEFLAG(&huart2);
     " Z- J3 n0 Q7 c
106. 
     & v; M6 ~$ |7 P7 Z
107.     HAL_UART_DMAStop(&huart2);
     
108. 
     # T1 ?! \4 ^) Q1 a
109.     temp  = hdma_usart2_rx.Instance->CNDTR;
     ! y0 h3 J2 Q( s8 L
110. 
     
111.     rx_len2 =  BUFFER_SIZE - temp;
     ; G* R9 E/ j. w% l: ]# Z! Z
112. 
     ; Y1 O' D7 s/ a
113.     recv_end_flag2 = 1;
     
114.   }
     ; [* M3 K9 ~) O: {6 s$ H
115.   /* USER CODE END USART1_IRQn 1 */
       E. L7 O" t) p% w; e5 ]
116. }
     

复制代码

& a; ]9 d/ f1 J
上面的代码，也是参考了网上网友的帖子。 希望网友指出问题，和给出更好的代码方案。
也还听说串口DMA有三种方法，我这里用的只是其中之一的“空闲中断”法。

7 F' P7 v+ v6 k7 H附完整代码：
) r7 H9 f1 `' t8 }" I2 h) N+ C
6 j2 @. \3 v. i/ t, w

今天，有做了一些测试。从使用的角度来看，一楼附件的程序是可以使用的，只要，
1. 数据包长度不超过DMA缓存的长度。2. 发送的间隔不少于200ms。
就可以115200双向同时收发无差错。
3 o8 ^6 v5 d% P" j7 H; k
至于单方向收发，1Mbps，2Mbps，都没有问题的，放心使用。

学习了。

感谢LZ的分享。个人认为DMA的好处还是能释放CPU。一组大量的数据DMA传输，启动后CPU就不用怎么管了，DMA中断也只在一半完成或全部完成时触发；但无DMA时，每个字节收发时其实CPU都需要入中断操作一次，只不过库函数帮你做了而已。
( Q" t' n: w5 h7 Q! s# A8 u所以个人认为LZ的测试方式其实问题在于，用中断CPU可以收一个马上发一个，虽然两边都CPU占满了但响应肯定快；但DMA是收完全部时再全部返回，那CPU虽然很闲，但响应就肯定慢。这样测试时DMA对CPU占用少的优势就测不出来。

学习中，之前没有用到DMA，用的好像就是空闲中断

wh8 发表于 2019-3-21 10:47
感谢LZ的分享。个人认为DMA的好处还是能释放CPU。一组大量的数据DMA传输，启动后CPU就不用怎么管了，DMA中 ...

同意，谢谢。

, J3 W: I% _6 U- q5 ?总之，串口通讯，本身是没有纠错重发功能，速度又很慢的外设。
) v. `, ]5 b" J$ |  U影响丢数据的因素，也就是那么几种，照顾到了就没有问题。

收藏

学习了

你这个怎么测试的啊，一点串口一点反应都没有的?

学习了                                   

学习了

有测试作为数据支持，不错

谢谢 分享

学习一下DMA的操作

谢谢了，好用