简单自定义协议的封包和解包
原文链接：https://blog.csdn.net/sinat_16643223/article/details/118830297
一、通信协议
有一些初学者总觉得通信协议是一个很复杂的知识，把它想的很高深，导致不知道该怎么学。
同时，偶尔有读者问关于串口自定义通信协议相关的问题，今天就来写写串口通信协议，并不是你想想中的那么难？
1什么通信协议？
通信协议不难理解，就是两个（或多个）设备之间进行通信，必须要遵循的一种协议。
1 百度百科的解释
通信协议是指双方实体完成通信或服务所必须遵循的规则和约定。通过通信信道和设备互连起来的多个不同地理位置的数据通信系统，要使其能协同工作实现信息交换和资源共享，它们之间必须具有共同的语言。交流什么、怎样交流及何时交流，都必须遵循某种互相都能接受的规则。这个规则就是通信协议。
相应该有很多读者都买过一些基于串口通信的模块，市面上很多基于串口通信的模块都是自定义通信协议，有的比较简单，有的相对复杂一点。
举一个很简单的串口通信协议的例子：比如只传输一个温度值，只有三个字节的通信协议：
这种看起来是不是很简单？它也是一种通信协议。
只是说这种通信协议应用的场合相对比较简单（一对一两个设备之间），同时，它存在很多弊端。
2 过于简单的通信协议引发的问题
上面那种只有三个字节的通信协议，相信大家都看明白了。虽然它也能通信，也能传输数据，但它存在一系列的问题。
比如：多个设备连接在一条总线（比如485）上，怎么判断传输给谁？（没有设备信息）
还比如：处于一个干扰环境，你能保障传输数据正确吗？（没有校验信息）
再比如：我想传输多个不确定长度的数据，该怎么办？（没有长度信息）。
上面这一系列问题，相信做过自定义通信的朋友都了解。
所以，在通信协议里面要约定更多的“协议信息”，这样才能保证通信的完整。
3 通信协议常见内容
基于串口的通信协议通常不能太复杂，因为串口通信速率、抗干扰能力以及其他各方面原因，相对于TCP/IP这种通信协议，是一种很轻量级的通信协议。
所以，基于串口的通信，除了一些通用的通信协议（比如：Modubs、MAVLink）之外，很多时候，工程师都会根据自己项目情况，自定义通信协议。
下面简单描述下常见自定义通信协议的一些要点内容。
（这是一些常见的协议内容，可能不同情况，其协议内容不同）
1.帧头
帧头，就是一帧通信数据的开头。
有的通信协议帧头只有一个，有的有两个，比如：5A、A5作为帧头。
2.设备地址/类型
设备地址或者设备类型，通常是用于多种设备之间，为了方便区分不同设备。
这种情况，需要在协议或者附录中要描述各种设备类型信息，方便开发者编码查询。
当然，有些固定的两种设备之间通信，可能没有这个选项。
3.命令/指令
命令/指令比较常见，一般是不同的操作，用不同的命令来区分。
举例：温度：0x01；湿度：0x02；
4.命令类型/功能码
这个选项对命令进一步补充。比如：读、写操作。
举例：读Flash：0x01； 写Flash：0x02；
5.数据长度
数据长度这个选项，可能有的协议会把该选项提到前面设备地址位置，把命令这些信息算在“长度”里面。
这个主要是方便协议（接收）解析的时候，统计接收数据长度。
比如：有时候传输一个有效数据，有时候要传输多个有效数据，甚至传输一个数组的数据。这个时候，传输的一帧数据就是不定长数据，就必须要有【数据长度】来约束。
有的长度是一个字节，其范围：0x01 ~ 0xFF，有的可能要求一次性传输更多，就用两个字节表示，其范围0x0001 ~ 0xFFFFF。
当然，有的通信长度是固定的长度（比如固定只传输、温度、湿度这两个数据），其协议可能没有这个选项。
6.数据
数据就不用描述了，就是你传输的实实在在的数据，比如温度：25℃。
7.帧尾
有些协议可能没有帧尾，这个应该是可有可无的一个选项。
8.校验码
校验码是一个比较重要的内容，一般正规一点的通信协议都有这个选项，原因很简单，通信很容易受到干扰，或者其他原因，导致传输数据出错。
如果有校验码，就能比较有效避免数据传输出错的的情况。
校验码的方式有很多，校验和、CRC校验算是比较常见的，用于自定义协议中的校验方式。
还有一点，有的协议可能把校验码放在倒数第二，帧尾放在最后位置。
4 通信协议代码实现（DGUS串口屏的例子）
自定义通信协议，代码实现的方式有很多种，怎么说呢，“条条大路通罗马”你只需要按照你协议要写实现代码就行。
当然，实现的同时，需要考虑你项目实际情况，比如通信数据比较多，要用消息队列（FIFO），还比如，如果协议复杂，最好封装结构体等。
下面分享一些以前用到的代码，可能没有描述更多细节，但一些思想可以借鉴。
1.消息数据发送
a.通过串口直接发送每一个字节
这种对于新手来说都能理解，这里分享一个之前DGUS串口屏的例子：
#define DGUS_FRAME_HEAD1 0xA5 //DGUS屏帧头1
#define DGUS_FRAME_HEAD2 0x5A //DGUS屏帧头2
#define DGUS_CMD_W_REG 0x80 //DGUS写寄存器指令
#define DGUS_CMD_R_REG 0x81 //DGUS读寄存器指令
#define DGUS_CMD_W_DATA 0x82 //DGUS写数据指令
#define DGUS_CMD_R_DATA 0x83 //DGUS读数据指令
#define DGUS_CMD_W_CURVE 0x85 //DGUS写曲线指令
/* DGUS寄存器地址 */
#define DGUS_REG_VERSION 0x00 //DGUS版本
#define DGUS_REG_LED_NOW 0x01 //LED背光亮度
#define DGUS_REG_BZ_TIME 0x02 //蜂鸣器时长
#define DGUS_REG_PIC_ID 0x03 //显示页面ID
#define DGUS_REG_TP_FLAG 0x05 //触摸坐标更新标志
#define DGUS_REG_TP_STATUS 0x06 //坐标状态
#define DGUS_REG_TP_POSITION 0x07 //坐标位置
#define DGUS_REG_TPC_ENABLE 0x0B //触控使能
#define DGUS_REG_RTC_NOW 0x20 //当前RTCS
//往DGDS屏指定寄存器写一字节数据
void DGUS_REG_WriteWord(uint8_t RegAddr, uint16_t Data)
{
DGUS_SendByte(DGUS_FRAME_HEAD1);
DGUS_SendByte(DGUS_FRAME_HEAD2);
DGUS_SendByte(0x04);
DGUS_SendByte(DGUS_CMD_W_REG); //指令
DGUS_SendByte(RegAddr); //地址
DGUS_SendByte((uint8_t)(Data>>8)); //数据
DGUS_SendByte((uint8_t)(Data&0xFF));
}
//往DGDS屏指定地址写一字节数据
void DGUS_DATA_WriteWord(uint16_t DataAddr, uint16_t Data)
{
DGUS_SendByte(DGUS_FRAME_HEAD1);
DGUS_SendByte(DGUS_FRAME_HEAD2);
DGUS_SendByte(0x05);
DGUS_SendByte(DGUS_CMD_W_DATA); //指令
DGUS_SendByte((uint8_t)(DataAddr>>8)); //地址
DGUS_SendByte((uint8_t)(DataAddr&0xFF));
DGUS_SendByte((uint8_t)(Data>>8)); //数据
DGUS_SendByte((uint8_t)(Data&0xFF));
}
b.通过消息队列发送
在上面基础上，用一个buf装下消息，然后“打包”到消息队列，通过消息队列的方式（FIFO）发送出去。
static uint8_t sDGUS_SendBuf[DGUS_PACKAGE_LEN];
//往DGDS屏指定寄存器写一字节数据
void DGUS_REG_WriteWord(uint8_t RegAddr, uint16_t Data)
{
sDGUS_SendBuf[0] = DGUS_FRAME_HEAD1; //帧头
sDGUS_SendBuf[1] = DGUS_FRAME_HEAD2;
sDGUS_SendBuf[2] = 0x06; //长度
sDGUS_SendBuf[3] = DGUS_CMD_W_CTRL; //指令
sDGUS_SendBuf[4] = RegAddr; //地址
sDGUS_SendBuf[5] = (uint8_t)(Data>>8); //数据
sDGUS_SendBuf[6] = (uint8_t)(Data&0xFF);
DGUS_CRC16(&sDGUS_SendBuf[3], sDGUS_SendBuf[2] - 2, &sDGUS_CRC_H, &sDGUS_CRC_L);
sDGUS_SendBuf[7] = sDGUS_CRC_H; //校验
sDGUS_SendBuf[8] = sDGUS_CRC_L;
DGUSSend_Packet_ToQueue(sDGUS_SendBuf, sDGUS_SendBuf[2] + 3);
}
//往DGDS屏指定地址写一字节数据
void DGUS_DATA_WriteWord(uint16_t DataAddr, uint16_t Data)
{
sDGUS_SendBuf[0] = DGUS_FRAME_HEAD1; //帧头
sDGUS_SendBuf[1] = DGUS_FRAME_HEAD2;
sDGUS_SendBuf[2] = 0x07; //长度
sDGUS_SendBuf[3] = DGUS_CMD_W_DATA; //指令
sDGUS_SendBuf[4] = (uint8_t)(DataAddr>>8); //地址
sDGUS_SendBuf[5] = (uint8_t)(DataAddr&0xFF);
sDGUS_SendBuf[6] = (uint8_t)(Data>>8); //数据
sDGUS_SendBuf[7] = (uint8_t)(Data&0xFF);
DGUS_CRC16(&sDGUS_SendBuf[3], sDGUS_SendBuf[2] - 2, &sDGUS_CRC_H, &sDGUS_CRC_L);
sDGUS_SendBuf[8] = sDGUS_CRC_H; //校验
sDGUS_SendBuf[9] = sDGUS_CRC_L;
DGUSSend_Packet_ToQueue(sDGUS_SendBuf, sDGUS_SendBuf[2] + 3);
}
c.用“结构体”代替“数组SendBuf”方式
结构体对数组更方便引用，也方便管理，所以，结构体方式相比数组buf更高级，也更实用。（当然，如果成员比较多，如果用临时变量方式也会导致占用过多堆栈的情况）
比如：
typedef struct
{
uint8_t Head1; //帧头1
uint8_t Head2; //帧头2
uint8_t Len; //长度
uint8_t Cmd; //命令
uint8_t Data[DGUS_DATA_LEN]; //数据
uint16_t CRC16; //CRC校验
}DGUS_PACKAGE_TypeDef;
d.其他更多
串口发送数据的方式有很多，比如用DMA的方式替代消息队列的方式。
2.消息数据接收
串口消息接收，通常串口中断接收的方式居多，当然，也有很少情况用轮询的方式接收数据。
a.常规中断接收
还是以DGUS串口屏为例，描述一种简单又常见的中断接收方式：
void DGUS_ISRHandler(uint8_t Data)
{
static uint8_t sDgus_RxNum = 0; //数量
static uint8_t sDgus_RxBuf[DGUS_PACKAGE_LEN];
static portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
sDgus_RxBuf[gDGUS_RxCnt] = Data;
gDGUS_RxCnt++;
/* 判断帧头 */
if(sDgus_RxBuf[0] != DGUS_FRAME_HEAD1) //接收到帧头1
{
gDGUS_RxCnt = 0;
return;
}
if((2 == gDGUS_RxCnt) && (sDgus_RxBuf[1] != DGUS_FRAME_HEAD2))
{
gDGUS_RxCnt = 0;
return;
}
/* 确定一帧数据长度 */
if(gDGUS_RxCnt == 3)
{
sDgus_RxNum = sDgus_RxBuf[2] + 3;
}
/* 接收完一帧数据 */
if((6 <= gDGUS_RxCnt) && (sDgus_RxNum <= gDGUS_RxCnt))
{
gDGUS_RxCnt = 0;
if(xDGUSRcvQueue != NULL) //解析成功, 加入队列
{
xQueueSendFromISR(xDGUSRcvQueue, &sDgus_RxBuf[0], &xHigherPriorityTaskWoken);
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
}
}
b.增加超时检测
接收数据有可能存在接收了一半，中断因为某种原因中断了，这时候，超时检测也很有必要。
比如：用多余的MCU定时器做一个超时计数的处理，接收到一个数据，开始计时，超过1ms没有接收到下一个数据，就丢掉这一包（前面接收的）数据。
static void DGUS_TimingAndUpdate(uint16_t Nms)
{
sDGUSTiming_Nms_Num = Nms;
TIM_SetCounter(DGUS_TIM, 0); //设置计数值为0
TIM_Cmd(DGUS_TIM, ENABLE); //启动定时器
}
void DGUS_COM_IRQHandler(void)
{
if((DGUS_COM->SR & USART_FLAG_RXNE) == USART_FLAG_RXNE)
{
DGUS_TimingAndUpdate(5); //更新定时(防止超时)
DGUS_ISRHandler((uint8_t)USART_ReceiveData(DGUS_COM));
}
}
c.更多
接收和发送一样，实现方法有很多种，比如接收同样也可以用结构体方式。但有一点，都需要结合你实际需求来编码。
5 最后
以上自定义协议内容仅供参考，最终用哪些、占用几个字节都与你实际需求有关。
基于串口的自定义通信协议，有千差万别，比如：MCU处理能力、设备多少、通信内容等都与你自定义协议有关。
有的可能只需要很简单的通信协议就能满足要求。有的可能需要更复杂的协议才能满足。
最后强调两点：
1.以上举例并不是完整的代码（有些细节没有描述出来），主要是供大家学习这种编程思想，或者实现方式。
2.一份好的通信协议代码，必定有一定容错处理，比如：发送完成检测、接收超时检测、数据出错检测等等。所以说，以上代码并不是完整的代码。
二、怎样用串口发送结构体-简单协议的封包和解包
https://blog.csdn.net/qq_33904382/article/details/112718948
定义要发送的结构体
/**
@part 通信数据结构
*/
/* 加速度信息结构体-XYZ三分量 */
typedef struct CSModuleInfo_ACC{
float _acc_X;
float _acc_Y;
float _acc_Z;
}CSInfo_Acc;
/* 经纬度信息结构体-经纬两分量 */
typedef struct CSmouduleInfo_LL{
float _latitude;
float _longitude;
}CSInfo_LL;
/* 测控站信息结构体 */
typedef struct CSInfoStrcutre CSInfoS;
typedef struct CSInfoStrcutre{
/* 核心温度 MCU温度 */
float _temp_O_MCU;
/* 气温 */
float _temp_env;
/* 气压 */
float _gp;
/* 加速度 */
CSInfo_Acc _acc;
/* 经纬度 */
CSInfo_LL _ll;
}* ptrCSInfo;
为了保证本文能符合大伙的需求，咱搞一个结构体嵌套，并且把数据类型都定义浮点数。意在说明我们这种传输结构体的方式不受结构体类型的限制，也不受浮点数的存储方式的限制，请放心学习使用。
注：代码中/* 测控站信息结构体 */部分的ptrCSInfo是这个大结构体的指针类型，CSInfoS是这个结构体的别名，这种写法是C语言的语法规则所允许的，不用感到奇怪。
下位机封包发送
封包发送的过程可以用下面的代码实现：
/**
* @brief 将数据打包并发送到上位机
* @param
ptrInfoStructure 指向一个装填好信息的infoStructure的指针
* @retval 无
*/
void CSInfo_PackAndSend(ptrCSInfo ptrInfoStructure)
{
uint8_t infoArray[32]={0};
uint8_t infoPackage[38]={0};
CSInfo_2Array_uint8(ptrInfoStructure,infoArray);
CSInfo_Pack(infoPackage,infoArray,sizeof(infoArray));
CSInfo_SendPack(infoPackage,sizeof(infoPackage));
}
向这个函数传入一个装有数据的结构体的指针ptrInfoStructure，依次调用CSInfo_2Array_uint8、CSInfo_Pack、CSInfo_SendPack这三个自定义函数，即可通过串口将结构体发送出去。
这三个函数分别对应着擦拆分结构体、按照协议/规则封包和发送数据三个过程，具体说明和代码如下：
1、拆分
文章开头我们已经说了，先要把结构体拆分成8位无符号整型(uint8_t)的数据：
/**
* @brief 将数据段（CSInfoStructure）重组为uint8类型的数组
* @param
infoSeg 指向一个CSInfoStructure的指针
infoArray 由数据段重组的uint8类型数组
* @retval 无
*/
void CSInfo_2Array_uint8(ptrCSInfo infoSeg,uint8_t* infoArray)
{
int ptr=0;uint8_t
*infoElem=(uint8_t*)infoSeg;
for(ptr=0;ptr<sizeof(CSInfoS);ptr++){
infoArray[ptr] = (*(infoElem+ptr));
}
}
传入一个结构体的指针，并传入一个对应大小(uint8_t)类型的数组，用来装结构体拆分出来的元素。
那么数组需要多大呢？我们知道8位(bit)就是一个字节(Byte)，所以这个数组理论上只需要和这个结构体的字节数一样大就可以了！也就是：
sizeof(CSInfoS)
的返回值。这里我们也可以口算一下，结构体中总共有8个float类型的数据，也就是8×32bit=8×4Byte=32Byte。结构体的大小也就是32字节，所以可以拆分成32个unit8_t类型的元素，数组大小也就需要32。
注意：传入的数组需要足够的大小，不要整个空指针或者不够大的数组进去。当然，你也可以返回一个数组，但我喜欢这种隐式返回的风格。
2、封包
选定一组特定的数据作为数据包的头部，选定另一组特定的数据作为数据包的尾部，方便我们在上位机接收数据后找到每一组数据的开始和结尾。
这里我们选定:
0x80 0x81 0x82
作为数据包的头部，同时选定：
0x82 0x81 0x80
作为数据包的尾部。所以我们向上位机发送的单个数据包都是如下形式的：
/**
@part 通信协议
@Protocol
------------------------------------------------------------
头 | 信息 | 尾
------------------------------------------------------------
0x80|0x81|0x82| CSInfoStrcutre |0x82|0x81|0x80
------------------------------------------------------------
3Byte | 32Byte | 3Byte
------------------------------------------------------------
*/
上面|CSInfoStrcutre|的位置就是我们在上一步获得的uint8_t类型的数组infoArray，内容是CSInfoStrcutre中的数据。
封包的过程如下面的代码所示：
/**
* @brief 按协议打包
* @param
package 打包结果，按协议结果为3+32+3=38字节 （38*8bit）
infoArray 由数据段重组的uint8类型数组 | 结果
infoSize 数据段的大小--占用内存字节数（协议规定为32Byte）
* @retval 无
*/
void CSInfo_Pack(uint8_t* infopackage,uint8_t* infoArray,uint8_t infoSize)
{
uint8_t ptr=0;
infopackage[0] = HEAD1;
infopackage[1] = HEAD2;
infopackage[2] = HEAD3;
/* 将信息封如入数据包中 */
for(;ptr<infoSize;ptr++){
infopackage[ptr+3] = infoArray[ptr];
}
infopackage[ptr+3] = TAIL1;
infopackage[ptr+4] = TAIL2;
infopackage[ptr+5] = TAIL3;
}
3、发送
接着，我们将把这个玩意儿(infopackage)通过串口发送出去：
/**
* @brief 将数据包发送到上位机
* @param
infoPackage 数据包
packSize 数据包的大小--占用内存字节数（协议规定为38Byte）
* @retval 无
*/
void CSInfo_SendPack(uint8_t* infoPackage,uint8_t packSize)
{
int ptr=0;
for(ptr=0;ptr<packSize;ptr++){
USART_SendByte(infoPackage[ptr]);
}
}
注意，为了方便使用，这里我们用到了一个名为USART_SendByte的自定义函数，其定义如下：
/**
* @brief 通过USART通道向上位机发送一个字节（8bit）的数据
* @param byte 要发送的8位数据
* @retval 无
*/
void USART_SendByte(uint8_t byte)
{
/* 发送一个字节数据到串口 */
USART_SendData(DEBUG_USARTx,byte);
/* 等待发送完毕 */
while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
}
到这里，我们就了解完了下位机打包发送的部分，接下来我们转到上位机视角，看一下咋个接收数据，咋个解析数据，也就是咋个把数据又装回一个结构体里，方便我们引用。
上位机接收数据并解包
回顾一下文章开头，我们说上位机的这部分工作的流程是这样的：
1、把串口里的数据读取出来
2、找到包头，
3、把数据包中对应数据的部分按顺序装填到结构体中
大致流程如下面的代码所示：
/* 读取数据 */
uint8_t packages[INFOSIZE*3]={0};
int numHasRead = readInfoFromSerialport(packages);
/* 解析数据 */
uint8_t infoArray[INFOSIZE];
/* 提取数据包 */
bool readable = CSInfo_GetInfoArrayInpackages(infoArray,packages,numHasRead);
/* 解包 */
if(readable)
CSInfo_InfoArray2CSInfoS(infoArray,this->_ptrCSInfo);
也即是依次调用readInfoFromSerialport、CSInfo_GetInfoArrayInpackages、CSInfo_InfoArray2CSInfoS在这三个函数，从串口缓冲区的一堆数据里找到一个完整的数据包并把它装填到结构体里。
下面详细介绍这三个自定义函数：
1、读取数据
你可以用你所知的任何方法从串口的缓冲区读取出来，只要你能把它们放到一个方便后续的解包操作访问的地方。
这里我使用Qt开发的上位机界面，故而也顺带使用Qt提供的serialport类中的方法来读取，具体可以参考Qt的帮助文档，这里只做简要说明：
/**
* @brief 把当前serialport缓冲区的数据全部读取到一个uint8类型的数组中
* @param
packages 从串口读取到的包含数据包的数据
* @retval
* numHasRead 从缓冲区读取到的字节数
*/
int readInfoFromSerialport(uint8_t* packages)
{
int numHasRead(0);
/* 没有可用的串口设备则中止读取操作 退出函数 */
if(QSerialPortInfo::availablePorts().isEmpty())
return 0;
_port = new QSerialPort(QSerialPortInfo::availablePorts()[0]);
_port->setPort(QSerialPortInfo::availablePorts()[0]);
if(!_port->open(QIODevice::ReadWrite)){
goto next;
}else{
_port->setParity(QSerialPort::NoParity);
_port->setBaudRate(QSerialPort::Baud115200);
_port->setDataBits(QSerialPort::Data8);
_port->setStopBits(QSerialPort::OneStop);
_port->setFlowControl(QSerialPort::NoFlowControl);
/* 开始从serialport读取数据 */
/* 读取串口缓冲区所有的数据到CSInfo的缓冲区infoArray */
_port->waitForReadyRead();
QByteArray dataArray = _port->read(200);
numHasRead = dataArray.size();
if(INFOSIZE*3<numHasRead){
for(int i=0;i<INFOSIZE*3;i++){
*(packages+i) = dataArray[i];
}
}
}
next:;
delete _port;
return numHasRead;
}
上述代码首先获取了一个serialport类的对象_port，然后通过一系列的setxxx函数配置了必要的参数。接着调用readAll把串口中所有的数据读取到dataArray（readAll()的返回值就是一个QByteArray类型的容器），然后把大小等同于三个infoStructure的数据放到packages中，预备进行下一步的解包操作。
注意，之所以要读取三个基数，是为了保证至少包含一个完整的数据包。
2、找到一个完整的数据包
前面提到了，我们设定每个数据包的头部是0x80|0x81|0x82,而数据包的尾部则反过来。根据这个特征：
/**
@part 通信协议
@Protocol
------------------------------------------------------------
头 | 信息 | 尾
------------------------------------------------------------
0x80|0x81|0x82| CSInfoStrcutre |0x82|0x81|0x80
------------------------------------------------------------
3Byte | 32Byte | 3Byte
------------------------------------------------------------
*/
我们可以先在上一步获得的packages中找到一个数据包的头部，以确定一个数据包的开始位置：
/**
* @brief 在串口读取到的数据中提取出一个数据包的数据段（CSInfoStructure对应的部分）
* 转存到infoArray中，供后续解析为CSInfoStructure.
* @param
infoArray 转存CSInfo的数组
packages 从串口读取到的包含数据包的数据
sizepackages 从串口读取到的字节数（packages的大小）
* @retval 无
*/
bool CSInfo_GetInfoArrayInpackages(uint8_t* infoArray,uint8_t* packages,int sizepackages)
{
int ptr;bool readable(true);
if(sizepackages<INFOSIZE*3){
readable = false;
return readable;
}
for(ptr=0;ptr<INFOSIZE*3;ptr++){
// or: for(ptr=0;ptr<sizepackages-3;ptr++){ */
if((packages[ptr]==HEAD1)&&(packages[ptr+1]==HEAD2)&&(packages[ptr+2]==HEAD3))
break;
}
ptr += 3;
for(int i=0;i<INFOSIZE;i++)
infoArray[i] = packages[ptr+i];
return readable;
}
通过调用这个函数，我们把packages中的一个完整的数据包的InfoStructure部分放到了infoArray中。接下看第三步，我们将把这个结构体的数据写入一个结构体中，真正还原它在下位机中的样子：
3、解析数据
直接把结构体当成一个数组，把数据依次填写进去就ok了
/**
* @brief 把存有一个数据段的数组解析为一个CSInfoStructure,结果存到参数2对应的地址
* @param
infoArray 存有一个数据段的uint8类型的数组
infoStrc 从串口读取到的字节数（packages的大小）
* @retval 无
*/
void CSInfo_InfoArray2CSInfoS(uint8_t* const infoArray,ptrCSInfo infoStrc)
{
uint8_t* u8PtrOStrc = (uint8_t*)infoStrc;
for(int i=0;i<INFOSIZE;i++)
*(u8PtrOStrc+i) = infoArray[i];
}
到这里，我们就完成了使用串口发送结构体的任务，而且了解了封包和解包的基本思路。
我把上位机的源代码链接放到这里，需要的可以单击自取。读取和解析的代码分别在Sources/CSInfoReader.c和Sources/CSInfoParser.c文件中。
三、嵌入式硬件通信接口协议-UART（五）数据包设计与解析
https://blog.csdn.net/DigCore/article/details/85710462
应用层数据包设计思路
回到工程本身，帧结构中的数据包才是应用程序最终需要解析使用的，且与具体的业务需求有关。
这篇文章将简单介绍，在数据包里如何设计应用层的交互指令，从而实现具体的业务需求。分享个思路，就当抛砖引玉了。
类似于帧结构，在设计数据包时，根据交互逻辑的具体需求，同样采用逐字节组成字段，字段组成数据包，从而完成指令交互。
具体到项目中，一般地有目标地址、源地址、指令类型、传输方向、级联序号、参数ID、参数值等等。
字段的定义因项目需求而定，以上提及的字段可能存在且不限于此。
以下介绍在具体项目中，对数据包设计与解析思路。工程实践中方法众多，相信很多经验娴熟的老工程师肯定都有各自巧妙的编程思路，欢迎在本页留言交流。
项目案例
基于nRF51822的BLE终端设备，与上位机使用UART通信，物理线路使用USB转UART。
常规解析过程
解析函数，一般地会把输入参数的 *indata，利用一个新的结构体指针指向该输入参数，之后的解析使用结构体指针来对数据处理，增强代码可读性！
常规的判断处理，多采用switch(){case :}联合if(…){;}else(…){;}判断逻辑，这个模式的判断处理架构如下：
以上的做法，依次去判断类型type、参数名para，然后直接处理。当这两个字段的枚举成员数量少，倒还可以这么判断；但是如果工程需要扩展、业务有了新的需求，那么if(…){;}else(…){;}的逐一判断将会使得解析函数里的代码量巨大！
总结有这几个缺点：
1.业务需求有多少个类型或者其他分支，就需要多少个这样的判断逻辑，对于编写代码变成个体力活；
2.在代码查看、维护时，面对的还是罗列了一大堆的switch(){case :}和if(…){;}else(…){;}语句；
3.增删功能时，需要找到代码中具体的判断位置，然后小心翼翼给注释或者修改掉。
这里已经没有任何的技术含量，基本上就是复制粘贴判断语句、修改判断对象，说到底也就是个查表的过程！
构建查表方式解析
既然要查表，当然是有个while()循环，然后递增某一变量来查表的过程。在这里，数据包结构体中定义的类型type、参数名para，都可以作为查表的对象，该如何选择？
假设：
1.以类型作为查表对象，假如查表后类型等于查询参数，那么参数名仍然是个多个分支的情况，要么继续查表要么继续采用switch(){case :}或者if(…){;}else(…){;}来判断众多不同的参数名；
2.以参数名作为查表对象，假如查表后参数名等于设备运行状态，那么类型需要做最多三种判断：查询、设置、其他。
对比以上两种，必然是第2个更能提高编程效率、缕清逻辑框架。
要查表就要建表，建表的结构体，以参数名para作为被查对象，并且以回调函数的形式执行查表结果。建表如下：
在执行数据包解析的时候，查表的思路是：
1.先创建一个表结构的指针ptable指向表的开始位置，也就是指向数组内第一个元素{ECHO, dcapp_dev_echo}
2.再创建一个数据包结构的指针pbuf指向输入数据首地址
3.通过递增ptable指针，对ptable与pbuf的参数名成员进行比对
4.最后执行ptable指针对应回调函数
以上的思路，放到代码中，仅仅数行就可以实现对输入数据包参数名的解析！高效、清晰！
另外，建表时，把无效参数名对应的值和对应的回调函数放在最后，这样做的好处是查完整个表，无需区分是否找到对应的参数名，而直接执行指针对应的回调函数即可。
这样即使是未找到参数名，也会执行表中最后一个元素，就是错误解析的回调函数dcapp_parser_err()。
有了这样一个查表的处理方式，增删指令功能就变得简单太多了！增加功能，只需要在表中添加参数名和对应的回调函数，删除某功能，也是回到表中找到对应的参数名和回调函数即可！
总结一下，虽然查表方式非常清晰，但是对应的回调函数内部，需要独自处理和实现，并且每个参数名都需要单独处理。相比于采用switch(){case :}联合if(…){;}else(…){;}判断逻辑，确实清晰很多。
以上的查表思路，来源于经历的项目，同时还参考了
《STM32CubeExpansion_MEMSMIC1_V1.1》
这个ST官方的数字麦克风开源项目示例，作为USB音频设备时，类似的回调函数方式：
四、DL-T 645协议格式或者DL-T 698协议格式的数据帧的串口解析思路
https://blog.csdn.net/weixin_40872563/article/details/95076982
题目要求如下：
用C语言写一个程序，此程序持续从串口读取数据（串口速率是115200，偶校验），串口数据有可能包含DL-T 645协议格式或者DL-T 698协议格式的数据帧（协议见word文档）。
要求把收到的符合以上两种格式的数据帧检出来。
附加要求：注意程序的可扩展性（如果以后此程序再支持其他协议数据解析，要容易扩展）。*
由于文档比较内容繁琐，特贴出来，协议格式
DL-T 645协议格式
(以下简称协议A)
DL-T 698协议格式
(以下简称协议B)
串口解析思路
- 一、串口数据接收：
定义一个1024字节的buf，将串口接收到的数据依次追加到此buf中；
- 二、解析串口数据流程：
1、从buf中检索起始字符0x68的位置，->2
2、去匹配是否符合协议A，会有三种解析结果
a.解析到完整的一帧数据，->5
b.数据未接收完 ->3
c.解析不满足规则 ->3
3、去匹配是否符合协议B，会有三种解析结果
a.解析到完整的一帧数据， ->5
b.数据未接收完 ->6
c.解析不满足规则
协议A也不满足规则 ->7
协议A未接收完 ->6
5、解析到完整的一帧数据，->10
6、协议匹配未接收完 ->9
7、两个协议解析都不满足，->8
8、从1中的位置继续寻找下一个0x68的位置
a.找到0x68 ->1
b.未找到0x68 ->6
9、继续循环，等待串口数据过来
10、解析完成，将buf中剩余数据前移到位置0，
代码如下：
先定义两种协议对应的结构体
typedef struct dl_t_698
{
uint8_t st_byte;//起始字符
uint16_t data_length;//长度域--此处注意大小端的问题
uint8_t control_byte;//控制域
uint8_t address_bytes[100];//地址域
uint16_t frame_head_hcs;//帧头校验
uint8_t user_data[100];//用户数据
uint16_t frame_crc_fcs;//帧校验
uint8_t end_byte;//结束字符
}dlt_698_frame_body;
typedef struct dl_t_645
{
uint8_t st_byte;//帧起始符
uint8_t address_bytes[5];//地址欲
uint8_t mid_st_byte;//帧起始符
uint8_t control_byte;//控制码
uint16_t data_length;//长度域--此处注意大小端的问题-- 前面字符长度为10
uint8_t user_data[100];//数据data
uint16_t frame_crc_cs;//校验
uint8_t end_byte;//结束字符
}dlt_645_frame_body;
//解析到一帧数据可能出现的情况
typedef enum frame_result
{
UNKNOWN,
OK, //成功找到一帧
UNFINISHED,//未接收完成
ERROR, //不满足此协议
} frame_result_t;
//定义协议类型
typedef enum protocol_type {
PROTOCOL_UNKNOWN,
PROTOCOL_DL_T_698,
PROTOCOL_DL_T_645,
PROTOCOL_OTHER,
}protocol_type_t;
char uart_rcvd_buf[UART_BUFFER_LEN];//接收串口发送过来的数据
char frame_buf[FRAME_BUFFER_LEN];//用来存取一帧数据
uint16_t uart_rcvd_pos = 0;//当前buf接收到的数据长度
dlt_698_frame_body s_dlt_698_frame_body;
dlt_645_frame_body s_dlt_645_frame_body;
/*
* 功能:接收串口过来的数据
**/
/*void uart_rev_data(uint8_t data)
{
uart_rcvd_buf[uart_rcvd_len] = data;
uart_rcvd_len++;
if (uart_rcvd_len >= UART_BUFFER_LEN) {
//清空所有命令
uart_rcvd_len = 0;
//my_memset(uart_rcvd_buf,0,sizeof(uart_rcvd_buf));
}
}*/
/*
* 该函数由库函数调用
**/
/*void UART_INT_Func(void)
{
uint8_t u8TempData=0;
if(1 == M0P_UART1->ISR_f.RI)
{
u8TempData = M0P_UART1->SBUF_f.SBUF;
uart_rev_data(u8TempData);
M0P_UART1->ICR_f.RICLR = 0;
}
}*/
/*
* 功能:检索一帧数据将值赋给结构体
* 校验OK return 1;
**/
uint8_t parse_dlt645_frame(char *p_frame, uint16_t frame_len, dlt_645_frame_body* sframe_body) {
uint16_t temp16_t = 0;//一帧数据的总长度
uint16_t i = 0;
//计算校验码
for (i = 0; i < frame_len - 3; i ++) {
temp16_t += p_frame[i];
}
if (temp16_t == p_frame[frame_len - 3] | p_frame[frame_len - 2]) {
sframe_body->st_byte = p_frame[0];
for (i = 0; i < 6; i ++) {
sframe_body->address_bytes[i] = p_frame[1+i];
}
sframe_body->mid_st_byte = p_frame[7];
sframe_body->control_byte = p_frame[8];
temp16_t = (p_frame[9]<<8) |p_frame[10];
sframe_body->data_length = temp16_t;
for (i = 0; i < temp16_t; i ++) {
sframe_body->user_data[i] = p_frame[11 + i];
}
sframe_body->frame_crc_cs = p_frame[frame_len - 3] | p_frame[frame_len - 2];
sframe_body->end_byte = p_frame[frame_len - 1];
return 1;
}
return 0;
}
/*
* 功能:检索一帧数据将值赋给结构体
**/
uint8_t parse_dlt698_frame(char *p_frame, uint16_t frame_len, dlt_698_frame_body* sframe_body) {
uint16_t temp16_t = 0;//一帧数据的总长度
uint16_t adr_temp16_t = 0;//地址域的地址长度
uint16_t i = 0;
//校验
for (i = 0; i < frame_len - 3; i ++) {
temp16_t += p_frame[i];
}
if (temp16_t == p_frame[frame_len - 3] | p_frame[frame_len - 2]) {
sframe_body->st_byte = p_frame[0];
temp16_t = ((p_frame[1]<<8) |p_frame[2]) & 0x3FFF;
sframe_body->data_length = temp16_t;
sframe_body->control_byte = p_frame[3];
sframe_body->address_bytes[0] = p_frame[4];//地址域第一个字节
adr_temp16_t = p_frame[4] & 0x0F;
for (i = 0; i < adr_temp16_t; i ++) {
sframe_body->address_bytes[i] = p_frame[5 + i];
}
sframe_body->frame_head_hcs = (p_frame[6 + adr_temp16_t - 1] >> 8) | p_frame[6 + adr_temp16_t];
for (i = 0; i < temp16_t; i ++) {
sframe_body->user_data[i] = p_frame[adr_temp16_t + 7];
}
sframe_body->frame_crc_fcs = p_frame[frame_len - 3] | p_frame[frame_len - 2];
sframe_body->end_byte = p_frame[frame_len - 1];
return 1;
}
return 0;
}
/*
* 功能:从缓存区buf中检索dlt645帧数据
* 将一帧数据读取到frame_buf中
* line:缓存区0x68开头的数据
* out:将捡出来的帧复制到该数组中
* frame_len:捡出来的帧的长度，
* line_len:缓存区buf中0x68开头的数据长度
**/
frame_result_t find_dlt645_frame(char* line, char* out, uint16_t* frame_len, uint16_t line_len) {
uint16_t frame_length = 0;//一帧数据的总长度
uint16_t temp_len = 0;
if (line_len < DLT_645_LEAST_LEN) {
return UNFINISHED;
}
//判断第七位
if (line[7] != 0x68) {
return ERROR;
}
frame_length = 9;/*帧起始符+地址域+帧起始符+控制域*/
temp_len = (line[9]<<8) |line[10];//数据data的长度
printf("645 data len = %d\n", temp_len);
frame_length = frame_length + 2 + temp_len;/*2-长度域占的字节*/
frame_length += 3;/*校验码和结束符*/
if (frame_length > FRAME_BUFFER_LEN) {
//超过单包缓存区的最大长度
return ERROR;
} else {
if (frame_length <= line_len) {
if (line[frame_length - 1] == 0x16) {
//检到一帧数据
for (temp_len = 0; temp_len < frame_length; temp_len ++) {
out[temp_len] = *line;
line++;
}
*frame_len = frame_length;
return OK;
} else {
//不满足此协议的0x16结束符
return ERROR;
}
} else {
//数据还没接收完整
return UNFINISHED;
}
}
return UNKNOWN;
}
/*
* 功能:从缓存区buf中检索dlt698帧数据
* 将一帧数据读取到frame_buf中
* line:缓存区0x68开头的数据
* out:将捡出来的帧复制到该数组中
* frame_len:捡出来的帧的长度，
* line_len:缓存区buf中0x68开头的数据长度
**/
frame_result_t find_dlt698_frame(char* line, char* out, uint16_t* frame_len, uint16_t line_len) {
uint16_t frame_length = 0;//一帧数据的总长度
uint16_t temp_len = 0;
if (line_len < DLT_698_LEAST_LEN) {
return UNFINISHED;
}
frame_length = 4;/*起始符+长度域+控制域*/
//地址域
temp_len = line[4] & 0x0F;
//printf("698 address len = %d\n", temp_len);
frame_length = frame_length + 1 + temp_len;
//帧头校验
frame_length += 2;
//用户数据长度
temp_len = ((line[1]<<8) |line[2]) & 0x3FFF;
//printf("698 data len = %d\n", temp_len);
frame_length += temp_len;//data长度
//
frame_length += 3;//帧校验+结束符
if (frame_length > FRAME_BUFFER_LEN) {
//超过单包缓存区的最大长度
return ERROR;
} else {
if (frame_length <= line_len) {
if (line[frame_length - 1] == 0x16) {
//检到一帧数据
for (temp_len = 0; temp_len < frame_length; temp_len ++) {
out[temp_len] = *line;
line++;
}
*frame_len = frame_length;
return OK;
} else {
//不满足此协议的0x16结束符
return ERROR;
}
} else {
//数据还没接收完整
return UNFINISHED;
}
}
return UNKNOWN;
}
/*
* 功能:协议数据解析
**/
void parse_buf (void)
{
uint16_t frame_length = 0;//一帧数据的总长度
uint16_t i = 0, temp_len = 0;
uint8_t has_content = 0;//buf中是否有数据
uint8_t frame_error = 0;//缓存区当前的数据对所有协议都不满足
char* p_buf;
protocol_type_t protl_type = PROTOCOL_UNKNOWN;
frame_result_t find_frame_re = UNKNOWN;
//用来保存每个协议解析后的结果
//frame_results[0] 保存PROTOCOL_DL_T_645协议解析结果
//frame_results[1] 保存PROTOCOL_DL_T_698协议解析结果
frame_result_t frame_results[2] = {UNKNOWN, UNKNOWN};
has_content = uart_rcvd_pos > 2;
while (has_content) {
p_buf = uart_rcvd_buf;
printf("p_buf = %#x\n", *p_buf);
//检索0x68开头的数据
while (*p_buf != 0x68 && p_buf < uart_rcvd_buf + uart_rcvd_pos) {
p_buf ++;
}
if (p_buf == uart_rcvd_buf + uart_rcvd_pos) {
//检索当前包数据，都不包含，清空
uart_rcvd_pos = 0;
break;
}
//uart_rcvd_buf中剩余的数据长度
temp_len = uart_rcvd_pos - (p_buf - uart_rcvd_buf);
printf("while start has_content uart_rcvd_pos - (p_buf - uart_rcvd_buf) = %d\n", temp_len);
//以下处理不包含校验
switch(protl_type) {
case PROTOCOL_UNKNOWN:
memset(frame_buf,0,sizeof(frame_buf));
find_frame_re = UNKNOWN;
frame_error = 0;
frame_length = 0;
for (i = 0; i < 3; i ++) {
frame_results[i] = UNKNOWN;
}
case PROTOCOL_DL_T_645:
find_frame_re = find_dlt645_frame(p_buf, frame_buf, &frame_length, temp_len);
frame_results[0] = find_frame_re;
if (find_frame_re == OK) {
printf("\nfind dlt_645 OK frame_buf = %s, frame_length = %d\n", frame_buf, frame_length);
printf("\n");
memset(&s_dlt_645_frame_body, 0, sizeof(dlt_645_frame_body));
if (parse_dlt645_frame(frame_buf, frame_length, &s_dlt_645_frame_body)) {
//解析到一包有效数据
}
break;
}
case PROTOCOL_DL_T_698:
find_frame_re = find_dlt698_frame(p_buf, frame_buf, &frame_length, temp_len);
frame_results[1] = find_frame_re;
if (find_frame_re == OK) {
printf("\nfind dlt_698 OK frame_buf = %s, frame_length = %d\n", frame_buf, frame_length);
printf("\n");
memset(&s_dlt_698_frame_body, 0, sizeof(dlt_698_frame_body));
break;
}
case PROTOCOL_OTHER:
//此处添加其他协议解析
//break;
default :
if (frame_results[0] == ERROR && frame_results[1] == ERROR) {
//缓存区的数据不满足现有协议的解析
//继续找下一个0x68起始符
p_buf ++;//跳过当前的0x68
//检索0x68开头的数据
while (*p_buf != 0x68 && p_buf < uart_rcvd_buf + uart_rcvd_pos) {
p_buf ++;
}
if (p_buf == uart_rcvd_buf + uart_rcvd_pos) {
//检索当前包数据，都不包含，清空
uart_rcvd_pos = 0;
break;
}
//找到下一条0x68开头的数据帧
frame_error = 1;
}
break;
}
//当成功检索到一帧数据或缓存区的数据不满足现有协议的解析
//buf中剩余的有效数据前移
if (find_frame_re == OK || frame_error) {
//uart_rcvd_buf剩余的数据长度
temp_len = uart_rcvd_pos - (p_buf - uart_rcvd_buf) - frame_length;
if (temp_len > 0) {
//当前uart_rcvd_buf中剩余的数据前移
for (i = 0; i < temp_len; i ++) {
uart_rcvd_buf[i] = *(p_buf + frame_length + i);
*(p_buf + frame_length + i) = 0x00;
}
has_content = 1;//继续循环解析
} else {
//解析过的位清空
for (i = 0; i < (p_buf - uart_rcvd_buf) + frame_length; i ++) {
uart_rcvd_buf[i] = 0x00;
}
has_content = 0;
}
uart_rcvd_pos = temp_len;
} else {
has_content = 0;
}
printf("while end has_content = %d, uart_rcvd_pos = %d\n", has_content, uart_rcvd_pos);
}
}
int main(void)
{
uint16_t timer;
//RCH 24MHz 使用内部时钟
Clk_SwitchTo(ClkRCL);
Clk_SetRCHFreq(ClkFreq24Mhz);
Clk_SwitchTo(ClkRCH);
//enable module clk
M0P_CLOCK->PERI_CLKEN_f.GPIO = 1; //打开GPIO的clk
M0P_CLOCK->PERI_CLKEN_f.BASETIM = 1;
M0P_CLOCK->PERI_CLKEN_f.UART1 = 1;
M0P_CLOCK->PERI_CLKEN_f.I2C = 1;
//UART init
Gpio_SetFunc_UART1TX_P23();
Gpio_SetFunc_UART1RX_P24();
M0P_UART1->SCON_f.DBAUD = 1; //双倍波特率
timer = 0x10000-((24000000*2)/(115200*32)); //单倍波特率，定时器配置
//使用basetimer1作为串口的波特率产生器
M0P_BT1->CR_f.GATE_P = 0u;
M0P_BT1->CR_f.GATE = 0u;
M0P_BT1->CR_f.PRS = 0u;
M0P_BT1->CR_f.TOG_EN = 0u;
M0P_BT1->CR_f.CT = 0u; //定时器模式
M0P_BT1->CR_f.MD = 1u; //重载模式
M0P_BT1->ARR_f.ARR = timer;
M0P_BT1->CNT_f.CNT = timer;
M0P_BT1->CR_f.TR = TRUE;
M0P_UART1->SCON_f.SM01 = 0x1; //模式1
M0P_UART1->SCON_f.SM2 = 0; //多主机通信disable
EnableNvic(UART1_IRQn, 3u, TRUE);
M0P_UART1->SCON_f.TIEN = 0;
M0P_UART1->SCON_f.RIEN = 1;
M0P_UART1->ICR_f.RICLR = 0;
M0P_UART1->ICR_f.TICLR = 0;
M0P_UART1->SCON_f.REN = 1;
测试代码
char* p_temp;
uint8_t i = 0;
char dlt_645_frame_msg[38] = {0x06, 0x06,0x68, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x68,0x03,
0x00,0x04, 0x0D, 0x0D, 0x0D, 0x0D, 0x02, 0x0A, 0x16,
0x68, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x68,0x03,
0x00,0x04, 0x0D, 0x0D, 0x0D, 0x0D, 0x02, 0x0A, 0x16};
char dlt_698_frame_msg[34] = {0x06, 0x06,0x68, 0x00, 0x05, 0x0C, 0x01, 0x0A, 0x00, 0xCC,
0x0A, 0x0D, 0x0D, 0x0D, 0x0E, 0x0F, 0xCC, 0x16,
0x68, 0x00, 0x05, 0x0C, 0x01, 0x0A, 0x00, 0xCC,
0x0A, 0x0D, 0x0D, 0x0D, 0x0E, 0x0F, 0xCC, 0x16 };
char error_frame_msg[20] = {0x06, 0x06,0x68, 0x00, 0x05, 0x0C, 0x01, 0x0A, 0x00, 0xCC,
0x16, 0x06,0x68, 0x60, 0x05, 0x01, 0x01, 0x0A, 0x00, 0xCC};
char dlt_645_frame_msg_half_st[29] = {0x06, 0x06,0x68, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x68,0x03,
0x00,0x04, 0x0D, 0x0D, 0x0D, 0x0D, 0x02, 0x0A, 0x16,
0x68, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x68,0x03};
char dlt_645_frame_msg_half_end[9] = {0x00,0x04, 0x0D, 0x0D, 0x0D, 0x0D, 0x02, 0x0A, 0x16};
p_temp = uart_rcvd_buf;
//DLT_645 TEST
#if 0
printf("\n ****** dlt 645 start ******\n");
//stpcpy(uart_rcvd_buf, dlt_645_frame_msg);
//strcat(uart_rcvd_buf, end_byte);
memcpy(uart_rcvd_buf, dlt_645_frame_msg, sizeof(dlt_645_frame_msg));
uart_rcvd_pos = sizeof(dlt_645_frame_msg);
printf("main start 645 msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
parse_buf();
printf("\n ****** dlt 645 end ******\n");
#endif
//DLT_698 TEST
#if 0
printf("\n ****** dlt 698 start ******\n ");
memcpy(uart_rcvd_buf, dlt_698_frame_msg, sizeof(dlt_698_frame_msg));
uart_rcvd_pos = sizeof(dlt_698_frame_msg);
printf("main start 698 msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
parse_buf();
printf("\n ****** dlt 698 end ******\n ");
#endif
//ALL TEST
#if 0
printf("\n ****** dlt 698 and 645 start ******\n ");
memcpy(uart_rcvd_buf + uart_rcvd_pos, dlt_698_frame_msg, sizeof(dlt_698_frame_msg));
uart_rcvd_pos += sizeof(dlt_698_frame_msg);
memcpy(uart_rcvd_buf + uart_rcvd_pos, dlt_645_frame_msg, sizeof(dlt_645_frame_msg));
uart_rcvd_pos += sizeof(dlt_645_frame_msg);
printf("main start 698 and 645 msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
//parse_buf();
printf("\n ****** dlt 698 and 645 end ******\n ");
#endif
//Error msg TEST
#if 1
printf("\n ****** dlt error msg start ******\n ");
memcpy(uart_rcvd_buf + uart_rcvd_pos, error_frame_msg, sizeof(error_frame_msg));
uart_rcvd_pos += sizeof(error_frame_msg);
printf("main start error msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
//parse_buf();
printf("\n ****** dlt error msg end ******\n ");
#endif
//Half test
#if 1
printf("\n ****** dlt 645 half start ******\n ");
memcpy(uart_rcvd_buf + uart_rcvd_pos, dlt_645_frame_msg_half_st, sizeof(dlt_645_frame_msg_half_st));
uart_rcvd_pos += sizeof(dlt_645_frame_msg_half_st);
parse_buf();
printf("\n ****** dlt 645 half middle +++ ******\n ");
memcpy(uart_rcvd_buf + uart_rcvd_pos, dlt_645_frame_msg_half_end, sizeof(dlt_645_frame_msg_half_end));
uart_rcvd_pos += sizeof(dlt_645_frame_msg_half_end);
printf("main start 645 half msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
printf("\n ****** dlt 645 half end ******\n ");
#endif
//ALL TEST
#if 1
printf("\n ****** dlt 698 and 645 start ******\n ");
memcpy(uart_rcvd_buf + uart_rcvd_pos, dlt_645_frame_msg, sizeof(dlt_645_frame_msg));
uart_rcvd_pos += sizeof(dlt_645_frame_msg);
memcpy(uart_rcvd_buf + uart_rcvd_pos, dlt_698_frame_msg, sizeof(dlt_698_frame_msg));
uart_rcvd_pos += sizeof(dlt_698_frame_msg);
memcpy(uart_rcvd_buf + uart_rcvd_pos, dlt_645_frame_msg, sizeof(dlt_645_frame_msg));
uart_rcvd_pos += sizeof(dlt_645_frame_msg);
printf("main start 698 and 645 msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
printf("\n ****** dlt 698 and 645 end ******\n ");
#endif
//Error msg TEST
#if 1
printf("\n ****** dlt error msg start ******\n ");
memcpy(uart_rcvd_buf + uart_rcvd_pos, error_frame_msg, sizeof(error_frame_msg));
uart_rcvd_pos += sizeof(error_frame_msg);
printf("main start error msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
//parse_buf();
printf("\n ****** dlt error msg end ******\n ");
#endif
parse_buf();
printf("main end msg uart_rcvd_buf = %s, uart_rcvd_pos = %d\n", uart_rcvd_buf, uart_rcvd_pos);
}
五、Qt 实现数据协议控制–组帧、组包、解析帧、解析包
https://blog.csdn.net/qq_21291397/article/details/109641476
数据传输中的组帧和组包
一、数据帧，数据包的概念
数据帧
数据传输往往都有一定的协议，通过CRC校验来验证数据的可靠性。数据帧包含三部分，帧头、数据部分、帧尾。其中帧头和帧尾包含一些必要的控制信息，比如同步信息，地址信息、差错控制信息等等。
组包
多个数据帧可以捆在一起，添加包头信息，就可以组包。组包可以使得多帧的数据同时发送，提高通信的效率。
数据的帧包可以提高数据传输的可靠性。
下面来介绍一种数据帧和包的封装：
组帧格式：
为了保证数据的可靠性，我们在帧结构中的长度，指令类型，数据，校验和数据包含5A556A69时需要转义，接收时也需要转义，以防止帧解析出现异常。
一帧数据只有一个指令。指令用于控制设备的状态等
组包格式：
这里我们将包头内容包含 版本信息和帧数据的长度信息。
按照该协议，我们可以串口传输，SOCKET TCP传输中来实现数据的发送和接收。
二、 程序实现：
这里我们讨论上位机SOCKET端的组帧和组包，以及解析帧和解包。我们下Qt中编写测试代码。
2.1、frame(帧)类的实现：
- 新建一个frame类，命名为frame。 在frame.h中我们如下设计
第一步：
设置数据区格式：
#define INT8U unsigned char
#define INT32U unsigned int
#define INT16U unsigned short
#define MAX_MSG_LEN 128
typedef struct _Msg_
{
INT8U length;
INT8U crc;
INT8U data[MAX_MSG_LEN];
}Msg,*pMsg;
第二步：
设计组帧和解析帧
bool PackFrame(Msg src, INT8U * dst, INT8U *len); //组包
INT8U UnpackFrame(INT8U ch, Msg *pmsg); //解包
第三步：
因为我们还要实现对帧中的帧长度，数据区，校验中实现转义，于是我们定义两个函数：
INT8U protocol_convert(INT8U ch); //转义
INT8U protocol_deconvert(INT8U ch); //反转义
最后，我们添加校验函数
INT8U CRC8( INT8U*buffer, INT8U len);
因为在数据转义中，需要对帧的格式进行判断，我们这里设计一个枚举结构
enum FRAME_STATE
{undefined
F_ERROR = -1,
F_HEADER_H,
F_HEADER_L,
F_LENGTH,
F_DATA,
F_CRC,
F_END_H,
F_END_L,
F_OVER,
};
frame.h 预览如下：
#ifndef FRAME_H
#define FRAME_H
#include "encrypt/type.h"
#include "encrypt/encrypt.h"
# define MAX_MSG_LEN 128
#pragma pack(1)
typedef struct _Msg_
{
INT8U length;
INT8U crc;
INT8U data[MAX_MSG_LEN];
}Msg,*pMsg;
#pragma pack()
class Frame
{
public:
Frame();
bool PackFrame(Msg src, INT8U * dst, INT8U *len); //组包
INT8U UnpackFrame(INT8U ch, Msg *pmsg); //解包
private:
enum FRAME_STATE
{
F_ERROR = -1,
F_HEADER_H,
F_HEADER_L,
F_LENGTH,
F_DATA,
F_CRC,
F_END_H,
F_END_L,
F_OVER,
};
Encrypt *_encrypt; //加密对象
int converter = 0;
int data_point = 0;
FRAME_STATE frame_state;
INT8U protocol_convert(INT8U ch); //转义
INT8U protocol_deconvert(INT8U ch); //反转义
INT8U CRC8( INT8U*buffer, INT8U len);
};
#endif // FRAME_H
2、frame.cpp 设计如下：
校验：
这里我们通过加密类中的CRC来返回一个CRC校验值，当然我们也一个自定义一个CRC计算的算法来实现
INT8U Frame::CRC8( INT8U*buffer, INT8U len)
{
return _encrypt->CRC8(buffer, len);
}
转义：
INT8U Frame::protocol_convert(INT8U ch)
{
if ((converter == 1) && (ch == 0xA5))
{
converter = 0;
ch = 0x5A;
}
else if ((converter == 1) && (ch == 0x66))
{
converter = 0;
ch = 0x99;
}
else if ((converter == 1) && (ch == 0x95))
{
converter = 0;
ch = 0x6A;
}
else if (converter == 1)
{
frame_state = F_ERROR;
}
return ch;
}
反转义：
INT8U Frame::protocol_deconvert(INT8U ch)
{
INT8U rtn = 0;
switch(ch)
{
case 0x5A:
rtn = 0xA5;
break;
case 0x99:
rtn = 0x66;
break;
case 0x6A:
rtn = 0x95;
break;
default:
rtn = ch;
break;
}
return rtn;
}
组帧和解析帧：
bool Frame::PackFrame(Msg src, INT8U * dst, INT8U *len)
{
// 增加CRC校验
src.crc = CRC8(src.data, src.length);
dst[0] = 0x5A;
dst[1] = 0x55;
int8_t j = 2;
// lenth
if (src.length == protocol_deconvert(src.length))
{
dst[j++] = src.length;
}
else
{
dst[j++] = 0x99;
dst[j++] = protocol_deconvert(src.length);
}
//data
for (int i = 0; i < src.length; i++)
{
if (src.data[i] == protocol_deconvert(src.data[i]))
{
dst[j++] = src.data[i];
}
else
{
dst[j++] = 0x99;
dst[j++] = protocol_deconvert(src.data[i]);
}
}
//crc
if (src.crc == protocol_deconvert(src.crc))
{
dst[j++] = src.crc;
}
else
{
dst[j++] = 0x99;
dst[j++] = protocol_deconvert(src.crc);
}
dst[j++] = 0x6A; //packet tail1
dst[j++] = 0x69; //packet tail2
(*len) = j;
return true;
}
INT8U Frame::UnpackFrame(INT8U ch, Msg *pmsg)
{
if ((ch == 0x5a) && (frame_state != F_HEADER_H) && (frame_state != F_CRC))
{
frame_state = F_HEADER_H;
}
if ((ch == 0x6a) && (frame_state != F_END_H) && (frame_state != F_CRC))
{
frame_state = F_ERROR;
}
if (frame_state == F_HEADER_H)
{
if (ch == 0x5A)
{
data_point = 0;
frame_state = F_HEADER_L;
}
else
{
frame_state = F_ERROR;
}
}
else if (frame_state == F_HEADER_L)
{
if (ch == 0x55)
{
frame_state = F_LENGTH;
}
else
{
frame_state = F_ERROR;
}
}
else if (frame_state == F_LENGTH)
{
if (ch == 0x99)
{
converter = 1;
return 0;
}
pmsg->length = protocol_convert(ch);
if (pmsg->length > MAX_MSG_LEN)
{
frame_state = F_ERROR;
}
else
{
frame_state = F_DATA;
}
}
else if (frame_state == F_DATA)
{
if (pmsg->length == 0)//没有数据区
{
frame_state = F_CRC;
return 0;
}
if (ch == 0x99) //转义
{
converter = 1;
return 0;
}
pmsg->data[data_point] = protocol_convert(ch);
data_point++;
if (data_point == pmsg->length)
{
data_point = 0;
frame_state = F_CRC;
}
}
else if (frame_state == F_CRC)
{
if (ch == 0x99) //转义
{
converter = 1;
return 0;
}
pmsg->crc = protocol_convert(ch);
frame_state = F_END_H;
}
else if (frame_state == F_END_H)
{
if (ch != 0x6A)
{
frame_state = F_ERROR;
}
else
{
frame_state = F_END_L;
}
}
else if (frame_state == F_END_L)
{
if (ch != 0x69)
{
frame_state = F_ERROR;
}
else
{
// frame_state = FRAME_STATE.F_HEADER_H;
//CRC success
if (pmsg->crc == CRC8(pmsg->data, pmsg->length))
{
frame_state = F_HEADER_H;
return 1;
}
else
{
frame_state = F_ERROR;
}
}
}
if (frame_state == F_ERROR)
{
frame_state = F_HEADER_H;
return 2;
}
return 0;
}
在解析帧的过程中，我们用frame_state 作为协议状态机的转换状态，用于确定当前字节处于一帧数据中的那个部位，在数据包接收完的同时也进行了校验的比较。
接收过程中，只要哪一步收到的数据不是预期值，则直接将状态机复位，用于下一帧数据的判断，因此系统出现状态死锁的情况非常少，系统比较稳定。
2.2、Pack(包)类的实现：
packer.h
#ifndef PACKER_H
#define PACKER_H
#include<QList>
#include "protocal/frame.h"
const int packVersion = 1;
class Packer
{
public:
Packer();
Frame *ptc; //帧对象指针
QList<Msg*> *lstMsg;// 解包后的通讯数据
QByteArray Pack(QList<Msg> lstMsg); //组包
QList<Msg*> *UnPack(INT8U * data, INT16U packLen); //解包
};
#endif // PACKER_H
packer.cpp
#include "packer.h"
#include<QDebug>
#include<QString>
Packer::Packer()
{
ptc = new Frame();
lstMsg = new QList<Msg*>();
}
QByteArray Packer:: Pack(QList<Msg> lstMsg)
{
QByteArray pack;
pack.resize(4);
pack[0]= (uint8_t)((packVersion & 0xff00)>>8);
pack[1] = (uint8_t)(packVersion &0xff);
pack[2] = 0;
pack[2] = 0;
int pos = 4;
Msg msg;
int i = 0;
foreach( msg , lstMsg)
{
INT8U dst[256];
INT8U len = 0;
ptc->PackFrame(msg, dst, &len);
INT8U pre_len = pack.size() ;
INT8U cur_len = pack.size() + len;
pack.resize( cur_len);
for(int j = pre_len; j<cur_len;j++ )
{
pack[j] = dst[j-pre_len];
}
// char * p_buf= new char[128]();
// std::memcpy(p_buf,dst,len);
// pack.append(p_buf);
pos += len;
}
pos = pos - 4;
pack[2] = (uint8_t)((pos & 0xff00) >> 8);
pack[3] = (uint8_t)(pos & 0xff);
return pack;
}
QList<Msg*> *Packer::UnPack(INT8U * data, INT16U packLen) //packLen: 数据区的长度
{
if (data == NULL)
{
qDebug()<< "数据为空！";
return NULL;
}
int version = data[0] << 8 | data[1];
// 版本异常
if (version != packVersion)
{
qDebug()<< "协议版本不正确!";
return NULL;
}
int len = data[2] << 8 | data[3];
//数据长度异常
if (len + 4 > packLen)
{
qDebug()<< "数据截断异常!" ;
return NULL;
}
if(len + 4 < packLen)
{
qDebug()<< "数据过长异常!" ;
}
Msg *pmsg = new Msg();
packLen = (INT16U)(len + 4);
for (int i = 4; i < packLen; i++)
{
INT8U ch = data[i];
INT8U result = ptc->UnpackFrame(ch, pmsg);
if (result == 1)
{
lstMsg->append(pmsg);
pmsg = new Msg();
}
}
return lstMsg;
}
三、测试
我们在main() 函数中添加如下代码 进行测试：
//解析帧测试
unsigned char destdata[] = {0x00,0x01,0x00,0x1b,0x5A,0x55,0x15,0x81,0x31,
0xFF,0xD8,0x05,0x4E,0x56,0x33,0x36,0x25,0x39,
0x22,0x43,0x72,0xF7,0xFD,0x30,0x23,0x51,0x09,
0xEF,0x0A,0x6A,0x69};
QList<Msg*> *testlist;
Packer *testpacker = new Packer();
testlist = testpacker->UnPack(destdata,31);
QList<Msg*>::iterator i;
for (i = testlist->begin(); i != testlist->end(); ++i)
{
for(int j = 0;j<(*i)->length;j++)
{
qDebug()<<QString::number((*i)->data[j],16) ;
}
}
//组包测试
Msg testmsg;
testmsg.length = 21;
testmsg.data[0] = 0x81;
testmsg.data[1] = 0x31;
testmsg.data[2] = 0xFF;
testmsg.data[3] = 0xD8;
testmsg.data[4] = 0x05;
testmsg.data[5] = 0x4E;
testmsg.data[6] = 0x56;
testmsg.data[7] = 0x33;
testmsg.data[8] = 0x36;
testmsg.data[9] = 0x25;
testmsg.data[10] = 0x39;
testmsg.data[11] = 0x22;
testmsg.data[12] = 0x43;
testmsg.data[13] = 0x72;
testmsg.data[14] = 0xF7;
testmsg.data[15] = 0xFD;
testmsg.data[16] = 0x30;
testmsg.data[17] = 0x23;
testmsg.data[18] = 0x51;
testmsg.data[19] = 0x09;
testmsg.data[20] = 0xEF;
QList<Msg> lstMsg ;
lstMsg.append(testmsg);
QByteArray ba;
ba = testpacker->Pack(lstMsg);
qDebug()<<ba.toHex();
输出：
jjjj
“81”
“31”
“ff”
“d8”
“5”
“4e”
“56”
“33”
“36”
“25”
“39”
“22”
“43”
“72”
“f7”
“fd”
“30”
“23”
“51”
“9”
“ef”
“0001001b5a55158131ffd8054e5633362539224372f7fd30235109ef0a6a69”
六、如何用串口解析出协议帧，并解决分包，组包，粘包问题？
原文链接：https://blog.csdn.net/qq_32166779/article/details/99943574
生产者（4个）：
硬件：串口一； 串口二； 串口三； 串口四；采用普通接受中断
软件： 中断时以字节传入到 ringbuffer，建立ringbuffer数组[4]，分别在四个中断里存入
void USART1_IRQHandler(void)
{
...
ring_buffer_write_byte_forced(&RingBuffer[UART_1], DeviceList[UART_1].handle->DR);
...
}
消费者（4个）：
软件：
第一步：
保证事件独立开
如果是前后台程序
while（1）
{
串口一事件；
串口二事件；
串口三事件；
串口四事件；
}
//rtos程序
while（1）
{undefined
//串口一事件；
}
while（2）
{undefined
//串口二事件；
}
…
第二步：建立 解析库 cmd_parser（&CmdParser, buffer, bufferLen）函数
解析库作用：
消费任何ringbuffer的内容，放到解析库中，如果消费内容不够，则继续消费，如果消费内容过多，用长度来控制需要消费的完整帧，进行下一步解析。
虽然每个协议获取整帧的长度方法不一样，但是几乎都是head + datalen+taildata 的方法
1，AT指令head是“+IPD”， datalen在其后
2，modbus（RTU）的head是address，datalen在其后，taildata是crc校验数据
3，如果没有head和datalen，则直接获取固定长度
第三步：建立数据结构
建立协议需要的数据结构
struct
{undefined
1，processFunc解析函数指针，因为每个串口解析函数不一样，所以在每个串口事件中，增加相关回调函数
2，第二步 中的会用到的一些变量，比如head，datalen，u8 *buffer;等
}cmdParser
第四步：
建立自己的解析函数，process_parser（）,这里的形参和cmdParser里的processFunc的形参是一样的，
这个函数就是在获取完整帧之后，接下来处理的函数。
第五步：
当获取完整帧之后，把整帧buff提取出来，调用cmdParser.processFunc（buff，bufflen）相当于调用process_parser（），这里为什么要这样做？ 因为调用这个函数时还在解析库cmd_parser（&CmdParser, buffer, bufferLen）函数内，为了做到多串口通用性，用这个cmdParser.processFunc（buff，bufflen）代替所有自己生成的process_parser（）函数。
如何使用？
拿串口一事件举例子
串口一事件函数
{
ui8 buffer[128];
si32 bufferLen;
cmdParser.processFunc = process_parser（）；
bufferLen= ring_buffer_read(&RingBuffer[UART_1], buffer, sizeof(buffer));
if(bufferLen > 0) {
cmd_parser(&CmdParser, buffer, bufferLen);
}
}
难点： cmd_parser（&CmdParser, buffer, bufferLen） 如何实现？
根据公司的多种协议帧 实现，用状态机 保证 各个情况，比如校验函数，解密函数，计算数据长度函数等等，如果做到了高鲁棒性，那么 这个库可以封装好不动了。
七、串口协议包的接收及解析处理
https://blog.csdn.net/xiaoyuanwuhui/article/details/104775612
八、大彩串口屏和STM32 HAL库使用经验
原文链接：https://blog.csdn.net/hpy518/article/details/123022758
1、硬件方面
首先查看背面电路板J5跳线，有一块丝印写着“OFF=RS232 ON=TTL”，附近有个J5焊点先找到。如果是和单片机连接的，则要把此焊点连接起来。如果是和PC模拟的，这里要断开。
1、软件方面
STM32CubeMX设置
与串口屏连接的串口开启中断。
2.MDK程序方面设置
我是用STM32的HAL库来写的，大彩官方大部分程序BUG我已修复，不难，主要是变量定义要修改。
官方例程有个小错误,就是其中的ProcessMessage函数，每当执行到PTR2U16宏定义时就死机了。要将在cmd_process.h文件内
#define PTR2U16(PTR) ((((uint8_t *)(PTR))[0]<<8)|((uint8_t *)(PTR))[1]) //从缓冲区取16位数据
改成，就正常执行了。
#define PTR2U16(PTR) ((((uint16_t *)(PTR))[0]<<8)|((uint8_t *)(PTR))[1]) //从缓冲区取16位数据
将HMIRun()；放入main.c的while(1)中，HMIRun()函数中就是将原来大彩官方放在main函数中的各类变量，函数全部集中整合好，做成一个独立函数，方便后期移植。
新建uint8_t Rx2Buffer; //存放串口2接收缓存
// /* 使能接收，进入中断回调函数 */
HAL_UART_Receive_IT(&huart2,&Rx2Buffer,1);
/**
* 函数功能: 串口接收完成回调函数
* 输入参数: 无
* 返 回 值: 无
* 说 明：将USART2串口接收到的值用USART1发出
*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
{
// HAL_UART_Transmit(&huart1,&aRxBuffer,1,0); //将接收到的数据用串口1发送出去
HAL_UART_Receive_IT(&huart2,&Rx2Buffer,1); //重新开启中断
queue_push(Rx2Buffer);
// printf("Rx2Buffer=%x",Rx2Buffer); //打印查看
}
九、大彩串口屏与STM32G070CBT6通讯调试
原文链接：https://blog.csdn.net/qq_42539055/article/details/129450443
本文主要讲解如何将大彩提供的DEMO移植到自己项目的工程文件中。首先通过STM32CubeMX生成基于STM32G070CBT6的Hall库程序；然后将大彩的程序移植到生成的Hall库程序中。
1 大彩串口屏
对串口屏基本功能不作过多介绍。主要讲解一下指令格式和硬件连接。
1.1 指令格式和指令集
对串口屏基本功能不作过多介绍。主要讲解一下指令格式和指令集。
一条完整的无 CRC 校验指令帧格式如表所示。具体指令集解析可看官方大彩串口屏指令集。
真实切屏指令;
读取文本控件后单片机获取的指令：
1.2 硬件连接与程序下载
大彩屏与单片机硬件接线图如下。在 VisualTFT中设计好界面，编译通过后，可通过USB转串口将程序下载至串口屏，接线参考如下。如果不确定一开始串口屏中程序的波特率，可通过VisualTFT联机设备查看一开始串口屏中的波特率。
2 串口屏例程移植到STM32G070CBT6
2.1 STM32CubeMX生成基于STM32G070CBT6的Hall库程序
打开cubemx后，选择STM32G070CBT6作为主控，串口配置如下，注意波特率要跟串口屏中的波特率一致，这里设置为119200，串口屏的也为119200：
同时必须勾选上中断：
此处可设置中断的优先级，这里设置成1。
这里还配置了一个PC13引脚，用来控制led灯的闪烁。
之后就可以配置生成代码：
2.2 大彩demo程序移植
先到大彩官网去下载对应的例程。本文选择的是如下例程做的移植。
1、首先将STM32_KEIL5\STM32\DCDEMO7\src里面的cmd_queue.c、hmi_driver.c两个.c文件复制到proj1\Core\Src中（这里的pro1是我配置cubemx的时候设置的项目名称Project Name，看自己设置的名称）。然后再打开STM32_KEIL5\STM32\DCDEMO7\inc，把**cmd_process.h、cmd_queue.h、hmi_driver.h，**三个头文件复制到proj1\Core\Inc中。
具体操作也可参看链接: link
这个博主写得很详细，是基于STM32F407。本文这部分是参考了这一篇。
2、把cmd_queue.c中的#include "ulitity.h"注释掉。
3、将hmi_driver.h中的#include "hmi_user_uart.h"改为自己的#include “usart.h”（如果用cubemx生成的代码，就是改成usart.h这个头文件）。
接着，找到官方程序里的hmi_user_uart.h头文件。首先#include “stm32f10x_it.h” 不需要；接着将里面的宏定义全部复制到#include “usart.h”（自己的串口头文件）；然后串口初始化函数也不需要(hall会自己生成初始化函数，要改波特率直接在里面改就行了)；最后void SendChar(uchar t)；这个函数要移植到自己的串口文件。
这里注重讲一下SendChar这和函数，在自己项目usart.c文件中定义代码如下：
/*!
* \brief 发送1个字节
* \param t 发送的字节
*/
void SendChar(uint8_t t)
{
HAL_UART_Transmit(&huart2,&t,1, 20);
while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET);//等待发送结束
}
接着在usart.h头文件中声明一下这个函数：void SendChar(uint8_t t);
4、最后是main.c头文件的修改。要把例程里main.c的头文件，变量，函数等复制过来。头文件只需要复制三个（#include “hmi_driver.h”，#include “cmd_queue.h”，#include “cmd_process.h”）；变量声明全部复制；最后函数则图上的位置开始，一直复制到main.c的最后。把这些复制到自己的main.c文件中。
5、如果要正常接受到串口屏发来的指令，必须重新写一下串口的回调函数（注意要把cubemx自动生成的回调函数注释掉-在proj1\Drivers\STM32G0xx_HAL_Driver\Src\stm32g0xx_hal_uart.c文件中，搜索HAL_UART_RxCpltCallback）。
在main.c中重定义如下：
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(huart);
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_UART_RxCpltCallback can be implemented in the user file.
*/
if(huart->Instance==USART2)
{
queue_push(uart2_rx_buf);
HAL_UART_Receive_IT(&huart2,&uart2_rx_buf, 1);
}
}
**其中uart2_rx_buf定义在usart.c中uint8_t uart2_rx_buf;，在usart.h中extern uint8_t uart2_rx_buf;
6、最后可在main函数中加入自己的代码了。至此应该可以正常通讯了。
在开始必须 HAL_UART_Receive_IT(&huart2,&uart2_rx_buf, 1);开启中断，并且在回调函数里重新开启。
ps：在调试的时候发现进入ProcessMessage( PCTRL_MSG msg, uint16 size )函数里后，处理uint16 screen_id = PTR2U16(&msg->screen_id); 这条语句发现会卡死，原因还没有弄清楚。这条语句的作用是将画面ID这个16位的变量高低八位互换了一下位置。所以重新加了一个函数，交换高低位位置。改了以后就没有问题了。
其中Convert函数为16位的高低八位互换函数，用移位计算实现，（引用链接: link）具体代码如下：
unsigned short Convert(unsigned short s) {
char right, left;
right = s& 0XFF;//低八位
left = s >> 8;//高八位 右移8位
s = right * 256 + left;
return s;
}
7、在这里我们还将数据通过另一个串口，即串口1，发送到电脑串口调试工具上显示。硬件接线就是单片机通过一个usb转串口与电脑相连。这里只对屏幕界面切换，和画面ID4中文本控件某个数值做响应，在电脑调试工具中显示对触摸屏做的改变。
首先在void NotifyText(uint16 screen_id, uint16 control_id, uint8 *str)函数中加入代码如下，实现最高电压value的值发给电脑：
void NotifyText(uint16 screen_id, uint16 control_id, uint8 *str)
{
if(screen_id==4) //画面ID2：文本设置和显示
{
int32 value=0;
sscanf(str,"%ld",&value); //把字符串转换为整数
if(control_id==2) //最高电压
{
//限定数值范围（也可以在文本控件属性中设置）
if(value<0)
{
value = 0;
}
else if(value>380)
{
value = 380;
}
SetTextInt32(4,2,value,0,1); //更新最高电压
SetTextInt32(4,5,value/2,1,1); //更新最高电压/2
//下面就是加入的代码
sprintf(tx_buffer,"value = %ld ",value);//把最高电压value的值，通过sprintf函数放在tx_buffer中。要包含头文件：#include <stdio.h>
HAL_UART_Transmit(&huart1,(uint8_t*)tx_buffer,sizeof(tx_buffer), 20);//通过串口1把数据发送出去
while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)!=SET);//等待发送结束
}
}
}
在画面切换调动的函数NotifyScreen(screen_id); 中加入代码，实现切屏信息发送给串口助手。
//进入音乐画面自动播放
if(current_screen_id == 17)
{
uint8 buffer[6] = {0x90,0x01 ,0x00 ,0x01 ,0x01};
SetButtonValue(17,3,1);
PlayMusic(buffer); //播放音乐
}
**//就在这个函数最后，加入的代码**
sprintf(tx_buffer,"current_screen_id = %d ",current_screen_id);
HAL_UART_Transmit(&huart1,(uint8_t*)tx_buffer,sizeof(tx_buffer), 20);
while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)!=SET);
//
}
效果如下，此处串口1波特率设置的是115200，用文本模式接收：
3 总结
本次调试的一般流程如下。
1、首先通过VisualTFT联机设备，确定串口屏有无问题，并把官方的串口屏程序通过串口下载进去。下载完成以后，可以通过电脑的串口助手接收串口屏发送来的指令格式是否正确。注意波特率要一致。
2、使用cubemx生成代码，生成后首先验证单片机的串口是否能正常通信，这里可参考链接: link ，单片机通过USB转串口连接电脑，电脑上的串口助手发给单片机什么数据，单片机就返回什么数据。
3、根据移植步骤移植大彩提供的demo到自己的项目里。通讯不上的话，一般是串口中断那块代码有问题：程序一开始没有打开串口接收中断；在回调函数中写压指令函数，还有回调函数中必须重新开启中断；这里指令处理函数ProcessMessage中的PTR2U16(&msg->screen_id); 和PTR2U16(&msg->control_id); 会跳入死循环，暂时不知道原因，重写一下交换高低位函数就好了。
以上是一些我的调试过程与总结，水平有限，如有错误，希望大家指正。
十、广州大彩串口屏与STM32F407通讯
原文链接：https://blog.csdn.net/prolop87/article/details/118080741
广州大彩串口屏与STM32F407通讯
之前一直用正点原子的LCD屏，但是占用太多GPIO引脚，所以打算换一块串口屏，某宝上看了一圈，看中了广州大彩的M系列8寸屏，厂家提供了单片机例程，但是芯片是F103的，而我的板子是ST的STM32F4DISCOVERY，需要进行移植，移植花了我半天时间，踩了不少坑，为了避免后来者少踩坑，所以决定写一下移植过程。其实之前有人写过怎么移植，个人觉得写得不够透彻，而且有些步骤多余，所以决定自己来。
一、大彩串口屏介绍
作为工控行业从业十年的工程师，接触过不少外国牌子的触摸屏，如西门子的TP1200\TP900，三菱的GOT1000、GOT2000，等等，还有台达的触摸屏。这回做项目开发，本着支持国产的初衷（省钱），在某宝选中了广州大彩的M系列串口屏，确实很惊艳，功能丝毫不逊色与一线品牌，全中文的组态软件也很友好。
我选的串口屏型号是DC80600M080AV_1111_0X(T/C/N) ，M系列8寸医用级，支持RS232/TTL串口通讯，带了个小喇叭，支持AV输入（可流畅播放外部视频），声音输出。其实不管F系列还是M系列，都可以参照我的方法移植。
二、硬件连接
先看一下触摸屏背部构成，看下图。
需要我们接线的主要在最下方的通信接口，这是一个8Pin的接口，局部图片如下：
8pin接口从左到右依次为VCC、VCC、NC、DOUT、DIN、DIN、GND、GND。
其中VCC跟GND用于供电接入，支持4.5V-30V；而DOUT、DIN分为别触摸屏自身的串口TX、RX端口，接线连接如下：
VCC-------+5V输入
GND------0V输入/串口共地端
DOUT-----接单片机USART_RX
DIN-------接单片机USART_TX
2.除了上面的连接外，请务必注意！！！因为我们单片机的USART只支持TTL电平，所以需要把串口屏背部的J5这里短接起来，自己拿电烙铁放焊锡把这两个点焊起来就OK了，不短接的话，大概率要烧掉你的单片机板子了，因为RS232输出的是15~24V的电平。
3.当然，你也可以学我这么接。我利用厂家配的调试板，加了个6针的排针，这里要注意的是：板子上的TXD接单片机的TX，板子上的RXD接单片机的RX，最后把GND共地接起来。这样接的好处是可以直接利用厂家的AC220–DC5V的供电接口，改动小一些。
三、程序移植
购买串口屏，厂家提供了相应的例程，但是例程是基于F103开发的，在厂家官网可以下载。而当你用的是别的MCU的时候，就比较头疼了。并且最苦恼的是什么？这个例程是基于标准库函数写的，而现在大部分项目都用HAL库函数写，导致很多地方不可以直接复制粘贴，要针对性地修改！直接拷贝过去的话，error大概有45条，warming大概200多条！ 是不是很麻烦？
把厂家的例程下下来之后，打开这个例程项目。
- 打开项目文件夹的以下路径：keil5_STM32\STM32\DCDEMO7\src，把cmd_queue.c、hmi_driver.c，两个C文件复制到你的项目里；再打开：keil5_STM32\STM32\DCDEMO7\inc，把cmd_process.h、cmd_queue.h、hmi_driver.h，三个头文件复制到你的项目里。至于怎么添加C文件、头文件，这个不用我教了吧。。。
- 这里说一下这两个C文件有啥用，cmd_queue.c文件其实就是个自己写的FIFO函数，包括清除缓存、取缓存数据。而hmi_driver.c文件里存放了所有跟串口屏数据交互的函数，例如画面切换、控件数值更新等等，全在这里面。
修改cmd_queue.c，把19行这一句注释掉，这个ulitity.h没啥用，其对应的C文件里面重新定义了delay函数，你自己项目里有，没必要用他的，所以注释掉。
3. 修改hmi_driver.c、hmi_driver.h，把这两个文件里面的串口头文件改成你自己的串口，比如我项目，用USART3来连接串口屏，那么就是#include
“usart3.h”
- 打开厂家例程里的hmi_user_uart.h,把这几行复制到你自己的串口头文件里（如usart3.h），这里面要注意，那句#include
"stm32F10x_it.h"不要，宏定义全部都挪过去，串口初始化函数改成你自己的（比如void
usart3_init），最下面那个senchar函数，千万不要改函数名，下一步讲一下这个函数怎么修改。
- 接第4部分，讲一下void SenChar(uchar t) 函数怎么修改，这个函数的作用是发送一个字节到串口屏。原函数是这样
这里分两种情况，如果你的项目用标准库函数开发的，那么只需要把USART1改成你对应的串口就行了；如果你用HAL库函数开发的，就需要重写这个函数，不然会报错，我用的是USART3，像我这样改写即可，在usart的头文件跟C文件中，把t重新定义成uint8_t：有人会问为什么我不直接用HAL库的串口发送函数HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)?你们可以仔细看，这个HAL库函数里传入的不是你要发送的数据，而是数据的指针首地址，而senchar函数的目的是只发送一个字节，所以我直接把传输的对象赋值给数据寄存器，达到我们的目的。贴上串口初始化及收发函数代码：
#include "sys.h"
#include "usart3.h"
#include "cmd_queue.h"
#define UART3_RX_BUFFER_SIZE 256
uint8_t UART3RxBuffer[UART3_RX_BUFFER_SIZE];
UART_HandleTypeDef UART3_handler; /*UART句柄*/
/**
* @brief 串口X初始化
* @param 无
* @retval 无
*/
void usart3_init(uint32_t bound)
{
GPIO_InitTypeDef gpio_initure;
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
gpio_initure.Pin = GPIO_PIN_10;
gpio_initure.Mode = GPIO_MODE_AF_PP;
gpio_initure.Pull = GPIO_PULLUP;
gpio_initure.Speed = GPIO_SPEED_FREQ_HIGH;
gpio_initure.Alternate = GPIO_AF7_USART3;
HAL_GPIO_Init(GPIOB, &gpio_initure);
gpio_initure.Pin = GPIO_PIN_11;
gpio_initure.Mode = GPIO_MODE_AF_PP;
HAL_GPIO_Init(GPIOB, &gpio_initure);
/* USART3 初始化设置 引脚PB10 PB11 */
UART3_handler.Instance = USART3;
UART3_handler.Init.BaudRate = bound; /*波特率*/
UART3_handler.Init.WordLength = UART_WORDLENGTH_8B; /*字长为8位数据格式*/
UART3_handler.Init.StopBits = UART_STOPBITS_1; /*一个停止位*/
UART3_handler.Init.Parity = UART_PARITY_NONE; /*无奇偶校验位*/
UART3_handler.Init.HwFlowCtl = UART_HWCONTROL_NONE; /*无硬件流控*/
UART3_handler.Init.Mode = UART_MODE_TX_RX; /*收发模式*/
HAL_UART_Init(&UART3_handler); /*HAL_UART_Init()会使能UART3*/
__HAL_UART_ENABLE_IT(&UART3_handler, UART_IT_RXNE);
HAL_NVIC_EnableIRQ(USART3_IRQn);
HAL_NVIC_SetPriority(USART3_IRQn, 3, 3);
}
/**
* @brief 串口3发送
* @param data: 发送的数据
* @param len: 数据长度
* @retval uint8_t: 0成功 其他：失败
*/
void usart3_sendData(uint8_t *data, uint16_t len)
{
HAL_UART_Transmit(&UART3_handler, data, len, 500);
while(__HAL_UART_GET_FLAG(&UART3_handler,UART_FLAG_TC)!=SET);
}
void SendChar(uint8_t t)
{
USART3->DR=t;
while((USART3->SR&0X40)==0);//等待发送结束 等待发送结束
}
/*
* @brief 串口X中断服务函数
* @param 无
* @retval 无
*/
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&UART3_handler);
if (__HAL_UART_GET_FLAG(&UART3_handler, UART_FLAG_RXNE) != RESET) /*!< 接收非空中断 */
{
uint8_t res = UART3_handler.Instance->DR;
queue_push(res);
}
}
main.c文件修改，对于主C文件，我们需要把例程main.c里面的头文件引用、变量声明、函数，都拷贝到新项目里，其中变量如果没用到的，最后再删掉，避免浪费内存，如下：
其中头文件只需要拷贝三个；而变量声明则全部拷贝过去，最后用不上再删除；而函数则从上图的位置开始，一直拷贝到main.c的最底端；以上挪到自己项目的main.c文件中。至此，项目移植基本完了。
四、触摸屏组态及函数调用
官网有出厂工程文件，直接下载下来根据自己需求修改就行，背景图片可以用photoshop之类的软件修改，大家可以看看我修改后的主画面内容。
效果还行吧，毕竟是基于官方的工程修改的。以主画面里面的状态指示画面为例，讲述如何实现程序设计及调用。
- 设置好画面的背景图片，然后在每个数据显示的位置方式文本控件（不明白的建议最好自己学学触摸屏的组态教程），文本控件属性设置为用户主机输入，设置好后编译触摸屏，得到该画面ID、控件ID。
- 主函数main.c调用串口屏函数，主函数的while(1)循环里添加以下函数调用，代码如下。
while(1)
{
size = queue_find_cmd(cmd_buffer,CMD_MAX_SIZE); //从缓冲区中获取一条指令
if(size>0&&cmd_buffer[1]!=0x07) //接收到指令 ，及判断是否为开机提示
{
ProcessMessage((PCTRL_MSG)cmd_buffer, size); //指令处理
}
if(time%20==0)
{
UpdateUI();
}
}
第一个if的作用是接收缓存区的第一条指令，判定如果非开机提示，则调用ProcessMessage()函数，解析串口屏发过来的指令集，以我上面的状态指示画面为例，当解析到串口屏发过来的画面切换指令时，将自动调用NotifyScreen()函数，判定切换到了哪个画面，然后在对应if(screen_id == X)的条件语句中写入自己需要执行的动作函数，比如我需要在状态指示画面的文本控件2上显示左轮速度（整数），在文本控件4上显示航向角（浮点数），则调用的函数如下：
void NotifyScreen(uint16 screen_id)
{
//TODO: 添加用户代码
current_screen_id = screen_id; //在工程配置中开启画面切换通知，记录当前画面ID
//进到画面1亮
if(screen_id == 1) //判断如果是画面1，则操作以下控件更新数据显示
{
AnimationPlayFrame(1,9,0);
SetTextInt32(1,2,Left_val,0,1); //更新画面ID=1，控件ID=2上的数据，其中Left_val为你需要传入的数据，整数型
SetTextInt32(1,3,Right_val,0,1);
SetTextFloat(1,4,attitude.yaw,1,1); //更新画面ID=1，控件ID=4上的数据，其中attitude.yaw为你需要传入的数据，浮点型
SetTextInt32(1,5,mag_letf_sensor,0,1);
SetTextInt32(1,6,mag_right_sensor,0,1);
}
}
显示整数需要调用SetTextInt32()，显示浮点数需要调用SetTextFloat()，所有需要执行动作的指令函数，都在hmi_driver.c文件里可以找到，你想实现什么功能就相应地调用哪个函数。此外我在UpdateUI()函数里也添加了同样的判定语句，只要检测到画面切换到1，那么就更新文本控件内的数据。大家可以看我的主循环while(1)里，UpdateUI()函数并不是每次都调用，而是有一定的间隔时间，大家注意一定不要频繁调用，因为厂家建议10~100ms往屏写一次数据比较好，避免内存溢出，我是间隔200ms发一次。
void UpdateUI()
{
//文本设置和显示 定时20ms刷新一次
if(current_screen_id==1) //判断如果是画面1，则操作以下控件更新数据显示
{
AnimationPlayFrame(1,9,0);
SetTextInt32(1,2,Left_val,0,1);
SetTextInt32(1,3,Right_val,0,1);
SetTextFloat(1,4,attitude.yaw,2,1);
SetTextInt32(1,5,mag_letf_sensor,0,1);
SetTextInt32(1,6,mag_right_sensor,0,1);
}
}
五、最终效果
最后贴一个我移植成功后的效果图吧，画面ID=1时，各个控件每200ms刷新一次数据，效果图如下：
结语
经过一番操作，相信你已经成功移植串口屏例程到自己项目里面了，如果有问题，可以私信我，文章转载，请注明作者跟出处哦。
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
