什么是DMA —- Directional Memory Access, 直接存储器存取用来提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。无须CPU干预，数据可以通过DMA快速地移动，这就节省了CPU的资源来做其他操作

我们通过以下几方面学习串口DMA：
, g) X  {: c# U7 s8 q3 _7 d一、如何理解DMA
2 Z* {" l) [0 }. g7 c2 z对于DMA，打个比方就很好理解：
1 u/ F0 h% V4 e0 A2 {3 k6 T角色预设： 淘宝店主 —- STM32 MCU
快递员 —- 外设（如UART,SPI）
发货室 —- DMA
: X. Y# R+ v% P1、首先你是一个淘宝店主，如果每次发货收货都要跟快递沟通交涉会很浪费时间和精力。
+ |# S& A; s8 ]; ~0 \+ q7 G2 k2、然后你就自己建了一个发货室，发货室里有好多个货柜箱子，每个箱子上都写着快递名字(如果申通快递，顺丰快递等)。
3、每次发什么快递，你就找到对应的货柜箱子，把货物放进去即可，然后跟快递通知一声。
# r2 @( r2 A; k  g7 r! f4、快递取走快件。
5、如果是收货，快递直接把快件放到对应的柜子，然后通知你一下。
$ w+ x* s4 C) Y4 _( P6、你过来提取货物。

通过上面的方式，你可以不需要直接跟快递打交道，就可以轻松发货成功，DMA处理方式跟上面例子是一样的。
如果下图：

二、STM32 DMA 配置
- L' _! x* v* i! Z那么DMA在STM32上是具体怎么实现的呢？ 我们先了解一下STM32关于DMA的相关配置。
1、两个DMA控制器有12个通道(DMA1有7个通道，DMA2有5个通道)
( u" B. m7 `; S( D8 d; t2 \& cps：对应我们例子，就是有两个大的发货室，一个有7个货柜，另个有5个货柜。

2、在同一个DMA模块上，多个请求间的优先权可以通过软件编程设置(共有四级：很高、高、中等和低)，优先权设置相等时由硬件决定(请求0优先于请求1，依此类推)
ps: 店主可以跟每个快递公司签订协议，可以在货柜前贴上加急(很高)，很急(高)，急(中)，一般(低)， 如果同时有几个快递员过来取货，优先根据上面的优先级先取件。

3、独立数据源和目标数据区的传输宽度(字节、半字、全字)，模拟打包和拆包的过程。源和目标地址必须按数据传输宽度对齐。
ps: 指的是货件大小

4、支持循环的缓冲器管理(会把原来的数据覆盖)

5、每个通道都有3个事件标志(DMA半传输、DMA传输完成和DMA传输出错)，这3个事件标志逻辑或成为一个单独的中断请求。
ps: 送快递出现的异常情况(送到了一半，送完，快递出错)

解释到这里，不知道大家能不能理解呢。后面是具体的配置。
3 I6 `- ]: O: Y1、DMA 对应通道如下图
DMA1：

DMA2：

2、DMA配置
" c+ f' `5 d# l" O4 v1）数据传输的目的地和来源
+ _: ^$ O+ H' z1 r1 q3 t
对应我的例子，就是送快递还是取快递。

2）定义DMA通道的DMA缓存的大小
) {! X' |. j. _, D: I8 f/ I* d4 `9 Jps: 即货柜大小，能存多少个快件

3）外设地址寄存器递增与否

# u- P( y8 }$ c; j) w

4）内存地址寄存器递增与否

5）设定了外设数据宽度

6）设定了内存数据宽度

/ L+ C; m2 }- g

7）设置了DMA的工作模式

8）DMA通道的软件优先级

8 `+ j  \1 \6 l! U9 F1 T' A

9）使能或关闭DMA通道的内存到内存传输

三、 编程
串口用DMA方式发送和接收，分以下几步：
+ w  d. K4 ^& i- p0 O: C1）串口初始化
% \4 _1 k# l3 Y5 G/ D2）DMA初始化
3）发送数据
4）接收数据

我们按部就班：
. e  X* ^9 A+ [- m- {; y& C1） 串口初始化 — 使用串口一

1. 1 #define  DMASIZE 1024
   % ^, M- F2 k0 u4 l! v" j5 p: R; X
2. 2  
   
3. 3 // 配置串口一的发送和接收的GPIO口功能，以及中断
   5 O. c7 @3 y# v" G% B+ x/ |
4. 4 static void _uart1_gpio_init(void)
   , O3 k( T! ^1 A  M! W
5. 5 {
   7 s, I1 @  s; |
6. 6   NVIC_InitTypeDef NVIC_InitStructure;
   - O- d% e9 q1 F2 U, L
7. 7   GPIO_InitTypeDef GPIO_InitStructure;
   0 @  w) y: ?5 i, w
8. 8  
   
9. 9   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA   |
   
10. 10                      RCC_APB2Periph_USART1  |
    
11. 11                          RCC_APB2Periph_AFIO, ENABLE) ;
    7 v* @. E9 p" d
12. 12  
    
13. 13   GPIOA->CRH&=0XFFFFF00F;
    ( T4 i$ m% J4 W+ q: S% T. i; w( n
14. 14   GPIOA->CRH|=0X000008B0;//IO状态设置 10pin_上拉输入  9pin_推挽输出
    $ u$ F" c6 l; T/ w7 T
15. 15  
    
16. 16   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
17. 17     /* Configure USART1 Rx as input floating */
    
18. 18   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    4 W* T( Q- u& m% C6 U
19. 19   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    
20. 20   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
21. 21  
    ; @8 c# W3 {" G! Q
22. 22   /* Configure USART1 Tx as alternate function push-pull */
    
23. 23   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
24. 24   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    # s7 P- {* C& ?+ x2 r# L5 `- k! S6 ~
25. 25   GPIO_Init(GPIOA, &GPIO_InitStructure);
    % K3 P8 g0 ?' V6 Z5 L( i
26. 26  
    
27. 27  
    
28. 28   /* Enable the USART1 Interrupt */
    
29. 29   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel;
    4 E+ V, q  ^- \/ C
30. 30   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    - f* j, D8 o% S9 u' ]
31. 31   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    + |9 o: C: R+ ~& I
32. 32   NVIC_Init(&NVIC_InitStructure);
    ( Q9 `# A5 V9 V  x
33. 33  
    
34. 34   USART_ClearFlag(USART1, USART_FLAG_TC); /* 清发送外城标志，Transmission Complete flag */
    % ~8 \! [9 m, h1 G0 a) p) |
35. 35  
    
36. 36   USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);// 采用空闲中断，目的是在产生空闲中断时，说明接收或者发送已经结束，此时可以读取DMA中的数据了。
    % R- [! @' v! @0 `
37. 37   //USART_ITConfig(USART1, USART_IT_TC, ENABLE);
    
38. 38   //USART_ITConfig(USART1, USART_IT_FE, ENABLE);
    
39. 39 }
    
40. 40 // 设置对应串口的波特率
    . u9 D; w1 n- H1 J2 X3 X
41. 41 static void _uart_setbaudrate(USART_TypeDef* USARTx,u32 value)
    
42. 42 {
    
43. 43   USART_InitTypeDef USART_InitStructure;
    : \! z# X' ^  N/ m1 e8 T( i& ^$ \
44. 44   USART_InitStructure.USART_BaudRate =value;
    " ^( s# K% y/ o/ c. i9 a
45. 45   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    0 B& N8 |  c+ ]" o1 I
46. 46   USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
47. 47   USART_InitStructure.USART_Parity = USART_Parity_No;
    1 c# H. a6 G1 _( f* c" [
48. 48   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    2 ^. Q8 Q4 [3 A1 P
49. 49   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
50. 50   USART_Init(USARTx, &USART_InitStructure);
    3 S) \3 q3 v( ~9 ]& O  j7 J
51. 51   USART_Cmd(USARTx, ENABLE);
    
52. 52 }

复制代码

2）初始化DMA

1. 1 u8 sendbuf[1024];
   6 ~& |& G8 e# T$ P
2. 2 u8 receivebuf[1024];
   
3. 3 static void _uart1_dma_configuration()
   2 q2 Y6 i, d$ m; g( S
4. 4 {
   6 `$ I% A. I/ x$ T3 s# L
5. 5   DMA_InitTypeDef DMA_InitStructure;
   5 B7 p- C! j" ^+ B
6. 6  
   % |0 V1 {2 s2 h+ a' d
7. 7   /* DMA1 Channel6 (triggered by USART1 Rx event) Config */
   : `0 b- J9 P  j0 F0 b( P! p2 \
8. 8   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 ,
   % A. B* C' h/ |$ t! \# K: {- J
9. 9                         ENABLE);
   : }. @; f7 d* w8 t+ |& T
10. 10  
    
11. 11   /* DMA1 Channel5 (triggered by USART1 Rx event) Config */
    
12. 12   DMA_DeInit(DMA1_Channel5);
    
13. 13   DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;// 初始化外设地址，相当于“哪家快递”  
    ! w, U# S( s3 h' q+ c2 S
14. 14   DMA_InitStructure.DMA_MemoryBaseAddr =(u32)receivebuf;// 内存地址，相当于几号柜
    
15. 15   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;//外设作为数据来源，即为收快递
    4 f6 E' x) X0 @0 _) p, N/ O* b
16. 16   DMA_InitStructure.DMA_BufferSize = DMASIZE ;// 缓存容量，即柜子大小
    
17. 17   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; // 外设地址不递增，即柜子对应的快递不变
    
18. 18   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;// 内存递增
    
19. 19   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设字节宽度，即快递运输快件大小度量（按重量算，还是按体积算）
    9 `( Z2 G' Q- h" p4 Y' q! B1 j2 x
20. 20   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;// 内存字节宽度，即店主封装快递的度量(按重量，还是按体质进行封装)
    7 K9 _0 u$ _" e( ]' q! b
21. 21   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 正常模式，即满了就不在接收了，而不是循环存储
    
22. 22   DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;// 优先级很高，对应快递就是加急
    
23. 23   DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; // 内存与外设通信，而非内存到内存
    
24. 24   DMA_Init(DMA1_Channel5, &DMA_InitStructure);// 把参数初始化，即拟好与快递公司的协议
    
25. 25  
    / T5 V! d; I# \1 Y8 H
26. 26   DMA_Cmd(DMA1_Channel5, ENABLE);// 启动DMA，即与快递公司签订合同，正式生效
    3 B/ g* u& t# m3 }
27. 27  
    
28. 28   /* DMA1 Channel4 (triggered by USART1 Tx event) Config */
    6 @" E- P5 A7 l  X7 P7 `- L
29. 29   DMA_DeInit(DMA1_Channel4);
    
30. 30   DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;  // 外设地址，串口1， 即发件的快递
    ; C5 T2 b1 c: F  ~
31. 31   DMA_InitStructure.DMA_MemoryBaseAddr =(u32)sendbuf;// 发送内存地址
    ! n. N7 t; r! r( Z; b
32. 32   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;// 外设为传送数据目的地，即发送数据，即快递是发件
    
33. 33   DMA_InitStructure.DMA_BufferSize = 0;  //发送长度为0，即未有快递需要发送
    
34. 34   DMA_Init(DMA1_Channel4, &DMA_InitStructure);//初始化
    
35. 35  
    ( t: A) ?9 ^, }. U: }- n5 ?' X$ ^
36. 36   USART_ITConfig(USART1, USART_IT_TC, ENABLE);// 使能串口发送完成中断
    4 R. ~  }, m8 Z& x$ `% q
37. 37   USART_DMACmd(USART1, USART_DMAReq_Tx|USART_DMAReq_Rx, ENABLE);// 使能DMA串口发送和接受请求
    : x, t/ u. Z, D5 P2 _2 h
38. 38 }

复制代码

3、数据发送
流程：串口发送数据，全部数据发送完毕后，会产生一个发送中断，所以
1 [5 Z% Y4 X& n$ a发送数据分为两部分，
A、发送数据
( \5 W1 I) J0 [9 aB、中断处理

1. 1 A、发送数据
   " b( [! Y% T% Y, J0 X( ?  |
2. 2 u16 Uart_Send_Data(void* buffer, u16 size)
   . w/ m- f6 b! k3 p# ~
3. 3 {
   # S; X. U# E, a, e, H
4. 4   if(!size) return 0;// 判断长度是否有效
   
5. 5   while (DMA_GetCurrDataCounter(DMA1_Channel4));// 检查DMA发送通道内是否还有数据
   
6. 6   if(buffer) memcpy(sendbuf, buffer,(size > 1024?1024:size));
   
7. 7   //DMA发送数据-要先关 设置发送长度 开启DMA
   
8. 8   DMA_Cmd(DMA1_Channel4, DISABLE);
   
9. 9   DMA1_Channel4->CNDTR = size;// 设置发送长度
   
10. 10   DMA_Cmd(DMA1_Channel4, ENABLE);  // 启动DMA发送
    
11. 11   return size;
    ' {* [$ ~" c6 q6 d! f- W, D9 k9 T
12. 12 }
    
13. 13  
    $ u) B' j7 Y3 c! `) q4 [
14. 14 B、中断处理
    # z9 a* H1 ?  A/ P- t, V/ t$ B* @
15. 15 1）中断处理相关准备工作
    6 L! E- Z! u3 q% d
16. 16 typedef enum _UartEvent_
    6 {, [9 {* }( x+ M' c) v2 P/ v
17. 17 {
    
18. 18    E_uart_0 = 0,// 没有事件
    
19. 19    E_uart_tc=0x40,                  //发送完成
    
20. 20    E_uart_idle=0x80,               //接收完成
    
21. 21 }UartEvent;
    
22. 22 u16 receivelen = 0;// 声明接收数据长度
    
23. 23 UartEvent event;//申明一个事件参数
    
24. 24  
    ) w$ ?' f( e2 ~! l! K/ L% e
25. 25 //清除DMA 缓存，并终止DMA
    
26. 26 void Uart_Dma_Clr(void)
    
27. 27 {
    , [; q( C6 m0 u5 ~
28. 28     DMA_Cmd(DMA1_Channel4, DISABLE);
    ' l* ?) H9 @4 l* r& o% j# s
29. 29     DMA1_Channel4->CNDTR=0;
    " a, \) l, U1 `5 ?
30. 30     DMA_Cmd(DMA1_Channel5, DISABLE);
    3 y2 f5 T( Z4 X$ k% B1 m+ k
31. 31     DMA1_Channel5->CNDTR=DMASIZE ;
    
32. 32     DMA_Cmd(DMA1_Channel5, ENABLE);
      z, Q) ~; P$ w
33. 33 }
    
34. 34 // 获取一个事件，事件分为发送完成事件和接收完成事件，可以根据事件进行进行处理
    
35. 35 UartEvent Uart_Get_Event(void)
    
36. 36 {
    / @5 k, i! _. x3 [
37. 37   UartEvent e;
    
38. 38   if(!DMA1_Channel5->CNDTR) Uart_Dma_Clr();// 如果产生一个事件后，接收数据通道已经没有了缓存空间，进行清除DMA清空
    4 N+ P6 `# C6 n" J
39. 39   return event;
    
40. 40 }
    ' W2 `& I2 A. u/ {: V9 K
41. 41 // 清除对应的事件
    * G, J) m1 @9 [6 A
42. 42 void Uart_Clr_Event(UartEvent event_in)
    ( t5 b! u; u4 {8 s1 `4 [% }2 S
43. 43 {
    
44. 44     event&=~event_in;
    7 b3 Q/ B& c* [4 b* x# v/ u8 J& o0 y
45. 45 }
    , [. q+ P  z! Z" ^' z
46. 46  
    ) U( G$ `. p& d
47. 47  
    
48. 48 2） 中断处理，当所有数据发送完毕，串口1产生一个发送完成中断
    
49. 49 void Uatr1_Back_IRQHandler()
    
50. 50 {
    
51. 51   u8 tem;
    4 I& P/ o  j7 W% ?
52. 52   if(USART_GetITStatus(USART1,USART_IT_IDLE)!= RESET)
    ( d  {: @4 d  k
53. 53   {
    * U# r  l6 ^/ _# ]
54. 54     tem=USART1->SR;//先读SR，然后读DR才能清除
    ; o6 B4 X/ L9 {; B6 C" M" Q
55. 55     tem=USART1->DR;
    ' a! ?4 r  m; g9 H5 A6 D& u6 Q: T
56. 56     tem=tem;
    5 E- ?/ _0 Y' s2 |- n3 z& A
57. 57     Uart_Set_Event(E_uart_idle);
    
58. 58     receivelen =DMASIZE - DMA1_Channel5->CNDTR;// 总的buf长度减去剩余buf长度，得到接收到数据的长度
    
59. 59     USART_ClearITPendingBit(USART1, USART_IT_IDLE);
    
60. 60   }
    
61. 61  
    
62. 62   **if(USART_GetITStatus(USART1,USART_IT_TC)!= RESET) // 全部数据发送完成，产生该标记**
    ! l' g3 ^8 z, M7 Y2 E! Z$ v7 P$ n
63. 63   {
    
64. 64     USART_ClearITPendingBit(USART1, USART_IT_TC);   // 清除完成标记
    
65. 65     DMA_Cmd(DMA1_Channel4, DISABLE); // 关闭DMA
    / i6 |0 `6 @, ?% ~) ?/ e8 @
66. 66     DMA1_Channel4->CNDTR=0;          // 清除数据长度
    ! M4 k1 o& S$ N9 M, T7 H  ]
67. 67     Uart_Set_Event(E_uart_tc);     //设置发送完成事件
    
68. 68   }
    # Q1 X$ G% G" C- |& T4 b
69. 69 }

复制代码

$ X$ t  Z8 z# I6 ^8 K
- {8 x) L: {9 N; C0 C$ E1 E

4、接收数据

! @0 c5 ^- g. x6 r根据上图描述，流程如下：
1、串口接收到数据
2、DMA自动取走数据
3、DMA把数据存到内存receive[1024]中
3 h4 D2 S& M+ M/ ~/ r* c5 B/ R* t
4、串口接收完毕后会产生一个空闲中断

根据上面流程，我们接收数据需要做到两步：
1）串口产生一个空闲中断后，设置一个接收完成事件
中断处理：

1. 1 void Uatr1_Back_IRQHandler()
   
2. 2 {
   
3. 3   u8 tem;
   
4. 4   **if(USART_GetITStatus(USART1,USART_IT_IDLE)!= RESET)**
   - w& }- n% |7 _6 Z' P: A" b& {, @
5. 5   {
   
6. 6     tem=USART1->SR;//先读SR，然后读DR才能清除
   & j" x3 o* m, N! g, k9 X( M  j
7. 7     tem=USART1->DR;// 清除DR
   
8. 8     tem=tem; // 防止编译器警告
   5 S% \- W5 M1 o9 C
9. 9     Uart_Set_Event(E_uart_idle);// 设置接收完成(空闲)事件
   
10. 10     receivelen =DMASIZE - DMA1_Channel5->CNDTR;// 总的buf长度减去剩余buf长度，得到接收到数据的长度
    ; y: F  m: R/ Q
11. 11     USART_ClearITPendingBit(USART1, USART_IT_IDLE); // 清除空闲中断
    - p, n+ s' u. r. w. I
12. 12   }
    + A! b" g2 @* d! {' V) [$ f
13. 13  
    
14. 14 if(USART_GetITStatus(USART1,USART_IT_TC)!= RESET) // 全部数据发送完成，产生该标记  
    
15. 15 {
    
16. 16     USART_ClearITPendingBit(USART1, USART_IT_TC);   // 清除完成标记
    
17. 17     DMA_Cmd(DMA1_Channel4, DISABLE); // 关闭DMA
    . F  _* k) i6 M0 t
18. 18     DMA1_Channel4->CNDTR=0;          // 清除数据长度
    
19. 19     Uart_Set_Event(E_uart_tc);     //设置发送完成事件
    
20. 20   }
    ! m+ Y7 e" ~  _
21. 21 }

复制代码

  k6 c# e" J' x- c/ S

2）接收数据函数检测事件，如果发现是接收完成事件，取走数据，并且做相关清除操作

1. 1 u8 Uart_Receive_Data(u8*recbuf u16 *revLen)
   
2. 2 {
   % {% ?" ]. _  N9 J( Q
3. 3     u8 *str;
   
4. 4     if( event & E_uart_idle) // 是否产生空闲中断
   7 O& x6 ]4 V) d9 P
5. 5     {
   2 o; Q4 ~- O# n8 _
6. 6         str = Uart_Get_Data(revLen);   
   - U, a' G& v/ t1 j5 l8 u
7. 7         memcpy(recbuf,receivebuf,*revLen);
   
8. 8         Uart_Clr_Event(E_uart_idle);
   
9. 9         Uart_Dma_Clr();
   + ?( v, w$ ], y! i! p
10. 10         return TRUE;
    
11. 11     }
    % y5 S, |% r! G* e# Q' `
12. 12     else
    
13. 13     {
    7 w: E8 r/ v* K$ z7 p
14. 14         revLen = 0;
    
15. 15         return FALSE;
    8 }4 e% U  ~" z4 i. B% k  Z% T
16. 16     }
    
17. 17 }

复制代码

好了，到此DMA已经讲完了，有点长！！！
$ }  h) [! H; ^8 q8 Q) o) J& E2 e# S小结：
/ i1 E* F( N. G, X& C1、DMA其实就是个自动缓存器，数据来了，缓存到指定位置。发送数据则把缓存数据发送出去。
2、串口空闲中断，实测在接收完成数据后，空闲闲置时产生的，而发送数据不会产生该中断。
3、串口发送完成中断，实测在全部数据发送成功后，才会产生中断。