记录串口数据命令提取 -- STM32

最新推荐文章于 2024-09-03 04:19:56 发布
最新推荐文章于 2024-09-03 04:19:56 发布
阅读量2.6k 收藏 12
点赞数 3
分类专栏： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wekic/article/details/88683788
版权 
#include "usartDeal.h"
#include "stdlib.h"
#include "usart.h"
#include "string.h"
//Edit time: 2019-03-20 
//author   : Wenkic
/* .h 定义宏
#define USARTDEALPenetrate(Soure)  Soure->Usart_Flag.Penetrate    //开启的模式  透传模式开关(0:关 1:开)
#define USARTDEALOKFlag(Soure)     Soure->Usart_Flag.PackOKFlag   //检查OK标志  提取包标志
#define USARTDEALCmdBuff(Soure)    Soure->Usart_CmdBuff.Cmd_Buff  //命令缓存Buff
#define USARTDEALCmdLen(Soure)     Soure->Usart_CmdBuff.Cmd_Len   //命令缓存Buff长度
#define USARTDEALTimeOut(Soure)    Soure->Usart_CmdBuff.TimeOutMS //超时时间

#define USARTDEALFormHead(Soure)   Soure->Usart_Form.head         //命令格式包头
#define USARTDEALFormEnd(Soure)    Soure->Usart_Form.End          //命令格式包尾

//使用 判断标志是否等1 ,使用完,就清除寻找下一条命令格式
      if(USARTDEALOKFlag(Uart1Dat) == 1)
			{
				 Usart_SendString(COM1, (u8*)USARTDEALCmdBuff(Uart1Dat),USARTDEALCmdLen(Uart1Dat) );
				 USARTDEALOKFlag(Uart1Dat) = 0;
			}

*/
#if 0  //.h 定义的数据结构
/*
//数据的格式
*/
typedef struct _Usart_Form
{
    __IO uint8_t  headByteSize;   //包头字节数
    __IO uint8_t *head;           //包头
    __IO uint8_t  EndByteSize;	  //包尾字节数
    __IO uint8_t *End;            //包尾
    __IO uint8_t  DLenAddr;       //数据长度位(初始)
    __IO uint8_t  OtherLen;       //除去数据包后剩余的字节
} Usart_FormType,*pUsart_FormType;
/*
//数据包
*/
typedef struct _Usart_RxBuff
{
    __IO uint16_t Rx_BuffSize;         //缓存数据包的大小
    __IO uint8_t *Rx_Buff;    				 //接受数据包
    __IO uint16_t BuffWptr;            //写指针
    __IO uint16_t BuffRptr;	           //读指针

} Usart_RxBuffType,*pUsart_RxBuffType;
/*
//命令包
*/
typedef struct _Usart_CmdBuff
{
    __IO uint16_t Cmd_BuffSize;        //提取命令数据包大小
    __IO uint8_t *Cmd_Buff;   				 //存放提取命令数组
    __IO uint16_t Cmd_Len;             //提取命令数据包大小
    __IO uint16_t CacheSize;           //数据剩余量
    __IO uint16_t TimeOutMS;           //计算超时时间
} Usart_CmdBuffType,*pUsart_CmdBuffType;
/*
//==标志,模式
*/
typedef struct _Usart_Flag
{
    __IO uint8_t PackOKFlag;           //提取包标志
    __IO uint8_t Penetrate;            //透传模式开关(0:关 1:开)
} Usart_FlagType,*pUsart_FlagType;

typedef struct _Usart_Dat   //串口数据处理
{
    Usart_FormType     Usart_Form;     //数据命令的格式
    Usart_RxBuffType   Usart_RxBuff;   //缓存数据包
    Usart_CmdBuffType  Usart_CmdBuff;  //命令提取数据包
    Usart_FlagType     Usart_Flag   ;  //标记
} USARTDEALTYPE,*pUSARTDEALTYPE;
#endif




pUSARTDEALTYPE Uart1Dat = NULL;  //创建结构指针
//公开函数
void UsartDealInit(void);     /*上电初始化*/
void UsartDealTime1ms(void);  /*放入1ms定时器*/

//私有函数
pUSARTDEALTYPE UsartDatCreateInit(void); //初始化数据结构
void UsartDatDel(pUSARTDEALTYPE temp);   //释放内存
void UsartDataParse(pUSARTDEALTYPE Soure);/*命令提取*/
void UsartDatWrite(pUSARTDEALTYPE Dat, u8 Data);/*环形数据写*/


/*
思路(缓存区):
  1>一个数据环形缓存区
  2>环形缓存区写函数, 如果数据超前,会覆盖就的数据
  3>环形缓存区读函数
思路(数据结构)
  1>提取命令格式,包头,包头大小,包尾,包尾大小,数据包大小的位置,剩余长度
	2>缓存区结构,缓存区,缓存区大小,缓存写指针,缓存读指针
	3>提取命令结构, 命令缓存,命令缓存区大小,缓存数,提取超时计数,数据剩余量
  4>命令标志结构, 提取成功标志,是否透传数据标志,
思路(命令提取)
  1>是否是透传模式
  2>透传模式,有数据就提取,直到无数据为止
  3>非透传模式(命令提取模式)
	  1)检测起始包头字节,开始超时赋值
		2)检测多字节包头
		3)等待到数据包长度位,计算总长度
		4)接收总长度数据
		5)完成后,向后回推包尾的位置,检测包尾是否相同,相同就判断提取成功
		6)成功后,标志置位,清除超时时间
*/

void USART2_IRQHandler(void)
{
    u8 res = 0;
    if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET)
    {
        res = USART_ReceiveData(USART2);
        UsartDatWrite( Uart1Dat, res);    //环形数据缓存
    }
}

/*上电初始化*/
void UsartDealInit(void)
{
    Uart1Dat = UsartDatCreateInit();  //创建对象
}

/*放入1ms定时器*/
void UsartDealTime1ms(void)
{
    if(Uart1Dat->Usart_CmdBuff.TimeOutMS)
    {
        Uart1Dat->Usart_CmdBuff.TimeOutMS--;    //超时计算
    }
    /*命令提取*/
    UsartDataParse(Uart1Dat);
}



//数据包创建与初始化
pUSARTDEALTYPE UsartDatCreateInit(void)
{
    pUSARTDEALTYPE temp = (pUSARTDEALTYPE)malloc(sizeof(USARTDEALTYPE));
    COM_Printf(2, "pUSARTDEALTYPE sizeof = %d \r\n", sizeof(USARTDEALTYPE));

    if(temp == NULL)
    {
        COM_Printf(2, "err file = \"%s\" ,line = \"%d\"\r\n", (uint8_t *)__FILE__, __LINE__);
    }
    temp->Usart_Form.headByteSize = 2;  //包头的长度
    temp->Usart_Form.head = malloc(temp->Usart_Form.headByteSize);
    if(temp->Usart_Form.head == NULL)
    {
        COM_Printf(2, "err file = \"%s\" ,line = \"%d\"\r\n", (uint8_t *)__FILE__, __LINE__);
    }
    temp->Usart_Form.head[0] = 0xAD;    //包头
    temp->Usart_Form.head[1] = 0xDA;
    temp->Usart_Form.EndByteSize  = 2;  //包尾长度
    temp->Usart_Form.End  = malloc(temp->Usart_Form.EndByteSize);
    if(temp->Usart_Form.End == NULL)
    {
        COM_Printf(2, "err file = \"%s\" ,line = \"%d\"\r\n", (uint8_t *)__FILE__, __LINE__);
    }
    temp->Usart_Form.End[0] = 0xDA ;	  //包尾
    temp->Usart_Form.End[1] = 0xAD ;
    temp->Usart_Form.DLenAddr     = 2;	//数据包长度的位置--->修改(注意是0开始)
    temp->Usart_Form.OtherLen     = 5;	//剩余长度 -->修改

    temp->Usart_RxBuff.Rx_BuffSize   = 200; //接收的缓存
    temp->Usart_RxBuff.Rx_Buff       = malloc(temp->Usart_RxBuff.Rx_BuffSize);
    if(temp->Usart_RxBuff.Rx_Buff == NULL)
    {
        COM_Printf(2, "err file = \"%s\" ,line = \"%d\"\r\n", (uint8_t *)__FILE__, __LINE__);
    }
    temp->Usart_RxBuff.BuffRptr      = 0;
    temp->Usart_RxBuff.BuffWptr      = 0;
    temp->Usart_CmdBuff.Cmd_BuffSize = 100; //命令提取缓存
    temp->Usart_CmdBuff.Cmd_Buff     = malloc(temp->Usart_CmdBuff.Cmd_BuffSize);
    if(temp->Usart_CmdBuff.Cmd_Buff  == NULL)
    {
        COM_Printf(2, "err file = \"%s\" ,line = \"%d\"\r\n", (uint8_t *)__FILE__, __LINE__);
    }
    temp->Usart_CmdBuff.Cmd_Len      = 0;   //命令长度
    temp->Usart_CmdBuff.CacheSize    = 0;   //剩余数据
    temp->Usart_Flag.PackOKFlag      = 0;   //提取是否成功
    temp->Usart_Flag.Penetrate       = 0;   //0:关闭透传 1:开启透传
    return temp;
}
//数据包对象释放
void UsartDatDel(pUSARTDEALTYPE temp)
{
    if(temp == NULL)
    {
        return;
    }
    if(temp->Usart_Form.head != NULL)
    {
        free((u8 *)temp->Usart_Form.head);    //释放包头
    }
    if(temp->Usart_Form.End  != NULL)
    {
        free((u8 *)temp->Usart_Form.End);    //释放包尾
    }
    if(temp->Usart_RxBuff.Rx_Buff != NULL)
    {
        free((u8 *)temp->Usart_RxBuff.Rx_Buff);
    }
    if(temp->Usart_CmdBuff.Cmd_Buff != NULL)
    {
        free((u8 *)temp->Usart_CmdBuff.Cmd_Buff);
    }
    free(temp);
}


/*环形数据写*/
void UsartDatWrite(pUSARTDEALTYPE Dat, u8 Data)
{

    static u16 Cnt = 0;
    if(Dat->Usart_RxBuff.BuffWptr == (Dat->Usart_RxBuff.BuffRptr - 1))
    {
        Dat->Usart_RxBuff.BuffRptr++;  //数据超前,覆盖旧的数据
        Dat->Usart_RxBuff.BuffRptr %= Dat->Usart_RxBuff.Rx_BuffSize;
        printf("Cnt = %d \r\n",Cnt);
    }
    Dat->Usart_RxBuff.Rx_Buff[Dat->Usart_RxBuff.BuffWptr ++] = Data;
    Dat->Usart_RxBuff.BuffWptr %= Dat->Usart_RxBuff.Rx_BuffSize;	//写地址环形变换
}
/*环形数据提取*/
uint8_t UsartDatRead(pUSARTDEALTYPE Soure, uint8_t *ReaDat)
{
    if(Soure->Usart_RxBuff.BuffWptr == (Soure->Usart_RxBuff.BuffRptr))
    {
        return 0;
    }
    ReaDat[0] = Soure->Usart_RxBuff.Rx_Buff[Soure->Usart_RxBuff.BuffRptr++];
    Soure->Usart_RxBuff.BuffRptr %= Soure->Usart_RxBuff.Rx_BuffSize; //读地址环形变化
    return 1;
}


/*命令提取*/
void UsartDataParse(pUSARTDEALTYPE Soure)
{
    static uint8_t Part = 0;      //提取命令解析的步骤记录
    static uint8_t WillCount = 0; //保存将提取的次数
    uint16_t clcye = 100;         //一个循环提取的次数


    if(Soure == NULL)
    {
        return;
    }
    if(Soure->Usart_RxBuff.BuffWptr == (Soure->Usart_RxBuff.BuffRptr))
    {
        //无数据提取
        return;
    }
    if(Soure->Usart_Flag.PackOKFlag == 1)
    {
        //有命令未处理
        return;
    }
    if(Soure->Usart_Flag.Penetrate == 1)   ///透传模式
    {
        //初始提取长度
        USARTDEALCmdLen(Soure) = 0;
        //读取数据
        while(UsartDatRead(Soure, (uint8_t *)&USARTDEALCmdBuff(Soure)[USARTDEALCmdLen(Soure)] ))
        {
            USARTDEALCmdLen(Soure)++; //长度地址自增
            //长度地址越界退出
            if(USARTDEALCmdLen(Soure) >= Soure->Usart_CmdBuff.Cmd_BuffSize)
            {
                break;
            }
        }
        if(USARTDEALCmdLen(Soure))
        {
            Soure->Usart_Flag.PackOKFlag = 1; //标志置位
        }
    }
    else
    {
        while(clcye --)
        {
            if(USARTDEALTimeOut(Soure)  == 0)
            {
                Part = 0;
                USARTDEALCmdLen(Soure) = 0; //初始提取长度
            }

            if(UsartDatRead(Soure, (uint8_t *)&USARTDEALCmdBuff(Soure)[USARTDEALCmdLen(Soure)] ))
            {
                //提取数据成功
                switch(Part)
                {
                    case 0:   //寻找包头收字母
                    {
                        if(USARTDEALCmdBuff(Soure) [0] == USARTDEALFormHead(Soure)[0] )
                        {
                            USARTDEALTimeOut(Soure)  = 10; //设置命令查找倒计时
                            USARTDEALCmdLen(Soure)++;
                            Part++;
                            if(Soure->Usart_Form.headByteSize == 1)
                            {
                                Part = 2;
                            }
                        }
                        break;
                    }
                    case 1:   //多字节包头数据比较
                    {
                        USARTDEALCmdLen(Soure)++;
                        if(USARTDEALCmdLen(Soure) == Soure->Usart_Form.headByteSize)
                        {
                            if(strncmp((char *)USARTDEALCmdBuff(Soure), (char *)USARTDEALFormHead(Soure), Soure->Usart_Form.headByteSize) == 0)
                            {
                                Part++;
                            }
                            else     //对比失败
                            {
                                Part = 0;
                                USARTDEALCmdLen(Soure) = 0; //初始提取长度
                            }
                        }
                        break;
                    }
                    case 2:   //数据长度位置
                    {
                        if(Soure->Usart_Form.DLenAddr == USARTDEALCmdLen(Soure))
                        {
                            WillCount = USARTDEALCmdBuff(Soure) [USARTDEALCmdLen(Soure)] + \
                                        Soure->Usart_Form.OtherLen;
                            Part++;
                        }
                        USARTDEALCmdLen(Soure)++;
                        break;
                    }
                    case 3:   //接收完数据包
                    {
                        if(USARTDEALCmdLen(Soure) == WillCount - 1)   //
                        {
                            if(strncmp((char *)&USARTDEALCmdBuff(Soure)                                                         [USARTDEALCmdLen(Soure) - Soure->Usart_Form.EndByteSize+1], \
                                       (char *)USARTDEALFormEnd(Soure), Soure->Usart_Form.EndByteSize) == 0)
                            {
                                Part = 0;
                                USARTDEALTimeOut(Soure)  = 0; //倒计时清零
                                USARTDEALCmdLen(Soure)++;
                                Soure->Usart_Flag.PackOKFlag = 1;
                                return ;
                            }
                            else      //检测包尾失败
                            {
                                USARTDEALTimeOut(Soure)  = 0; //倒计时清零
                                break;
                            }
                        }
                        USARTDEALCmdLen(Soure)++;
                        break;
                    }
                    default:
                    {
                        USARTDEALTimeOut(Soure)  = 0; //倒计时清零
                    }
                }
            }
        }
    }
}

 

wenkic 小琪
关注
专栏目录
stm32串口自定义协议接收一串十六进制数据（将其中两个字节转化为十进制数据）+部分串口基础知识
qq_37281984的博客
01-04 4万+
1、串口通信部分基础知识 2、串口自定义协议接收一串十六进制数据进行存储，并将其中的两个字节转化为十进制数据 3、串口助手发送字符控制LED的亮灭 4、发送一个字节函数 5、发送两个字节函数 6、重定向printf和getchar函数
使用变参函数实现STM32串口接收指定字符的功能(新版)
08-04
本文主要介绍了使用新版的四点改动之处，并用代码予以说明。
学习STM32的数据存储与处理
qq_67153941的博客
07-21 635
在滤波函数中，使用了一个静态变量保存上一次输入数据的值，在计算输出数据时使用了上一次输入数据的值。数据存储与处理是嵌入式系统开发中一个重要的方面，本文将详细介绍如何在STM32微控制器上进行数据存储与处理，并提供相关的代码案例。在STM32中，闪存可以通过不同的接口进行编程和读取。在STM32中，可以将数据存储与处理的功能综合起来，在实际应用中进行数据的存储和处理。首先，在代码中定义一个变量数组，将要存储在SRAM中的数据放入数组中。首先，在代码中定义一个常量数组，将要存储在闪存中的数据放入数组中。
STM32如何从串口接收数据，取出数据中的密码段再保存到flash中。
魏波
05-20 5699
STM32如何从串口接收数据，取出数据中的密码段再保存到flash中STM32如何从串口接收数据，取出数据中的密码段再保存到flash中 u8 Usart2_buf[256]; unsigned int usart2_lent; void main(void) { char buf_password[19] = "000000";//6位密码 memset((char *) &am...
STM32串口提取所需数据
m0_64386340的博客
07-12 294
从STM32接收到的数据中提取我们所需的数据，极大的便利了串口控制的流程。如：从“Z轴移动10mm”中，将10提取出来，并赋值给其他变量。
STM32读取串口传感器数据（颗粒物传感器，主动上传）
weixin_57246604的博客
09-01 7398
STM32读取传感器数据（颗粒物传感器），串口通信，中断，代码
STM32 串口 DMA 数据读取(详细代码)
qq_57273600的博客
04-08 3641
STM32 串口 DMA 数据读取(详细代码）
stm32-串口数据收发
Adaobaozhao的博客
02-23 324
000图形化配置 001代码基础 与IT相关的都是中断函数 使用阻塞式 给出题目： 002代码编写 第一小题 下载函数到stm32板子上，同时打开串口监视器，调好波特率，之后按下板子上的按钮，观察串口监视器。 第二小题 ...
STM32串口笔记
kongxiaobin1990的博客
08-04 195
STM32串口程序1.初始化部分2.串口中断处理函数 参考原子的程序(基本照抄o(╯□╰)o) 1.初始化部分 串口设置的一般步骤可以总结为如下几个步骤： 1) 串口时钟使能， GPIO 时钟使能 2) 串口复位 3) GPIO 端口模式设置 4) 串口参数初始化 5) 开启中断并且初始化 NVIC（如果需要开启中断才需要这个步骤） 6) 使能串口 7) 编写中断处理函数 时钟设置，端口模式等、设置初始化的部分按说明书抓药就行~ 有两个寄存器要了解： ①串口数据寄存器： USART_DR ，这是个双寄存器，
ADIS16228-real_time_code.txt_babyvtt_stm32f407_振动检测_振动传感器_stm32振
10-01
SPI是一种全双工同步串行接口，通常由主设备（如STM32）控制数据传输，从设备（如ADIS16228）响应。在设置SPI接口时，需要配置STM32的SPI时钟、数据模式、片选信号和中断等参数。 在编程实现过程中，首先需要初始化...
STM32单片机解码NEC红外控制器C语言程序
08-11
STM32单片机在处理红外遥控器信号时，经常涉及到不同类型的红外编码协议，其中NEC红外协议是一种广泛使用的标准。在这个项目中，我们将深入理解如何使用STM32单片机来解码NEC红外遥控器的信号，以及如何通过C语言...
STM32F103单片机源码STM32-外部中断4控制
05-12
STM32F103单片机源码STM32-外部中断4控制提取方式是百度网盘分享地址
串口数据捕获工具
04-23
很实用的串口数据捕获工具，用于查看串口协议
STM32读取GPS（北斗）数据驱动程序
zsj2016o的博客
12-17 1万+
本文博客链接：https://blog.csdn.net/zsj2016o/article/details/88883863 作者:zsj ,转载请注明. 啰里啰嗦 好久没有写文章，这段时间一直在着急赶项目，时间一直被压缩，手里积累了不少想分享的资源，现在开始陆陆续续的编写，希望大家都在自己的技术之路上，越走越远，越研越深。 #此次分享的是 利用STM32解析GPS（北斗）数据，利用STM32F103串口接收SKG12D发来的定位数据，并进行接收判断，有效性判断以及关键信息提取。 /1、GPS（北斗）介绍
深入解析MAVLink 1协议在STM32上的应用：从外部命令到自定义数据处理的完整实现指南
最新发布
qq_38334677的博客
09-03 744
在无人机和机器人系统的开发过程中，通信协议的选择至关重要。MAVLink（Micro Air Vehicle Link）是广泛应用于无人机和机器人系统的轻量级通信协议，特别是在飞行控制系统和地面站之间的数据传输中。它提供了可靠且高效的数据交换机制，用于传输位置、姿态、传感器读数等信息，并允许远程操控设备执行复杂的任务。尽管MAVLink 2已经发布，但MAVLink 1仍然在许多项目中得到广泛支持。
基于STM32设计的掌上游戏机(运行NES游戏模拟器)详细开发过程
热门推荐
08-11 3万+
利用STM32单片机移植NES游戏模拟器，完成NES游戏开发，可以玩标准的NES游戏，已测试超级玛丽、魂斗罗之类的都可以正常运行。
STM32串口读取数据示例—CSDN独家
qq_41659472的博客
07-07 999
【代码】STM32串口读取数据示例—CSDN独家。
STM32实现串口通信
weixin_47554309的博客
10-22 2516
STM32实现串口通信一、串口通信与USART1. 串口通信2. USRAT二、程序实现三、运行结果四、总结五、参考 一、串口通信与USART 1. 串口通信 RS-232标准: 主要规定了信号的用途、通信接口以及信号的电平标准。 串口用于ASCII码字符的传输。通信使用3根线完成，分别是地线、发送、接收。 波特率：衡量符号传输速率的参数，指的是信号被调制以后在单位时间内的变化，即单位时间内载波参数变化的次数 数据位：衡量通信中实际数据位的参数 停止位：用于表示单个包的最后一位 2. USRAT US
STM32 CubeMX学习实验7：USART printf打印和串口接收特定数据包
qq_46038320的博客
10-23 2372
学过C语言的同学都知道printf函数，是打开C语言大门的一个函数，如何在stm32上使用该函数呢！要在stm32上使用printf函数，需要对printf进行重定向，把串口发送的数据通过printf打印出来对printf重定向后，避免使用半主机模式二导致库函数程序无法运行，使用微库Micro LIB可以避免半主机模式，在keil中点击Options for Target...，勾选Use Micro LIB，点击OK即可。
μC/OS-II在STM32F103上的移植与应用
论文还简要提及了STM32F103的部分外围设备，如串口通信接口、CAN总线控制器和GPIO端口，这些都是在实际应用中常见的硬件组件。 移植过程中，论文详细阐述了μC/OS-II在STM32F103上的具体步骤，包括初始化设置、中断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值