所谓的DMA指的是：直接存储器存取(DMA)用来提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。无须CPU干预，数据可以通过DMA快速地移动，这就节省了CPU的资源来做其他操作。
两个DMA控制器有12个通道(DMA1有7个通道，DMA2有5个通道)，每个通道专门用来管理来自
% J$ c8 l1 }* Z( Y$ j# m& N于一个或多个外设对存储器访问的请求。还有一个仲裁器来协调各个DMA请求的优先权。

3 X8 V! o( `) N& B9 ~6 e: O9 W+ N6 X  简单的来说，DMA功能指的就是，不需要程序控制，单片机内部自己可以控制数据从一个地方到另一个地方的传输。下面直接通过代码来看DMA功能如何实现。

1. #include "dma.h"
   2 v; M2 i# m+ `. `! Y
2. 
   " n; ?) ]. B: [8 C, h8 \
3. 
   
4. u16 DMA1_MEM_LEN;                                //保存DMA每次数据传送的长度
   
5. 
   4 Q9 z  k. h  {1 f) r! i( s
6. //DMA1的各通道配置
   # X; p# U4 H3 H9 X+ V6 o; m
7. //这里的传输形式是固定的,这点要根据不同的情况来修改
   
8. //从存储器->外设模式/8位数据宽度/存储器增量模式
   
9. //DMA_CHx:DMA通道CHx
   8 Q2 e8 P" j$ G" z( \) M
10. //cpar:外设地址
    5 A" h% }) P2 \' r% b' q# _+ L' g
11. //cmar:存储器地址
    ( f$ d8 _5 S7 u( x+ F
12. //cndtr:数据传输量
    
13. void MYDMA_Config(DMA_Channel_TypeDef *DMA_Chx, u32 cpar, u32 cmar, u16 cndtr)
    
14. {
    & n7 x% R1 N! _, _/ ^8 z
15.     DMA_InitTypeDef DMA_InitStructure;
    3 W* l) g( L3 K& y
16. 
    
17.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);                                                 //使能DMA传输
    5 R5 x6 o* z9 m
18.     DMA_DeInit(DMA_Chx);                                                                                                         //将DMA的通道1寄存器重设为缺省值
    4 [( ~& X; \2 Q5 a4 K! L! X
19. 
    
20.     DMA1_MEM_LEN = cndtr;
    , N4 {2 q1 T) a; {. ^
21. 
    , X8 ?; k* r) T+ @, \$ m
22.     DMA_InitStructure.DMA_PeripheralBaseAddr = cpar;                                                 //DMA外设基地址
    3 B( R7 B5 i8 r7 P
23.     DMA_InitStructure.DMA_MemoryBaseAddr = cmar;                                                         //DMA内存基地址
    ( a# n3 N1 n5 }: |
24.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;                                                 //数据传输方向，从内存读取发送到外设
    
25.     DMA_InitStructure.DMA_BufferSize = cndtr;                                                                 //DMA通道的DMA缓存的大小
    
26.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;                 //外设地址寄存器不变
    & n* R3 @, c* t5 {
27.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                                         //内存地址寄存器递增
    
28.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;         //数据宽度为8位
    4 o" i6 @' n/ `
29.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;                         //数据宽度为8位
    
30.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;                                                         //工作在正常模式
    & _% b' Y; a, v; B7 s& H7 l
31.     DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;                                         //DMA通道 x拥有中优先级
    6 k" H6 i" q' K# t' h9 Q
32.     DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                                                         //DMA通道x没有设置为内存到内存传输
    
33.     DMA_Init(DMA_Chx, &DMA_InitStructure);
    3 C7 a! F9 w1 C) a% X  j4 U- N
34. }
    
35. 
    
36. void MYDMA_Enable(DMA_Channel_TypeDef* DMA_CHx)
    5 Y. c& k4 o' [0 @! D
37. {
    & C  m9 r+ }& K0 s2 n! J# J" Y  E6 U
38.         DMA_Cmd(DMA_CHx,DISABLE);
    8 }; ?6 X0 [% e+ K- Z
39.         DMA_SetCurrDataCounter(DMA_CHx,DMA1_MEM_LEN);
    5 \8 T3 W- I$ O, O" {$ E/ F
40.         DMA_Cmd(DMA_CHx,ENABLE);
    
41. }

复制代码

' x, v! D3 b4 R' a, @' Y  这里使用了一个通用的DMA初始化，没有具体说明数据是从哪个内存发送到哪个外设，当哪个外设需要使用DMA功能时，在初始化的时候设置外设地址和内存地址就可以了。比如这里要使用串口发送的DMA功能。

% m7 [, }+ w# c8 ]/ i! F

1. #define SEND_BUF_SIZE 8200                        //发送数据长度,最好等于sizeof(TEXT_TO_SEND)+2的整数倍.
   
2. u8 SendBuff[SEND_BUF_SIZE];
   
3. 
   
4. const u8 TEXT_TO_SEND[] = {"DMA 串口实验,缓冲区的数据,用DMA功能,通过串口2发送出来。"};
   
5. int main(void)
   9 T& B0 z: e$ N/ K& \: H0 E
6. {
   
7.     u16 i;
   
8.     u8 t = 0;
   " W5 X) U+ c& I- J/ S1 {" ?! l
9.     u8 j, mask = 0;
   ) ]* h8 [% p. U2 F. L
10.     float pro = 0;
    
11. 
    9 A' B* |0 C( W9 [6 x1 t
12.     delay_init();
    9 ~/ O% f3 D0 ~, Y8 }
13.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    . N2 B, i( z5 q+ u, R7 m
14.     uart_init(115200);
    
15.     UART2_Init(115200);
    
16.     LED_Init();
    
17.     KEY_Init();
    
18.     //MYDMA_Config(DMA1_Channel4, (u32)&USART1->DR, (u32)SendBuff, SEND_BUF_SIZE);  //DMA1通道4,外设为串口1,存储器为SendBuff,长度SEND_BUF_SIZE.
    
19.     MYDMA_Config(DMA1_Channel7, (u32)&USART2->DR, (u32)SendBuff, SEND_BUF_SIZE);         //DMA1通道7,外设为串口2,存储器为SendBuff,长度SEND_BUF_SIZE.
    
20. 
    
21. 
    
22.     j = sizeof(TEXT_TO_SEND);
    
23.     for(i = 0; i < SEND_BUF_SIZE; i++)        //填充数据到SendBuff
    ; \9 W2 \* e1 ?0 V7 A
24.     {
    
25.         if(t >= j)                                                //加入换行符
    
26.         {
    
27.             if(mask)
    / n, |& |$ |* I0 j/ m
28.             {
    
29.                 SendBuff= 0x0a;
    ( y7 Z3 W  e1 F" K9 I. ^! V
30.                 t = 0;
    9 r9 v3 D. g0 j) F) ]% V
31.             }
    9 C+ C3 l. S6 g+ q9 A- x1 l
32.             else
    
33.             {
    - a- `  Q! O/ G# G. v0 s
34. SendBuff = 0x0d;
    " M% @) R' V- S, x
35.                 mask++;
    
36.             }
    
37.         }
    
38.         else
    5 M) ?0 X; y# m
39.         {
    , q6 i$ n$ T& j
40.             mask = 0;
    8 Q4 }, V3 a! V+ D' j" [5 Q
41.             SendBuff = TEXT_TO_SEND[t];
    & O$ r- K9 k, u/ T- W8 ]' D
42.             t++;
    
43.         }
    
44.     }
    
45. 
    / x$ f1 L) r6 a* J0 l4 q# ~. n
46.     printf("DMA test!!!\r\n");
    . ~  p- W9 o1 q8 M7 H
47.     while(1)                //串口1打印信息  通过DMA功能将SendBuff中的数据，通过串口2发送出来
    * b* k) K8 ^3 t; K/ s7 C( X
48.     {
    ( N2 k2 M% E. e1 J: \3 M  B2 b
49.         t = KEY_Sacn(0);
    $ p5 V- L" c7 e
50.         if(t == KEY1_PRES)
    4 e$ E2 B* f% g) i
51.         {
    - J% `0 w0 |  m4 `: ^
52.             printf("Start Transimit....");
    ) X, E  V+ I8 Y/ G
53.             printf("\r\nDMA DATA:\r\n");
    
54.             //串口1 DMA 发送
    
55. //            USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);                        //使能串口1的DMA发送
    $ I$ L1 z1 \' W3 H0 h6 D
56. //            MYDMA_Enable(DMA1_Channel4);                                                                //开始一次DMA传输
    * z) p: l+ _% j7 w6 }. B( K
57. 
    1 y- d. @* Y6 j* m/ {
58.             //串口2 DMA 发送
    ( t" A4 ]4 g, c
59.             USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);                                //使能串口1的DMA发送
    
60.             MYDMA_Enable(DMA1_Channel7);                                                                //开始一次DMA传输
    
61. 
    
62.             //等待DMA传输完成，此时我们来做另外一些事，点灯
    7 E/ O1 \0 u! W# X! `
63.             //实际应用中，传输数据期间，可以执行另外的任务
      Z7 f# Y! @& E4 ~
64.             while(1)
    $ {, X, n/ v4 a  e' _6 F5 d
65.             {
    
66.                 //串口1 DMA 判断
    9 n! H( A$ _* ^) ^
67. //                if(DMA_GetFlagStatus(DMA1_FLAG_TC4) != RESET)                        //判断通道4传输完成
    
68. //                {
    ; s5 D5 r" F' M. ~
69. //                          DMA_ClearFlag(DMA1_FLAG_TC4);                                        //清除通道4传输完成标志
    
70. //                    break;
    
71. //                }
    
72. 
    & P$ z) H. A% {5 G& Z& P$ o
73.                 //串口2 DMA 判断
    4 \- |! n& u* {8 j5 Y
74.                 if(DMA_GetFlagStatus(DMA1_FLAG_TC7) != RESET)                        //判断通道7传输完成
    $ v! k  T8 q5 d; P7 @0 y- J& Z
75.                 {
    
76.                     DMA_ClearFlag(DMA1_FLAG_TC7);                                                //清除通道7传输完成标志
    
77.                     break;
    ' q& e* ^( b% N7 F3 N) w/ `% c+ f9 o
78.                 }
    
79. 
    
80.                 //pro = DMA_GetCurrDataCounter(DMA1_Channel4);
    - N& {5 `% x% e0 \4 h
81.                 pro = DMA_GetCurrDataCounter(DMA1_Channel7);
    
82.                 pro = 1 - pro / SEND_BUF_SIZE;
    
83.                 pro *= 100;
    
84.                 printf("%f %%\r\n", pro);
    & O: m* _- g( h
85.             }
    . a5 g8 Z4 w/ i* e1 e
86.             printf("100%%");
    
87.             printf("\r\nTransimit Finished!\r\n");
    
88.         }
    
89.         i++;
    6 ?1 G, Q* x. E4 b! C; N
90.         delay_ms(10);
    % O5 o; c' s( `5 u6 A6 t
91.         if(i == 20)
    # O+ _: v4 |( l) N& h( n
92.         {
    
93.             LED0 = !LED0;
    / Y2 c' ~/ X4 m' N$ T2 g
94.             i = 0;
    2 }, \; D) j8 N2 `5 m+ F* \
95.         }
    
96. 
    0 n/ s9 j) m' T* p! L& F4 ]
97.     }
    * A4 R& A$ Q$ G* m
98. }

复制代码

  在初始化的时候，将串口数据发送寄存器作为外设地址，将存储发送数据的地址作为内存地址。数据的传输方向是从内存读取数据然后发送到外设地址中去。也就是一旦开启DMA传输功能之后，单片机就会自动将数组中的数据依次传输到串口发送数据寄存器中。这样数据就自动从串口发送出来了。不需要程序控制。

  这里分别使用串口1和串口2进行了测试，每按一次按键，就启动一次DMA数据传输。在传输数据的过程中模拟程序执行其他操作。当DMA数据传输完成后，会打印出当前传输了多少字节的数据。
/ x) k( T1 f- i; n