2019年01月07日 | STM32F103实现DMA接收串口不定长度数据

这两天调试STM32F103的开发板，需要实现接收一定长度连续的数据。当数据流接收结束的时候，触发串口接收中断。计算数据流长度，并将数据传到内存中。

main.c

// DMA 存储器到外设（串口）数据传输实验

#include "stm32f10x.h"

#include "bsp_usart_dma.h"

#include "bsp_led.h"

extern uint8_t ReceiveBuff[RECEIVEBUFF_SIZE];

static void Delay(__IO u32 nCount); 

/**

  * @brief  主函数

  * @param  无

  * @retval 无

  */

int main(void)

{

  uint16_t i;

  /* 初始化USART */

  USART_Config(); 

  /* 配置使用DMA模式 */

  USARTx_DMA_Config();

  USARTx_NVIC_Config();

  /* 配置RGB彩色灯 */

  LED_GPIO_Config();

  //printf("\r\n USART1 DMA TX 测试 \r\n");

/*填充将要发送的数据*/

for(i=0;i

{

ReceiveBuff[i] = 'P';

}

  /*为演示DMA持续运行而CPU还能处理其它事情，持续使用DMA发送数据，量非常大，

  *长时间运行可能会导致电脑端串口调试助手会卡死，鼠标乱飞的情况，

  *或把DMA配置中的循环模式改为单次模式*/

  /* 此时CPU是空闲的，可以干其他的事情 */  

  //例如同时控制LED

  while(1)

  {

    LED1_TOGGLE

    Delay(0xFFFFF);

  }

}

static void Delay(__IO uint32_t nCount) //简单的延时函数

{

for(; nCount != 0; nCount--);

}

/*********************************************END OF FILE**********************/

bsp_usart_dma.c

#include "bsp_usart_dma.h"

uint8_t ReceiveBuff[RECEIVEBUFF_SIZE];

/**

  * @brief  USART GPIO 配置,工作参数配置

  * @param  无

  * @retval 无

  */

void USART_Config(void)

{

GPIO_InitTypeDef GPIO_InitStructure;

USART_InitTypeDef USART_InitStructure;

// 打开串口GPIO的时钟

DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);

// 打开串口外设的时钟

DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);

// 将USART Tx的GPIO配置为推挽复用模式

GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);

  // 将USART Rx的GPIO配置为浮空输入模式

GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);

// 配置串口的工作参数

// 配置波特率

USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;

// 配置 针数据字长

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(DEBUG_USARTx, &USART_InitStructure);

//开启空闲中断

USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);

/* 使能USART1 DMA接收 */

USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Rx, ENABLE);

// 使能串口

USART_Cmd(DEBUG_USARTx, ENABLE);     

}

/*****************  发送一个字节 **********************/

void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t ch)

{

/* 发送一个字节数据到USART */

USART_SendData(pUSARTx,ch);

/* 等待发送数据寄存器为空 */

while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);

}

/****************** 发送8位的数组 ************************/

void Usart_SendArray( USART_TypeDef * pUSARTx, uint8_t *array, uint16_t num)

{

  uint8_t i;

for(i=0; i

  {

    /* 发送一个字节数据到USART */

    Usart_SendByte(pUSARTx,array[i]);

  }

/* 等待发送完成 */

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

}

/*****************  发送字符串 **********************/

void Usart_SendString( USART_TypeDef * pUSARTx, char *str)

{

unsigned int k=0;

  do 

  {

      Usart_SendByte( pUSARTx, *(str + k) );

      k++;

  } while(*(str + k)!='\0');

  /* 等待发送完成 */

  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)

  {}

}

/*****************  发送一个16位数 **********************/

void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)

{

uint8_t temp_h, temp_l;

/* 取出高八位 */

temp_h = (ch&0XFF00)>>8;

/* 取出低八位 */

temp_l = ch&0XFF;

/* 发送高八位 */

USART_SendData(pUSARTx,temp_h);

while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);

/* 发送低八位 */

USART_SendData(pUSARTx,temp_l);

while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);

}

///重定向c库函数printf到串口，重定向后可使用printf函数

int fputc(int ch, FILE *f)

{

/* 发送一个字节数据到串口 */

USART_SendData(DEBUG_USARTx, (uint8_t) ch);

/* 等待发送完毕 */

while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);

return (ch);

}

///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数

int fgetc(FILE *f)

{

/* 等待串口输入数据 */

while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);

return (int)USART_ReceiveData(DEBUG_USARTx);

}

/**

  * @brief  USARTx RX NVIC 配置，外设到内存(DR->USART1)

  * @param  无

  * @retval 无

  */

void USARTx_DMA_Config(void)

{

DMA_InitTypeDef DMA_InitStructure;

// 开启DMA时钟

RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

// 设置DMA源地址：串口数据寄存器地址*/

DMA_InitStructure.DMA_PeripheralBaseAddr = USART_DR_ADDRESS;

// 内存地址(要传输的变量的指针)

DMA_InitStructure.DMA_MemoryBaseAddr = (u32)ReceiveBuff;

// 方向：从外设到内存

DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;

// 传输大小

DMA_InitStructure.DMA_BufferSize = RECEIVEBUFF_SIZE;

// 外设地址不增     

DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;

// 内存地址自增

DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;

// 外设数据单位

DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;

// 内存数据单位

DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;  

// DMA模式，一次或者循环模式

DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;

//DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;

// 优先级：中

DMA_InitStructure.DMA_Priority = DMA_Priority_High;

// 禁止内存到内存的传输

DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

// 配置DMA通道    

DMA_Init(USART_RX_DMA_CHANNEL, &DMA_InitStructure);

// 使能DMA

DMA_Cmd (USART_RX_DMA_CHANNEL,ENABLE);

}

//重新恢复DMA指针

void MYDMA_Enable(DMA_Channel_TypeDef*DMA_CHx)

{

    DMA_Cmd(DMA_CHx, DISABLE );  //关闭USART1 TX DMA1所指示的通道

    DMA_SetCurrDataCounter(DMA_CHx, RECEIVEBUFF_SIZE);//DMA通道的DMA缓存的大小

    DMA_Cmd(DMA_CHx, ENABLE);  //打开USART1 TX DMA1所指示的通道

}

/**

  * @brief  USARTx RX NVIC 配置，外设到内存(DR->USART1)

  * @param  无

  * @retval 无

  */

void USARTx_NVIC_Config(void)

{

NVIC_InitTypeDef NVIC_InitStructure;

    /* Configure the NVIC Preemption Priority Bits */

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_3);

    /* Enable the USART Interrupt */

    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

}

//串口中断函数

void USART1_IRQHandler(void)                //串口1中断服务程序

{

uint8_t Usart1_Rec_Cnt;

     if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)

      {

          USART_ReceiveData(USART1);//读取数据注意：这句必须要，否则不能够清除中断标志位。

          Usart1_Rec_Cnt = RECEIVEBUFF_SIZE - DMA_GetCurrDataCounter(DMA1_Channel5); //算出接本帧数据长度

         //***********帧数据处理函数************//

          printf ("Thelenght:%d\r\n",Usart1_Rec_Cnt);

          printf ("The data:\r\n");

          Usart_SendArray(DEBUG_USARTx, ReceiveBuff, RECEIVEBUFF_SIZE);

          printf ("\r\nOver! \r\n");

        //*************************************//

         USART_ClearITPendingBit(USART1,USART_IT_IDLE);         //清除中断标志

         MYDMA_Enable(DMA1_Channel5);                  //恢复DMA指针，等待下一次的接收

     }

}

bsp_usart_dma.h 

#ifndef __USARTDMA_H

#define __USARTDMA_H

#include "stm32f10x.h"

#include

// 串口工作参数宏定义

#define  DEBUG_USARTx                   USART1

#define  DEBUG_USART_CLK                RCC_APB2Periph_USART1

#define  DEBUG_USART_APBxClkCmd         RCC_APB2PeriphClockCmd

#define  DEBUG_USART_BAUDRATE           115200

// USART GPIO 引脚宏定义

#define  DEBUG_USART_GPIO_CLK           (RCC_APB2Periph_GPIOA)

#define  DEBUG_USART_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd

#define  DEBUG_USART_TX_GPIO_PORT       GPIOA   

#define  DEBUG_USART_TX_GPIO_PIN        GPIO_Pin_9

#define  DEBUG_USART_RX_GPIO_PORT       GPIOA

#define  DEBUG_USART_RX_GPIO_PIN        GPIO_Pin_10

// 串口对应的DMA请求通道

#define  USART_TX_DMA_CHANNEL     DMA1_Channel4

#define  USART_RX_DMA_CHANNEL     DMA1_Channel5

// 外设寄存器地址

#define  USART_DR_ADDRESS        (USART1_BASE+0x04)

// 一次发送的数据量

#define  RECEIVEBUFF_SIZE            50

void USART_Config(void);

void USARTx_DMA_Config(void);

#endif /* __USARTDMA_H */

编译后成功运行，运行结果：