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

8 Q) O' o+ x* U7 \, b# P/ JDMA全称Direct Memory Access，即直接内存访问。
普通DMA的使用是在DMA的数据流中进行的，设置好DMA的起点和终点以及传输的数据量即可开启DMA传输。

6 y% a0 ^. ]& X3 w7 s" O" ^

DMA开启后就开始从起点将数据搬运至终点，每搬一次，传输数据量大小就减1，当传输数据量为0时，DMA停止搬运。
" p  ^( [- \& z  b
* v* y+ ^% Y" c) |( T/ @& }: |DMA的传输模式如果是普通模式，则当传输数据量为0时，需要程序中手动将传输数据量重新设置满才能开启下一次的DMA数据传输。
( D# _( h) L  F* _: F3 j8 O1 u. [DMA的传输模式如果是循环模式，则当传输数据量为0时，会自动将传输数据量设置为满的，这样数据就能不断的传输。


0 t5 [& C" h+ L2 W5 n3 m0 ~5 w: T8 [
" Q2 Y+ j! [# B# g' ~- D% G那么，双缓冲是什么意思呢？
我们知道，普通DMA的目标数据储存区域只有一个，也就是如果当数据存满后，新的数据又传输过来了，那么旧的数据会被新的数据覆盖。（这就是普通DMA的缺点）
* W( Y  O$ ]5 |7 f8 v  {
6 g  O; ]) {5 g5 R3 H# f

7 o' q4 i" K2 q. S% n) r; F
而双缓冲模式下，我们DMA的目标数据储存区域有两个，也就是双缓冲，
! Q% T% N" Z9 U) ], U当一次完整的数据传输结束后（即Counter值从初始值变为0），会自动指向另一个内存区域。

- ?" _; E+ f! }0 q6 u

如何使用DMA双缓存？
那么我们在程序里怎么使用双缓冲呢？
* {+ ~! L* U: L/ A/ @7 D' M6 N这里我们有两种方案使用双缓冲，一种是利用双缓冲自动跳转内存区域，一种是主动跳转内存区域。

5 f# g2 ]; G6 d这里我们使用DMA的传输模式是循环模式
- i8 _" t' {, P) ~: D

1. DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
   ( u/ `1 e- i8 b

复制代码

首先是第一种：
这里我们以大疆RoboMaster的遥控器使用为示例：
首先我们定义好双缓冲使用的两个内存区域
/ w$ g8 W, p& k3 t; ~5 C

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

复制代码

这里我们设置长度为18，也就是一帧遥控器数据的长度。

7 _/ M4 z1 x  B% V5 [$ C

1. DMA_InitStruct.DMA_BufferSize = 18;
   ' X$ Q3 R6 I" w7 G4 U

复制代码

) l8 R4 a  k  [" [然后配置好双缓冲的两个内存区域地址

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

复制代码

这里配置内存区域2的地址，并把当前DMA指向内存区域1的地址

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

复制代码

9 `' m' c" z5 Z3 p' j启动DMA双缓冲
2 O1 I# S8 ?, y" j' s

1. DMA_DoubleBufferModeCmd(DMA1_Stream1, ENABLE);
   

复制代码

我们使用DMA时利用串口的空闲中断接收一帧一帧的数据。
在串口中断处理函数中对数据进行处理
7 T* U' O" C8 |* r# A3 S; C" A

1. 
   
2. uint16_t this_time_rx_len = 0;        //当前剩余数据长度
   
3. 
   , ?1 B: S; Q8 W$ P  e& c5 P5 {
4. if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)        //判断是否为空闲中断
   ' M; ]) D+ K0 y) _& T# [" r5 F2 b( d
5.     {
   
6.         USART_ReceiveData(USART3);        //清除空闲中断标志位
   & [( ]- g8 y$ @: k
7. 
   ( H0 d3 N6 V9 |  A7 [; S) t# l
8.         if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0)        //获取当前目标内存是否为 DMA_Memory_0
   
9.         {
   
10.             //重新设置DMA
    8 C/ X: v: w/ h: h" f
11.             DMA_Cmd(DMA1_Stream1, DISABLE);
    1 p2 u, x4 ~. x2 _+ b1 S
12.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);        //获取当前剩余数据量
    
13.                                        
    ) M! I/ {$ Y* s
14.                                          DMA_SetCurrDataCounter(DMA1_Stream1, 18);        //重新设置数据量
    
15.                                           
    
16.                                          DMA_Cmd(DMA1_Stream1, ENABLE);
    * I# T. m# L; I) G9 L
17.             if(this_time_rx_len == 18)        //接收成功18个字节长度
    " t; [% g; G9 |7 v# y, ~
18.             {
    
19.                 //处理遥控器数据
    
20.                 RemoteDataProcess(sbus_rx_buffer[1]);        //Memory_1
    1 p. n. V; K9 I- Q4 f
21.             }
    & \7 O6 S$ }7 W* K' W3 N. n5 s, C
22. 
    1 j. M% \- }. U
23.         }
    
24.         else        //获取当前目标内存是否为 DMA_Memory_1
    
25.         {
      K) x% x8 a5 N7 K: I5 u
26.             //重新设置DMA
    
27.             DMA_Cmd(DMA1_Stream1, DISABLE);
    9 A1 @- g- H( E( B1 m0 m
28.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);                //获取当前剩余数据量
    * r% @* ]% o* m& O3 V& ~
29. 
    5 W1 W8 I' j/ R' ~- x
30.                                                 DMA_SetCurrDataCounter(DMA1_Stream1, 18);        //重新设置数据量
    
31. 
    / ]  D1 F/ k: P( I% v) u1 Y
32.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    8 L8 p: \, T" q' I8 v
33. 
    
34.             if( this_time_rx_len== 18)        //接收成功18个字节长度
    . B' q; t& q% W
35.             {
    * u0 Z1 T& [6 d/ k8 H6 |% o+ s* c
36.                 //处理遥控器数据
    
37.                 RemoteDataProcess(sbus_rx_buffer[0]);        //Memory_0
    
38.             }
    
39. 
    $ H  z5 D# v# P. h; J! a- i- B; E
40.         }
    , k9 j5 s' Q4 O* Q. q
41.     }
    7 Z: L4 P3 I! H- p& I* }# G: _* R

复制代码

该逻辑在程序复位后，当一帧遥控器数据发送过来后，Memory0区域被填满18个字节，DMA自动指向Memory1，所以第一次进入中断处理函数时，获取内存指向的时候得到的指向是Memory1。
然后判断剩余数据大小是否为18，如果是则说明上一帧数据接收正常，可以对数据进行处理，如果不为18，则说明上一帧数据接收长度不正常，这时候就不对数据进行处理，当下一帧数据发送过来后对数据进行检验，正常后才对数据进行处理。
1 E6 d, g: I$ r- ~; z" o8 F
然后是第二种：
" i6 Z: |+ d+ m5 M; S4 m$ J这里我们将BufferSize改为比一帧数据长度大的值（比18大），这样可以在一帧数据传输完成后不会因Counter值变0导致DMA指向下一内存区域。

! T3 r  V/ p1 l+ C" z, U3 v

1. DMA_InitStruct.DMA_BufferSize = 36;
   

复制代码

1. uint16_t this_time_rx_len = 0;        //当前剩余数据长度
   
2. 
   1 r4 `  R) _. A7 d6 J2 @" J& N4 E% H8 c
3. if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)        //判断是否为空闲中断
   , s0 H& o# F9 V8 `8 S9 w
4.     {
   
5.         USART_ReceiveData(USART3);        //清除空闲中断标志位
   
6. 
   
7.         if(DMA_GetCurrentMemoryTarget(DMA1_Stream1) == DMA_Memory_0)        //获取当前目标内存是否为 DMA_Memory_0
   
8.         {
   
9.             //重新设置DMA
   
10.             DMA_Cmd(DMA1_Stream1, DISABLE);
    
11.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);        //获取当前剩余数据量  接收18字节，则剩余数据量为36-18=18
    
12.                                        
    
13.                                           DMA_SetCurrDataCounter(DMA1_Stream1, 36);        //重新设置数据量
    & ~* u$ i* f, K" z9 n2 u) t, g" {( K
14.                                                 DMA1_Stream1->CR |= (uint32_t)(DMA_SxCR_CT);  //将DMA指向Memory1
    
15.                                        
    
16.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    $ |" H; f8 B# U, X* ^% h
17.             if(this_time_rx_len == 18)        //接收成功18个字节长度
    
18.             {
    . _% p/ r. o) x" y( ]
19.                 //处理遥控器数据
    
20.                 RemoteDataProcess(sbus_rx_buffer[0]);        //Memory_0
    ( h: O4 e- T+ Q2 G
21.             }
    
22. 
      d$ x. ]1 J3 r4 D% Q
23.         }
    
24.         else        //获取当前目标内存是否为 DMA_Memory_1
    
25.         {
    
26.             //重新设置DMA
    
27.             DMA_Cmd(DMA1_Stream1, DISABLE);
    ( Z) J8 M- \' v6 b. ?$ O
28.                                           this_time_rx_len = DMA_GetCurrDataCounter(DMA1_Stream1);                //获取当前剩余数据量 接收18字节，则剩余数据量为36-18=18
    8 p2 o7 ~6 c$ l- P8 `$ O6 Y9 Y/ z/ G
29. 
    0 y' b2 z# j' A( m# |( D
30.                                                 DMA_SetCurrDataCounter(DMA1_Stream1, 36);        //重新设置数据量
    
31.                                                 DMA1_Stream1->CR &= ~(uint32_t)(DMA_SxCR_CT);  将DMA指向Memory0
    
32. 
    
33.                                                 DMA_Cmd(DMA1_Stream1, ENABLE);
    : Y& |8 w/ B  l  c5 b
34. 
    7 m/ _9 A  ^' _' H* y' Q* E
35.             if( this_time_rx_len == 18)        //接收成功18个字节长度
    
36.             {
    
37.                 //处理遥控器数据
    
38.                 RemoteDataProcess(sbus_rx_buffer[1]);        //Memory_1
    
39.             }
    
40. 
    
41.         }
    ! A# m# K2 ]+ i: h3 V
42.     }
    

复制代码

! m8 o# J% R$ k4 D, @9 |: ]两种DMA双缓冲使用方法的区别
" Q$ I7 j# H, U. G7 |' C. \第二种方法和第一种方法的区别大同小异，这种方法由于将BufferSize设为比18大的值，也就是当第一帧数据传输完成后，Counter值不会自动填满，且内存区域还是指向Memory0，然后我们将剩余数据量保存下来，再将Counter值填满，接着把DMA指向Memory1，最后通过判断剩余数据量来决定是否对数据进行处理。

8 W+ k8 n- a7 B0 n可以看到，在第一种方法下，我们并没有使用

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

复制代码

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

复制代码

. l4 z% O. i7 T  B
! N  O# w" @! Z- h( o! J这是因为当传输数据量和BufferSize大小一致时，完整接收完一帧数据后，DMA会自动指在向下一内存地址，因此在第二种方法中的手动改变内存指向就由DMA自动处理了。
————————————————
# d9 Q: [" h! ^% v5 ~- ]版权声明：水木皆Ming
5 O3 E: U$ _5 j; X

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