STM32之串口DMA接收不定长数据

小样岁月

　　STM32之串口DMA接收不定长数据引言
　　在使用stm32或者其他单片机的时候，会经常使用到串口通讯，那么如何有效地接收数据呢?假如这段数据是不定长的有如何高效接收呢?
' T0 c; r. j- I　　同学A：数据来了就会进入串口中断，在中断中读取数据就行了!
　　中断就是打断程序正常运行，怎么能保证高效呢?经常把主程序打断，主程序还要不要运行了?
7 V% i: q  {8 H: X( h5 N( ]- S; K　　同学B：串口可以配置成用DMA的方式接收数据，等接收完毕就可以去读取了!
' i+ {& D) ]% p" g4 L  d　　这个同学是对的，我们可以使用DMA去接收数据，不过DMA需要定长才能产生接收中断,如何接收不定长的数据呢?
　　DMA简介
5 v& Y5 n( c- o( A# d( {* Y; s8 ~$ p　　题外话：其实，上面的问题是很有必要思考一下的，不断思考，才能进步。
. t$ a. N% G& P8 a　　什么是DMA
　　DMA：全称Direct Memory Access，即直接存储器访问
+ g2 ^- Y* k1 s/ w* E& ]# v　　DMA 传输将数据从一个地址空间复制到另外一个地址空间。CPU只需初始化DMA即可，传输动作本身是由 DMA 控制器来实现和完成。典型的例子就是移动一个外部内存的区块到芯片内部更快的内存区。这样的操作并没有让处理器参与处理，CPU可以干其他事情，当DMA传输完成的时候产生一个中断，告诉CPU我已经完成了，然后CPU知道了就可以去处理数据了，这样子提高了CPU的利用率，因为CPU是大脑，主要做数据运算的工作，而不是去搬运数据。DMA 传输对于高效能嵌入式系统算法和网络是很重要的。
$ g: d3 M8 {. m. B& b2 i　　在STM32的DMA资源
　　STM32F1系列的mcu有两个DMA控制器(DMA2只存在于大容量产品中)，DMA1有7个通道，DMA2有5个通道，每个通道专门用来管理来自于一个或者多个外设对存储器的访问请求。还有一个仲裁器来协调各个DMA请求的优先权。


, j: _, N; W7 s3 ?! y4 {! E, n* Z' G* X　　STM32F1

% g! }) y6 O6 c/ c' c0 J& n
　　STM32F1
　　而STM32F4/F7/H7系列的MCU有两个DMA控制器总共有16个数据流(每个DMA控制器8个)，每一个DMA控制器都用于管理一个或多个外设的存储器访问请求。每个数据流总共可以有多达8个通道(或称请求)。每个通道都有一个仲裁器，用于处理 DMA 请求间的优先级。


2 R+ u( n7 p% \, P! U, ?$ I$ U　　STM32F4

' k9 u; C0 K, o% A3 @
# j6 L" n! ^+ z% n% f9 M  C0 v　　STM32F4
7 `+ P& X' W* d/ p6 q. T. \% Y　　DMA接收数据
　　DMA在接收数据的时候，串口接收DMA在初始化的时候就处于开启状态，一直等待数据的到来，在软件上无需做任何事情，只要在初始化配置的时候设置好配置就可以了。等到接收到数据的时候，告诉CPU去处理即可。
　　判断数据接收完成
　　那么问题来了，怎么知道数据是否接收完成呢?
　　其实，有很多方法：
& E" Y' q! e  m( y　　对于定长的数据，只需要判断一下数据的接收个数，就知道是否接收完成，这个很简单，暂不讨论。
" J) ?5 {0 A; x4 e% \　　对于不定长的数据，其实也有好几种方法，麻烦的我肯定不会介绍，有兴趣做复杂工作的同学可以在网上看看别人怎么做，下面这种方法是最简单的，充分利用了stm32的串口资源，效率也是非常之高。
　　DMA+串口空闲中断
8 n3 E8 n" U, Q' r" k　　这两个资源配合，简直就是天衣无缝啊，无论接收什么不定长的数据，管你数据有多少，来一个我就收一个，就像广东人吃“山竹”，来一个吃一个~(最近风好大，我好怕)。
0 i  w( S8 O* G6 [1 F+ ~+ W, Q3 x　　可能很多人在学习stm32的时候，都不知道idle是啥东西，先看看stm32串口的状态寄存器：


　　idle


　　idle说明
　　当我们检测到触发了串口总线空闲中断的时候，我们就知道这一波数据传输完成了，然后我们就能得到这些数据，去进行处理即可。这种方法是最简单的，根本不需要我们做多的处理，只需要配置好，串口就等着数据的到来，dma也是处于工作状态的，来一个数据就自动搬运一个数据。
" J* a/ D4 F! l8 Z( R　　接收完数据时处理
, E7 F+ D  M' Z% @! r2 A! Y% T. p8 R　　串口接收完数据是要处理的，那么处理的步骤是怎么样呢?
　　暂时关闭串口接收DMA通道，有两个原因：1.防止后面又有数据接收到，产生干扰，因为此时的数据还未处理。2.DMA需要重新配置。
- [% y0 V. k' a& d$ T3 o- B1 Z　　清DMA标志位。
: ~" j( ]8 x2 K  P2 i　　从DMA寄存器中获取接收到的数据字节数(可有可无)。
: f; ~; z0 s, U. W. R9 T8 @6 d! ?4 ?　　重新设置DMA下次要接收的数据字节数，注意，数据传输数量范围为0至65535。这个寄存器只能在通道不工作(DMA_CCRx的EN=0)时写入。通道开启后该寄存器变为只读，指示剩余的待传输字节数目。寄存器内容在每次DMA传输后递减。数据传输结束后，寄存器的内容或者变为0;或者当该通道配置为自动重加载模式时，寄存器的内容将被自动重新加载为之前配置时的数值。当寄存器的内容为0时，无论通道是否开启，都不会发生任何数据传输。
6 p4 M7 ^1 E( a0 C　　给出信号量，发送接收到新数据标志，供前台程序查询。
: p; Z4 \7 s! I  Z1 _5 e6 \　　开启DMA通道，等待下一次的数据接收，注意，对DMA的相关寄存器配置写入，如重置DMA接收数据长度，必须要在关闭DMA的条件进行，否则操作无效。
% G2 O! i* k) q6 w　　注意事项
* n1 j$ n8 [% `4 U　　STM32的IDLE的中断在串口无数据接收的情况下，是不会一直产生的，产生的条件是这样的，当清除IDLE标志位后，必须有接收到第一个数据后，才开始触发，一断接收的数据断流，没有接收到数据，即产生IDLE中断。如果中断发送数据帧的速率很快，MCU来不及处理此次接收到的数据，中断又发来数据的话，这里不能开启，否则数据会被覆盖。有两种方式解决：
　　在重新开启接收DMA通道之前，将Rx_Buf缓冲区里面的数据复制到另外一个数组中，然后再开启DMA，然后马上处理复制出来的数据。
　　建立双缓冲，重新配置DMA_MemoryBaseAddr的缓冲区地址，那么下次接收到的数据就会保存到新的缓冲区中，不至于被覆盖。
5 S, {! _0 s& r; S4 I0 k! L! \9 L　　程序实现
: h$ y* a1 S9 }　　实验效果：
: b) O% {$ f$ W. O- M' I　　当外部给单片机发送数 据的时候，假设这帧数据长度是1000个字节，那么在单片机接收到一个字节的时候并不会产生串口中断，只是DMA在背后默默地把数据搬运到你指定的缓冲区里面。当整帧数据发送完毕之后串口才会产生一次中断，此时可以利用DMA_GetCurrDataCounter()函数计算出本次的数据接受长度，从而进行数据处理。
: ]6 T. ^: W$ p8 Z) d* s  Y　　串口的配置
　　很简单，基本与使用串口的时候一致，只不过一般我们是打开接收缓冲区非空中断，而现在是打开空闲中断——USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);。
0 p! b$ o% e( k9 m

1. 　/**
   - e9 C/ s# {$ K# E! P0 H6 [3 Y
2. 
   
3. 　　* @brief USART GPIO 配置,工作参数配置
   
4. 
   % c; `1 Q6 [3 e$ x+ a! e- V7 t0 F
5. 　　* @param 无
   
6. 
   , f( d# l5 v. {; I
7. 　　* @retval 无
   5 j% T, F  [* P) s/ q
8. 
   
9. 　　*/
   5 J) C3 q6 \( O$ _  b
10. 
    
11. 　　void USART_Config(void)
    . Y9 o7 [* o# `) t9 V
12. 
    ' r( _4 ?6 D4 m$ o/ K
13. 　　{
    
14. 
    ' F, S( J% ~' C! K( |
15. 　　GPIO_InitTypeDef GPIO_InitStructure;
    6 e8 k3 Q/ ^9 v4 n5 ~1 f
16. 
    
17. 　　USART_InitTypeDef USART_InitStructure;
    
18. 
    
19. 　　// 打开串口GPIO的时钟
    : H' N; F- v) }7 k; Q
20. 
    % R! A  }- v3 M' M/ C; Y
21. 　　DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
    
22. 
    
23. 　　// 打开串口外设的时钟
    - T1 W3 x3 r/ h
24. 
    
25. 　　DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
      v0 A9 r. t. ~1 L# n% B/ b
26. 
    
27. 　　// 将USART Tx的GPIO配置为推挽复用模式
    ' ?9 S8 Y! [6 z; Z6 V; ~; @2 U9 h
28. 
    ! T5 U' `* \# s+ L
29. 　　GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
    / \9 Q) |, F) G$ T
30. 
    " p8 M1 n* M$ W5 q& f2 E$ J
31. 　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    , t' I9 n& V, u# V% |
32. 
    
33. 　　GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
34. 
    1 ~* v" s& u+ f  Y: C. G
35. 　　GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
    1 [0 O# n4 n7 c! ^4 v( a1 U9 g
36. 
    
37. 　　// 将USART Rx的GPIO配置为浮空输入模式
    
38. 
    8 q/ v8 _4 F% g( x! S* @
39. 　　GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
    
40. 
    
41. 　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
42. 
    1 w0 L9 E+ f5 ^$ P; X+ @
43. 　　GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
    
44. 
    
45. 　　// 配置串口的工作参数
    ( s" ^  j/ n3 J' B
46. 
    
47. 　　// 配置波特率
    
48. 
    
49. 　　USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
    + w* e. u/ l" Y  ?. }5 u
50. 
    
51. 　　// 配置 针数据字长
    , I0 }$ L8 D0 r/ k4 ]
52. 
    0 N1 x( l) k8 g4 l% x$ t6 }
53. 　　USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    % b/ d+ c, l3 ~; ?  R9 N
54. 
    1 x, C+ E* k6 [  }
55. 　　// 配置停止位
    
56. 
    
57. 　　USART_InitStructure.USART_StopBits = USART_StopBits_1;
    5 F% ^, k2 _, |
58. 
    * Y* e$ D0 V4 c; k' O! F
59. 　　// 配置校验位
    
60. 
    9 G8 a- `' r+ u, Q: e
61. 　　USART_InitStructure.USART_Parity = USART_Parity_No ;
    
62. 
    5 g; t; z9 q9 U4 g: z8 w
63. 　　// 配置硬件流控制
    
64. 
    9 c# o1 f- X. B) v/ D
65. 　　USART_InitStructure.USART_HardwareFlowControl =
    / |& G. D0 j# v
66. 
    ; @* i* q, x* z  e
67. 　　USART_HardwareFlowControl_None;
    
68. 
    ) V+ l2 F% O2 T$ v; `( b
69. 　　// 配置工作模式，收发一起
    
70. 
    8 Y2 Y* z; T+ X$ j4 y8 \, Q3 l
71. 　　USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    + R& p/ c* L: z. g9 ?9 |' n
72. 
    , D# t' M  z# z' k6 p# i. a9 Z  J
73. 　　// 完成串口的初始化配置
    
74. 
    3 }3 ~) }- U6 Z4 U* G
75. 　　USART_Init(DEBUG_USARTx, &USART_InitStructure);
    
76. 
    
77. 　　// 串口中断优先级配置
    1 ~1 k# W* ~, q) s' {
78. 
    
79. 　　NVIC_Configuration();
    
80. 
    ! p. A, Z  W) r! N
81. 　　#if USE_USART_DMA_RX
    
82. 
    
83. 　　// 开启 串口空闲IDEL 中断
    
84. 
    
85. 　　USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);
    . v1 }8 n# l3 F# A& k& J% t, l
86. 
    
87. 　　// 开启串口DMA接收
    * g) l% ~& X7 u
88. 
    
89. 　　USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Rx, ENABLE);
    $ m. _& T2 f* n7 J( |  {" g
90. 
    
91. 　　/* 使能串口DMA */
    
92. 
    2 s4 d/ Y/ B/ M  U
93. 　　USARTx_DMA_Rx_Config();
    & x2 S1 q: ?, a
94. 
    ( ~7 b% H/ N/ Q+ ]$ H( Q1 i
95. 　　#else
    
96. 
    ! G/ o6 w% n3 _: l9 `+ S' @* [
97. 　　// 使能串口接收中断
    
98. 
    ) O0 L0 T% s/ @! A& D+ m7 F3 L
99. 　　USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);
    4 _; V% L" K$ P: _9 b! V
100. 
     $ {. ?- `1 L! F5 c% {; n: b0 D
101. 　　#endif
     
102. 
     
103. 　　#if USE_USART_DMA_TX
     7 t& s" w- }7 t, |5 Z
104. 
       |; `( {; J- `! V5 u3 \
105. 　　// 开启串口DMA发送
     7 F9 i- [: I# H6 }
106. 
     , q& p( z8 ~2 b3 K, U8 N! U
107. 　　// USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Tx, ENABLE);
     / d' q4 Y3 t* J' m  }2 m
108. 
     3 L; ~, E8 d8 k
109. 　　USARTx_DMA_Tx_Config();
     ( n( Y" b  T: f, P
110. 
     4 @( z* B" }1 I
111. 　　#endif
     
112. 
     ( r3 k# g, Z6 A! ^# R
113. 　　// 使能串口
     ) D5 @  g  f$ r
114. 
     
115. 　　USART_Cmd(DEBUG_USARTx, ENABLE);
     
116. 
     7 e8 d6 W# t* _9 `% @
117. 　　}

复制代码

% `: T, F- Q" b0 }　　串口DMA配置
( \: `3 S# V3 d2 S1 m" U　　把DMA配置完成，就可以直接打开DMA了，让它处于工作状态，当有数据的时候就能直接搬运了。
2 ^6 v% G4 R# Y　　#if USE_USART_DMA_RX
% C$ |+ c/ F: g8 q2 Q　　游客，如果您要查看本帖隐藏内容请回复
　　接收完数据处理
0 G+ p+ l3 a6 ]8 v- ~9 M' s　　因为接收完数据之后，会产生一个idle中断，也就是空闲中断，那么我们就可以在中断服务函数中知道已经接收完了，就可以处理数据了，但是中断服务函数的上下文环境是中断，所以，尽量是快进快出，一般在中断中将一些标志置位，供前台查询。在中断中先判断我们的产生在中断的类型是不是idle中断，如果是则进行下一步，否则就无需理会。

1. 　　void DEBUG_USART_IRQHandler(void)
   
2. 
   8 C: c/ ~/ c- X, e& E) b
3. 　　{
   
4. 
   
5. 　　#if USE_USART_DMA_RX
   - }! m3 V+ G$ j" q
6. 
   ; ^% f  O7 ]! l; q
7. 　　/* 使用串口DMA */
   
8. 
   
9. 　　if(USART_GetITStatus(DEBUG_USARTx,USART_IT_IDLE)!=RESET)
   ) f" v4 [. H$ Z; a: v9 o) ~5 X
10. 
    + D; {0 u" |+ j- |: ^, Y
11. 　　{
    
12. 
    ' V' s4 G7 F) v/ J4 m' F
13. 　　/* 接收数据 */
    3 X. |# p) w" J5 n6 ?
14. 
    
15. 　　Receive_DataPack();
    
16. 
    
17. 　　// 清除空闲中断标志位
    
18. 
    
19. 　　USART_ReceiveData( DEBUG_USARTx );
    
20. 
    9 V: N$ R" y8 m
21. 　　}
    - c; [9 ]8 ?% ]. c
22. 
    
23. 　　#else
    
24. 
    4 |: A3 Q$ [3 H; N4 G. ~6 Y
25. 　　/* 接收中断 */
    $ a( D) G2 T9 `9 R- A+ i6 z, ?2 Q
26. 
    ) i4 l+ y+ u1 |* }' U
27. 　　if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET)
    . T* u5 f' c+ o( B$ ^7 }% p
28. 
    1 F1 l, y- R: X9 v# z
29. 　　{
    . n. k" U% O' N, |8 J) G0 \8 Z, l! H
30. 
    
31. 　　Receive_DataPack();
    1 R" Y& k; r# O$ @. v
32. 
    
33. 　　}
    5 C, O+ a/ x( C! I9 x. e
34. 
    
35. 　　#endif
    : i* d0 u2 O$ u" q6 @+ `
36. 
    ! S$ i6 ~6 H! l
37. 　　}
    
38. 
    
39. 　　Receive_DataPack()

复制代码

" [% V0 D! E+ J: R+ M6 \8 B4 v! t) o$ R) ~　　这个才是真正的接收数据处理函数，为什么我要将这个函数单独封装起来呢?因为这个函数其实是很重要的，因为我的代码兼容普通串口接收与空闲中断，不一样的接收类型其处理也不一样，所以直接封装起来更好，在源码中通过宏定义实现选择接收的方式!更考虑了兼容操作系统的，可能我会在系统中使用dma+空闲中断，所以，供前台查询的信号量就有可能不一样，可能需要修改，我就把它封装起来了。不过无所谓，都是一样的。

　　/*
　　DMA 开启，等待数据。注意，如果中断发送数据帧的速率很快，MCU来不及处理此次接收到的数据，
　　中断又发来数据的话，这里不能开启，否则数据会被覆盖。有2种方式解决：
　　1. 在重新开启接收DMA通道之前，将Rx_Buf缓冲区里面的数据复制到另外一个数组中，
　　然后再开启DMA，然后马上处理复制出来的数据。
! ^3 z6 W4 e) d) A8 u2 k3 O　　2. 建立双缓冲，重新配置DMA_MemoryBaseAddr的缓冲区地址，那么下次接收到的数据就会
　　保存到新的缓冲区中，不至于被覆盖。
　　*/
8 S# o0 y9 ^: ]  c! {5 U　　}
8 o; z/ O2 W8 ^3 l; {
, z% X, R+ x) t6 z- t
5 b& E1 `# w5 J8 Z8 _

ad_gao

硬件接收信息可以用DMA