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

7 q/ q' l/ u( {9 O我在去年，测试了一下【中断模式】的，结果是速度超快。
速度115200bps和1Mbps，双向同时收发100万字符无差错。 2Mbps，单方向100万字符无差错。
5 M! x3 g: U- H' w0 v# b. y详情请见：  STM32基于CubeMX的高速串口收发程序（中断模式）
! P7 `6 E" A) C8 P- |4 |' q# z% o
; \2 s& |' d  q  ^& l那时就有网友，问我为什么不用DMA模式，我也认为DMA的好处多多，只是没有时间验证一下。
现在，我得到的结果是，DMA模式用在UART这种低速外设上面，可能性能并不好，不如中断模式的。
请网友们给看一看，希望我的代码有问题。
先说我的测试结果吧：
STM32F103C8T6 Bluepill板，MCU时钟72MHz，用CubeMX配置出DMA模式的两个串口收发。
4 O  C* B# `3 D) }, c, g添加少量代码，就做成了两个串口互相收发。 与上面说的中断模式的用法一样。
结果是，115200波特率，以10ms间隔发送接收40个字符，单方向正常，双方向同时收发就丢失数据。
' q3 x; u! Q/ Y( u5 f, f6 \如果时间间隔放到200ms，双方向同时收发，也能正常了。

: |3 R# h1 i( M: s& }, _) @2 V8 F+ S下面，看看我用的代码：
CubeMX的配置过程，就不累叙了，附件里面有配置文件。

1. //main.c 添加的代码：
   
2. 
   - N8 K2 [# p; V
3. //变量：
   
4. #define DMA_RX_BUFFER_SIZE            128
   3 i' F) E4 `4 w' j3 }- H$ K
5. uint8_t UART1_Rx_Buffer[DMA_RX_BUFFER_SIZE] = {0};
   
6. uint8_t UART2_Rx_Buffer[DMA_RX_BUFFER_SIZE] = {0};
   
7. 
   
8. uint8_t recv_end_flag1 = 0;
   
9. uint8_t rx_len1 = 0;
   $ z$ O5 I4 r, q" g& x
10. uint8_t recv_end_flag2 = 0;
    
11. uint8_t rx_len2 = 0;
    
12. 
    
13. 。。。
    
14. 
    
15. //初始化
    
16.   __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    8 D, m: R& I2 \, I0 {
17.   __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
    
18.   
    + L; h8 k& @5 Z7 ^1 `
19.   HAL_UART_Receive_DMA(&huart1, UART1_Rx_Buffer, DMA_RX_BUFFER_SIZE);
    " ?$ H( J9 b$ ^" V0 i3 E0 I
20.   HAL_UART_Receive_DMA(&huart2, UART2_Rx_Buffer, DMA_RX_BUFFER_SIZE);
    
21. 
    
22.   。。。
    
23.   
    
24. //main（）
    ) q' T) b# c4 C1 ~% Y
25.     if(recv_end_flag1 ==1){     //UART1 Rx, UART2 Tx
    
26. 
    
27.       HAL_UART_Transmit_DMA(&huart2,UART1_Rx_Buffer,rx_len1);
    ! H) `# z5 C' H/ Z' L9 L" J  \: v. X
28. 
    6 |9 L% u$ `8 {
29.       rx_len1=0;
    3 v, C/ g) ?1 ~" V; Y
30. 
    . K4 t& i* C* p; n5 m- `
31.       recv_end_flag1=0;
    
32. 
      J) C1 q4 L: l
33.       HAL_UART_Receive_DMA(&huart1,UART1_Rx_Buffer,DMA_RX_BUFFER_SIZE);
    
34.     }
    
35.    
    
36.     if(recv_end_flag2 ==1){    //UART2 Rx, UART1 Tx
    0 }# ~* W' p7 f7 d. S" O1 V' P1 I
37. 
    0 U% A% ]1 X! `8 x9 l
38.       HAL_UART_Transmit_DMA(&huart1,UART2_Rx_Buffer,rx_len2);
    
39. 
    # W3 a7 H' V5 a. B5 m1 j# D
40.       rx_len2=0;
    : b9 Z' w* r( Q0 y7 N$ n
41. 
    7 t, J" D3 A4 D" J& E0 v- }' l2 H
42.       recv_end_flag2=0;
    ! i' r5 l+ n: Y9 a8 ^5 _
43. 
    * X5 Q7 P$ x8 ^+ m, Q9 B' x6 v( l
44.       HAL_UART_Receive_DMA(&huart2,UART2_Rx_Buffer,DMA_RX_BUFFER_SIZE);
    & v" N6 @3 f- E1 B/ N
45.     }
    " b# }0 Y! L: J! Q, m/ F
46.    
    5 x) i( N0 ~% ]1 f% G* G1 F
47.    
    ) [( N0 o& Z0 C8 S
48.    
    " g( d5 [) k/ B) Y+ i# J
49.    
    
50.    
    + k" f1 O8 I( q$ w0 V* {$ C
51. //stm32f1xx_it.c 中断服务程序里面修改的代码：
    
52. 
    
53. extern uint8_t recv_end_flag1;
    
54. extern uint8_t rx_len1;
    
55. extern uint8_t recv_end_flag2;
    : ^3 e9 h' o2 D& C
56. extern uint8_t rx_len2;
    
57. 
    9 U( I& Z) q% M; v" c2 D' n
58. #define BUFFER_SIZE 128
    
59. 
    
60. void USART1_IRQHandler(void)
    ' U% u! D5 O( D0 l: n! w) i
61. {
    - d, S( b& w/ }% N+ u+ h
62.   /* USER CODE BEGIN USART1_IRQn 0 */
    
63.     uint32_t tmp_flag = 0;
    1 ^7 d5 Q8 o' M* [7 i% {
64.     uint32_t temp;
    - i- ^/ T- U2 J1 [, D
65. 
    
66.   /* USER CODE END USART1_IRQn 0 */   
    
67.   HAL_UART_IRQHandler(&huart1);
    3 _( |& W2 Z5 D) {6 x- ]6 w
68.   /* USER CODE BEGIN USART1_IRQn 1 */
    - i2 m" {# K" n; z9 c1 H( |& n9 K2 T8 q
69. 
    
70.   tmp_flag =  __HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE);
    $ W0 s0 A4 J: U9 x1 }, n
71. 
    
72.   if((tmp_flag != RESET)){
    
73. 
    
74.     __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    9 I( M5 ]' H2 p" T: N! Y6 N
75. 
    
76.     HAL_UART_DMAStop(&huart1);
    
77. 
    ! o2 T; C- r1 B! b
78.     temp  = hdma_usart1_rx.Instance->CNDTR;
    
79. 
    % x) e5 {+ J' R
80.     rx_len1 =  BUFFER_SIZE - temp;
    9 M: r0 g9 G  f( O; T
81. 
    
82.     recv_end_flag1 = 1;
    : X  Y) }+ q9 k2 k
83.   }
    
84.   /* USER CODE END USART1_IRQn 1 */
    ) P( b% P- D: A8 B
85. }
    9 B1 B, k+ Q; }4 |
86. 
    
87. 
    * `1 S5 d' C' Z/ X
88. /**
    
89. * @brief This function handles USART2 global interrupt.
    
90. */
    
91. void USART2_IRQHandler(void)
    $ z3 r" J& H4 ^" F0 Z2 h& R1 e
92. {
    
93.   /* USER CODE BEGIN USART1_IRQn 0 */
    
94.     uint32_t tmp_flag = 0;
    % W! S4 r" n" U: r+ p
95.     uint32_t temp;
    
96. 
    
97.   /* USER CODE END USART1_IRQn 0 */   
    " r! j, S$ f$ V6 o5 t
98.   HAL_UART_IRQHandler(&huart2);
    
99.   /* USER CODE BEGIN USART1_IRQn 1 */
    
100. 
     - j* Z( m% e5 Y+ \2 p  n0 k
101.   tmp_flag =  __HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE);
     ) k9 I$ ^/ t5 ~. o* I
102. 
     ( j# W5 `8 w; W, g
103.   if((tmp_flag != RESET)){
     
104. 
     + G2 p4 a: p0 d; U; ^: }* q0 F
105.     __HAL_UART_CLEAR_IDLEFLAG(&huart2);
     
106. 
     
107.     HAL_UART_DMAStop(&huart2);
     + Q- v! a9 t; z% C4 f, N$ M, Z
108. 
     
109.     temp  = hdma_usart2_rx.Instance->CNDTR;
     
110. 
     * }2 }: @* G! o- L& c
111.     rx_len2 =  BUFFER_SIZE - temp;
     
112. 
     ; L4 `, R3 p4 j4 p- h
113.     recv_end_flag2 = 1;
     4 l, t7 C" Z" v8 F  ?
114.   }
     6 E% b% O/ |! N; ?+ s* f, I: o
115.   /* USER CODE END USART1_IRQn 1 */
     1 `6 c6 e! i$ _% H. N% g1 Q7 T
116. }
     3 V7 ~+ X( ~2 a! H9 c1 v

复制代码

1 c0 A; g+ S9 {' H& [; P2 n; h- u

2 R7 D* R1 d, P- L) A( A& ^8 {上面的代码，也是参考了网上网友的帖子。 希望网友指出问题，和给出更好的代码方案。
也还听说串口DMA有三种方法，我这里用的只是其中之一的“空闲中断”法。

附完整代码：

今天，有做了一些测试。从使用的角度来看，一楼附件的程序是可以使用的，只要，
, E4 f6 V5 @: y( z6 s3 f$ a' ~' p1. 数据包长度不超过DMA缓存的长度。2. 发送的间隔不少于200ms。
就可以115200双向同时收发无差错。
) b& E4 k# ^) C2 z
* R  L, e% W6 ~+ y* I/ n* K至于单方向收发，1Mbps，2Mbps，都没有问题的，放心使用。

学习了。

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

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

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

* _" b9 z7 j' L1 @3 r- ?9 F同意，谢谢。
- X8 y; \1 a* {( k/ ~, `- |2 l
总之，串口通讯，本身是没有纠错重发功能，速度又很慢的外设。
6 t0 C) U1 P. R% g$ J* n" U影响丢数据的因素，也就是那么几种，照顾到了就没有问题。

收藏

学习了

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

学习了                                   

学习了

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

谢谢 分享
9 ^( E+ c5 W+ V% M

学习一下DMA的操作

谢谢了，好用