单片机接收数据帧帧头帧尾校验数据解析

最新推荐文章于 2024-07-05 11:28:05 发布
最新推荐文章于 2024-07-05 11:28:05 发布
阅读量1.9w 收藏 176
点赞数 23
分类专栏： C语言 文章标签： C语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XR528787067/article/details/52822377
版权

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

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 <stdlib.h>
#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 <stdlib.h>
#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 <stdio.h>
#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%x\n", parser_get_data(data_parser, 0));
            printf("第二个数据是：0x%x\n", parser_get_data(data_parser, 1));
            printf("第三个数据是：0x%x\n\n\n", parser_get_data(data_parser, 2));
        }
    }

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

    return 0;
}


测试结果如下：


从上面可以看出，解析的结果与目标一致。

github地址：https://github.com/528787067/DataFrameParser

XR528787067
关注
  • 23
    点赞
  • 踩
  • 176
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
单片机接收数据帧帧头帧尾校验数据解析C语言
02-17
单片机接收数据帧帧头帧尾校验数据解析C语言，采用VS2010编译器书写，已经通过验证，单片机里面也十分实用。双向链表方法。
基于MODSCAN32的MODBUS通讯数据解析
11-13
基于MODSCAN32的MODBUS通讯数据解析，用于嵌入式工程师开发底层数据通讯驱动。
【I2C通信中添加帧头、帧尾、校验和或CRC】
最新发布
MHD0815的博客
07-05 1115
在I2C通信中添加帧头、帧尾、校验和或CRC可以提高数据传输的可靠性和完整性，尤其是在噪声较大的环境中或需要确保数据准确无误的应用场景中。下面是一个使用这些技术的I2C通信实例：假设我们正在设计一个I2C通信协议，用于在微控制器和一个外部传感器模块之间传输数据。我们将使用`0xA5`作为帧头，`0x5A`作为帧尾，并且在每个数据包中加入一个8位的CRC校验码。
帧头帧尾代码
zhangminglong_的博客
06-15 1443
#include<stdio.h> #include<string.h> char head_tail(char str,char result){ int i = 0; while(str != ‘h’){ str++; } if(str==‘h’&&(str+1)==‘e’&&(str+2)==‘a’&&(str+3)==‘d’){ while((str+i+3)!=’\0’){ (result+i)=(str+i+3); i++;
游戏网络通信数据解析_1
m0_55875295的博客
05-11 673
网络数据分析原理与依据 软件中通过网络发送数据来通信，而通信的数据包要由发送方编码组织，由接收方进行解读，因此在软件开发之处，发送方和接收方就有着约定的编码与解码规则 我们就通过数据包分析来确定它的编码规则 网络通信编码解码的两种架构 1、数据结构约定 数据组织的时候本身有一个结构体，写代码的时候就定义在头文件里 2、数据解析约定： 发送的就是一段数据 比如01:char 02 short 03 bool 04 int 05 float....有一个编码表 对于解码约定需要通过分析大量数据包，来..
MODBUS通信数据解析和测试步骤讲解
06-19
根据本人实际开发总结，里面有具体通信参数设定、详细的发送反回案例、串口调试校验工具。文档分步骤进行讲解，实现对MODBUS的通信。
PIC系列单片机
m0_46202433的博客
05-15 964
PIC系列单片机 由美国Microchip公司推出的PIC单片机系列产品，首先采用了RISC结构的嵌入式微控制器，其高速度、低电压、低功耗、大电流LCD驱动能力和低价位OTP技术等都体现出单片机产业的新趋势。 现在PIC系列单片机在世界单片机市场的份额排名中已逐年升位，尤其在8位单片机市场，据称已从1990年的第20位上升到目前的第二位。PIC单片机从覆盖市场出发，已有三种(又称三层次)系列多种型号的产品问世，所以在全球都可以看到PIC单片机从电脑的外设、家电控制、电讯通信、智能仪器、汽车电子到金融电子各个
单片机接收数据帧帧头和帧尾用于数据包完整性的判别.pdf
02-20
单片机接收数据帧帧头和帧尾用于数据包完整性的判别 单片机接收数据帧帧头和帧尾是数据通信协议的重要组成部分。数据通信协议是建立在物理层之上的通信数据包格式。物理层包括 RS232、RS485、红外、光纤、无线等等...
单片机接收数据帧帧头和帧尾用于数据包完整性的判别.docx
02-20
3. 帧体接收：状态机在后续状态中接收数据并进行累加和及异或校验和的计算，直到到达帧尾。 4. 校验和比较：当收到帧尾的校验和字节时，状态机将比较计算的校验和与接收到的校验和，如果相等，则数据包被视为有效；...
单片机接收数据帧帧头和帧尾用于数据包完整性的判别 (2).pdf
02-20
"单片机接收数据帧帧头和帧尾用于数据包完整性的判别" 在数据通信协议中，帧头和帧尾是用于判别数据包的完整性和正确性的重要组成部分。它们通常是固定长度的字节组成，要求在整个数据链中能够最小化匹配机会。有两...
串行数据添加帧头以及帧头检测
weixin_43753381的博客
09-01 3914
发送链为串行数据添加帧头，接收链检测串行数据中的帧头，并完成环路测试。
h264协议帧头数据解析
zz460833359的博客
07-15 2680
一、序言 h264常见的帧头数据为： 00 00 00 01 67 (SPS) 00 00 00 01 68 (PPS) 00 00 00 01 65 ( IDR 帧) 00 00 00 01 61 (P帧) 等等，那么他们代表的意思是什么呢？ 二、start code start code有两种，四个字节的“00 00 00 01”和三个字节的“00 00 01”都是。 三、NALU indicator +---------------+ |0|1|2|3|4|5|...
goLang 实现根据帧头帧尾截取数据 备忘
weixin_43542114的博客
12-25 613
/* 1.此类想做成数据缓冲区的功能能，能够接受网络包进行数据缓冲区，根据 2. 根据帧头帧尾去能够完成数据截取，老的思路是去掉没有用的数据把数据都一个一个移位 3. 功能测试 目前功能正常 */ package queue import ( "sync" ) type queue struct { head int foot int arr []byte mutexP *sync.Mutex headArr []byte footArr []
c语言根据头部信息判断文件类型,C语言解析pcap文件得到HTTP信息实例
weixin_33415023的博客
05-23 448
程序功能为解析由Wireshark生成的pcap文件。实现步骤：1)用Wireshark软件抓包得到test.pcap文件2)程序：分析pcap文件头 -> 分析pcap_pkt头 -> 分析帧头 -> 分析ip头 -> 分析tcp头 -> 分析http信息#include#include#include#include#include#define BUFSIZE ...
单片机串口接收的几种常用的数据处理方法
ShenZhen_zixian的博客
11-23 2万+
单片机串口接收的几种常用的数据处理方法 一、为什么串口接收的数据需要处理 我们在做项目的时候经常会用到串口，当我们用串口和别的设备通讯的时候就需要严格遵循通讯协议，然而，仅仅是遵循通讯协议是不够的，因为单片机串口受到别的信号干扰的时候，容易出现数据错误，特别是串口发送的第一个字节和最后一个字节。一旦出现这种情况，设备之间的通讯可能会受到影响，甚至会导致系统瘫痪。另外，串口收到数据的时候，我们也需要...
通讯协议之几种常用的数据帧校验方式
路过的熊的博客
05-19 6607
简介     我们知道数据在传输过程中，可能会存在数据出错的情况。为了保证数据传输的正确性，因此会采取一些方法来判断数据是否正确，或者在数据出错的时候及时发现进行改正。常用的几种数据校验方式有奇偶校验、CRC校验、LRC校验、格雷码校验、和校验、异或校验等。 一、奇偶校验 1. 定义 根据被传输的一组二进制代码中“1”的个数是奇数或偶数来进行校验。 使用：通常专门设置一个奇偶校验位，存放代码中“1”的个数为奇数还是偶数。若用奇校验，则奇偶校验位为奇数，表示数据正确。若用偶校验，则奇偶校验位为偶数，表示数据正
如何使用逻辑分析仪，解析通信数据
jun8086的博客
02-10 2291
逻辑分析仪定位解决嵌入式通信中的问题PulseView
串口中怎样接收一个完整数据包的解析
热门推荐
铸剑娃的专栏
11-26 3万+
这里以串口作为传输媒介，介绍下怎样来发送接收一个完整的数据包。过程涉及到封包与解包。设计一个良好的包传输机制很有利于数据传输的稳定性以及正确性。串口只是一种传输媒介，这种包机制同时也可以用于SPI,I2C的总线下的数据传输。在单片机通信系统（多机通信以及PC与单片机通信）中，是很常见的问题。 一、根据帧头帧尾或者帧长检测一个数据帧 1、帧头+数据+校验+帧尾 这是一个典型的方案，但是对帧头与
51单片机串口接收数组
06-11
以下是51单片机串口接收数组的示例代码： ```c #include <reg52.h> #include <stdio.h> #define FOSC 11059200L #define BAUD 9600 #define TH1Value (256 - FOSC / 12 / BAUD) sbit LED = P1^0; void InitUART() { TMOD |= 0x20; SCON = 0x50; TH1 = TH1Value; TL1 = TH1Value; TR1 = 1; } void UARTInterrupt() interrupt 4 { static unsigned char i = 0; static unsigned char buffer[10]; if (RI == 1) { RI = 0; buffer[i] = SBUF; i++; if (i == 10) { i = 0; // 对接收到的数组进行处理 } } } void main() { InitUART(); EA = 1; ES = 1; while (1) { LED = ~LED; DelayMs(500); } } ``` 这是一个基本的串口中断程序，可以接收长度为10的数组。当接收到10个字符后，会将接收到的数组进行处理。你可以根据你的需求修改代码。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值