DMA简介：

  DMA(Direct Memory Access，直接存储器存取)，是一种可以减轻CPU工作量的数据存取方式，如今被广泛的使用。它在传输数据的同时，CPU可以做其他事，比如数据运算或者响应中断等，DMA就给CPU分担了不少的工作量！

DMA工作分析：

. r  ?" Q7 O% k9 [7 V+ |

                                                            

如图，我们可以看到STM32内核，存储器，外设及DMA的连接，这些硬件最终通过各种各样的线连接到总线矩阵中，硬件结构之间的数据转移都经过总线矩阵的协调，使各个外设和谐的使用总线来传输数据。

下面看有与没有DMA的情况下，ADC采集的数据是怎样存放到SRAM中的？

1.如果没有DMA,CPU传输数据还要以内核作为中转站，比如要将ADC采集的数据转移到到SRAM中，这个过程是这样的：内核通过DCode经过总线矩阵协调，使用AHB把外设ADC采集的数据，然后内核，DCode再通过总线矩阵协调把数据存放到内存SRAM中。

2.有DMA的话，DMA控制器的DMA总线与总线矩阵协调，使用AHB把外设ADC采集的数据经由DMA通道存放到SRAM中，这个数据的传输过程中，完全不需要内核的参与，也就是CPU的参与，不过DMA传输时要对DMA外设发出请求，才会触发其工作。

下面我是通过串口通信的例子来学习DMA的！

主函数main.c:

1. #include <stdio.h>
   + k4 z& v$ Z0 m1 F* W3 o, J
2. uint8_t sendbuff[500];
   6 e8 z1 v' @- O3 X, b: s1 R. q
3. uint16_t i;
   
4. int main()
   9 e' S% c& W# A. m9 h" E& p
5. {
   ( v1 F4 o8 e! g2 `- S
6. printf_init();
   9 v! ]- o' l! K2 }; J
7. dma_init();
   
8. for(i=0;i<500;i++)
   # B7 Y% W$ q" w  ?" l9 l3 I9 s
9. {
   . i7 k/ Z5 n5 b) n" Y" D
10. sendbuff[i] =0xaf;
      s. I( g" b3 i. B* U
11. }
    
12. USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);
    ; s0 y0 v4 Y" r/ |' ~% I* X
13. LED3_ON;
    
14. 
    ; G' |$ D+ U/ R( d- h
15. while(1);

复制代码

这个主函数实现的功能是利用DMA把数据（数组，数组里面的存放了500个AF字符）从内存转移到外设（串口），最后通过串口传输到我们的PC上显示。为了证明DMA在搬运数据的同时，CPU还可以做其他事，于是将LED3点亮，来测试一下。主函数至于为啥加while(1)，才会产生中断？还不明白。。。

DMA配置dma.c:

1. #include "stm32f10x.h"
   4 g  H# i/ q) D
2. #include "stm32f10x_rcc.h"
   + L7 E6 ?. {/ ^  q6 {* [5 S1 ~; X' |3 [
3. #include "stm32f10x_usart.h"
   
4. #include "stm32f10x_dma.h"
   
5. #include "misc.h"
   
6. #include "dma.h"
   
7. void dma_init()
   % N# `8 D3 X3 N6 c
8. {
   
9. 
   
10. DMA_InitTypeDef DMA_InitStructure;
    5 p, ^. ]3 Y) k- l6 Y$ d; R/ J6 R
11. RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    ! P( S% k  O% a4 ?  L
12. NVIC_Config();
    
13. /*DMA配置*/
    
14. DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;//串口数据寄存器地址
    ; x  n: V" z) d1 k' z  W
15. DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)sendbuff; //内存地址(要传输的变量的指针)
    
16. DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST; //方向(从内存到外设)
    
17. DMA_InitStructure.DMA_BufferSize = 500; //传输内容的大小
    
18. DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设地址不增
    
19. DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //内存地址自增
    / g/ h/ n( f  Q0 Z8 h; l3 F
20. DMA_InitStructure.DMA_PeripheralDataSize =
    & z/ Y6 M( W( }& k, ?! O" h
21. DMA_PeripheralDataSize_Byte ; //外设数据单位
    
22. DMA_InitStructure.DMA_MemoryDataSize =
    
23. DMA_MemoryDataSize_Byte ; //内存数据单位
    
24. DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ; //DMA模式：一次传输，循环
    
25. DMA_InitStructure.DMA_Priority = DMA_Priority_Medium ; //优先级：高
    
26. DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; //禁止内存到内存的传输
    
27. 
    
28. DMA_Init(DMA1_Channel4, &DMA_InitStructure); //配置DMA1的4通道
    * v3 C/ c8 l! b6 Q$ P: P
29. DMA_Cmd(DMA1_Channel4,ENABLE);
    
30. DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE);//配置DMA发送完成后产生中断
    + `/ v! g; ^5 K4 D
31. 
    
32. }
    ! y6 K: b" w2 _* b' U6 e
33. 
    : E: K, a( V" ?( N) `+ P8 S
34. static void NVIC_Config(void)
    
35. {
    
36. NVIC_InitTypeDef NVIC_InitStructure;
    
37. /*中断配置*/
      G& M$ Y& R+ R; r$ r4 v- u6 f6 U
38. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    
39. 
    2 \0 Z; H, K  N" q3 U
40. NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
    2 H  N- E" Y. Q: i: i& {
41. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    ! l# g( F5 R' ?. J
42. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
43. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
44. NVIC_Init(&NVIC_InitStructure);
    
45. }

复制代码

这里的串口数据寄存器地址配置是参考STM32的datasheet来设置的，USART1_DR_Base是一个宏，#define USART1_DR_Base 0x40013804,至于地址为啥是这个，请看下图：

5 \/ C; U# {  Z; F, Q  ~. @+ f

: e. R7 x" o& n8 p+ `( F& |) m" P

存储器映射图，找到USART1的基址，再看USART1数据寄存器偏移地址就可以知道串口1的地址了。

+ c$ u/ t/ ~- N+ _2 }8 V/ s( H2 H5 {

; U' c( C+ ?# x; m. z

3 s4 L+ I, D% q, o" n# `! \/ L

至于在配置DMA1通道时，那里为啥是通道4,而不是其它通道，请看下图：

4 @0 R1 Y5 j0 K: Q/ F4 b& m0 v2 g

! S3 t# d$ ]7 Y4 U% _# `

dma.h:

1. #ifndef _dma_H
   6 a" S* i$ Y3 i- ]! `. [8 ?4 k7 g+ T
2. #define _dma_H
   3 O- y1 x; x% X+ y
3. #include "stm32f10x.h"
   
4. #define USART1_DR_Base 0x40013804;
   
5. extern uint8_t sendbuff[500];
   
6. static void NVIC_Config(void);
   % ?7 f. _5 b- u( g5 Z) l2 m7 ]
7. void dma_init(void);
   
8. 
   
9. #endif

复制代码

0 B# N5 r1 r" q! ?

串口配置：printf.c

1. #include "printf.h"
   
2. #include "stm32f10x.h"
   8 f3 @% U, N) g! A
3. #include "stm32f10x_rcc.h"
   
4. #include "stm32f10x_gpio.h"
   
5. #include "stm32f10x_usart.h"
   
6. #include "misc.h"
   7 i5 j5 p+ Z$ n6 ]$ _
7. 
   
8. int fputc(int ch,FILE *f)
   
9. {
   
10. while(USART_GetFlagStatus(USART1,USART_FLAG_TC) != SET);
    
11. USART_SendData(USART1,(unsigned char)ch);
    
12. while(USART_GetFlagStatus(USART1,USART_FLAG_TC) != SET);
    : a" v1 w, k8 ?) Y' L- j
13. return (ch);
    
14. }
    
15. 
    + T0 }6 D8 h$ V# p8 B1 |5 Y
16. void printf_init(void)
    
17. {
    
18. GPIO_InitTypeDef GPIO_InitStructure;
    9 G( u6 C9 l8 f' @
19. USART_InitTypeDef USART_InitStructure;
    
20. 
    
21. /*config USART clock*/
    * M; M# e. g: Q6 k) n7 W$ w+ K
22. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    + S* T# v6 y9 i# j) I8 E$ l
23. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    ' i7 j* \* H: Z6 Y1 G# X
24. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
    
25. /*USART1 GPIO config*/
    3 C, e$ C# |# S
26. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_9;
    
27. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_AF_PP; //复用推挽输出
    8 |0 {+ e& h# j' m+ L, Q5 m4 P
28. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
29. GPIO_Init(GPIOA,&GPIO_InitStructure);
    # D! `4 a) e& i$ }0 }3 U' e" o4 f5 B
30. 
    
31. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_10;
    
32. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_IN_FLOATING; //复用开漏输入
    
33. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    0 }4 m( N+ C8 s  H5 z
34. GPIO_Init(GPIOA,&GPIO_InitStructure);
    
35. 
    + y' n8 e2 ^+ K3 b' X' \
36. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;
    
37. GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    & V6 ?- A) \* {/ }
38. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
    
39. GPIO_Init(GPIOD,&GPIO_InitStructure);
    7 n4 o7 S4 g8 a
40. /*USART1 mode Config*/
      M, P; }; B  F: y# I( l# Y- Z3 u
41. USART_InitStructure.USART_BaudRate = 9600;
    0 c, p* F. L, ?' l# |/ h
42. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
43. USART_InitStructure.USART_StopBits = USART_StopBits_1;
    0 o8 X4 L1 X9 R: n3 c8 U9 A1 `
44. USART_InitStructure.USART_Parity = USART_Parity_No;
    
45. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    # c/ d' O  ~7 c! E1 e1 ^
46. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    ! A9 b' t2 h1 y- S+ E) M
47. USART_Init(USART1,&USART_InitStructure);
    4 R- Q9 [4 l& u' p7 j' ?% V
48. USART_Cmd(USART1,ENABLE);

复制代码

0 l( n+ k/ Q" g; f, I

printf.h:

1. #ifndef __printf_H
   
2. #define __printf_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. #include <stdio.h>
   
6. #define LED3_ON GPIO_SetBits(GPIOD,GPIO_Pin_3)
   6 U' j6 }& T+ a# Y4 o2 C( Z
7. #define LED3_OFF GPIO_ResetBits(GPIOD,GPIO_Pin_3)
   ! \3 T+ F7 N/ a% h% {
8. void printf_init(void);
   8 n6 @5 t. Y3 l: C# \
9. int fputc(int ch,FILE *f);
   
10. 
    8 O) i  Q4 |! P
11. #endif

复制代码

中断代码：

1. #include "stm32f10x_it.h"
   
2. #include "stm32f10x.h"
   
3. #include "printf.h"
   8 p0 G3 \+ e3 O: V& x1 h
4. void DMA1_Channel4_IRQHandler(void)
   
5. {
   
6. if(DMA_GetFlagStatus(DMA1_FLAG_TC4)==SET)
   
7. {
   , {% K9 p& l6 `/ c- `/ P5 ~
8. LED3_OFF;
   9 U  C9 }( l0 E& N0 f
9. DMA_ClearFlag(DMA1_FLAG_TC4);
   6 o+ M, z3 D# _# h2 u. Q
10. }
    8 n" R- i( y! n( W$ F$ e: u
11. }

复制代码

效果图：