stm32 DMA数据搬运 [操作寄存器+库函数]

 DMA（Direct Memory Access）常译为“存储器直接存取”。早在Intel的8086平台上就有了DMA应用了。

 

        一个完整的微控制器通常由CPU、存储器和外设等组件构成。这些组件一般在结构和功能上都是独立的，而各个组件的协调和交互就由CPU完成。如此一来，CPU作为整个芯片的核心，其处理的工作量是很大的。如果CPU先从A外设拿到一个数据送给B外设使用，同时C外设又需要D外设提供一个数据。。。这样的数据搬运工作将使CPU的负荷显得相当繁重。

 

       严格的说，搬运数据只是CPU的比较不重要的一种工作。CPU最重要的工作室进行数据运算，从加减乘除到一些高级的运算，包括浮点、积分、微分、FFT等。CPU还需要负责复杂的中断申请和响应，以保证芯片的实时性能。

 

    理论上常见的控制外设，比如Usart、I2C、SPI甚至是USB等通信接口，单纯的利用CPU进行协议模拟也是可以实现的，比如51单片机经常使用I/O口模拟I2C协议通信。但这样既浪费了CPU的资源，同时实现后的性能表现往往和使用专门的硬件模块实现的效果相差甚远。从这个角度来看，各个外设控制器的存在，无疑降低了CPU的负担，解放了CPU的资源。

    

    数据搬运这一工作占用了大部分的CPU资源，成为了降低CPU的工作效率的主要原因之一。于是需要一种硬件结构分担CPU这一职能 —— DMA。

 

    从数据搬运的角度看，如果要把存储地址A的数值赋给另外一个地址上B的变量，CPU实现过程为首先读出A地址上的数据存储在一个中间变量，然后再转送到B地址的变量上。使用DMA则不需要中间变量，直接将A地址的数值传送到B地址的变量里。无疑减轻了CPU的负担，也提高了数据搬运的效率。

 

stm32中 DMA1有7个通道，DMA2有5个通道。DMA挂载的时钟为AHB总线,其时钟为72Mhz，所以可以实现高速数据搬运。

 

                                                stm32的DMA1通道一览表

 

本例实现使用CPU和DMA搬运同一组数据，通过计时，比较两者的搬运效率。

 

直接操作寄存器

 

DMA的中断状态寄存器（DMA_ISR）：

 

TEIFx：通道x的传输错误标志(x = 1 … 7) (Channel x transfer error flag) 硬件设置这些位。在DMA_IFCR寄存器的相应位写入’1’可以清除这里对应的标志位。

            0：在通道x没有传输错误(TE)；             1：在通道x发生了传输错误(TE)。

 

HTIFx：通道x的半传输标志(x = 1 … 7) (Channel x half transfer flag) 硬件设置这些位。在DMA_IFCR寄存器的相应位写入’1’可以清除这里对应的标志位。

            0：在通道x没有半传输事件(HT)；         1：在通道x产生了半传输事件(HT)。

 

TCIFx：通道x的传输完成标志(x = 1 … 7) (Channel x transfer complete flag) 硬件设置这些位。在DMA_IFCR寄存器的相应位写入’1’可以清除这里对应的标志位。

            0：在通道x没有传输完成事件(TC)；       1：在通道x产生了传输完成事件(TC)。

 

DMA_IFCR中断标志清除寄存器：

 

结构类似DMA_ISR。

 

CTEIFx：清除通道x的传输错误标志(x = 1 … 7) (Channel x transfer error clear) 这些位由软件设置和清除。     0：不起作用         1：清除DMA_ISR寄存器中的对应TEIF标志。

 

CHTIFx：清除通道x的半传输标志(x = 1 … 7) (Channel x half transfer clear) 这些位由软件设置和清除。           0：不起作用         1：清除DMA_ISR寄存器中的对应HTIF标志。

 

CTCIFx：清除通道x的传输完成标志(x = 1 … 7) (Channel x transfer complete clear) 这些位由软件设置和清除。 0：不起作用        1：清除DMA_ISR寄存器中的对应TCIF标志。

 

CGIFx：清除通道x的全局中断标志(x = 1 … 7) (Channel x global interrupt clear) 这些位由软件设置和清除。    0：不起作用         1：清除DMA_ISR寄存器中的对应的GIF、TEIF、HTIF和TCIF标志。

 

DMA通道配置寄存器（DMA_CCRx）：

 

 

MEM2MEM：存储器到存储器模式 (Memory to memory mode) 该位由软件设置和清除。 0：非存储器到存储器模式； 1：启动存储器到存储器模式。

 

PL：通道优先级 (Channel priority level)  这些位由软件设置和清除。 00：低 01：中 10：高 11：最高

 

MSIZE：存储器数据宽度 (Memory size) 这些位由软件设置和清除。 00：8位 01：16位 10：32位 11：保留

 

PSIZE：外设数据宽度 (Peripheral size)  这些位由软件设置和清除。 00：8位 01：16位 10：32位 11：保留

 

MINC：存储器地址增量模式 (Memory increment mode)  该位由软件设置和清除。 0：不执行存储器地址增量操作 1：执行存储器地址增量操作

 

PINC：外设地址增量模式 (Peripheral increment mode) 该位由软件设置和清除。 0：不执行外设地址增量操作 1：执行外设地址增量操作

 

CIRC：循环模式 (Circular mode)  该位由软件设置和清除。 0：不执行循环操作 1：执行循环操作

 

DIR：数据传输方向 (Data transfer direction)   该位由软件设置和清除。 0：从外设读 1：从存储器读

 

TEIE：允许传输错误中断 (Transfer error interrupt enable)  该位由软件设置和清除。 0：禁止TE中断 0：允许TE中断

 

HTIE：允许半传输中断 (Half transfer interrupt enable) 该位由软件设置和清除。 0：禁止HT中断 0：允许HT中断

 

TCIE：允许传输完成中断 (Transfer complete interrupt enable) 该位由软件设置和清除。 0：禁止TC中断 0：允许TC中断

 

EN：通道开启 (Channel enable) 该位由软件设置和清除。 0：通道不工作 1：通道开启

 

DMA通道x传输数量寄存器(DMA_CNDTRx)(x = 1…7)

 

低16位有效。这个寄存器控制通道每次传输的数据量，数据传输数量为0至65535。该寄存器会随着传输的进行而递减，为0表示已经发送完成。

 

DMA外设地址寄存器（DMA_CPARx）

32位寄存器。外设数据寄存器的基地址，作为数据传输的源或目标。 

 

DMA存储地址寄存器(DMA_CMARx)

存储器地址[31:0],存储器地址作为数据传输的源或目标。

 

代码如下：  （system.h 和 stm32f10x_it.h 等相关代码参照 ）

User/main.c

001

#include

002	#include "system.h"

003	#include "usart.h"

004	#include "dma.h"

005	#include "tim.h"

006	#include "string.h"

007

008	#define LED1 PAout(4)

009	#define LED2 PAout(5)

010	#define LED3 PAout(6)

011

012	void Gpio_Init(void);

013

014

015

//数据源

016	uc32 SRC_Const_Buffer[32] =

017

{

018	0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,

019	0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,

020	0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,

021	0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,

022	0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,

023	0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,

024	0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,

025	0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80

026

};

027

028

//目标位置

029	u32 DST_Buffer[32];

030

031

032

033	int main(void)

034

{

035

u8 i=0;

036	u16 StartTime=0,CPUSpendTime=0,DMASpendTime=0;;

037

038

039	Rcc_Init(9);                          //系统时钟设置

040

041	Usart1_Init(72,9600);

042

043	Tim_Init(TIM_2,65535,71);         //初始化TIM2定时器，设定重装值和分频值,计时时间为1us/次

044

045	Dma_Init(DMA1_Channel1,(u32)SRC_Const_Buffer,(u32)DST_Buffer);  //初始化DMA,外设地址示例 &USART1->DR

046

047	Nvic_Init(1,0,DMA1_Channel1_IRQChannel,4);    //设置抢占优先级为0，响应优先级为0，中断分组为4

048

049	Gpio_Init();

050

051	StartTime = TIM2->CNT;

052

053	while(i<32)                           //CPU搬运

054

{

055	DST_Buffer[i]=SRC_Const_Buffer[i];

056

i++;

057

}

058

059	CPUSpendTime = TIM2->CNT - StartTime;

060

061	printf("\r\n the CPU spend : %dus! \r\n",CPUSpendTime);

062

063	if(strncmp((const char *)SRC_Const_Buffer,(const char *)DST_Buffer,32) ==0)   //验证传输效果，判断两数组是否相同

064

{

065	printf("\r\n CPU Transmit Success! \r\n");

066

}else{

067	printf("\r\n CPU Transmit Fail! \r\n");

068

}

069

070

i=0;

071

072	while(i<32)                          //清空目标数组，准备DMA搬运

073

{

074	DST_Buffer[i]=0;

075

i++;

076

}

077

078	StartTime = TIM2->CNT;

079

080	Dma_Enable(DMA1_Channel1,32);                     //DMA搬运

081

082	while( DMA1_Channel1 -> CNDTR != 0);     //等待传输完成

083

084	DMASpendTime= TIM2->CNT - StartTime;

085

086	printf("\r\n the DMA spend : %dus! \r\n",DMASpendTime);

087

088	if(strncmp((const char *)SRC_Const_Buffer,(const char *)DST_Buffer,32) ==0)   //验证传输效果，判断两数组是否相同

089

{

090	printf("\r\n DMA Transmit Success! \r\n");

091

}else{

092	printf("\r\n DMA Transmit Fail! \r\n");

093

}

094

095

while(1);

096

}

097

098

099	void Gpio_Init(void)

100

{

101	RCC->APB2ENR|=1<<2;    //使能PORTA时钟

102

103	GPIOA->CRL&=0x0000FFFF; // PA0~3设置为浮空输入，PA4~7设置为推挽输出

104	GPIOA->CRL|=0x33334444;

105

106	//USART1 串口I/O设置

107

108	GPIOA -> CRH&=0xFFFFF00F;   //设置USART1 的Tx(PA.9)为第二功能推挽，50MHz；Rx(PA.10)为浮空输入

109	GPIOA -> CRH|=0x000008B0;

110

111

}

User/stm32f10x_it.c

01	#include "stm32f10x_it.h"

02	#include "system.h"

03	#include "stdio.h"

04

05	#define LED1 PAout(4)

06	#define LED2 PAout(5)

07	#define LED3 PAout(6)

08	#define LED4 PAout(7)

09

10	void DMAChannel1_IRQHandler(void)  //和启动文件有关,STM32F10x.s中 和  STM32F10x_md.s DMA中断接口函数不同

11

{

12

13	if( DMA1 ->ISR & (1<<1))       //传输完成中断

14

{

15

16

LED1 = 1;

17	DMA1->IFCR |= 1<<1;    //清除传输完成中断

18

}

19

20	if( DMA1 ->ISR & (1<<2))       //半传输完成中断

21

{

22

23	DMA1 ->IFCR |= 1<<2;   //清除半传输完成中断

24

}

25

26	if( DMA1 ->ISR & (1<<3))       //传输错误中断

27

{

28

LED4 =1 ;

29	DMA1 ->IFCR |= 1<<3;   //清除传输错误中断

30

}

31

32	DMA1 ->IFCR |= 1<<0;       //清除此通道的中断

33

}

Library/src/dma.c

01

#include

02	#include "system.h"

03	#include "dma.h"

04

05

06	//DMA通道初始化函数

07	//传输方向：存储器 -> 存储器模式 ,32位数据模式,存储器增量模式

08

//参数说明：

09	//          DMA_CHx      ：选择DMA控制器通道,DMA1有1-7，DMA2有1-4

10	//          P_Adress     ：外设地址

11	//          M_Adress     ：存储器地址

12

13	void Dma_Init(DMA_Channel_TypeDef * DMA_CHx,u32 P_Address ,u32 M_Address)

14

{

15

16	RCC->AHBENR |= 1<<0;

17

18	DMA_CHx -> CCR  &= 0xFFFF0000;       //复位

19

20	DMA_CHx -> CCR  |= 1<<1;           //允许传输完成中断

21	//DMA_CHx -> CCR  |= 1<<2;         //允许半传输中断

22	DMA_CHx -> CCR  |= 1<<3;           //允许传输错误中断 读写一个保留的地址区域,将会产生DMA传输错误

23

24

25	//设定数据传输方向

26	DMA_CHx -> CCR  |= 0<<4;           //设定数据传输方向   0：从外设读 1：从存储器读

27	DMA_CHx -> CCR  |= 0<<5;           //0：不执行循环操作 1：执行循环操作

28

29

//设定地址增量

30	DMA_CHx -> CCR  |= 1<<6;           //0：不执行外设地址增量操作 1：执行外设地址增量操作

31	DMA_CHx -> CCR  |= 1<<7;           //0：不执行存储器地址增量操作 1：执行存储器地址增量操作

32

33	//设定外设数据宽度  S

34	DMA_CHx -> CCR  |= 0<<8;           //外设数据宽度,由[9:8]两位控制

35	DMA_CHx -> CCR  |= 1<<9;           //00：8位 01：16位 10：32位 11：保留

36

37	//设定存储数据宽度

38	DMA_CHx -> CCR  |= 0<<10;          //存储器数据宽度,由[11:10]两位控制

39	DMA_CHx -> CCR  |= 1<<11;          //00：8位 01：16位 10：32位 11：保留

40

41	//设定为中等优先级

42	DMA_CHx -> CCR  |= 1<<12;          //通道优先级,由[13:12]两位控制

43	DMA_CHx -> CCR  |= 1<<13;          //00：低 01：中 10：高 11：最高

44

45	DMA_CHx -> CCR  |= 1<<14;          //0：非存储器到存储器模式； 1：启动存储器到存储器模式。

46

47	//必须配置好通道后配置地址

48	DMA_CHx -> CPAR = (u32)P_Address;    //设定外设寄存器地址

49	DMA_CHx -> CMAR = (u32)M_Address;    //设定数据存储器地址

50

51

}

52

53

54

55

//DMA通道使能

56

//参数说明：

57	//          DMA_CHx      ：选择DMA控制器通道,DMA1有1-7，DMA2有1-4

58	//          Number       ：数据传输量

59	void Dma_Enable(DMA_Channel_TypeDef * DMA_CHx,u16 Number)

60

{

61	DMA_CHx -> CCR &= ~(1<<0);     //关闭上一次DMA传输

62	DMA_CHx -> CNDTR = Number;       //数据传输量

63	DMA_CHx -> CCR |= 1<<0;            //开始DMA传输

64

}

Library/inc/dma.h

1

#include

2

3	void Dma_Init(DMA_Channel_TypeDef * DMA_CHx,u32 P_Adress ,u32 M_Address);

4	void Dma_Enable(DMA_Channel_TypeDef * DMA_CHx,u16 Number);

直接操作寄存器输出：

 

 the CPU spend : 972us! 

 CPU Transmit Success! 

 

 the DMA spend : 5us! 

 DMA Transmit Success! 

 

库函数操作

 

mian.c

001	#include "stm32f10x.h"

002	#include "stdio.h"

003	#include "string.h"

004

005	#define  PRINTF_ON  1

006	#define  BufferSize  32

007

008	vu16 LeftDataCounter;

009	vu32 Tick;

010

011	uc32 SRC_Const_Buffer[BufferSize] =

012

{

013	0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,

014	0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,

015	0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,

016	0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,

017	0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,

018	0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,

019	0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,

020	0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80

021

};

022

023	u32 DST_Buffer[BufferSize];

024	u8 i=0,DMASpendTime=0,CPUSpendTime=0;

025

026	void RCC_Configuration(void);

027	void GPIO_Configuration(void);

028	void NVIC_Configuration(void);

029	void USART_Configuration(void);

030	void DMA_Configuration(void);

031

032

033	int main(void)

034

{

035	RCC_Configuration();

036	GPIO_Configuration();

037	NVIC_Configuration();

038	USART_Configuration();

039	DMA_Configuration();

040

041	SysTick_Config(72);

042

043

Tick = 0;

044

while(i

045

{

046	DST_Buffer[i]=SRC_Const_Buffer[i];

047	CPUSpendTime = Tick;

048

i++;

049

}

050

i=0;

051

while(i

052

{

053	DST_Buffer[i]=0;

054

i++;

055

}

056

057

Tick = 0;

058	DMA_Cmd(DMA1_Channel6,ENABLE);

059	while(LeftDataCounter != 0);    //等待传输完成

060	DMASpendTime = Tick;

061

062

063

064	if(strncmp((const char *)SRC_Const_Buffer,(const char *)DST_Buffer,BufferSize) ==0)

065

{

066	printf("\r\n Transmit Success! \r\n");

067

}else{

068	printf("\r\n Transmit Fail! \r\n");

069

}

070

071	printf("\r\n the CPU spend : %dus! \r\n",CPUSpendTime);

072	printf("\r\n the DMA spend : %dus! \r\n",DMASpendTime);

073

074

}

075

076	void DMA_Configuration(void)

077

{

078	DMA_InitTypeDef DMA_InitStructure;

079

080	DMA_DeInit(DMA1_Channel6);

081	DMA_InitStructure.DMA_PeripheralBaseAddr = (u32) SRC_Const_Buffer;

082	DMA_InitStructure.DMA_MemoryBaseAddr = (u32) DST_Buffer;

083	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;

084	DMA_InitStructure.DMA_BufferSize = BufferSize;

085	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;

086	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;

087	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;

088	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;

089	DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;

090	DMA_InitStructure.DMA_Priority = DMA_Priority_High;

091	DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;

092	DMA_Init(DMA1_Channel6,&DMA_InitStructure);

093

094	DMA_ITConfig(DMA1_Channel6,DMA_IT_TC,ENABLE);

095

}

096

097	void GPIO_Configuration(void)

098

{

099	GPIO_InitTypeDef GPIO_InitStructure;

100	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

101	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

102	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

103	GPIO_Init(GPIOA , &GPIO_InitStructure);

104	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

105	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

106	GPIO_Init(GPIOA , &GPIO_InitStructure);

107

108

}

109

110

111	void RCC_Configuration(void)

112

{

113	/* 定义枚举类型变量 HSEStartUpStatus */

114	ErrorStatus HSEStartUpStatus;

115

116	/* 复位系统时钟设置*/

117	RCC_DeInit();

118	/* 开启HSE*/

119	RCC_HSEConfig(RCC_HSE_ON);

120	/* 等待HSE起振并稳定*/

121	HSEStartUpStatus = RCC_WaitForHSEStartUp();

122	/* 判断HSE起是否振成功，是则进入if()内部 */

123	if(HSEStartUpStatus == SUCCESS)

124

{

125	/* 选择HCLK（AHB）时钟源为SYSCLK 1分频 */

126	RCC_HCLKConfig(RCC_SYSCLK_Div1);

127	/* 选择PCLK2时钟源为 HCLK（AHB） 1分频 */

128	RCC_PCLK2Config(RCC_HCLK_Div1);

129	/* 选择PCLK1时钟源为 HCLK（AHB） 2分频 */

130	RCC_PCLK1Config(RCC_HCLK_Div2);

131	/* 设置FLASH延时周期数为2 */

132	FLASH_SetLatency(FLASH_Latency_2);

133	/* 使能FLASH预取缓存 */

134	FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

135	/* 选择锁相环（PLL）时钟源为HSE 1分频，倍频数为9，则PLL输出频率为 8MHz * 9 = 72MHz */

136	RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

137	/* 使能PLL */

138	RCC_PLLCmd(ENABLE);

139	/* 等待PLL输出稳定 */

140	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

141	/* 选择SYSCLK时钟源为PLL */

142	RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

143	/* 等待PLL成为SYSCLK时钟源 */

144	while(RCC_GetSYSCLKSource() != 0x08);

145

}

146	/* 打开APB2总线上的GPIOA时钟*/

147	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE);

148	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

149

150	//RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP|RCC_APB1Periph_WWDG, ENABLE);

151

152

}

153

154

155	void USART_Configuration(void)

156

{

157	USART_InitTypeDef USART_InitStructure;

158	USART_ClockInitTypeDef USART_ClockInitStructure;

159

160	USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;

161	USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;

162	USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;

163	USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;

164	USART_ClockInit(USART1 , &USART_ClockInitStructure);

165

166	USART_InitStructure.USART_BaudRate = 9600;

167	USART_InitStructure.USART_WordLength = USART_WordLength_8b;

168	USART_InitStructure.USART_StopBits = USART_StopBits_1;

169	USART_InitStructure.USART_Parity = USART_Parity_No;

170	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

171	USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;

172	USART_Init(USART1,&USART_InitStructure);

173

174	USART_Cmd(USART1,ENABLE);

175

}

176

177	void NVIC_Configuration(void)

178

{

179	NVIC_InitTypeDef NVIC_InitStructure;

180

181	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);

182

183	NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel6_IRQn;

184	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

185	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

186	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

187	NVIC_Init(&NVIC_InitStructure);

188

}

189

190	#if  PRINTF_ON

191

192	int fputc(int ch,FILE *f)

193

{

194	USART_SendData(USART1,(u8) ch);

195	while(USART_GetFlagStatus(USART1,USART_FLAG_TC) == RESET);

196	return ch;

197

}

198

199

#endif

stm32f10x_it.c

01	#include "stm32f10x_it.h"

02	#include "stdio.h"

03

04

05	extern vu32 Tick;

06	extern vu16 LeftDataCounter;

07

08

09	void SysTick_Handler(void)

10

{

11

Tick++;

12

}

13

14	void DMA1_Channel6_IRQHandler(void)

15

{

16

17	LeftDataCounter = DMA_GetCurrDataCounter(DMA1_Channel6);   //获取剩余待传输数据

18	DMA_ClearITPendingBit(DMA1_IT_GL6);

19

}

库函数输出：

 

 Transmit Success! 

 the CPU spend : 68us! 

 the DMA spend : 7us!