DMA双缓冲是什么?
: ~" h- T+ G- h* g% b7 v. j在使用STM32的DMA时我们通常使用的是普通DMA传输,但STM32自带了一个双缓冲模式设置,这个模式有什么优点呢?7 P0 [, b: \! x3 q3 A
接下来我会在下面的介绍里详细说明:1 Q5 [# d2 _/ D
' H! i4 b, l- x' K6 \, n
DMA全称Direct Memory Access,即直接内存访问。
5 M) e# |, \+ }5 r! D: M& a4 {普通DMA的使用是在DMA的数据流中进行的,设置好DMA的起点和终点以及传输的数据量即可开启DMA传输。; y0 ]3 ]0 V; {1 ]
5 z# q! e* y; C. Y# M
0 i8 m$ t J) x. W
5 a7 W$ b7 ^. R4 u; L# \! eDMA开启后就开始从起点将数据搬运至终点,每搬一次,传输数据量大小就减1,当传输数据量为0时,DMA停止搬运。% x$ n1 b) F( W: R" y
+ v3 C2 b; y, D9 U6 X, PDMA的传输模式如果是普通模式,则当传输数据量为0时,需要程序中手动将传输数据量重新设置满才能开启下一次的DMA数据传输。8 Y+ f* l: x' W$ p. Y
DMA的传输模式如果是循环模式,则当传输数据量为0时,会自动将传输数据量设置为满的,这样数据就能不断的传输。/ G2 j) b6 a8 s9 y k8 T2 s
, c/ |; @% n G- I, d
& F% _' g4 ~& f* s; [! @9 w' w( m; j6 m& h1 n
那么,双缓冲是什么意思呢?5 f8 B- g. f3 W& T% j% G! \
我们知道,普通DMA的目标数据储存区域只有一个,也就是如果当数据存满后,新的数据又传输过来了,那么旧的数据会被新的数据覆盖。(这就是普通DMA的缺点)& U1 J7 L) h* Z( \
$ w/ R* a: ^8 _3 v3 w3 {
: ^0 B3 q7 U5 y& H( h, J/ _8 t" G
4 ?* R& M; h. ]
4 l n4 U" q: t. R, z r
而双缓冲模式下,我们DMA的目标数据储存区域有两个,也就是双缓冲,
- ^ J. y' n, d* ?: d当一次完整的数据传输结束后(即Counter值从初始值变为0),会自动指向另一个内存区域。! m9 K. T) w3 `+ H1 m8 ]+ h+ J
6 F, Q/ T' | v
& ~3 ^2 I" J# }* k: I
* d. }: v/ X' g; ~$ B. X9 v# K如何使用DMA双缓存?# T- x. {1 y! g5 H
那么我们在程序里怎么使用双缓冲呢?
* b4 W" G0 c6 v5 \/ H9 B4 a这里我们有两种方案使用双缓冲,一种是利用双缓冲自动跳转内存区域,一种是主动跳转内存区域。
% r% D! D% U; X! i& ?
6 R7 P, l7 R. c% E1 a E7 X这里我们使用DMA的传输模式是循环模式5 h- l Q: e: s; a
. c3 h! R I' y3 H& A* U& l- DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;: O! Q% k& x% o4 l
复制代码 5 [+ j, t8 O3 x, l6 ~1 I% D D
首先是第一种:9 P j2 j* t+ D* c) y& i0 h9 V
这里我们以大疆RoboMaster的遥控器使用为示例:
$ \' U% }; N8 E$ T' q) s( I" c8 ?5 t首先我们定义好双缓冲使用的两个内存区域
! m$ g2 y% Y# x3 d4 {& ^- uint8_t sbus_rx_buffer[2][18u]; //double sbus rx buffer to save data1 z1 \( R: D3 u. g
复制代码 5 P6 x+ w$ N$ n7 h( I0 H
这里我们设置长度为18,也就是一帧遥控器数据的长度。. C2 S* V6 b* @7 H
' x4 [6 a# ^* F- L W$ A
- DMA_InitStruct.DMA_BufferSize = 18;, q# l: o( @) h) t" F
复制代码 ( s& _* Z! S; t
然后配置好双缓冲的两个内存区域地址/ k' _2 x) ]2 k7 M$ N+ y2 z! @
! X+ F. c" Y/ r3 t5 H
- DMA_InitStruct.DMA_Memory0BaseAddr = (uint32_t)&sbus_rx_buffer[0][0];! E$ E' P. ~; _
复制代码 ; H& s) U' n- V2 o
这里配置内存区域2的地址,并把当前DMA指向内存区域1的地址0 S2 C' ~$ r+ k0 i, w
9 ~) r8 X' X) X: n% l7 f4 t- DMA_DoubleBufferModeConfig(DMA1_Stream1,(uint32_t)&sbus_rx_buffer[1][0],DMA_Memory_0); //first used memory configuration
: l5 j1 A5 v7 Z% `8 y" ?
复制代码
! C& z) R5 I) ~+ x8 l启动DMA双缓冲
* \0 E9 o8 F3 q/ M3 {
( [& m* j8 m0 @, |. `5 ]8 d- DMA_DoubleBufferModeCmd(DMA1_Stream1, ENABLE);
$ C) O* o+ O6 B/ V+ R9 w$ e
复制代码
: {& h3 E# `. o4 u我们使用DMA时利用串口的空闲中断接收一帧一帧的数据。# O3 \ k, J) `9 Q) h
在串口中断处理函数中对数据进行处理5 F7 @* N, }) Q# l* H9 g: i; D
! K2 f! F& f+ w w- l1 A X-
# [( }6 S7 ~1 [' l8 A* f0 w$ l - uint16_t this_time_rx_len = 0; //当前剩余数据长度
$ c6 v4 @8 s# ]0 U# F% v) M3 r - 5 Q, Y7 p# D7 ?# g k" X0 ^
- if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET) //判断是否为空闲中断" U% t1 ^0 ]* G1 C+ k
- {
: _* G8 K2 H# _$ n" s4 q - USART_ReceiveData(USART3); //清除空闲中断标志位
/ j9 M8 Z% m' _ - ! K6 a3 v! y# ~) t, c' f
- if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0) //获取当前目标内存是否为 DMA_Memory_0
G, s: N( j7 ] - { a; p2 @0 L) y" q# M3 e- H9 g
- //重新设置DMA* H* H0 O' ~3 P: h1 B
- DMA_Cmd(DMA1_Stream1, DISABLE);; Z0 Z7 r( {3 B; h4 B9 g
- this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1); //获取当前剩余数据量
& i( f2 `5 ]6 F - # @' r1 r' z/ h9 e
- DMA_SetCurrDataCounter(DMA1_Stream1, 18); //重新设置数据量
4 T0 q" F0 V: e -
) ]* I' _" }. m" O( V: K - DMA_Cmd(DMA1_Stream1, ENABLE);, u( f |* r2 o# O. q4 M
- if(this_time_rx_len == 18) //接收成功18个字节长度8 F+ F2 x# F9 a3 E+ F7 z
- {
9 b% Z& M# _" A2 N2 x - //处理遥控器数据
6 t+ G7 P4 Y" H3 u+ t - RemoteDataProcess(sbus_rx_buffer[1]); //Memory_1
. S5 q6 k5 S. w" I0 |0 T - }, \& D" \! I- \" A' G( S
) j. D; M/ j* u4 b$ `( m- }
7 R9 k9 X6 R* H7 [; q, K x% L2 l - else //获取当前目标内存是否为 DMA_Memory_1
# V3 c" K0 v# u5 b" J0 ^: P/ w2 b' M! } - {: _3 D- W! I* ^% y8 L$ t/ {
- //重新设置DMA% C4 n# T+ b4 v x: p* Z
- DMA_Cmd(DMA1_Stream1, DISABLE);
) q2 b; K; q# j3 Z1 s. Q - this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1); //获取当前剩余数据量4 M4 D3 a4 x. i4 E3 T, I
- $ a d: g/ N* \3 p% V/ v2 e
- DMA_SetCurrDataCounter(DMA1_Stream1, 18); //重新设置数据量
3 X) [% B# }. I$ U1 A, C# x - * G1 u! q0 m- O0 ^6 c: b
- DMA_Cmd(DMA1_Stream1, ENABLE);& V6 m' Z9 p% B+ H n
9 s* J% k7 y! r- u L2 G- l- if( this_time_rx_len== 18) //接收成功18个字节长度
" ^, O( b8 d4 F* m ~+ N2 H+ j4 r - {9 p8 U! _' u! c: f2 l* Q# K# h0 Q9 ?
- //处理遥控器数据1 b1 T+ Q$ {. L
- RemoteDataProcess(sbus_rx_buffer[0]); //Memory_0
1 k0 `# r7 `- s* y - } e+ {) x3 P2 p9 t2 T B
! s* [1 i' _; R2 |- }9 i. L6 q' c8 y, U% m: A
- }
& P5 M% Q1 {1 [+ E/ m% _: V
复制代码 8 q {3 s7 N9 s! Y0 @ `
该逻辑在程序复位后,当一帧遥控器数据发送过来后,Memory0区域被填满18个字节,DMA自动指向Memory1,所以第一次进入中断处理函数时,获取内存指向的时候得到的指向是Memory1。
- K4 r% @, p# V4 F+ J8 [9 t4 [& W& }# R然后判断剩余数据大小是否为18,如果是则说明上一帧数据接收正常,可以对数据进行处理,如果不为18,则说明上一帧数据接收长度不正常,这时候就不对数据进行处理,当下一帧数据发送过来后对数据进行检验,正常后才对数据进行处理。
8 N" H% _9 N! E1 P: E6 j8 R4 {: `9 h; n& \
然后是第二种:! t8 X+ [* _4 [/ B! O: A0 t
这里我们将BufferSize改为比一帧数据长度大的值(比18大),这样可以在一帧数据传输完成后不会因Counter值变0导致DMA指向下一内存区域。
9 s/ ^( V/ [$ G; g# M
; ~( E, j0 S4 p: X9 |+ l- DMA_InitStruct.DMA_BufferSize = 36;
2 j0 x: Z4 d U5 x* x0 Z/ N
复制代码- uint16_t this_time_rx_len = 0; //当前剩余数据长度; d1 U- H6 g' n' [" w; ?$ T8 A
- $ k+ x' w9 l! {- i6 v& o6 o
- if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET) //判断是否为空闲中断" C# [8 P( S, f
- {- c8 n K0 ]9 ]1 L! H, T* r
- USART_ReceiveData(USART3); //清除空闲中断标志位
1 D8 E( F: P+ s h2 P: b' v9 i% g
: B( u9 P0 U, }- if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0) //获取当前目标内存是否为 DMA_Memory_0% l8 g1 G, m! o: o9 S% q: R2 x
- {! ?! J S* ]- X8 A2 l
- //重新设置DMA. n! q& F; u( t8 m+ W2 H
- DMA_Cmd(DMA1_Stream1, DISABLE);
! y* l5 U' U/ m* H/ V- p& J - this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1); //获取当前剩余数据量 接收18字节,则剩余数据量为36-18=18$ r- y+ E: E2 ^
- 1 R( f# i# ?9 _
- DMA_SetCurrDataCounter(DMA1_Stream1, 36); //重新设置数据量; a: t7 B& S3 x( T8 p" l2 N
- DMA1_Stream1->CR |= (uint32_t)(DMA_SxCR_CT); //将DMA指向Memory1
! L4 ` P; x5 }' j% L$ A# m -
. G5 b: ]: y( j" U4 _ - DMA_Cmd(DMA1_Stream1, ENABLE);8 w; U1 ?/ A5 e. `% e
- if(this_time_rx_len == 18) //接收成功18个字节长度
0 d# n2 ^! n+ C/ c6 y - {, `" a; X/ ~7 b4 a/ U
- //处理遥控器数据
Y# K; `$ u# p - RemoteDataProcess(sbus_rx_buffer[0]); //Memory_0. F; y' H3 U: [4 ~& R
- }
2 D# Y+ u- O* @# M. x - % [. ~8 I! a- _- z( q! h0 d& l3 p
- }
* u! g' t, T" i( U( a' F, B7 } - else //获取当前目标内存是否为 DMA_Memory_1, _- c2 O$ e8 t0 z W3 E2 l
- {
/ n) p3 Q% _ v W - //重新设置DMA
6 ~& A1 a! `( ^) w - DMA_Cmd(DMA1_Stream1, DISABLE);
: K# C7 x) b3 e2 n6 G' x6 l) p - this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1); //获取当前剩余数据量 接收18字节,则剩余数据量为36-18=18& l- g2 K, }( ^& V" X1 }
1 G3 ^+ c4 J9 O0 {3 H- _# P- DMA_SetCurrDataCounter(DMA1_Stream1, 36); //重新设置数据量% {4 c v0 {3 R& l) |
- DMA1_Stream1->CR &= ~(uint32_t)(DMA_SxCR_CT); 将DMA指向Memory0
L, V+ G: s. X - 5 e. z, Y* y* n) I, _5 n
- DMA_Cmd(DMA1_Stream1, ENABLE);8 W+ g* J3 h8 g% \4 d
* C9 t, ^ h1 O- if( this_time_rx_len == 18) //接收成功18个字节长度
( i: _* j' ~; g R$ }! O" U - {9 b. [- L: Y" |; m
- //处理遥控器数据
9 t% {4 {( E* i% J) u - RemoteDataProcess(sbus_rx_buffer[1]); //Memory_1
3 Q i0 K ~0 v7 u+ C - }5 Z' }5 x+ Y" l9 n6 q5 G9 _
- & E4 s2 p# c! U& S: Z# z2 a( ]$ _
- }1 Q& j) ?& {9 b
- }
# J- P, E2 }) j' U4 E0 X% V
复制代码 4 g0 w5 @+ m9 D; y t6 V+ k; J- D
两种DMA双缓冲使用方法的区别8 V% g, c, m: k7 h4 ~! f$ P, N; m
第二种方法和第一种方法的区别大同小异,这种方法由于将BufferSize设为比18大的值,也就是当第一帧数据传输完成后,Counter值不会自动填满,且内存区域还是指向Memory0,然后我们将剩余数据量保存下来,再将Counter值填满,接着把DMA指向Memory1,最后通过判断剩余数据量来决定是否对数据进行处理。& Z; V- J( B8 F9 k* ^
: u2 _+ H) }5 V; r& h' D可以看到,在第一种方法下,我们并没有使用* K+ @+ J2 }! ]% Q8 }. K2 B
_- x+ M7 C) m. f' F- DMA1_Stream1->CR &= ~(uint32_t)(DMA_SxCR_CT); 将DMA指向Memory0
; g+ \5 X; ~0 k' D. v3 R
复制代码- DMA1_Stream1->CR |= (uint32_t)(DMA_SxCR_CT); 将DMA指向Memory0
复制代码 3 D& `! ]) D6 ?4 n9 w5 i4 v7 [5 u: v
) ^- `+ d, n" x3 {) b. {
这是因为当传输数据量和BufferSize大小一致时,完整接收完一帧数据后,DMA会自动指在向下一内存地址,因此在第二种方法中的手动改变内存指向就由DMA自动处理了。4 p% t, O2 u- G/ X; I$ n( T
————————————————4 \& \3 M* N2 I6 h+ e+ `
版权声明:水木皆Ming3 _2 o/ ^6 _8 E& {6 [6 s
9 I# R+ i# O5 c6 V0 b3 x- G5 L S
|
请问一下,使用DMA双缓冲区进行数据的发送的时候,出现了重复发送数据的情况,请问该怎么解决呢?感觉主要是剩余文件数量达不到BUFFER_SIZE要求,带来的重复发送数据。