1.32 Cubemx_STM32F429串口中断+空闲中断

最新推荐文章于 2024-03-19 21:04:27 发布
最新推荐文章于 2024-03-19 21:04:27 发布
阅读量1.3k 收藏
点赞数
分类专栏： Cubemx 文章标签： stm32 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oDuanYanGuHong/article/details/128151027
版权

1、简介

有时候串口接收数据时，没有帧头与帧尾，单纯使用单字节中断接收数据，不太好断帧。如果单纯使用空闲中断接收数据，当帧内数据不连续或者黏包，使用空闲中断接收就会出现接收的数据小于或者大于帧长度，比较难断帧。解决办法

方法1、单字节中断接收+空闲中断

发送命令，等待返回数据，利用单字节中断将接收的数据压入缓存堆栈，当发生空闲中断后，判断缓存里的数据是否达到帧长度，如果是，解析数据，清空缓存；否则继续接收数据，知道达到帧长度，然后解析数据，清空缓存。

方法2、单纯使用空闲中断。

发送命令，等待返回数据，如果产生空闲中断，数据压入缓存堆栈，判断是数据长度是否完成，如果是，解析数据，清空缓存；否则继续接收数据，直到达到帧长度，然后解析数据，清空缓存。

2、配置

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

3、 方法1

3.1 工程代码

中断以及接收


#define RS485_TMLC_BAUD	9600//波特率
#define MEMPOOL_OBJECTS 15     // number of Memory Pool Objects
typedef struct
{
   
	 uint8_t buf[126];  // 数据
	 uint16_t Length;   // 长度
}Message_t;

UART_HandleTypeDef *TMLCComm;
Message_t tmlcComRcvMsg;
uint8_t tmlcRdChar;
uint8_t tmlcComRdCounter = 0;
osMemoryPoolId_t tmlcRecMemPool;//内存池
osMessageQueueId_t tmlcRecMsgQueue;

/******************************************************************
函数名称：  bsp_InitUart
函数：  串口参数设置
*****************************************************************/ 
void bsp_InitUart(void)
{
   
	tmlcRecMemPool = osMemoryPoolNew(MEMPOOL_OBJECTS, 				     sizeof(Message_t), NULL);
	if(tmlcRecMemPool==NULL)
	{
   
		return ;//MemPool object not created, handle failure
	}
	tmlcRecMsgQueue = osMessageQueueNew(MEMPOOL_OBJECTS,sizeof(uint32_t), NULL);
	if (tmlcRecMsgQueue == NULL) {
   
		return -1;
	}
	
	TMLCComm = &huart4;
	Usart_SetBuadRate(TMLCComm,RS485_TMLC_BAUD);
	HAL_UART_Receive_IT(TMLCComm, (uint8_t *)&tmlcRdChar, 1);  
	__HAL_UART_ENABLE_IT(TMLCComm ,UART_IT_IDLE);
}

/******************************************************************
函数名称：  HAL_UART_RxCpltCallback
函数功能：  串口中断回调函数
*****************************************************************/ 
void HAL_UART_RxCpltCallback(UART_HandleTypeDef* uartHandle)
{
   
	if (uartHandle->Instance == TMLCComm->Instance)
	{
      
		   //if (__HAL_UART_GET_FLAG(TMLCComm,UART_FLAG_RXNE) != RESET)
			 {
   
		       tmlcComRcvMsg.buf[tmlcComRdCounter] = tmlcRdChar;
		       tmlcComRdCounter++;
		       if (tmlcComRdCounter>sizeof(tmlcComRcvMsg.buf)-1)
			     {
   
				      tmlcComRdCounter = 0;   
			     }
		   }
	}
}


/******************************************************************
函数名称： void tmlc_com_rev_idle_callback(UART_HandleTypeDef *huart)
函数功能：  TMLC串口空闲中断回调函数
*****************************************************************/
void tmlc_com_rev_idle_callback(UART_HandleTypeDef *huart)
{
   
	Message_t *pMemMsg;
	if(__HAL_UART_GET_FLAG(huart,UART_FLAG_IDLE) != RESET)
	{
   
		__HAL_UART_CLEAR_IDLEFLAG(huart);
		if (tmlcComRdCounter>0)
		{
   
			pMemMsg =  	(Message_t *)osMemoryPoolAlloc(tmlcRecMemPool, 0U);
			memset(pMemMsg,0,sizeof(Message_t));
			tmlcComRcvMsg.Length = tmlcComRdCounter;
			memcpy(pMemMsg,&tmlcComRcvMsg,sizeof(Message_t));
						
			osMessageQueuePut(tmlcRecMsgQueue,&pMemMsg,0u,0u);
			tmlcComRdCounter = 0;			
		}						 
	}
}

/******************************************************************
函数名称：  HAL_UART_ErrorCallback
函数功能：  串口错误回调函数
*****************************************************************/
void HAL_UART_ErrorCallback(UART_HandleTypeDef *uartHandle)
{
   
	if (uartHandle->Instance ==  TMLCComm->Instance)
	{
   
	uint32_t isrflags   = READ_REG(uartHandle->Instance->SR);//清错误都要先读SR
	if((__HAL_UART_GET_FLAG(uartHandle, UART_FLAG_PE))!=RESET)
	{
   
	READ_REG(uartHandle->Instance->DR);//PE清标志
	__HAL_UART_CLEAR_FLAG(uartHandle, UART_FLAG_PE);//清标志
	}
	if((__HAL_UART_GET_FLAG(uartHandle, UART_FLAG_FE))!=RESET)
	{
   
	READ_REG(uartHandle->Instance->DR);
	__HAL_UART_CLEAR_FLAG(uartHandle, UART_FLAG_FE);
	}

	if((__HAL_UART_GET_FLAG(uartHandle, UART_FLAG_NE))!=RESET)
	{
   
	READ_REG(uartHandle->Instance->DR);//NE清标志，第二步读DR
	__HAL_UART_CLEAR_FLAG(uartHandle, UART_FLAG_NE);
	}        

	if((__HAL_UART_GET_FLAG(uartHandle, UART_FLAG_ORE))!=RESET)
	{
   
	READ_REG(uartHandle->Instance->CR1);//ORE清标志，第二步读CR
	__HAL_UART_CLEAR_FLAG(uartHandle, UART_FLAG_ORE);
	}		
	uartHandle->RxState = HAL_UART_STATE_READY;        
	}
	else
	{
   
	;
	}
}

//中断函数
void UART4_IRQHandler(void)
{
   
  /* USER CODE BEGIN UART4_IRQn 0 */

  /* USER CODE END UART4_IRQn 0 */
  HAL_UART_IRQHandler(&huart4);
  /* USER CODE BEGIN UART4_IRQn 1 */
  tmlc_com_rev_idle_callback(&huart4);
  HAL_UART_Receive_IT(TMLCComm, (uint8_t *)&tmlcRdChar, 1);
  /* USER CODE END UART4_IRQn 1 */
}

接收处理

uint16_t RcvLength=0;
Message_t	tmlcRcvBuf;
void tmcl_task (void * arg) 
{
   
	uint32_t ptr;
	osStatus_t status;
    /*
	tmlcResponseRd = 0;
	tmlcResponseWr = 0;	
	createInitSeq(ADDR_1);
	clearRcvFifo();	
    */

    while (1) 
    {
    
    status = osMessageQueueGet(tmlcRecMsgQueue,&ptr,0U,0U);
    if (osOK == status)
    {
   		
        tmlcRcv_p = (Message_t *)ptr;
        memcpy(&tmlcRcvBuf.buf+RcvLength,tmlcRcv_p,tmlcRcv_p->Length);
        RcvLength +=tmlcRcv_p->Length;
        tmlcRcvBuf.Length=RcvLength;
        if(RcvLength>=9)//收到完整数据包
        {
   
            //do something... .
            //比如数据解析，处理完后记得将缓存相关数据全部清空
            /*
            if(analysisTmlcRcvCmd(&tmlcRcvBuf,&fb_data)==0)
            {
                tmlcResponseWr++;
                RcvLength=0;
            }
            else
            {
                osDelay(1);
            }
            */
        }
        osMemoryPoolFree(tmlcRecMemPool,tmlcRcv_p);
    }
    /*	
    if (tmcl_HasSeq) // 有命令序列
    {
        if (tmlcSeqCommandBuf.seqStatus == WRITESEQ)
        {
            tmcl_HasSeq = WriteTMLC_ActionSeg();
        }
        else
            tmcl_HasSeq = ReadTMLC_ActionSeg();	
        if (tmlcTimeOut > ACKCHECK_TIME)
        {
            tmcl_HasSeq = 0;
            clearRcvFifo();						
            osEventFlagsSet(tmlcCommuationTimeOutEvt_id,0x1u);//通讯失败
        }				 
    }
    else  //序列执行完成
    {
        status =  osMessageQueueGet(tmlcContrlcMsgQueue,&tmlcControlCommand,0,0);
        if (osOK ==status)
        {
            add_CtrlCmd=1;
        }
        else
        {
            createReadSeq(ADDR_1);
        }
    }
        checkCtlCmd();
        */
        osDelay(1);
    }
}

3.2 个人笔记与工程无关代码

tmcl_thread.c

#include  "tmcl_thread.h"
extern int32_t tmlcTimeOut;
tmlcControlMsg_t tmlcControlCommand; 
Message_t	*tmlcRcv_p;

uint8_t seq_NO=0;
uint8_t add_CtrlCmd=0;
uint32_t refreshTick;
uint32_t SendStatusPeriod=10;
uint16_t DebugCounter=0;
uint16_t RcvLength=0;
void tmcl_task (void * arg) 
{
   
	uint32_t ptr;
	int32_t fb_data;
	osStatus_t status;
	tmlcResponseRd = 0;
	tmlcResponseWr = 0;	
	createInitSeq(ADDR_1);
	clearRcvFifo();	
//	clearError();
  while (1) 
	{
    
//		SeqTest(seq_NO);
    status = osMessageQueueGet(tmlcRecMsgQueue,&ptr,0U,0U);
		if (osOK == status)
		{
   		
			tmlcRcv_p = (Message_t *)ptr;
			memcpy(&tmlcRcvBuf.buf+RcvLength,tmlcRcv_p,tmlcRcv_p->Length);
			RcvLength +=tmlcRcv_p->Length;
			tmlcRcvBuf.Length=RcvLength;
			if(RcvLength>=9)//收到完整数据包
			{
   
				if(analysisTmlcRcvCmd(&tmlcRcvBuf,&fb_data)==0)
				{
   
					tmlcResponseWr++;
					RcvLength=0;
				}
				else
				{
   
					osDelay(1);
				}
		  }
			osMemoryPoolFree(tmlcRecMemPool,tmlcRcv_p);
		}	
    if (tmcl_HasSeq) // 有命令序列
    {
   
			 if (tmlcSeqCommandBuf.seqStatus == WRITESEQ)
			 {
   
					 tmcl_HasSeq = WriteTMLC_ActionSeg();
			 }
			 else
					 tmcl_HasSeq = ReadTMLC_ActionSeg();	
			 if (tmlcTimeOut > ACKCHECK_TIME)
			 {
   
					tmcl_HasSeq = 0;
					clearRcvFifo();						
					osEventFlagsSet(tmlcCommuationTimeOutEvt_id,0x1u);//通讯失败
			 }				 
    }
    else  //序列执行完成
    {
   
			status =  osMessageQueueGet(tmlcContrlcMsgQueue,&tmlcControlCommand,0,0);
			if (osOK ==status)
			{
   
				 add_CtrlCmd=1;
			}
			else
			{
   
				createReadSeq(ADDR_1);
			}
    }
		checkCtlCmd();
		osDelay(1);
  }
}


/**
入参：checkCtlCmd(void)
功能：检测是否有控制命令
返回：NULL
**/
void checkCtlCmd(void)
{
   
	if((osKernelGetTickCount()-refreshTick)>SendStatusPeriod)
	{
   
		refreshTick = osKernelGetTickCount();
		if(add_CtrlCmd==1 && tmcl_HasSeq==1)
		{
   
			if(p_tmlcSeqCommandBuf->sumstep-1==p_tmlcSeqCommandBuf->currentstep)//等待前面序列执行完
			{
   
				osDelay(20);
				unpackTmlcControlCommand();
				add_CtrlCmd=0;
			}
		}
	}
}


//命令控制
void unpackTmlcControlCommand(void)
{
   
	 tmlc_contrlseq_t command;
	 command = (tmlc_contrlseq_t)tmlcControlCommand.action;
	 switch (command)
	 {
   
		 	case STOP_MODE:	//停止
				createRELPositionSeq(ADDR_1,4096);
			    //createStopSeq(ADDR_1);	 
			    break;				 
		 case LIMIT_MODE://运动到限位
			   createLimitgSeq(ADDR_1,DIR_NEGATIVE,
最低0.47元/天 解锁文章
车间溜盖子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libcudnn8_8.2.1.32-1+cuda11.3_amd64.deb
08-25
cudaa for ubuntu 20.4
[人才房产]php-JobSite v1.32 特别版_php-jobsite.rar
最新发布
04-16
包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。【项目质量】：所有源码都经过严格测试，可以直接运行。功能在确认正常工作后才上传。【适用人群】：适用...
简单学习速记-STM32串口接收使用DMA+空闲中断
ObviouslyCheng的博客
03-19 1011
这是一篇简单的学习笔记，记录使用STM32串口接收不定长数据，之前都是使用接收中断+缓冲区的方式，这篇笔记使用DMA+空闲中断的方式。清除idle标志位，停止DMA传输。DMA当前帧实际接收的数据长度。DMA当前帧实际接收的数据长度。使用串口空闲中断的基本思路是。设置串口接收完成标志。使能串口和DMA中断。
记录-使用STM32F1串口的空闲中断
保持每天的清醒
12-14 1382
STM32的空闲中断,看到网上的介绍说,数据流间隔超过一字节时间没接收到数据就会产生一个空闲总中断,这样我们就可以应用与一帧数据流的判断,这样就可以无需缓存解析处理串口数据,前提是命令接收间有间隔,否则很容易出现解析命令不完整 void USART2_IRQHandler(void) { static u8 buf[100]={0}; static u8 bufLen = 0; if(USART2->SR&(1<<5)) { .
stm32cubemx配置串口中断
wh617053508的博客
10-26 1403
我们是通过串口通信吗，设置串口1，单片机发送hellow windows，一直发送，当上位机发送#号到单片机时停止发送，当上位机*号到单片机时开始发送。
STM32CubeMX—串口空闲中断+DMA接收
qq_42565324的博客
04-21 6152
DMA(Direct Memory Access)—直接存储器存取，是单片机的一个外设，它的主要功能是用来搬数据，但是不需要占用CPU，即在传输数据的时候，CPU可以干其他的事情，好像是多线程一样。
STM32-HAL库串口DMA空闲中断的正确使用方式+解析SBUS信号
qq_30267617的博客
06-14 9827
使用STM32串口DMA空闲中断接收数功能实现串口解析航模遥控器sbus信号。本文进一步梳理一下HAL库串口空闲中断三种不同的使用方式，其中前两种使用DMA方式，最后一种使用HAL库自带的空闲中断机制。
STM32单片机 Cubemx使用LL库 + 串口DMA + 空闲中断实现不定长高效数据收发
HongShion的博客
05-11 4635
通过CubeMX生成LL库工程，在LL库的基础上使用串口空闲中断结合DMA完成串口的不定长数据接收。
SLISP_V1605.RAR_SLISP 1527_SLISP_v1605_sl isp 1.32_slisp 1605_sl
09-22
双龙的ISP下载软件,支持ATMEL的多种芯片，来自http://www.sl.com.cn/
Bandwidth Splitter v1.32 Fo _Microsof Forefront TMG_2010
04-06
Bandwidth Splitter v1.32 Fo _Microsof Forefront TMG_2010
STM32CubeMX 串口 DMA+空闲中断实现不定长接收
07-28
STM32CubeMX 串口 DMA+空闲中断实现不定长接收 利用hal库进行修改实现不定长的uart接收，应用于不定长帧的传输
STM32CubeMX—串口空闲中断+DMA接收-附件资源
03-02
STM32CubeMX—串口空闲中断+DMA接收-附件资源
基于HTML实现上传下载网站_精灵下载系统 v1.32_filedown132(HTML源码+数据集+项目使用说明).rar
07-02
包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。【项目质量】：所有源码都经过严格测试，可以直接运行。功能在确认正常工作后才上传。【适用人群】：适用...
STM32_HAL库_CubeMx实现STM32F1五个串口通信（单字节中断接收）
qq_30267617的博客
07-13 4363
目录一. 串口通信简介二. STM32CubeMx实现STM32F103系列串口驱动三. 五个串口发送与中断接收例程 一. 串口通信简介 串口通信的原理网上教程一大堆了，入坑单片机的必会串口，这里就不多说了。唯一值得一提的就是STM32是有USART和UART之分的。UART就是通用异步收发传输器（Universal Asynchronous Receiver/Transmitter），是一种异步收发传输器。USART是通用同步/异步串行接收/发送器（Universal Synchronous/Asynch
Hal库_stm32开发之串口IDLE空闲中断+DMA接收不定长数据并修改数据
qq_62014938的博客
07-18 2963
本文写自于博主编写平衡智能车程序的时候，由于中断使用的较多，如定时器中断，串口中断等等。为了避免MCU运行程序时卡死，我就将串口中断改为串口IDLE空闲接收中断。可以实现不定长数据的接收；以此可以修改PID参数，对调车的朋友很友好。......
STM32F429 串口1实现DMA接收功能
Armind的博客
02-02 630
基于stm32f429实现串口1的dma接收中断功能
STM32怎么利用串口空闲中断进行DMA接收
liangbin414的博客
04-09 978
一、在底层中初始化DMA接收和串口中断 void MX_USART1_UART_Init(void) HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart) &emsp;&emsp;&emsp;&emsp;HAL_UART_MspInit(UART_HandleTypeDef* uartHan...
Qt串口接收数据不全
weixin_44965579的博客
02-14 1298
上面方式存在一个问题：使用虚拟串口本地测，不会发生数据分段接收，每次都是一个完整的数据进来，上面代码每次只允许一次，会发生Port_buffer里一直存数据包，时间长了就蹦了，处理方法：可以把接收改成定时处理。我的界面刷新数据也是每次接收都刷新，还画个曲线图，再加上每10ms发个包，都能接收的过来。如果数据有帧头和帧尾，使用全局缓冲区，将接收到的数据放进缓冲区，判断是否满足整包，满足再进行包处理，不满足一直接数据。接着使用两台电脑，两个串口模块连接，同样速率和数据，接收到的数据会一段一段的到达。
STM32F0 USART 常用配置，DMA不定长接收，pingpong接收，硬件流控制，过采样，接收超时中断和空闲中断
qq_36720691的博客
08-01 2161
STM32F0 USART 通信 1.DMA不定长接收 2.硬件流控制 3.过采样率 4.
data_1 = [[1.32] [1.32] [1.32]] data_2= [[2.32] [2.32] [2.32]] 将 data_1和 data_2填加到一个dateframe中
05-27
可以使用 pandas 库中的 DataFrame 类来实现： ```python import pandas as pd data_1 = [[1.32], [1.32], [1.32]] data_2 = [[2.32], [2.32], [2.32]] df = pd.DataFrame({'data_1': data_1, 'data_2': data_2}) ``` 这样就可以将 data_1 和 data_2 合并成一个 DataFrame，其中 'data_1' 和 'data_2' 是列名。可以使用 `print(df)` 打印出 DataFrame 的内容。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值