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

#include <stm32f10x_lib.h>        

#include "system.h"

#include "usart.h" 

#include "dma.h"

#include "tim.h"         

#include "string.h"



#define LED1 PAout(4)

#define LED2 PAout(5)

#define LED3 PAout(6)



void Gpio_Init(void);





//数据源

uc32 SRC_Const_Buffer[32] =

{  

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

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

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

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

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

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

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

    0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80

};



//目标位置

u32 DST_Buffer[32];







int main(void)

{                                  

        u8 i=0;

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





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



        Usart1_Init(72,9600);



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



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



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



        Gpio_Init();



        StartTime = TIM2->CNT;



        while(i<32)                                                         //CPU搬运

    {

        DST_Buffer[i]=SRC_Const_Buffer[i];

        i++;

    }



        CPUSpendTime = TIM2->CNT - StartTime;



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



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

    {

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

    }else{

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

    }



    i=0;



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

    {

        DST_Buffer[i]=0;

        i++;

    }  



        StartTime = TIM2->CNT;



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



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



        DMASpendTime= TIM2->CNT - StartTime;

                

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

        

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

    {

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

    }else{

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

    }         

        

        while(1);                

}





void Gpio_Init(void)

{

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



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

        GPIOA->CRL|=0x33334444; 

        

        //USART1 串口I/O设置



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

        GPIOA -> CRH|=0x000008B0;          



}

#include "stm32f10x.h"

#include "stdio.h"

#include "string.h"



#define         PRINTF_ON  1

#define  BufferSize  32



vu16 LeftDataCounter;

vu32 Tick;



uc32 SRC_Const_Buffer[BufferSize] = 

{        

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

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

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

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

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

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

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

        0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80

};



u32 DST_Buffer[BufferSize];

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



void RCC_Configuration(void);

void GPIO_Configuration(void);

void NVIC_Configuration(void);

void USART_Configuration(void);

void DMA_Configuration(void);





int main(void)

{

          RCC_Configuration();

          GPIO_Configuration();

        NVIC_Configuration();

        USART_Configuration();

        DMA_Configuration();



        SysTick_Config(72);



        Tick = 0;

        while(i<BufferSize)

        {

                DST_Buffer[i]=SRC_Const_Buffer[i];

                CPUSpendTime = Tick;

                i++;

        }

        i=0;

          while(i<BufferSize)

        {

                DST_Buffer[i]=0;

                i++;

        }



        Tick = 0;

        DMA_Cmd(DMA1_Channel6,ENABLE);

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

        DMASpendTime = Tick;

        

        



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

        {

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

        }else{

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

        }



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

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



}



void DMA_Configuration(void)

{

        DMA_InitTypeDef DMA_InitStructure;



        DMA_DeInit(DMA1_Channel6);

        DMA_InitStructure.DMA_PeripheralBaseAddr = (u32) SRC_Const_Buffer;

        DMA_InitStructure.DMA_MemoryBaseAddr = (u32) DST_Buffer;

        DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;

        DMA_InitStructure.DMA_BufferSize = BufferSize;

        DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;

        DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;

        DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;

        DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;

        DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;

        DMA_InitStructure.DMA_Priority = DMA_Priority_High;

        DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;

        DMA_Init(DMA1_Channel6,&DMA_InitStructure);



        DMA_ITConfig(DMA1_Channel6,DMA_IT_TC,ENABLE);

}



void GPIO_Configuration(void)

{

          GPIO_InitTypeDef GPIO_InitStructure;

       GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                        

          GPIO_Init(GPIOA , &GPIO_InitStructure); 

          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                        

          GPIO_Init(GPIOA , &GPIO_InitStructure); 



}





void RCC_Configuration(void)

{

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

        ErrorStatus HSEStartUpStatus;



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

          RCC_DeInit();

          /* 开启HSE*/

          RCC_HSEConfig(RCC_HSE_ON);

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

          HSEStartUpStatus = RCC_WaitForHSEStartUp();

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

          if(HSEStartUpStatus == SUCCESS)

          {

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

            RCC_HCLKConfig(RCC_SYSCLK_Div1); 

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

            RCC_PCLK2Config(RCC_HCLK_Div1); 

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

            RCC_PCLK1Config(RCC_HCLK_Div2);

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

            FLASH_SetLatency(FLASH_Latency_2);

            /* 使能FLASH预取缓存 */

            FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

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

            RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

            /* 使能PLL */ 

            RCC_PLLCmd(ENABLE);

            /* 等待PLL输出稳定 */

            while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

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

            RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

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

            while(RCC_GetSYSCLKSource() != 0x08);

          } 

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

          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE);

        RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);



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

                

}



 

void USART_Configuration(void)

{

        USART_InitTypeDef USART_InitStructure;

        USART_ClockInitTypeDef USART_ClockInitStructure;



        USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;

        USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;

        USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;                                                                                                                                                      

        USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;

        USART_ClockInit(USART1 , &USART_ClockInitStructure);



        USART_InitStructure.USART_BaudRate = 9600;

        USART_InitStructure.USART_WordLength = USART_WordLength_8b;

        USART_InitStructure.USART_StopBits = USART_StopBits_1;

        USART_InitStructure.USART_Parity = USART_Parity_No;

        USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

        USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;

        USART_Init(USART1,&USART_InitStructure);



         USART_Cmd(USART1,ENABLE);

}



void NVIC_Configuration(void)

{

        NVIC_InitTypeDef NVIC_InitStructure;

        

        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);        



        NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel6_IRQn;

        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

        NVIC_Init(&NVIC_InitStructure);

}



#if         PRINTF_ON



int fputc(int ch,FILE *f)

{

        USART_SendData(USART1,(u8) ch);

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

        return ch;

}



#endif