DMA双缓冲是什么？
在使用STM32的DMA时我们通常使用的是普通DMA传输，但STM32自带了一个双缓冲模式设置，这个模式有什么优点呢？
接下来我会在下面的介绍里详细说明：

DMA全称Direct Memory Access，即直接内存访问。
" G8 y: y" _  V. ?- j$ q普通DMA的使用是在DMA的数据流中进行的，设置好DMA的起点和终点以及传输的数据量即可开启DMA传输。
5 u3 `# u& N; u* t2 a; d; B' }


DMA开启后就开始从起点将数据搬运至终点，每搬一次，传输数据量大小就减1，当传输数据量为0时，DMA停止搬运。

DMA的传输模式如果是普通模式，则当传输数据量为0时，需要程序中手动将传输数据量重新设置满才能开启下一次的DMA数据传输。
DMA的传输模式如果是循环模式，则当传输数据量为0时，会自动将传输数据量设置为满的，这样数据就能不断的传输。


9 t; C( u$ J- e8 P0 j/ [4 f( K
2 I% d8 }* H" y/ i; [, G; k) k那么，双缓冲是什么意思呢？
我们知道，普通DMA的目标数据储存区域只有一个，也就是如果当数据存满后，新的数据又传输过来了，那么旧的数据会被新的数据覆盖。（这就是普通DMA的缺点）

# K" ~$ }" `5 P7 P& b7 s7 `$ X6 x
8 i- B7 A/ \( {0 K
; @- N* P, `9 z0 a# m
, i) ]* P1 h+ l/ S  v而双缓冲模式下，我们DMA的目标数据储存区域有两个，也就是双缓冲，
当一次完整的数据传输结束后（即Counter值从初始值变为0），会自动指向另一个内存区域。
0 r. A5 {6 N5 k0 e/ H/ S' P0 P


如何使用DMA双缓存？
那么我们在程序里怎么使用双缓冲呢？
这里我们有两种方案使用双缓冲，一种是利用双缓冲自动跳转内存区域，一种是主动跳转内存区域。
4 k; e' |( p6 v( j* Y1 ~
这里我们使用DMA的传输模式是循环模式
5 G! J, |( s7 u

1. DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
   

复制代码

首先是第一种：
这里我们以大疆RoboMaster的遥控器使用为示例：
; B3 n) S2 ?- Z% x3 h! k( `- }首先我们定义好双缓冲使用的两个内存区域
1 L" W! X+ e8 F: u+ C1 q6 K

1. uint8_t sbus_rx_buffer[2][18u]; //double sbus rx buffer to save data
   

复制代码

0 b  M7 {7 V% x* u这里我们设置长度为18，也就是一帧遥控器数据的长度。

, p* W" g4 U0 D% V- i/ b2 k

1. DMA_InitStruct.DMA_BufferSize = 18;
   / h# \1 y; Y7 k- R& W9 o  ?3 Q, ^

复制代码

然后配置好双缓冲的两个内存区域地址

+ P: W! E3 c5 k

1. DMA_InitStruct.DMA_Memory0BaseAddr =  (uint32_t)&sbus_rx_buffer[0][0];
   

复制代码

0 [8 Q' q/ ^+ Z" y这里配置内存区域2的地址，并把当前DMA指向内存区域1的地址
( L; c" T- C% E

1. DMA_DoubleBufferModeConfig(DMA1_Stream1,(uint32_t)&sbus_rx_buffer[1][0],DMA_Memory_0); //first used memory configuration
   % u/ y' C$ e( s/ ]- |

复制代码

启动DMA双缓冲

) M" p# k4 M0 ^

1. DMA_DoubleBufferModeCmd(DMA1_Stream1, ENABLE);
   ; m2 B" `8 O6 G8 J& q

复制代码

7 @# R3 S$ t- b$ R! F/ {我们使用DMA时利用串口的空闲中断接收一帧一帧的数据。
/ s* M( b. w8 u' y  c: E在串口中断处理函数中对数据进行处理
# O! B) Y: s( Y8 ]8 R

1. 
   
2. uint16_t this_time_rx_len = 0;        //当前剩余数据长度
   4 w# r: l5 F# V2 d' C2 d
3. 
   
4. if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)        //判断是否为空闲中断
   
5.     {
   
6.         USART_ReceiveData(USART3);        //清除空闲中断标志位
   
7. 
   
8.         if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0)        //获取当前目标内存是否为 DMA_Memory_0
   
9.         {
   9 D6 L! B: `$ [# s! A' h
10.             //重新设置DMA
    ! i$ A2 [, i% i' M5 F9 `. k
11.             DMA_Cmd(DMA1_Stream1, DISABLE);
    6 x! s) a: B7 v: M( A
12.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);        //获取当前剩余数据量
    
13.                                        
    
14.                                          DMA_SetCurrDataCounter(DMA1_Stream1, 18);        //重新设置数据量
    
15.                                           
    9 K4 H# M5 q2 W; d6 O
16.                                          DMA_Cmd(DMA1_Stream1, ENABLE);
    ( b) N5 G. Z  S
17.             if(this_time_rx_len == 18)        //接收成功18个字节长度
    
18.             {
    
19.                 //处理遥控器数据
    
20.                 RemoteDataProcess(sbus_rx_buffer[1]);        //Memory_1
    
21.             }
    8 P* @- b  y; M$ {* L0 j
22. 
    " a$ J) q" @  |6 \
23.         }
    
24.         else        //获取当前目标内存是否为 DMA_Memory_1
    # f% M8 M, x& v  [
25.         {
    7 u* Z) p& o1 B+ J
26.             //重新设置DMA
    " h- F' M* A( J0 k
27.             DMA_Cmd(DMA1_Stream1, DISABLE);
    
28.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);                //获取当前剩余数据量
    
29. 
    
30.                                                 DMA_SetCurrDataCounter(DMA1_Stream1, 18);        //重新设置数据量
    
31. 
    6 {3 ?/ S& c) ]9 ?
32.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    
33. 
    5 M6 M: k6 n# z0 {$ Z4 Z4 {
34.             if( this_time_rx_len== 18)        //接收成功18个字节长度
    , W% H  h7 b( j( e
35.             {
    
36.                 //处理遥控器数据
    " G% I6 [% s% Z' g, g8 B! y1 U
37.                 RemoteDataProcess(sbus_rx_buffer[0]);        //Memory_0
    
38.             }
    
39. 
    
40.         }
    
41.     }
    

复制代码

该逻辑在程序复位后，当一帧遥控器数据发送过来后，Memory0区域被填满18个字节，DMA自动指向Memory1，所以第一次进入中断处理函数时，获取内存指向的时候得到的指向是Memory1。
0 c" z6 c2 I- A8 c2 G7 o1 i9 x然后判断剩余数据大小是否为18，如果是则说明上一帧数据接收正常，可以对数据进行处理，如果不为18，则说明上一帧数据接收长度不正常，这时候就不对数据进行处理，当下一帧数据发送过来后对数据进行检验，正常后才对数据进行处理。
  T6 n: {/ k: @8 Q8 T
然后是第二种：
9 ?3 X$ ]: {4 D1 [. M这里我们将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)        //判断是否为空闲中断
   ; ~$ Z; }" X! K+ P' j- |2 Q- |2 x
4.     {
   
5.         USART_ReceiveData(USART3);        //清除空闲中断标志位
   8 _8 v& I8 I3 F/ ^: s1 f. Y
6. 
   5 Q% q- C' u3 L' E
7.         if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0)        //获取当前目标内存是否为 DMA_Memory_0
   , v2 b2 l* i. a: a% I) X2 ]5 f
8.         {
   # ^& p6 `% G9 P4 {- I* ?3 H
9.             //重新设置DMA
   , _4 Z, }$ U: v" m1 L% u. q4 b
10.             DMA_Cmd(DMA1_Stream1, DISABLE);
    5 d% R7 ^$ x) C1 b
11.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);        //获取当前剩余数据量  接收18字节，则剩余数据量为36-18=18
    
12.                                        
    ; u* ]( W, x" C( o' ~; _3 @
13.                                           DMA_SetCurrDataCounter(DMA1_Stream1, 36);        //重新设置数据量
    
14.                                                 DMA1_Stream1->CR |= (uint32_t)(DMA_SxCR_CT);  //将DMA指向Memory1
    
15.                                        
    : }7 a7 s  J; z7 f. J, g+ x3 Q
16.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    
17.             if(this_time_rx_len == 18)        //接收成功18个字节长度
    5 z( ?- |- m5 K: v9 O
18.             {
    . e+ h4 ~9 C- \, I4 b4 z7 j, P
19.                 //处理遥控器数据
    4 k- h' d& d: i% D; Y6 d1 W
20.                 RemoteDataProcess(sbus_rx_buffer[0]);        //Memory_0
    
21.             }
    
22. 
    - n- z' A" C3 Z& [0 D
23.         }
    1 x1 U( \% T3 Y7 J$ @3 ^3 d
24.         else        //获取当前目标内存是否为 DMA_Memory_1
    . c! s" ~+ b# S. A; M/ X
25.         {
    : _: S# r2 |* e0 o8 i
26.             //重新设置DMA
    : @: E* Y- X% N: |# I
27.             DMA_Cmd(DMA1_Stream1, DISABLE);
    
28.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);                //获取当前剩余数据量 接收18字节，则剩余数据量为36-18=18
    
29. 
    
30.                                                 DMA_SetCurrDataCounter(DMA1_Stream1, 36);        //重新设置数据量
    
31.                                                 DMA1_Stream1->CR &= ~(uint32_t)(DMA_SxCR_CT);  将DMA指向Memory0
    
32. 
    
33.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    
34. 
    
35.             if( this_time_rx_len == 18)        //接收成功18个字节长度
    
36.             {
    4 I( G  H% U, }! S8 @
37.                 //处理遥控器数据
    
38.                 RemoteDataProcess(sbus_rx_buffer[1]);        //Memory_1
    & G8 S7 q. h- m' M7 C% c- K  W1 L
39.             }
    
40. 
    ) d4 Y. C  g$ Y- U; X) ]2 r1 B5 d2 g
41.         }
    2 P$ P, w! A) _- t/ M3 a5 i5 U
42.     }
    1 ~# h8 V% s* T% O. i* m

复制代码

: E! L  ]5 [  r两种DMA双缓冲使用方法的区别
第二种方法和第一种方法的区别大同小异，这种方法由于将BufferSize设为比18大的值，也就是当第一帧数据传输完成后，Counter值不会自动填满，且内存区域还是指向Memory0，然后我们将剩余数据量保存下来，再将Counter值填满，接着把DMA指向Memory1，最后通过判断剩余数据量来决定是否对数据进行处理。

可以看到，在第一种方法下，我们并没有使用
: [9 N& c- y- s9 G! q4 \& z2 b; \
( l0 u$ t$ I( e

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

复制代码

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

复制代码

# Z& M( F/ {) |; f
/ c" ?% b7 V8 b这是因为当传输数据量和BufferSize大小一致时，完整接收完一帧数据后，DMA会自动指在向下一内存地址，因此在第二种方法中的手动改变内存指向就由DMA自动处理了。
. Q, T( v/ z7 N4 \————————————————
版权声明：水木皆Ming
1 [# I1 E& \% N

' h6 T. U/ |" j! Z" m0 {: M

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