单片机接收数据帧帧头帧尾校验数据解析
前阵子一朋友使用单片机与某外设进行通信时，外设返回的是一堆格式如下的数据：
AA AA 04 80 02 00 02 7B AA AA 04 80 02 00 08 75 AA AA 04 80 02 00 9B E2 AA AA 04 80 02 00 F6 87 AA AA 04 80 02 00 EC 91
其中 AA AA 04 80 02 是数据校验头，后面三位是有效数据，问我怎么从外设不断返回的数据中取出有效的数据。
对于这种问题最容易想到的就是使用一个标志位用于标志当前正解析到一帧数据的第几位，然后判断当前接收的数据是否与校验数据一致，如果一致则将标志位加一，否则将标志位置0重新判断，使用这种方法解析数据的代码如下：
if(flag == 0)
{
if(tempData == 0xAA)
flag++;
else
flag = 0;
}
else if(flag == 1)
{
if(tempData == 0xAA)
flag++;
else
flag = 0;
}
else if(flag == 2)
{
if(tempData == 0x04)
flag++;
else
flag = 0;
}
else if(flag == 3)
{
if(tempData == 0x80)
flag++;
else
flag = 0;
}
else if(flag == 4)
{
if(tempData == 0x02)
flag++;
else
flag = 0;
}
else if(flag == 5 || flag == 6 || flag == 7)
{
data[flag-5] = tempData;
flag = (flag == 7) ? 0 : flag+1;
}
使用上述方法是最容易想到的也是最简单的方法了，百度了一下基本上也都是使用类似的方法进行数据解析，但是使用这种方法有如下几个缺点：
1、 大量使用了判断，容易导致出现逻辑混乱
2、 代码重复率高，抽象程度低。从上述代码可以看到一大堆代码仅仅是判断的数据不同，其他代码都完全一致
3、 代码可复用性差。写好的代码无法用在其他类似的外设上，如果有多个外设就需要编写多份类似的代码
4、 可扩展性低。如果外设还有一个数据校验尾需要校验或者数据校验头发生改变，就需要再次写多个判断重新用于校验，无法在原有的代码上进行扩展
5、 容易出现误判
对此，这里提出了一种新的解决方案，可以通用与所有类似的数据解析，原理如下：
使用一个固定容量的队列用来缓存接收到的数据，队列容量等于一帧数据的大小，每来一个数据就将数据往队列里面加，当完整接收到一帧数据时此时队列中的全部数据也就是一帧完整的数据，因此只需要判断队列是否是数据校验头，队列尾是否是数据校验尾就可以得知当前是否已经接收到了一帧完整的数据，然后在将数据从队列中取出即可。原理图如下：
每来一个数据就往队列里面加：
当接收到一帧完整数据时队列头和数据校验头重合：
此时只需要从队列中取出有效数据即可。
如果有数据尾校验，仅仅只需要添加一个校验尾即可，如下图所示：
好，分析结束，开始编码。
首先需要一个队列，为了保证通用性，队列底层使用类似于双向链表的实现（当然也可以使用数组实现），需要封装的结构有队列容量、队列大小、队头节点和队尾节点，需要实现的操作有队列初始化、数据入队、数据出队、清空队列和释放队列，具体代码如下：
/* queue.h */
#ifndef _QUEUE_H_
#define _QUEUE_H_
#ifndef NULL
#define NULL ((void *)0)
#endif
typedef unsigned char uint8;
/* 队列节点 */
typedef struct Node
{
uint8 data;
struct Node *pre_node;
struct Node *next_node;
} Node;
/* 队列结构 */
typedef struct Queue
{
uint8 capacity; // 队列总容量
uint8 size; // 当前队列大小
Node *front; // 队列头节点
Node *back; // 队列尾节点
} Queue;
/* 初始化一个队列 */
Queue *init_queue(uint8 _capacity);
/* 数据入队 */
uint8 en_queue(Queue *_queue, uint8 _data);
/* 数据出队 */
uint8 de_queue(Queue *_queue);
/* 清空队列 */
void clear_queue(Queue *_queue);
/* 释放队列 */
void release_queue(Queue *_queue);
#endif
/* queue.c */ #include #include "parser.h" /** * 初始化一个队列 * * @_capacity: 队列总容量 */ Queue *init_queue(uint8 _capacity) { Queue *queue = (Queue *)malloc(sizeof(Queue)); queue->capacity = _capacity; queue->size = 0; return queue; } /** * 数据入队 * * @_queue: 队列 * @_data: 数据 **/ uint8 en_queue(Queue *_queue, uint8 _data) { if(_queue->size < _queue->capacity) { Node *node = (Node *)malloc(sizeof(Node)); node->data = _data; node->next_node = NULL; if(_queue->size == 0) { node->pre_node = NULL; _queue->back = node; _queue->front = _queue->back; } else { node->pre_node = _queue->back; _queue->back->next_node = node; _queue->back = _queue->back->next_node; } _queue->size++; } else { Node *temp_node = _queue->front->next_node; _queue->front->pre_node = _queue->back; _queue->back->next_node = _queue->front; _queue->back = _queue->back->next_node; _queue->back->data = _data; _queue->back->next_node = NULL; _queue->front = temp_node; } return _queue->size-1; } /** * 数据出队 * * @_queue: 队列 * * @return: 出队的数据 */ uint8 de_queue(Queue *_queue) { uint8 old_data = 0; if(_queue->size > 0) { old_data = _queue->front->data; if(_queue->size == 1) { free(_queue->front); _queue->front = NULL; _queue->back = NULL; } else { _queue->front = _queue->front->next_node; free(_queue->front->pre_node); _queue->front->pre_node = NULL; } _queue->size--; } return old_data; } /** * 清空队列 * * @_queue: 队列 */ void clear_queue(Queue *_queue) { while(_queue->size > 0) { de_queue(_queue); } } /** * 释放队列 * * @_queue: 队列 */ void release_queue(Queue *_queue) { clear_queue(_queue); free(_queue); _queue = NULL; }
其次是解析器，需要封装的结构有解析数据队列、数据校验头、数据校验尾、解析结果以及指向解析结果的指针，需要实现的操作有解析器初始化、添加数据解析、获取解析结果、重置解析器和释放解析器，具体代码如下：
/* parser.h */
#ifndef _PARSER_H_
#define _PARSER_H_
#include "queue.h"
typedef enum
{
RESULT_FALSE,
RESULT_TRUE
} ParserResult;
/* 解析器结构 */
typedef struct DataParser
{
Queue *parser_queue; // 数据解析队列
Node *resule_pointer; // 解析结果数据指针
uint8 *data_header; // 数据校验头指针
uint8 header_size; // 数据校验头大小
uint8 *data_footer; // 数据校验尾指针
uint8 footer_size; // 数据校验尾大小
uint8 result_size; // 解析数据大小
ParserResult parserResult; // 解析结果
} DataParser;
/* 初始化一个解析器 */
DataParser *parser_init(uint8 *_data_header, uint8 _header_size, uint8 *_data_footer, uint8 _foot_size, uint8 _data_frame_size);
/* 将数据添加到解析器中进行解析 */
ParserResult parser_put_data(DataParser *_parser, uint8 _data);
/* 解析成功后从解析器中取出解析结果 */
int parser_get_data(DataParser *_parser, uint8 _index);
/* 重置解析器 */
void parser_reset(DataParser *_parser);
/* 释放解析器 */
void parser_release(DataParser *_parser);
#endif
/* parser.c */
#include
#include "parser.h"
/**
* 初始化一个解析器
*
* @_data_header: 数据头指针
* @_header_size: 数据头大小
* @_data_footer: 数据尾指针
* @_foot_size: 数据尾大小
* @_data_frame_size: 一帧完整数据的大小
*
* @return: 解析器
*/
DataParser *parser_init(uint8 *_data_header, uint8 _header_size, uint8 *_data_footer, uint8 _foot_size, uint8 _data_frame_size)
{
if((_header_size+_foot_size) > _data_frame_size || (_header_size+_foot_size) == 0)
return NULL;
DataParser *parser = (DataParser *)malloc(sizeof(DataParser));
parser->parser_queue = init_queue(_data_frame_size);
parser->resule_pointer = NULL;
parser->data_header = _data_header;
parser->header_size = _header_size;
parser->data_footer = _data_footer;
parser->footer_size = _foot_size;
parser->result_size = _data_frame_size - parser->header_size - parser->footer_size;
parser->parserResult = RESULT_FALSE;
while(_data_frame_size-- > 0)
{
en_queue(parser->parser_queue, 0);
}
return parser;
}
/**
* 将数据添加到解析器中进行解析
*
* @_parser: 解析器
* @_data: 要解析的数据
*
* @return: 当前解析结果，返回 RESULT_TRUE 代表成功解析出一帧数据
*/
ParserResult parser_put_data(DataParser *_parser, uint8 _data)
{
uint8 i;
Node *node;
if(_parser == NULL)
return RESULT_FALSE;
en_queue(_parser->parser_queue, _data);
/* 校验数据尾 */
node = _parser->parser_queue->back;
for(i = _parser->footer_size; i > 0; i--)
{
if(node->data != _parser->data_footer[i-1])
goto DATA_FRAME_FALSE;
node = node->pre_node;
}
/* 校验数据头 */
node = _parser->parser_queue->front;
for(i = 0; i < _parser->header_size; i++)
{
if(node->data != _parser->data_header[i])
goto DATA_FRAME_FALSE;
node = node->next_node;
}
if(_parser->resule_pointer == NULL _parser->result_size > 0)
_parser->resule_pointer = node;
if(_parser->parserResult != RESULT_TRUE)
_parser->parserResult = RESULT_TRUE;
return _parser->parserResult;
DATA_FRAME_FALSE:
if(_parser->resule_pointer != NULL)
_parser->resule_pointer = NULL;
if(_parser->parserResult != RESULT_FALSE)
_parser->parserResult = RESULT_FALSE;
return _parser->parserResult;
}
/**
* 解析成功后从解析器中取出解析结果
*
* @_parser: 解析器
* @_index: 解析结果集合中的第 _index 个数据
*
* @return: 获取解析成功的数据，返回 -1 代表数据获取失败
*/
int parser_get_data(DataParser *_parser, uint8 _index)
{
Node *node;
if(_parser == NULL
|| _parser->parserResult != RESULT_TRUE
|| _index >= _parser->result_size
|| _parser->resule_pointer == NULL)
return -1;
node = _parser->resule_pointer;
while(_index > 0)
{
node = node->next_node;
_index--;
}
return node->data;
}
/**
* 重置解析器
*
* @_parser: 解析器
*/
void parser_reset(DataParser *_parser)
{
uint8 _data_frame_size;
if(_parser == NULL)
return;
_data_frame_size = _parser->parser_queue->size;
while(_data_frame_size-- > 0)
{
en_queue(_parser->parser_queue, 0);
}
_parser->resule_pointer = NULL;
_parser->parserResult = RESULT_FALSE;
}
/**
* 释放解析器
*
* @_parser: 解析器
*/
void parser_release(DataParser *_parser)
{
if(_parser == NULL)
return;
release_queue(_parser->parser_queue);
free(_parser);
_parser = NULL;
}
接下来编写测试代码测试一下：
/* main.c */
#include
#include "parser.h"
int main()
{
uint8 i;
// 数据头
uint8 data_header[] = {0xAA, 0xAA, 0x04, 0x80, 0x02};
// 要解析的数据，测试用
uint8 data[] = {
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x02, 0x7B, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0x08, 0x75, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x9B, 0xE2,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0xF6, 0x87, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0xEC, 0x91, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x15, 0x67,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x49, 0x33, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0xE7, 0x96, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x68, 0x15,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0x3C, 0x41, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0x66, 0x17, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0xA5, 0xD8,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x26, 0x56, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x01, 0x73, 0x09, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x64, 0x18,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x8B, 0xF1, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x01, 0xC6, 0xB6, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0x01, 0x7B, 0x01,
0xAA, 0xAA, 0x04, 0x80, 0x02, 0x00, 0xCB, 0xB2, 0xAA, 0xAA, 0x04, 0x80,
0x02, 0x00, 0x2C, 0x51, 0xAA, 0xAA, 0x04, 0x80, 0x02, 0xFF, 0xE5, 0x99
};
/**
* 初始化一个解析器
* 第一个参数是数据头
* 第二个参数是数据头长度
* 第三个参数是数据尾指针
* 第四个参数是数据尾大小
* 第五个参数是一整帧数据的大小
*/
DataParser *data_parser = parser_init(data_header, sizeof(data_header), NULL, 0, 8);
// 将要解析的数据逐个取出，添加到解析器中
for(i = 0; i < sizeof(data); i++)
{
// 解析数据，返回 RESULT_TRUE 代表成功解析出一组数据
if(parser_put_data(data_parser, data[i]) == RESULT_TRUE)
{
printf("成功解析出一帧数据...n");
/* 一位一位取出解析后的数据 */
printf("第一个数据是：0x%xn", parser_get_data(data_parser, 0));
printf("第二个数据是：0x%xn", parser_get_data(data_parser, 1));
printf("第三个数据是：0x%xnnn", parser_get_data(data_parser, 2));
}
}
// 当不再需要解析器时，应该把解析器释放掉，回收内存，避免造成内存泄漏
parser_release(data_parser);
return 0;
}
测试结果如下：
从上面可以看出，解析的结果与目标一致。
github地址：https://github.com/528787067/DataFrameParser
————————————————
免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理
审核编辑 黄宇
声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。
举报投诉
-
单片机
+关注
关注
6037文章
44560浏览量
635546 -
数据解析
+关注
关注
0文章
14浏览量
3506
发布评论请先 登录
相关推荐
CAN总线通信中的数据帧结构解析
CAN总线由Bosch公司在1980年代开发，旨在为汽车电子系统提供一个可靠的通信网络。随着技术的发展，CAN总线已经被广泛应用于各种工业和自动化领域。 2. CAN总线数据帧概述 CAN总线的数据
can标准帧和扩展帧能否共存
CAN（Controller Area Network）是一种用于汽车和工业自动化领域的现场总线通信协议。CAN协议具有多种帧格式，包括标准帧和扩展帧。在实际应用中，标准帧和扩展
can网络数据帧的特点
特点，在分布式系统中得到了广泛应用。 数据帧的重要性 ：数据帧是CAN网络中用于数据传输的基本单元，其结构设计和特性直接关系到整个网络的通信
can数据帧有哪几个域组成
CAN（控制器局域网络）是一种基于消息传递的通信协议，广泛应用于汽车、工业自动化和嵌入式系统等领域。CAN协议的数据帧是用于传输信息的基本单位。 1. CAN数据帧概述 CAN
CAN数据帧的各个域及其作用
CAN（Controller Area Network）是一种用于汽车电子系统中的通信协议，它具有高可靠性、实时性和灵活性等特点。在CAN通信中，数据帧是最基本的通信单元，用于传输信息。 概述
EtherCAT 数据帧格式和寻址方式简介
EtherCAT是一个高实时性，高速和高效率的工业以太网技术，数据根据自身独有的数据帧格式进行可靠传输，本文主要针对EtherCAT的数据帧
如何采用“状态机”解析UART数据帧
如果一个系统接收上述“不定长度”的协议帧，将会有一个挑战--如何高效接收与解析。 为简化系统设计，我们强烈建议您采用“状态机”来
下位机CY7C68013A发送数据，上位机C#读取数据，会丢帧或者帧内错位的原因？
下位机CY7C68013A发送数据，上位机C#在1个while循环内不断地读取数据，510字节1帧，1秒333
发表于 02-27 07:31
请问用CAN存储器存储的CAN总线数据帧格式有哪些呢？
请问用CAN存储器存储的CAN总线数据帧格式有哪些呢？ CAN总线是一种常用于汽车、工业控制和其他应用领域的串行通信协议。在CAN总线中，数据通过数据帧的形式进行传输。
MODBUS通讯之数据帧格式解读
/slave方式通信。本文主要介绍的MODBUS-RTU。二.MODBUS数据帧组成首先我们要知道一帧正常的MODBUS数据帧包含的内容有：
工商网监
评论