DMA双缓冲是什么？
在使用STM32的DMA时我们通常使用的是普通DMA传输，但STM32自带了一个双缓冲模式设置，这个模式有什么优点呢？
接下来我会在下面的介绍里详细说明：
7 b9 n. b9 z" ^* d7 {
) m" h3 n1 z! O# o$ G0 }. Y/ G; hDMA全称Direct Memory Access，即直接内存访问。
0 \1 E3 m* Z& {& J; {; w普通DMA的使用是在DMA的数据流中进行的，设置好DMA的起点和终点以及传输的数据量即可开启DMA传输。
& b! k9 v& n" I3 w$ a1 c- A

4 L2 [7 n$ d, Z% P2 |+ o
DMA开启后就开始从起点将数据搬运至终点，每搬一次，传输数据量大小就减1，当传输数据量为0时，DMA停止搬运。

DMA的传输模式如果是普通模式，则当传输数据量为0时，需要程序中手动将传输数据量重新设置满才能开启下一次的DMA数据传输。
: l' u$ E, ^% {" j9 |+ ?( }DMA的传输模式如果是循环模式，则当传输数据量为0时，会自动将传输数据量设置为满的，这样数据就能不断的传输。
* R. x" j, U' V. W7 F1 O


2 C% ~+ A% k! N那么，双缓冲是什么意思呢？
( T! Z- O# L0 g# L' h. i我们知道，普通DMA的目标数据储存区域只有一个，也就是如果当数据存满后，新的数据又传输过来了，那么旧的数据会被新的数据覆盖。（这就是普通DMA的缺点）
) [1 c4 K/ O$ W5 Y; X: e

5 n; b( x1 v4 z
$ H9 D  p# L; ?9 r
而双缓冲模式下，我们DMA的目标数据储存区域有两个，也就是双缓冲，
当一次完整的数据传输结束后（即Counter值从初始值变为0），会自动指向另一个内存区域。



如何使用DMA双缓存？
那么我们在程序里怎么使用双缓冲呢？
+ S2 t% _; _2 W- `- H  ^1 J3 G这里我们有两种方案使用双缓冲，一种是利用双缓冲自动跳转内存区域，一种是主动跳转内存区域。
1 j' k, _7 @' }  A
这里我们使用DMA的传输模式是循环模式

1. DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
   $ e/ o; y1 U- k- N0 B! f8 i1 o

复制代码

首先是第一种：
7 i) Z0 ?& j# ^9 S; B这里我们以大疆RoboMaster的遥控器使用为示例：
3 P4 J6 J% `4 o1 Z' d: W- a首先我们定义好双缓冲使用的两个内存区域
1 u" s: n: v( x7 N' N

1. uint8_t sbus_rx_buffer[2][18u]; //double sbus rx buffer to save data
     W+ y# m7 y' c

复制代码

这里我们设置长度为18，也就是一帧遥控器数据的长度。
" C1 w4 _2 o; y# z0 x

1. DMA_InitStruct.DMA_BufferSize = 18;
   

复制代码

* w1 E& R2 g( v- j. Q然后配置好双缓冲的两个内存区域地址

1. DMA_InitStruct.DMA_Memory0BaseAddr =  (uint32_t)&sbus_rx_buffer[0][0];
   6 S) a* C; u+ }

复制代码

这里配置内存区域2的地址，并把当前DMA指向内存区域1的地址
) r, e: {( ~8 ?3 o3 A( w) D* h0 K2 G

1. DMA_DoubleBufferModeConfig(DMA1_Stream1,(uint32_t)&sbus_rx_buffer[1][0],DMA_Memory_0); //first used memory configuration
   

复制代码

启动DMA双缓冲
" e5 a$ `! y5 T& H/ C4 d
) B! h/ N# V, u  {" N

1. DMA_DoubleBufferModeCmd(DMA1_Stream1, ENABLE);
   

复制代码

我们使用DMA时利用串口的空闲中断接收一帧一帧的数据。
, ~: H4 l$ {+ h( y5 {$ L* M在串口中断处理函数中对数据进行处理
: p% ]$ F1 y( c/ L# S
  u( u5 j1 K8 k; w2 C, F: G

1. 
   
2. uint16_t this_time_rx_len = 0;        //当前剩余数据长度
   : Z( }* x! k+ u7 U6 r( Y! D( m
3. 
   
4. if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)        //判断是否为空闲中断
   : y# D& \8 O, m+ u
5.     {
   
6.         USART_ReceiveData(USART3);        //清除空闲中断标志位
   
7. 
   " _5 u$ ]3 o, b# {4 X, z  `
8.         if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0)        //获取当前目标内存是否为 DMA_Memory_0
   3 h; U! f8 J. K5 h) n7 W6 g
9.         {
   
10.             //重新设置DMA
    , v+ L5 }3 j# P) _1 N  y
11.             DMA_Cmd(DMA1_Stream1, DISABLE);
    5 S& o/ e9 D- c. v; ?
12.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);        //获取当前剩余数据量
    
13.                                        
    + I! K7 B) o, w2 A  L5 k* o
14.                                          DMA_SetCurrDataCounter(DMA1_Stream1, 18);        //重新设置数据量
    7 i' {4 \- }9 k1 V, ^
15.                                           
    
16.                                          DMA_Cmd(DMA1_Stream1, ENABLE);
    ! m3 n1 Q- J) t5 R
17.             if(this_time_rx_len == 18)        //接收成功18个字节长度
    
18.             {
    
19.                 //处理遥控器数据
    2 ~; Q& }" P+ C# y
20.                 RemoteDataProcess(sbus_rx_buffer[1]);        //Memory_1
    * Z( x. }6 P  K% ]" Y
21.             }
    
22. 
    ( C3 A3 A) r9 ^( E
23.         }
    
24.         else        //获取当前目标内存是否为 DMA_Memory_1
    8 b3 r9 M6 D7 q
25.         {
    / v; M" X) e8 h3 ?% H4 u9 o
26.             //重新设置DMA
    
27.             DMA_Cmd(DMA1_Stream1, DISABLE);
    1 @5 t9 E; F3 _& {* m+ s
28.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);                //获取当前剩余数据量
    
29. 
    4 D9 A2 L) P. @" F4 g3 ?
30.                                                 DMA_SetCurrDataCounter(DMA1_Stream1, 18);        //重新设置数据量
    
31. 
    ! Z: C. M/ W" G* p7 j1 r
32.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    ) f, N1 e' q3 T" I3 O- l' D+ A3 h
33. 
    + V6 Z8 E  U/ z% [* e
34.             if( this_time_rx_len== 18)        //接收成功18个字节长度
    
35.             {
    & J% j  e8 C6 {3 g% n) @
36.                 //处理遥控器数据
    
37.                 RemoteDataProcess(sbus_rx_buffer[0]);        //Memory_0
    / J+ l, I& G1 P+ b0 |% v
38.             }
    * W5 ^- e! |& X  j5 x3 G! ], C
39. 
    1 Z: g: y: \# q7 C6 i+ I
40.         }
    ! s8 C& a3 ~# b! q3 y* c( x
41.     }
    ) x; ?6 Z$ g: M; i

复制代码

该逻辑在程序复位后，当一帧遥控器数据发送过来后，Memory0区域被填满18个字节，DMA自动指向Memory1，所以第一次进入中断处理函数时，获取内存指向的时候得到的指向是Memory1。
7 J; d0 m. L# B& O" a8 f然后判断剩余数据大小是否为18，如果是则说明上一帧数据接收正常，可以对数据进行处理，如果不为18，则说明上一帧数据接收长度不正常，这时候就不对数据进行处理，当下一帧数据发送过来后对数据进行检验，正常后才对数据进行处理。
/ K1 X( d' n% i# A8 J$ R
1 H3 b0 I" Z$ _+ r然后是第二种：
这里我们将BufferSize改为比一帧数据长度大的值（比18大），这样可以在一帧数据传输完成后不会因Counter值变0导致DMA指向下一内存区域。

1. DMA_InitStruct.DMA_BufferSize = 36;
   

复制代码

1. uint16_t this_time_rx_len = 0;        //当前剩余数据长度
   
2. 
   
3. if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)        //判断是否为空闲中断
   
4.     {
   ) t$ }# Y- w( F8 g
5.         USART_ReceiveData(USART3);        //清除空闲中断标志位
   $ L/ X/ i1 K( T' o& L: I' I6 F! g
6. 
   
7.         if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0)        //获取当前目标内存是否为 DMA_Memory_0
   
8.         {
   
9.             //重新设置DMA
   2 w7 D. p( F% u) s" J' m
10.             DMA_Cmd(DMA1_Stream1, DISABLE);
    + I5 W! {: R/ f/ W3 G
11.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);        //获取当前剩余数据量  接收18字节，则剩余数据量为36-18=18
    
12.                                        
    & Z7 }' e1 f9 b9 N, Z& m
13.                                           DMA_SetCurrDataCounter(DMA1_Stream1, 36);        //重新设置数据量
    . }- ?3 Z7 ]8 |+ l% a0 u. n. l- ], }
14.                                                 DMA1_Stream1->CR |= (uint32_t)(DMA_SxCR_CT);  //将DMA指向Memory1
    / u# g2 @2 |  ?; y
15.                                        
    ' n( y6 Q' ]  P. A
16.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    7 c$ p3 c- d0 c" u9 ^7 S
17.             if(this_time_rx_len == 18)        //接收成功18个字节长度
    
18.             {
    3 _2 \9 h; H* B8 e* D6 [! Y
19.                 //处理遥控器数据
    
20.                 RemoteDataProcess(sbus_rx_buffer[0]);        //Memory_0
    3 C) q: A. `# u* @* ?
21.             }
    . M" g/ ^( ?$ x6 v
22. 
    
23.         }
    . X6 {4 G" O, t/ X/ Z2 ?3 t
24.         else        //获取当前目标内存是否为 DMA_Memory_1
    - N/ o' q. o; l# A
25.         {
    ) L$ d4 Q, o4 E# H- ?6 B+ V4 |
26.             //重新设置DMA
    8 V4 K  N! u4 m* j% a: `( W+ \
27.             DMA_Cmd(DMA1_Stream1, DISABLE);
    
28.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);                //获取当前剩余数据量 接收18字节，则剩余数据量为36-18=18
    9 |9 W' O& s- w. h9 N$ D9 n/ R! P8 }
29. 
    
30.                                                 DMA_SetCurrDataCounter(DMA1_Stream1, 36);        //重新设置数据量
    $ K3 r! {. \; R; i! f/ M
31.                                                 DMA1_Stream1->CR &= ~(uint32_t)(DMA_SxCR_CT);  将DMA指向Memory0
    ' |. T+ Q$ V" F$ r# m2 m! Y
32. 
    5 y" J1 A8 \4 g4 ^2 O4 }
33.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    
34. 
    
35.             if( this_time_rx_len == 18)        //接收成功18个字节长度
    
36.             {
    * ^4 b, H/ n( I. Z1 X+ J
37.                 //处理遥控器数据
    
38.                 RemoteDataProcess(sbus_rx_buffer[1]);        //Memory_1
    2 o- J# [9 b5 a+ ]3 d& ^5 P5 X
39.             }
    
40. 
    ) v" C7 X  ]" G+ N
41.         }
    ! _5 a% F1 U0 _# A6 q
42.     }
    

复制代码

- i# Z; k( j% ?/ r6 G. ^两种DMA双缓冲使用方法的区别
' P; q) C- A' u第二种方法和第一种方法的区别大同小异，这种方法由于将BufferSize设为比18大的值，也就是当第一帧数据传输完成后，Counter值不会自动填满，且内存区域还是指向Memory0，然后我们将剩余数据量保存下来，再将Counter值填满，接着把DMA指向Memory1，最后通过判断剩余数据量来决定是否对数据进行处理。
+ M7 c  B" \8 r( e+ i
可以看到，在第一种方法下，我们并没有使用

, A( y+ z+ B1 L) d

1. DMA1_Stream1->CR &= ~(uint32_t)(DMA_SxCR_CT);  将DMA指向Memory0
   ' t- |* Z! Z: m* c- |! w

复制代码

1. DMA1_Stream1->CR |= (uint32_t)(DMA_SxCR_CT);  将DMA指向Memory0

复制代码

* Q' l$ v: U7 l* W
/ W3 q9 b: [/ p" ?这是因为当传输数据量和BufferSize大小一致时，完整接收完一帧数据后，DMA会自动指在向下一内存地址，因此在第二种方法中的手动改变内存指向就由DMA自动处理了。
9 [/ ?3 a( e1 Y6 C————————————————
. Q, e; Z7 D% A/ b7 X版权声明：水木皆Ming

请问一下，使用DMA双缓冲区进行数据的发送的时候，出现了重复发送数据的情况，请问该怎么解决呢？感觉主要是剩余文件数量达不到BUFFER_SIZE要求，带来的重复发送数据。