stm32的串口空闲中断接收数据

最新推荐文章于 2025-07-04 16:03:20 发布
原创 最新推荐文章于 2025-07-04 16:03:20 发布 · 9.6k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#串口通信 #DMA #stm32

本文详细介绍了如何使用DMA（Direct Memory Access）技术优化串口通信效率，通过中断服务函数实现数据的快速传输与接收。重点阐述了初始化设置、DMA配置、中断优先级配置等关键步骤，确保在不同波特率的通信场景下实现稳定的数据交换。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

举个例子：

1、后台数据->USART1-> USART2->其它设备，其它设备数据->USART2-> USART1->后台，这两个数据过程也可能同时进行。

2、由于硬件的限制，USART1和USART2的传输波特率不一样，比如USART1使用GPRS通信，USART2使用短距离无线通信；或者USART1使用以太网通信，USART2使用485总线通信。


现在我把我实现的过程简单描述一下：

1、 初始化设置：USART1_RX DMA1_ Channel5，USART2_RX DMA1_ Channel6，USART1_TX DMA1_ Channel4，USART2_TX DMA1_ Channel7（具体设置请看程序包）
2、 当数据发送给USART1接收完毕时候会引起USART1的串口总线中断，计算DMA1_ Channel5内存数组剩余容量，得到接收的字符长度。将接收的字符复制给DMA1_ Channel4内存数组，启动DMA1_ Channel4通道传输数据，（传输完成需要关闭。）下一次数据接收可以在启动DMA1_ Channel4时候就开始，不需要等待DMA1_ Channel4数据传输完成。但是上一次DMA1_ Channel4完成之前，不可以将数据复制给DMA1_ Channel4内存数组，会冲掉以前数据。

3、 USART2类同USART1。


源程序：

IO口定义：
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* 第1步：打开GPIO和USART部件的时钟 */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
/* 第2步：将USART Tx的GPIO配置为推挽复用模式 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* 第3步：将USART Rx的GPIO配置为浮空输入模式
由于CPU复位后，GPIO缺省都是浮空输入模式，因此下面这个步骤不是必须的
但是，我还是建议加上便于阅读，并且防止其它地方修改了这个口线的设置参数
*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* 第1步：打开GPIO和USART2部件的时钟 */
//RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
/* 第2步：将USART2 Tx的GPIO配置为推挽复用模式 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* 第3步：将USART2 Rx的GPIO配置为浮空输入模式
由于CPU复位后，GPIO缺省都是浮空输入模式，因此下面这个步骤不是必须的
但是，我还是建议加上便于阅读，并且防止其它地方修改了这个口线的设置参数
*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* 第3步已经做了，因此这步可以不做
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
*/
GPIO_Init(GPIOA, &GPIO_InitStructure);

}


串口初始化：
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
/* 第4步：配置USART参数
- BaudRate = 115200 baud
- Word Length = 8 Bits
- One Stop Bit
- No parity
- Hardware flow control disabled (RTS and CTS signals)
- Receive and transmit enabled
*/
USART_InitStructure.USART_BaudRate = 19200;
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);

//配置USART1空闲中断

USART_ITConfig(USART1, USART_IT_IDLE , ENABLE);

/* 第5步：使能 USART， 配置完毕 */
USART_Cmd(USART1, ENABLE); 
/* CPU的小缺陷：串口配置好，如果直接Send，则第1个字节发送不出去
如下语句解决第1个字节无法正确发送出去的问题 */
USART_ClearFlag(USART1, USART_FLAG_TC); /* 清发送完成标志，Transmission Complete flag */
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(USART2, &USART_InitStructure);

//配置USART2空闲中断

USART_ITConfig(USART2, USART_IT_IDLE , ENABLE);
USART_Cmd(USART2, ENABLE);
/* CPU的小缺陷：串口配置好，如果直接Send，则第1个字节发送不出去
如下语句解决第1个字节无法正确发送出去的问题 */
USART_ClearFlag(USART2, USART_FLAG_TC); /* 清发送外城标志，Transmission Complete flag */

}


DMA配置：
void DMA_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
/* DMA clock enable */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); //开启DMA1外设时钟
/* DMA1 Channel4 (triggered by USART1 Tx event) Config */
DMA_DeInit(DMA1_Channel4); 
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40013804;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART1_SEND_DATA;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = 512;
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_Circular; //循环模式
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel4, &DMA_InitStructure);
DMA_ITConfig(DMA1_Channel4, DMA_IT_TC, ENABLE);
DMA_ITConfig(DMA1_Channel4, DMA_IT_TE, ENABLE);
/* Enable USART1 DMA TX request */
USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
DMA_Cmd(DMA1_Channel4, DISABLE);
/* DMA1 Channel5 (triggered by USART2 Tx event) Config */
DMA_DeInit(DMA1_Channel7); 
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40004404;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART2_SEND_DATA;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = 512;
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_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel7, &DMA_InitStructure);
DMA_ITConfig(DMA1_Channel7, DMA_IT_TC, ENABLE);
DMA_ITConfig(DMA1_Channel7, DMA_IT_TE, ENABLE);
/* Enable USART1 DMA TX request */
USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);
DMA_Cmd(DMA1_Channel7, DISABLE);
/* DMA1 Channel5 (triggered by USART1 Rx event) Config */
DMA_DeInit(DMA1_Channel5); 
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40013804;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART1_RECEIVE_DATA;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 512;
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_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel5, &DMA_InitStructure);
DMA_ITConfig(DMA1_Channel5, DMA_IT_TC, ENABLE);
DMA_ITConfig(DMA1_Channel5, DMA_IT_TE, ENABLE);
/* Enable USART1 DMA RX request */
USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
DMA_Cmd(DMA1_Channel5, ENABLE);
/* DMA1 Channel6 (triggered by USART1 Rx event) Config */
DMA_DeInit(DMA1_Channel6); 
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40004404;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART2_RECEIVE_DATA;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 512;
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_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel6, &DMA_InitStructure);
DMA_ITConfig(DMA1_Channel6, DMA_IT_TC, ENABLE);
DMA_ITConfig(DMA1_Channel6, DMA_IT_TE, ENABLE);
/* Enable USART2 DMA RX request */
USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);
DMA_Cmd(DMA1_Channel6, ENABLE);

}


中断优先级配置：
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Configure one bit for preemption priority */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); 
/* Enable the USART1 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);
/* Enable the USART2 Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//Enable DMA Channel4 Interrupt 
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//Enable DMA Channel7 Interrupt 
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel7_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/*Enable DMA Channel5 Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel5_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/*Enable DMA Channel6 Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel6_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);

}


数组定义，含义如题名：
u8 USART1_SEND_DATA[512]; 
u8 USART2_SEND_DATA[512]; 
u8 USART1_RECEIVE_DATA[512]; 
u8 USART2_RECEIVE_DATA[512]; 
u8 USART1_TX_Finish=1; // USART1发送完成标志量

u8 USART2_TX_Finish=1; // USART2发送完成标志量


USART1中断服务函数
void USART1_IRQHandler(void)
{
u16 DATA_LEN;
u16 i;
if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET) //如果为空闲总线中断
{
DMA_Cmd(DMA1_Channel5, DISABLE); //关闭DMA,防止处理其间有数据
//USART_RX_STA = USART1->SR; //先读SR，然后读DR才能清除
//USART_RX_STA = USART1->DR;
DATA_LEN=512-DMA_GetCurrDataCounter(DMA1_Channel5); 
if(DATA_LEN > 0)
{ 
while(USART1_TX_Finish==0) //等待数据传输完成才下一次
{
;

}

//将数据送DMA存储地址
for(i=0;i<DATA_LEN;i )
{
USART1_SEND_DATA=USART1_RECEIVE_DATA;
}
//USART用DMA传输替代查询方式发送，克服被高优先级中断而产生丢帧现象。
DMA_Cmd(DMA1_Channel4, DISABLE); //改变datasize前先要禁止通道工作
DMA1_Channel4->CNDTR=DATA_LEN; //DMA1,传输数据量
USART1_TX_Finish=0; //DMA传输开始标志量
DMA_Cmd(DMA1_Channel4, ENABLE); 
}
//DMA_Cmd(DMA1_Channel5, DISABLE); //关闭DMA,防止处理其间有数据
DMA_ClearFlag(DMA1_FLAG_GL5 | DMA1_FLAG_TC5 | DMA1_FLAG_TE5 | DMA1_FLAG_HT5); //清标志
DMA1_Channel5->CNDTR = 512; //重装填
DMA_Cmd(DMA1_Channel5, ENABLE); //处理完,重开DMA
//读SR后读DR清除Idle
i = USART1->SR;
i = USART1->DR;
}
if(USART_GetITStatus(USART1, USART_IT_PE | USART_IT_FE | USART_IT_NE) != RESET) //出错
{
USART_ClearITPendingBit(USART1, USART_IT_PE | USART_IT_FE | USART_IT_NE);
}
USART_ClearITPendingBit(USART1, USART_IT_TC);
USART_ClearITPendingBit(USART1, USART_IT_IDLE);

}


USART2中断服务函数
void USART2_IRQHandler(void)
{
u16 DATA_LEN;
u16 i;
if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET) //如果为空闲总线中断
{
DMA_Cmd(DMA1_Channel6, DISABLE); //关闭DMA,防止处理其间有数据
//USART_RX_STA = USART1->SR; //先读SR，然后读DR才能清除
//USART_RX_STA = USART1->DR;
DATA_LEN=512-DMA_GetCurrDataCounter(DMA1_Channel6); 
if(DATA_LEN > 0)
{  
while(USART2_TX_Finish==0) //等待数据完成才下一次
{
;
}
//将数据送DMA存储地址
for(i=0;i<DATA_LEN;i )
{
USART2_SEND_DATA=USART2_RECEIVE_DATA;
}
//USART用DMA传输替代查询方式发送，克服被高优先级中断而产生丢帧现象。
DMA_Cmd(DMA1_Channel7, DISABLE); //改变datasize前先要禁止通道工作
DMA1_Channel7->CNDTR=DATA_LEN;         //DMA1,传输数据量
USART2_TX_Finish=0; //DMA传输开始标志量
DMA_Cmd(DMA1_Channel7, ENABLE); 
}
//DMA_Cmd(DMA1_Channel5, DISABLE); //关闭DMA,防止处理其间有数据
DMA_ClearFlag(DMA1_FLAG_GL6 | DMA1_FLAG_TC6 | DMA1_FLAG_TE6 | DMA1_FLAG_HT6); //清标志
DMA1_Channel6->CNDTR = 512; //重装填
DMA_Cmd(DMA1_Channel6, ENABLE); //处理完,重开DMA
//读SR后读DR清除Idle
i = USART2->SR;
i = USART2->DR;
}
if(USART_GetITStatus(USART2, USART_IT_PE | USART_IT_FE | USART_IT_NE) != RESET) //出错
{
USART_ClearITPendingBit(USART2, USART_IT_PE | USART_IT_FE | USART_IT_NE);
}
USART_ClearITPendingBit(USART2, USART_IT_TC);
USART_ClearITPendingBit(USART2, USART_IT_IDLE);

}


DMA1_Channel5中断服务函数
void DMA1_Channel5_IRQHandler(void)
{
DMA_ClearITPendingBit(DMA1_IT_TC5);
DMA_ClearITPendingBit(DMA1_IT_TE5);
DMA_Cmd(DMA1_Channel5, DISABLE); //关闭DMA,防止处理其间有数据
DMA1_Channel5->CNDTR = 580; //重装填
DMA_Cmd(DMA1_Channel5, ENABLE); //处理完,重开DMA

}


DMA1_Channel6中断服务函数
void DMA1_Channel6_IRQHandler(void)
{
DMA_ClearITPendingBit(DMA1_IT_TC6);
DMA_ClearITPendingBit(DMA1_IT_TE6);
DMA_Cmd(DMA1_Channel6, DISABLE); //关闭DMA,防止处理其间有数据
DMA1_Channel6->CNDTR = 580; //重装填
DMA_Cmd(DMA1_Channel6, ENABLE); //处理完,重开DMA

}


DMA1_Channel4中断服务函数
//USART1使用DMA发数据中断服务程序
void DMA1_Channel4_IRQHandler(void)
{
DMA_ClearITPendingBit(DMA1_IT_TC4);
DMA_ClearITPendingBit(DMA1_IT_TE4);
DMA_Cmd(DMA1_Channel4, DISABLE); //关闭DMA
USART1_TX_Finish=1; //置DMA传输完成

}


DMA1_Channel7中断服务函数
//USART2使用DMA发数据中断服务程序
void DMA1_Channel7_IRQHandler(void)
{
DMA_ClearITPendingBit(DMA1_IT_TC7);
DMA_ClearITPendingBit(DMA1_IT_TE7);
DMA_Cmd(DMA1_Channel7, DISABLE);//关闭DMA
USART2_TX_Finish=1;//置DMA传输完成

}

STM32—无需中断来实现使用DMA接收串口数据
weixin_34407348的博客
09-14 3479
本节目标: 通过DMA,无需中断,接收不定时长的串口数据 描述:当在串口多数据传输下,CPU会产生多次中断来接收串口数据,这样会大大地降低CPU效率,同时又需要CPU去做其它更重要的事情,我们应该如何来优化？比如四轴飞行器,当在不停地获取姿态控制方向时,又要去接收串口数据.答:使用DMA,无需CPU中断便能实现接收串口数据 1.DMA介绍DMA，全称为： Direct Memor...
利用 STM32 串口空闲中断实现高效的数据接收与处理
weixin_66608063的博客
12-15 699
幸运的是，STM32 微控制器提供了串口空闲中断功能，可以极大地提高数据接收和处理的效率。2. 在 "Pinout & Configuration" 选项卡中，配置 UART 接口的引脚，并打开串口空闲中断的开关。1. 点击 "Project" 菜单，选择 "Generate Code"，生成基于配置的代码。1. 打开生成的代码中的 "stm32f4xx_it.c" 文件，找到相应的串口中断处理函数。通过合理配置和编写相应的中断处理函数，可以轻松实现高效的数据接收和处理。
STM32F103单片机利用串口空闲中断接收不定长数据
10-15
在STM32F103C8T6单片机上，用串口2空闲中断，接收不定长数据。
关于STM32空闲中断
weixin_34194702的博客
04-21 1896
有一次做一个东西,为了尽量不占用CPU的处理数据时间,所以就使用DMA接收串口的数据,但是呢问题来了.,,,,,怎么样才能确定接收到了一条完整的数据了,,我们都知道只要打开DMA 那家伙就不停的把接收的数据放到我们指定的地方. 只要接收到一条完整的数据我就该去处理了 关于空闲中断,,,就是说每接收到一条完整的数据就会置位空闲标志位,我们只需要判断空闲标志位是否置一,,就能知道是不是接收到了一条完整...
stm32串口空闲中断实现
最新发布
2301_80143498的博客
07-04 822
本文解决了串口空闲中断处理问题
STM32_串口中断接收数据_空闲中断
会选科技的博客
02-01 6662
STM32_串口中断接收数据_空闲中断
STM32 串口 空闲中断使用
01-06
最近搞串口接收完整的数据帧，虽然很早就接触串口，但是工作上用还是会遇到不少问题。串口收包过程，首先要解决的问题就是要保证接收到完整的数据包，参考网上的串口收包方法，多数是使用定时器做超时判断，又或者加DMA之类的，考虑到我的串口只是做小数据量收发(收发指令)，要额外使用一个定时器，就太复杂了。查资料过程中发现了串口空闲中断，故想空闲中断来接收串口数据帧。以下是空闲中断的参考demo： 主函数 main.c /** ****************************************************************************** * @file
STM32串口之空闲中断
热门推荐
sh的博客
11-11 4万+
背景 在做Nbiot的一个路灯项目，NBiot模块一般都是串口接口，使用AT指令集，对接中国移动onenet平台。先用串口助手去测试，流程测试OK之后需要在MCU上重新写一遍。一开始用的STC15系列的MCU，然后跟平台之间对接协议很多，代码量较大，所以换到了STM32F1系列的MCU。在STC15MCU上面通过串口接收数据只能老老实实用接收中断来做，每接收一个字节都需要判断帧头帧尾，一帧结束再处...
【STM32】串口空闲中断
hallo的博客
04-20 761
当串口检测到一帧数据接收结束（即 RX 不再接收新字节）时，会触发一次 USART 空闲中断（IDLE）。💡 此机制适用于：数据之间存在短暂停顿的场景（如上位机发送数据时帧与帧之间有间隔）。系列函数适合接收不定长数据；配合回调使用，获取实际接收长度；使用 DMA 时需关闭“半传中断”避免提前回调：提升系统效率，避免使用定长缓冲和轮询接收。
STM32使用串口空闲中断（IDLE）和 DMA接收一串数据流
weixin_46251230的博客
09-06 2万+
空闲的定义是总线上在一个字节的时间内没有再接收到数据，USART_IT_IDLE空闲中断是检测到有数据被接收后，总线上在一个字节的时间内没有再接收到数据的时候发生的。串口空闲中断（UART_IT_IDLE）：STM32的IDLE的中断在串口无数据接收的情况下，是不会一直产生的，当清除IDLE标志位后，必须有接收到第一个数据后，才开始触发，一但接收的数据断流，没有接收到数据，即产生IDLE中断。IDLE位不会再次被置高直到RXNE位被置起（即又检测到一次空闲总线）。
STM32串口空闲中断接收不定长数据
qq_53381910的博客
06-12 1065
STM32串口空闲中断接收不定长数据
stm32f030c8t6串口空闲中断
12-19
主控stm32f030c8t6芯片，采用stm32CubeMX软件生成代码，由于没有串口空闲中断接收，经过编程已加上了这个功能，供嵌入式同行借鉴使用。
stm32f103串口空闲中断收发
12-20
为了解决stm32f103串口一次接收不定长度且没有结束标志的数据，选择空闲中断接收。经过修改，目前收发稳定，仅供参考。
STM32串口空闲中断DMA接收不定长数据消息队列
01-11
在本文中，我们将深入探讨如何在STM32微控制器中实现串口空闲中断与DMA（直接内存访问）相结合，以接收不定长的数据，并利用FreeRTOS操作系统中的消息队列进行处理。STM32系列是基于ARM Cortex-M内核的微控制器，...
STM32H750的IDLE串口空闲中断、DMA传输UART接收数据、STM32CUBEMX生成MDK5编译
08-27
综上所述，STM32H750的IDLE串口空闲中断、DMA传输UART接收数据以及STM32CUBEMX的使用，都是STM32嵌入式开发中的关键技术，它们共同构成了一个高效、实时的串口通信解决方案。在实践中，熟练掌握这些技能能够帮助...
【Bug】STM32串口空闲中断接收不定长数据异常
augu_的博客
10-20 1455
STM32标准库串口中断中不读取数据会导致程序异常，空闲中断能够有效接收数据不定长的情况。
STM32的串口空闲中断
lf9335的专栏
02-15 1万+
STM32串口使用DMA方式接收数据可以减小CPU的开销。对于接收定长数据，可以将DMA接收缓冲区的长度设定为待接收数据的长度，这样利用DMA的传输完成中断DMAx_IT_TCy就可以知道已经接收了一帧数据。对于接收不定长数据，如何知道意见完成了数据的接收呢？可以结合串口的空闲中断来实现。具体做法见http://wenku.baidu.com/link?url=ZGGaGpvy2dbSqoBaoT
STM32单片机串口空闲中断接收不定长数据
HXYDJ的博客
10-15 6328
在使用单片机的串口通信功能时，常用的接收数据方法是通过固定的字节数来判断一帧数是否发送完成，或者是通过固定的结束标志位来表示一帧数据发送完成。但是有时候会遇到发送的数据长度不固定，也没有固定的结束标志，对于这样的数据通常的做法是每隔一段时间查看一下接收数据的长度是否发生了变化，如果在想当长的一段时间内接收数据长度没有发生变化，就认为是一帧数据发送完成。在STM32单片机中串口提供了一个更好用的功能，就是空闲中断功能。也就是说当一帧数据发送结束后，就会产生一个空闲中断。这样就可以利用这个空闲中断...
stm32串口空闲中断接收数据
01-20
### STM32 UART Idle Interrupt Data Reception Example and Configuration In applications where the length of incoming data packets is not fixed, using an idle line detection interrupt can be beneficial to handle such scenarios efficiently on STM32 microcontrollers. The following sections provide a detailed explanation along with code examples. #### Configuring UART for Idle Line Detection To enable receiving data via the idle line state detection feature: - Initialize the UART peripheral. - Enable the IDLE interrupt within the UART configuration structure by setting `InterruptPriority` appropriately so that it does not conflict with other peripherals like DMA[^2]. ```c static void MX_USART2_UART_Init(void) { huart2.Instance = USART2; huart2.Init.BaudRate = 115200; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; if (HAL_UART_Init(&huart2) != HAL_OK) { Error_Handler(); } /* Ensure that UART interrupts are enabled */ __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); } ``` Ensure that the serial communication interface's settings match those expected by external devices communicating over this link. #### Setting Up DMA for Receiving Data For efficient handling of received bytes without CPU intervention until a complete packet arrives or timeout occurs due to idleness between characters: - Configure DMA channel parameters including source/destination addresses and buffer size according to application needs. - Clear any pending flags before starting transfers. - Enable relevant events as required but disable half-transfer notifications when continuous blocks need processing together instead of being split into smaller chunks during transfer completion[^1]. ```c void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(uartHandle->Instance==USART2) { /* Peripheral clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART2; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); hdma_usart2_rx.Instance = DMA1_Channel6; hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart2_rx.Init.Mode = DMA_CIRCULAR; hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW; if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx); /* USART2 interrupt Init */ HAL_NVIC_SetPriority(USART2_IRQn, 5, 0); // Lower than DMA priority HAL_NVIC_EnableIRQ(USART2_IRQn); } } // Before initiating reception... __HAL_DMA_CLEAR_FLAG(&hdma_usart2_rx, DMA_FLAG_TCIF6 | DMA_FLAG_HTIF6 | DMA_FLAG_TEIF6); __HAL_DMA_DISABLE_IT(&hdma_usart2_rx, DMA_IT_HT); // Disable Half Transfer ITs if(HAL_OK != HAL_UART_Receive_DMA(&huart2, RxBuffer, RXBUFFERSIZE)) { Error_Handler(); } ``` This setup ensures seamless operation even under varying load conditions while maintaining low power consumption through minimal processor involvement in routine tasks related to character-by-character I/O operations. #### Handling Received Packets Using ISR Finally, implement the interrupt service routine responsible for collecting completed messages once detected based upon periods of silence exceeding specified thresholds defined internally within hardware registers associated with each instance of Universal Synchronous Asynchronous Receiver Transmitter present inside these chips. ```c void USART2_IRQHandler(void) { uint16_t temp; HAL_UART_IRQHandler(&huart2); if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE) && __HAL_UART_GET_IT_SOURCE(&huart2, UART_IT_IDLE)) { // Stop ongoing DMA activity after detecting end-of-message condition signaled by prolonged absence of further input symbols arriving at receiver pin(s). HAL_UART_DMAStop(&huart2); // Read one byte from RDR register which also clears the IDLE flag automatically post-read action. temp = READ_REG(huart2.Instance->RDR); // Process your message here... // Restart listening process immediately afterwards readying system back up again awaiting next transmission event occurrence anytime soon thereafter. if(HAL_OK != HAL_UART_Receive_DMA(&huart2, RxBuffer, RXBUFFERSIZE)){ Error_Handler(); } } } ``` --related questions-- 1. How do you configure UART baud rates correctly? 2. What considerations should be taken when choosing DMA channels for different peripherals? 3. Can multiple UART instances share the same DMA resource safely? If yes, how would synchronization look like? 4. In what situations might disabling half-transfer interrupts improve performance? 5. Are there alternative methods besides using idle interrupts for managing variable-length data frames effectively?
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Jesse_嘉伟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值