一种单片机数据解析方法-电子发烧友网

前阵子一朋友使用单片机与某外设进行通信时，外设返回的是一堆格式如下的数据：

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;
}
elseif(flag==1)
{
if(tempData==0xAA)
flag++;
else
flag=0;
}
elseif(flag==2)
{
if(tempData==0x04)
flag++;
else
flag=0;
}
elseif(flag==3)
{
if(tempData==0x80)
flag++;
else
flag=0;
}
elseif(flag==4)
{
if(tempData==0x02)
flag++;
else
flag=0;
}
elseif(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_

#ifndefNULL
#defineNULL((void*)0)
#endif

typedefunsignedcharuint8;

/*队列节点*/
typedefstructNode
{
uint8data;
structNode*pre_node;
structNode*next_node;
}Node;

/*队列结构*/
typedefstructQueue
{
uint8capacity;//队列总容量
uint8size;//当前队列大小
Node*front;//队列头节点
Node*back;//队列尾节点
}Queue;

/*初始化一个队列*/
Queue*init_queue(uint8_capacity);
/*数据入队*/
uint8en_queue(Queue*_queue,uint8_data);
/*数据出队*/
uint8de_queue(Queue*_queue);
/*清空队列*/
voidclear_queue(Queue*_queue);
/*释放队列*/
voidrelease_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;
returnqueue;
}

/**
*数据入队
*
*@_queue:队列
*@_data:数据
**/
uint8en_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:出队的数据
*/
uint8de_queue(Queue*_queue)
{
uint8old_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--;
}
returnold_data;
}

/**
*清空队列
*
*@_queue:队列
*/
voidclear_queue(Queue*_queue)
{
while(_queue->size>0)
{
de_queue(_queue);
}
}

/**
*释放队列
*
*@_queue:队列
*/
voidrelease_queue(Queue*_queue)
{
clear_queue(_queue);
free(_queue);
_queue=NULL;
}

其次是解析器，需要封装的结构有解析数据队列、数据校验头、数据校验尾、解析结果以及指向解析结果的指针，需要实现的操作有解析器初始化、添加数据解析、获取解析结果、重置解析器和释放解析器，具体代码如下：

/*parser.h*/

#ifndef_PARSER_H_
#define_PARSER_H_

#include"queue.h"

typedefenum
{
RESULT_FALSE,
RESULT_TRUE
}ParserResult;

/*解析器结构*/
typedefstructDataParser
{
Queue*parser_queue;//数据解析队列
Node*resule_pointer;//解析结果数据指针
uint8*data_header;//数据校验头指针
uint8header_size;//数据校验头大小
uint8*data_footer;//数据校验尾指针
uint8footer_size;//数据校验尾大小
uint8result_size;//解析数据大小
ParserResultparserResult;//解析结果
}DataParser;

/*初始化一个解析器*/
DataParser*parser_init(uint8*_data_header,uint8_header_size,uint8*_data_footer,uint8_foot_size,uint8_data_frame_size);
/*将数据添加到解析器中进行解析*/
ParserResultparser_put_data(DataParser*_parser,uint8_data);
/*解析成功后从解析器中取出解析结果*/
intparser_get_data(DataParser*_parser,uint8_index);
/*重置解析器*/
voidparser_reset(DataParser*_parser);
/*释放解析器*/
voidparser_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)
returnNULL;

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);
}

returnparser;
}

/**
*将数据添加到解析器中进行解析
*
*@_parser:解析器
*@_data:要解析的数据
*
*@return:当前解析结果，返回RESULT_TRUE代表成功解析出一帧数据
*/
ParserResultparser_put_data(DataParser*_parser,uint8_data)
{
uint8i;
Node*node;

if(_parser==NULL)
returnRESULT_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])
gotoDATA_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])
gotoDATA_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代表数据获取失败
*/
intparser_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--;
}
returnnode->data;
}

/**
*重置解析器
*
*@_parser:解析器
*/
voidparser_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:解析器
*/
voidparser_release(DataParser*_parser)
{
if(_parser==NULL)
return;
release_queue(_parser->parser_queue);
free(_parser);
_parser=NULL;
}

接下来编写测试代码测试一下：

/*main.c*/

#include
#include"parser.h"

intmain()
{
uint8i;
//数据头
uint8data_header[]={0xAA,0xAA,0x04,0x80,0x02};
//要解析的数据，测试用
uint8data[]={
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("成功解析出一帧数据...
");

/*一位一位取出解析后的数据*/
printf("第一个数据是：0x%x
",parser_get_data(data_parser,0));
printf("第二个数据是：0x%x
",parser_get_data(data_parser,1));
printf("第三个数据是：0x%x


",parser_get_data(data_parser,2));
}
}

//当不再需要解析器时，应该把解析器释放掉，回收内存，避免造成内存泄漏
parser_release(data_parser);

return0;
}