STM32F407 USART不定长数据接收：空闲中断+DMA

最新推荐文章于 2024-03-19 21:04:27 发布
最新推荐文章于 2024-03-19 21:04:27 发布
阅读量2.3k 收藏 23
点赞数 6
分类专栏： 笔记 文章标签： stm32 串口通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45100839/article/details/118111463
版权

STM32F407 USART不定长数据接收：空闲中断+DMA（纯代码）

直接上代码就对了（_）

头文件

#ifndef __USART_H
#define __USART_H

#include "main.h"

#define USART1_RX_BUF_SIZE  128
#define USART1_TX_BUF_SIZE  64

#define USART3_RX_BUF_SIZE  128
#define USART3_TX_BUF_SIZE  64


extern uint8_t USART1_RX_Buff[USART1_RX_BUF_SIZE];
extern uint8_t USART1_TX_Buff[USART1_TX_BUF_SIZE];
extern uint8_t USART1_RC_Flag;
extern uint8_t USART1_TC_Flag;

extern uint8_t USART3_RX_Buff[USART3_RX_BUF_SIZE];
extern uint8_t USART3_TX_Buff[USART3_TX_BUF_SIZE];
extern uint8_t USART3_RC_Flag;
extern uint8_t USART3_TC_Flag;

void USART1_Init(uint32_t baud);
void USART1_DMA_ReceData(uint8_t *data);
void USART1_DMA_TranData(uint8_t *data,uint32_t dataLen);

void USART3_Init(uint32_t baud);
void USART3_DMA_ReceData(uint8_t *data);
void USART3_DMA_TranData(uint8_t *data,uint32_t dataLen);

void Usart_SendString(USART_TypeDef* USARTx,uint8_t *data,uint32_t dataLen);

#endif

源文件

#include "usart.h"
#include "main.h"

///

/******************************** 串口1 开始 **********************************/
uint32_t USART1_RX_Data_Size;
uint8_t USART1_RX_Buff[USART1_RX_BUF_SIZE] = {0};
uint8_t USART1_TX_Buff[USART1_TX_BUF_SIZE] = {0};
uint8_t USART1_RC_Flag = 0;
uint8_t USART1_TC_Flag = 0;


static void USART1_IO_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;	
  
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);	
  
  GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1);
  GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1);
  
  GPIO_StructInit(&GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin           = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Mode          = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType         = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd          = GPIO_PuPd_UP;
  GPIO_Init(GPIOA,&GPIO_InitStructure);
  
  GPIO_StructInit(&GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin           = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode          = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType         = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd          = GPIO_PuPd_UP;
  GPIO_Init(GPIOA,&GPIO_InitStructure);
}


static void USART1_Config(uint32_t baud)
{
  USART_InitTypeDef USART_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
  
  USART_DeInit(USART1);
  
  USART_StructInit(&USART_InitStructure);
  USART_InitStructure.USART_BaudRate              = baud;
  USART_InitStructure.USART_WordLength            = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits              = USART_StopBits_1;
  USART_InitStructure.USART_Parity                = USART_Parity_No ;
  USART_InitStructure.USART_Mode                  = USART_Mode_Rx | USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl   = USART_HardwareFlowControl_None;  
  USART_Init(USART1,&USART_InitStructure);
  
  
  NVIC_InitStructure.NVIC_IRQChannel                    = USART1_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority  = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority         = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd                 = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  USART_ClearFlag(USART1,USART_FLAG_TC);
  USART_ClearFlag(USART1,USART_FLAG_RXNE);
  USART_ClearFlag(USART1,USART_FLAG_IDLE);
  
  USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
  
  USART_Cmd(USART1,ENABLE);
}


static void USART1_DMA_RX_TX_Config(void)
{
   DMA_InitTypeDef  DMA_InitStructure;
   NVIC_InitTypeDef NVIC_InitStructure;	           
  
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2,ENABLE);//DMA2时钟使能 

  //DMA2_USART1_RX:通道4，数据流5
  DMA_Cmd(DMA2_Stream5, DISABLE);
  DMA_DeInit(DMA2_Stream5);
  
  DMA_InitStructure.DMA_Channel                = DMA_Channel_4;
  DMA_InitStructure.DMA_PeripheralBaseAddr     = (uint32_t)&USART1->DR;//DMA外设地址
  DMA_InitStructure.DMA_Memory0BaseAddr        = (uint32_t)USART1_RX_Buff;//接收基地址
  DMA_InitStructure.DMA_DIR                    = DMA_DIR_PeripheralToMemory;
  DMA_InitStructure.DMA_BufferSize             = USART1_RX_BUF_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_InitStructure.DMA_Mode                   = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority               = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_FIFOMode               = DMA_FIFOMode_Disable;
  DMA_InitStructure.DMA_FIFOThreshold          = DMA_FIFOThreshold_1QuarterFull;
  DMA_InitStructure.DMA_MemoryBurst            = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst        = DMA_PeripheralBurst_Single;
  DMA_Init(DMA2_Stream5, &DMA_InitStructure);
  
  NVIC_InitStructure.NVIC_IRQChannel                    = DMA2_Stream5_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority  = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority         = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd                 = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  DMA_ClearFlag(DMA2_Stream5,DMA_FLAG_TCIF5);
  DMA_ITConfig(DMA2_Stream5,DMA_IT_TC,ENABLE);
  
  USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);//串口DMA接收使能
  DMA_Cmd(DMA2_Stream5, ENABLE);//DMA传输使能 
  
  //DMA2_USART1_TX:通道4，数据流7
  DMA_Cmd(DMA2_Stream7, DISABLE);//DMA传输失能 
  DMA_DeInit(DMA2_Stream7);

  DMA_InitStructure.DMA_Channel                = DMA_Channel_4;
  DMA_InitStructure.DMA_PeripheralBaseAddr     = (uint32_t)&USART1->DR;            //DMA外设地址
  DMA_InitStructure.DMA_Memory0BaseAddr        = (uint32_t)USART1_TX_Buff;       //发送基地址
  DMA_InitStructure.DMA_DIR                    = DMA_DIR_MemoryToPeripheral;
  DMA_InitStructure.DMA_BufferSize             = USART1_TX_BUF_SIZE;                                   
  DMA_Init(DMA2_Stream7, &DMA_InitStructure);
  
  NVIC_InitStructure.NVIC_IRQChannel                    = DMA2_Stream7_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority  = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority         = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd                 = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  DMA_ClearFlag(DMA2_Stream7,DMA_FLAG_TCIF7); 
  DMA_ITConfig(DMA2_Stream7,DMA_IT_TC,ENABLE);
  
  USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);//串口DMA发送使能
  
  //DMA_Cmd(DMA2_Stream7, ENABLE);//DMA传输使能 
}



/******** 串口1初始化配置 *********/
void USART1_Init(uint32_t baud)
{
  USART1_IO_Config();
  
  USART1_Config(baud);
   
  USART1_DMA_RX_TX_Config();
  
}


/******** 串口1 DMA接收数据 *********/
void USART1_DMA_ReceData(uint8_t *data)
{
  DMA_Cmd(DMA2_Stream5, DISABLE);//关闭DMA设备（需要在DMA关闭的状态下才能进行配置）
  
  //DMA_ClearFlag(DMA2_Stream5,DMA_FLAG_TCIF5);
  
  while(DMA_GetCmdStatus(DMA2_Stream5) != DISABLE);//等待关闭完成
  
  DMA2_Stream5->M0AR = (uint32_t)data;//接收数据所放的地址

  DMA_Cmd(DMA2_Stream5, ENABLE);//开启DMA（等待接收数据）
}


/******** 串口1 DMA发送数据 *********/
void USART1_DMA_TranData(uint8_t *data,uint32_t dataLen)
{
  while(USART1_TC_Flag);//等待上一次数据传输完成
  
  USART1_TC_Flag = 1;//将传输标志位置1表示正在传数据
  
  //DMA_ClearFlag(DMA2_Stream7,DMA_FLAG_TCIF7);
  
  DMA_Cmd(DMA2_Stream7, DISABLE);//关闭DMA设备（需要在DMA关闭的状态下才能进行配置）
  
  while(DMA_GetCmdStatus(DMA2_Stream7) != DISABLE);//等待关闭完成
  
  DMA2_Stream7->M0AR = (uint32_t)data;//需要发送的数据地址
  DMA2_Stream7->NDTR = dataLen;//需要发送的数据长度
  //DMA_SetCurrDataCounter(DMA2_Stream7,dataLen);
 
  DMA_Cmd(DMA2_Stream7, ENABLE);//开启DMA（开始发送数据）
}


///

/******** 串口1 中断服务函数 ***********/
void USART1_IRQHandler(void)
{
  if(USART_GetITStatus(USART1, USART_IT_IDLE) == SET)
  {
    USART1_RC_Flag = 1;
    
    USART1->SR;USART1->DR;//清除串口空闲中断标志位
  }  
}


/**** 串口1 DMA接收中断服务函数 *****/
void DMA2_Stream5_IRQHandler(void)
{
  if(DMA_GetITStatus(DMA2_Stream5,DMA_IT_TCIF5) == SET)
  {
    //USART1_RC_Flag = 1;  
    
     DMA_ClearITPendingBit(DMA2_Stream5,DMA_IT_TCIF5);
  } 
 
}


/**** 串口1 DMA发送中断服务函数 *****/
void DMA2_Stream7_IRQHandler(void)
{
  if(DMA_GetITStatus(DMA2_Stream7,DMA_IT_TCIF7) == SET)
  {
    USART1_TC_Flag = 0;
    
    DMA_ClearITPendingBit(DMA2_Stream7,DMA_IT_TCIF7);
  }  
  
}

///

/******************************** 串口1 结束 **********************************/

///


///

/******************************** 串口3 开始 **********************************/

uint8_t USART3_RX_Buff[USART1_RX_BUF_SIZE] = {0};
uint8_t USART3_TX_Buff[USART1_TX_BUF_SIZE] = {0};
uint8_t USART3_RC_Flag = 0;
uint8_t USART3_TC_Flag = 0;


static void USART3_IO_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;	
  
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);	
  
  GPIO_PinAFConfig(GPIOB,GPIO_PinSource10,GPIO_AF_USART3);
  GPIO_PinAFConfig(GPIOB,GPIO_PinSource11,GPIO_AF_USART3);
  
  GPIO_StructInit(&GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin           = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode          = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType         = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd          = GPIO_PuPd_UP;
  GPIO_Init(GPIOB,&GPIO_InitStructure);
  
  GPIO_StructInit(&GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin           = GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Mode          = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed         = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType         = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd          = GPIO_PuPd_UP;
  GPIO_Init(GPIOB,&GPIO_InitStructure);
}


static void USART3_Config(uint32_t baud)
{
  USART_InitTypeDef USART_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
  
  USART_DeInit(USART3);
  
  USART_StructInit(&USART_InitStructure);
  USART_InitStructure.USART_BaudRate              = baud;
  USART_InitStructure.USART_WordLength            = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits              = USART_StopBits_1;
  USART_InitStructure.USART_Parity                = USART_Parity_No ;
  USART_InitStructure.USART_Mode                  = USART_Mode_Rx | USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl   = USART_HardwareFlowControl_None;  
  USART_Init(USART3,&USART_InitStructure);
  
  NVIC_InitStructure.NVIC_IRQChannel                    = USART3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority  = 1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority         = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd                 = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  USART_ClearFlag(USART3,USART_FLAG_TC);
  USART_ClearFlag(USART3,USART_FLAG_RXNE);
  USART_ClearFlag(USART3,USART_FLAG_IDLE);
  
  USART_ITConfig(USART3, USART_IT_IDLE, ENABLE);
  USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
  
  USART_Cmd(USART3,ENABLE);
}


static void USART3_DMA_RX_TX_Config(void)
{
  DMA_InitTypeDef  DMA_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;	           
  
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1,ENABLE);//DMA2时钟使能 

  //DMA1_USART3_RX:通道4，数据流1
  DMA_Cmd(DMA1_Stream1, DISABLE);
  DMA_DeInit(DMA1_Stream1);
  
  DMA_InitStructure.DMA_Channel                = DMA_Channel_4;
  DMA_InitStructure.DMA_PeripheralBaseAddr     = (uint32_t)&USART3->DR;//DMA外设地址
  DMA_InitStructure.DMA_Memory0BaseAddr        = (uint32_t)USART3_RX_Buff;//接收基地址
  DMA_InitStructure.DMA_DIR                    = DMA_DIR_PeripheralToMemory;
  DMA_InitStructure.DMA_BufferSize             = USART3_RX_BUF_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_InitStructure.DMA_Mode                   = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority               = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_FIFOMode               = DMA_FIFOMode_Disable;
  DMA_InitStructure.DMA_FIFOThreshold          = DMA_FIFOThreshold_1QuarterFull;
  DMA_InitStructure.DMA_MemoryBurst            = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst        = DMA_PeripheralBurst_Single;
  DMA_Init(DMA1_Stream1, &DMA_InitStructure);
  
  NVIC_InitStructure.NVIC_IRQChannel                    = DMA1_Stream1_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority  = 1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority         = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd                 = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  DMA_ClearFlag(DMA1_Stream1,DMA_FLAG_TCIF1);
  DMA_ITConfig(DMA1_Stream1,DMA_IT_TC,ENABLE);
  
  USART_DMACmd(USART3,USART_DMAReq_Rx,ENABLE);//串口DMA接收使能
  DMA_Cmd(DMA1_Stream1, ENABLE);//DMA传输使能 
  
  //DMA1_USART3_TX:通道4，数据流3
  DMA_Cmd(DMA1_Stream3, DISABLE);//DMA传输失能 
  DMA_DeInit(DMA1_Stream3);

  DMA_InitStructure.DMA_Channel                = DMA_Channel_4;
  DMA_InitStructure.DMA_PeripheralBaseAddr     = (uint32_t)&USART3->DR;            //DMA外设地址
  DMA_InitStructure.DMA_Memory0BaseAddr        = (uint32_t)USART3_TX_Buff;       //发送基地址
  DMA_InitStructure.DMA_DIR                    = DMA_DIR_MemoryToPeripheral;
  DMA_InitStructure.DMA_BufferSize             = USART3_TX_BUF_SIZE;                                   
  DMA_Init(DMA1_Stream3, &DMA_InitStructure);
  
  NVIC_InitStructure.NVIC_IRQChannel                    = DMA1_Stream3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority  = 1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority         = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd                 = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  
  DMA_ClearFlag(DMA1_Stream3,DMA_FLAG_TCIF3); 
  DMA_ITConfig(DMA1_Stream3,DMA_IT_TC,ENABLE);
  
  USART_DMACmd(USART3,USART_DMAReq_Tx,ENABLE);//串口DMA发送使能
  
  //DMA_Cmd(DMA1_Stream3, ENABLE);//DMA传输使能 
}


/******** 串口3初始化配置 *********/
void USART3_Init(uint32_t baud)
{
  USART3_IO_Config();
  
  USART3_Config(baud);
   
  USART3_DMA_RX_TX_Config();
}


/******** 串口1 DMA接收数据 *********/
void USART3_DMA_ReceData(uint8_t *data)
{
  DMA_Cmd(DMA1_Stream1, DISABLE);//关闭DMA设备（需要在DMA关闭的状态下才能进行配置）
  
  //DMA_ClearFlag(DMA1_Stream1,DMA_FLAG_TCIF1);
  
  while(DMA_GetCmdStatus(DMA1_Stream1) != DISABLE);//等待关闭完成
  
  DMA1_Stream1->M0AR = (uint32_t)data;//接收数据所放的地址
 
  DMA_Cmd(DMA1_Stream1, ENABLE);//开启DMA（等待接收数据）
}


/******** 串口1 DMA发送数据 *********/
void USART3_DMA_TranData(uint8_t *data,uint32_t dataLen)
{
  while(USART3_TC_Flag);//等待上一次数据传输完成
  
  USART3_TC_Flag = 1;//将传输标志位置1表示正在传数据
  
  //DMA_ClearFlag(DMA1_Stream3,DMA_FLAG_TCIF3);
  
  DMA_Cmd(DMA1_Stream3, DISABLE);//关闭DMA设备（需要在DMA关闭的状态下才能进行配置）
  
  while(DMA_GetCmdStatus(DMA1_Stream3) != DISABLE);//等待关闭完成
  
  DMA1_Stream3->M0AR = (uint32_t)data;//需要发送的数据地址
  DMA1_Stream3->NDTR = dataLen;//需要发送的数据长度
  //DMA_SetCurrDataCounter(DMA1_Stream3,dataLen);
 
  DMA_Cmd(DMA1_Stream3, ENABLE);//开启DMA（开始发送数据）
}

///

/******** 串口3 中断服务函数 ***********/
void USART3_IRQHandler(void)
{
  if(USART_GetITStatus(USART3, USART_IT_IDLE) == SET)
  {
    USART3_RC_Flag = 1;
    
    USART3->SR;USART3->DR;//清除串口空闲中断标志位
  }  
}


/**** 串口3 DMA接收中断服务函数 *****/
void DMA1_Stream1_IRQHandler(void)
{
  if(DMA_GetITStatus(DMA1_Stream1,DMA_IT_TCIF1) == SET)
  {
    //USART1_RC_Flag = 1;  
    
     DMA_ClearITPendingBit(DMA1_Stream1,DMA_IT_TCIF1);
  } 
 
}


/**** 串口3 DMA发送中断服务函数 *****/
void DMA1_Stream3_IRQHandler(void)
{
  if(DMA_GetITStatus(DMA1_Stream3,DMA_IT_TCIF3) == SET)
  {
    USART3_TC_Flag = 0;
    
    DMA_ClearITPendingBit(DMA1_Stream3,DMA_IT_TCIF3);
  }  
  
}

///

/******************************** 串口3 结束 **********************************/


/******** 串口 发送字符串 *********/
void Usart_SendString(USART_TypeDef* USARTx,uint8_t *data,uint32_t dataLen)
{
  uint32_t i;
  
  for(i = 0;i < dataLen;i ++)
  {
    USART_SendData(USARTx,data[i]);
    while(USART_GetFlagStatus(USARTx,USART_FLAG_TXE) == RESET);
  }
}

主函数

int main()
{
  uint32_t temp = 0;
  
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
  
  USART1_Init(115200);
  USART3_Init(115200);
  delay(10);
    
  while (1)
  {
    
    if(USART1_RC_Flag == 1)
    {
      USART1_DMA_TranData(USART1_RX_Buff,strlen((char*)USART1_RX_Buff));
      USART1_DMA_ReceData(USART1_RX_Buff);
      
      USART1_RC_Flag = 0;
    }
    
    if(USART3_RC_Flag == 1)
    {
      USART3_DMA_TranData(USART3_RX_Buff,strlen((char*)USART3_RX_Buff));
      USART3_DMA_ReceData(USART3_RX_Buff);
      
      USART3_RC_Flag = 0;
    }
    
    delay(500);
  }
  
  return 0;
}
我是东山啊_
关注
  • 6
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
正点原子阿波罗F429+STM32CubeMX实现串口不定长接收(DMA+空闲中断)
01-07
正点原子阿波罗F429+STM32CubeMX实现串口不定长接收(DMA+空闲中断).新建一个最基本的代码工程,为后面的系统移植做好准备.
基于STM32F407标准库串口DMA+空闲中断
m0_64354650的博客
07-06 5180
核心板：STM32F407 实验目的：通过DMA接收串口发来的数据，并且利用串口空闲中断在将这些数据发送至串口助手。
STM32F4使用DMA收发数据
热门推荐
u010001130的博客
09-03 2万+
STM32F4串口1使用DMA收发数据
简单学习速记-STM32串口接收使用DMA+空闲中断
最新发布
ObviouslyCheng的博客
03-19 648
这是一篇简单的学习笔记，记录使用STM32串口接收不定长数据，之前都是使用接收中断+缓冲区的方式，这篇笔记使用DMA+空闲中断的方式。清除idle标志位，停止DMA传输。DMA当前帧实际接收的数据长度。DMA当前帧实际接收的数据长度。使用串口空闲中断的基本思路是。设置串口接收完成标志。使能串口和DMA中断。
USART.zip_DMA串口_STM32F103_不定长接收_串口_空闲中断
09-21
使用DMA+空闲中断，实现串口的不定长接收
stm32f103+freertos+USART(DMA)不定长接收
08-29
stm32f103运行FreeRTOS实现串口DMA发送和DMA不定长接收。 驱动OLED屏和空气检测传感器PMS5003ST.
STM32F407 DMA+串口接收不定长数据程序
05-04
使用STM32F407单片机的DMA功能，利用串口接收不定长数据的程序，验证可以使用。
STM32F407 USART1串口使用DMA接收不定长数据和DMA中断发送
ba_wang_mao的专栏
11-09 1512
STM32F407 USART1串口使用DMA接收不定长数据和DMA中断发送
Stm32407串口1空闲中断+DMA收发(基于标准库实现)
qq_18935435的博客
04-23 4646
基于STM32F407提供一种串口空闲中断+DMA接收的方式，通过库函数编程实现。
STM32F407串口之间通过DMA的方式进行数据_Recv_Send
zaichen321的博客
07-15 931
STM32串口通过DMA的方式进行数据帧的先接收后发送
stm32f407 usart1+dma接收固定长度数据 并在dma中断中进行解析
m0_55409593的博客
10-20 987
stm32f407 usart1+dma接收固定长度数据 并在dma中断中进行解析 使用turtlebot3激光雷达，串口接收，该雷达数据42字节为一帧，采用dma搬运数据，并在dma中断里转移数据到一个数据结构体中以备后续处理。 1、这个程序没有重定向fputc，自己写了一个usart_sendbyte()。最开始的时候判断sr寄存器那一位的时候逻辑错误，本来应该是不满足条件就进while死循环，但是我把后续移到移位寄存器的操作放到了死循环里，导致一直发不出去。 2、串口发送成功，雷达转起来了，但是发现d
STM32 HAL库串口+DMA空闲中断接收不定长数据
11-04
STM32 HAL库+串口DMA+空闲中断（IDLE）实现不定长数据接收，可以用来参考学习使用，简单易懂。
STM32F407串口1使用DMA收发数据
09-03
函数实现了STM32F407使用串口1收发数据：当串口接收到数据时，立刻返回原数据，在stm32f4xx_it.c文件中需要添加中断函数DMA2_Stream7_IRQFuc()和USART1_IRQFuc()
STM32F103C8T6串口1空闲中断+DMA接收不定长数据源代码.zip
07-21
本文件是使用STM32F103C8T6的串口1的空闲中断+DMA实现接收不定长数据源代码测试文件记录，仅供参考。
STM32F407串口空闲中断+DMA
qiyu040526的博客
10-26 1878
STM32F407串口空闲中断+DMA 空闲中断，DMA简介 空闲中断 区别于普通串口中断的每一字节数据进入一次中断的中断方式，空闲中断在一帧数据接收完成之后才会触发中断进行数据处理。使用空闲中断的好处是有效降低了串口中断的触发频率，对处理不定长数据帧带来很大的便利，也方便需要频繁接收数据且串口较多（STM32F407有六路串口）的情况下使用。但是弊端也是明显的，由于每次都要接收完一个完整的数据帧后才触发中断，所以当一帧数据出错时，我们无法察觉到数据的异常，只能被动在这一帧数据接受完后舍弃它。因此在通讯可靠
STM32开发小结--使用STM32F4串口的空闲中断模式+DMA接收不定长数据帧
静静流淌的柯溪的博客
07-26 1万+
开发平台：Keil 5 库函数版本：V3.5 芯片：STM32F407VET6 1 STM32的串口接收数据的方式 STM32的串口接收数据有三种方式可以选择： 1.1 轮询接收 在主循环中一直判断串口接收完成标志位是否置位，如果置位则读取收到的数据。该种模式一般不会使用，其缺点很明显，当主函数在做其他工作时接收数据标志位置位，此时将得不到及时响应，从而错过后续数据的接收。...
STM32F4 UART1 DMA发送和接收不定长度数据
芯创博客
05-26 2万+
STM32F4 串口收发使用DMA还是很方便的。但是配置DMA时需要配置数据长度，这一点对于发送来说可以预估计自己发送的长度来配置DMA发送数据长度，但是对于接收不是很好解决，因为如果使用DMA接收中断是要配置的数据长度减到0才能出发中断。但是我们无法判断接受数据的长度，导致无法判断数据接收完成。网上有提出的解决方法是用定时器固定周期的读DMA接收的长度来判断是否接收完成，也有使用UART的空闲中
stm32f407 6路串口dma如何配置_「STM32笔记」串口空闲中断接收不定长数据（DMA方式）...
weixin_39942785的博客
11-22 438
在使用STM32的串口接收数据的时候，我们常常会使用接收中断的方式来接收数据，常用的是RXNE。这里分享另一种接收数据的方式——IDLE中断(PS：本文的例子运行在STM32F103ZET6上)。一、IDLE中断什么时候发生？IDLE就是串口收到一帧数据后，发生的中断。什么是一帧数据呢？比如说给单片机一次发来1个字节，或者一次发来8个字节，这些一次发来的数据，就称为一帧数据，也可以叫做一包数据。二...
STM32F407探索者，DMA串口接收
racer2的博客
04-05 1597
其实进入，串口中断服务函数，就说明一次完整的串口-DMA-存储buffer传输已经完成了，存储buffer中已经有了数据。但是为了设置传输完成信号给cpu的中任务查询，Receive_DataPack()对标记了传输完成，并将DMAy_Streamx->NDTR再次设置为存储buffer的大小，以便下次接收数据。接收也会涉及到接受长度的问题：定长接收，不定长接收，这里只做了不定长接收的例子。探索者开发指南只有DMA串口发送，所以愣是想实现串口接收，当然了也有DMA_SPI收发、DMA_I2C收发等。
STM32 串口空闲中断使用DMA接收不定长数据
11-16
使用STM32的串口空闲中断和DMA可以实现接收不定长度数据的功能，具体步骤如下： 1. 配置串口和DMA 首先需要配置串口和DMA，使其能够正常工作。具体配置方法可以参考STM32的官方文档或者其他相关资料。 2. 配置接收数组和接收计数器 在代码中定义一个接收数组和一个接收计数器，用于存储接收到的数据和记录接收到的数据长度。 3. 配置空闲中断 在空闲中断中判断接收数据是否完成，如果完成则将接收到的数据发送出去。具体实现方法如下： ```c void HAL_UART_IDLECallback(UART_HandleTypeDef *huart) { if(huart->Instance == USART1) { uint32_t tmp_flag = 0; uint32_t temp; tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE); //获取空闲中断标志 if((tmp_flag != RESET)) //判断是否是空闲中断 { __HAL_UART_CLEAR_IDLEFLAG(&huart1); //清除空闲中断标志 HAL_UART_DMAStop(&huart1); //停止DMA传输 temp = huart1.hdmarx->Instance->CNDTR; //获取DMA缓存区剩余数据量 uart1_rx_len = UART_RCV_BUF_SIZE - temp; //计算接收到的数据长度 HAL_UART_Transmit(&huart1, uart1_rx_buf, uart1_rx_len, 0xffff); //将接收到的数据发送出去 HAL_UART_Receive_DMA(&huart1, uart1_rx_buf, UART_RCV_BUF_SIZE); //重新开启DMA传输 } } } ``` 4. 启动DMA传输 在代码中启动DMA传输，将串口接收到的数据存储到接收数组中。具体实现方法如下： ```c HAL_UART_Receive_DMA(&huart1, uart1_rx_buf, UART_RCV_BUF_SIZE); ``` 以上就是使用STM32的串口空闲中断和DMA实现接收不定长度数据的方法。如果您有任何问题，请随时提出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我是东山啊_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值