单片机数据拼包

对于数据包拼包方式常规方式有

  • 数组
  • 指针
  • 结构体

下文将此三种方式分别列举此数据包的实现。
然后对比优缺点。

本文举例数据包协议

包头 长度Length 消息类型 消息序列号Seq 负载数据 校验
2字节 1字节 1字节 1字节 N字节 2字节
名称 描述 其他
包头 固定 0X0A,0X0A 对于以太网数据包可以不设立此段。串口一般需要使用,对解包有利,这里不赘述。
长度 Length 数据包长度,(除去包头和自身)
消息类型 - 低7bit是消息类型,最高bit标记是否是回复消息
消息序列号Seq 消息编号,用于回复消息与请求消息的匹配
负载数据 消息类型对应的负载数据 负载数据长度 = Length - 4
校验 前面所有字节的校验值

代码中使用类型如下定义

// https://github.com/NewLifeX/microCLib.git  Core 目录 Type.h 内定义。
typedef char			        sbyte;
typedef unsigned char			byte;
typedef unsigned short			ushort;
typedef unsigned int			uint;
typedef long long int			int64;
typedef unsigned long long int	uint64;

基本定义

/// <summary>消息类型</summary>
typedef enum
{
	/// <summary></summary>
	Ping = 0x01,
	/// <summary>注册</summary>
	Reg = 0x02,
	/// <summary>登录</summary>
	Login = 0x03,
}MsgType_e;

// 数据包头
static byte PktHead[] = {0x0A,0x0A};

// 函数原型
/// <summary>创建消息</summary>
/// <param name="seq">消息序列号Seq</param>
/// <param name="payload">负载数据内容指针</param>
/// <param name="payloadlen">负载数据长度</param>
/// <param name="data">消息输出缓冲区</param>
/// <param name="len">缓冲区长度</param>
/// <returns>返回消息真实长度</returns>
int Buil(byte seq, byte* payload, int payloadlen, byte* data, int len);

// 下列代码,会根据事项方式在函数名加尾缀 ByXXX

数组

int BuilByteArray(byte seq, byte* payload, int payloadlen, byte* data, int len)
{
	if (data == NULL)return -1;
	// 判断缓冲区长度是否足够
	if (len < payloadlen + 4 + 3)return -1;

	// 用于记录长度/写入位置
	int idx = 0;
	// 写数据包头
	// memcpy(&data[idx], PktHead, sizeof(PktHead)); // idx=0 可以直接写data
	memcpy(data, PktHead, sizeof(PktHead));
	idx += sizeof(PktHead);
	// 长度
	data[idx++] = payloadlen + 4;
	// 类型
	data[idx++] = (byte)Reg;
	// 序列号
	data[idx++] = seq;
	// 负载
	memcpy(&data[idx], payload, payloadlen);
	idx += payloadlen;

	// 计算crc
	ushort crc = CaclcCRC16(data, idx);

	// 写入crc
	memcpy(&data[idx], (byte*)&crc, sizeof(crc));
	idx += sizeof(crc);

	return idx;
}
  • 常规操作,在各种c项目中最为常见。
  • 容易出错的点在 idx 维护。
  • 基本无难度。
  • 阅读难度很高,如果不写好备注。基本头秃。

指针

int BuilByPoint(MsgType_e type, byte seq, byte* payload, int payloadlen, byte* data, int len)
{
	if (data == NULL)return -1;
	// 判断缓冲区长度是否足够
	if (len < payloadlen + 4 + 3)return -1;

	byte* p = data;

	// 写数据包头
	// memcpy(&data[idx], PktHead, sizeof(PktHead)); // idx=0 可以直接写data
	memcpy(p, PktHead, sizeof(PktHead));
	p += sizeof(PktHead);
	// 长度
	*p++ = payloadlen + 4;
	// 类型
	*p++ = (byte)type;
	// 序列号
	*p++ = seq;
	// 负载
	memcpy(p, payload, payloadlen);
	p += payloadlen;

	// 计算crc
	ushort crc = CaclcCRC16(data, p - data);

	// 写入crc
	memcpy(p, (byte*)&crc, sizeof(crc));
	p += sizeof(crc);

	return p - data;
}
  • 基本就是数组方式的翻版。
  • 在执行效率上优于数组方式。
  • 指针对于 c 来说一直都是难点。
  • 容易写出错。
  • 阅读难度非常高,如果不写好备注。基本头秃。

结构体

// 压栈编译器配置
#pragma pack(push)	
// 告诉编译按照1字节对齐排布内存。
#pragma pack(1)

/// <summary>固定位置的数据部分</summary>
typedef struct
{
	/// <summary>包头</summary>
	ushort PktHead;
	/// <summary>长度</summary>
	byte Length;
	/// <summary>消息类型,enum长度不确定,所以写个基础类型</summary>
	byte Type;
	/// <summary>消息序列号</summary>
	byte Seq;
}MsgBase_t;
// 恢复编译器配置(弹栈)
#pragma pack(pop)

int BuilByStruct(MsgType_e type, byte seq, byte* payload, int payloadlen, byte* data, int len)
{
	if (data == NULL)return -1;
	// 判断缓冲区长度是否足够
	if (len < payloadlen + 4 + 3)return -1;

	// 直接写入能描述的部分。
	MsgBase_t* mb = (MsgBase_t*)data;
	memcpy((byte*)&(mb->PktHead), PktHead, sizeof(PktHead));
	mb->Length = payloadlen + 4;
	mb->Type = (byte)type;
	mb->Seq = seq;

	int idx = sizeof(MsgBase_t);
	// 负载
	memcpy(&data[idx], payload, payloadlen);
	idx += payloadlen;

	// 计算crc
	ushort crc = CaclcCRC16(data, idx);

	// 写入crc
	memcpy(&data[idx], (byte*)&crc, sizeof(crc));
	idx += sizeof(crc);

	return idx;
}
  • 很少出现在各种开源软件中。
  • 需要掌握一个高级知识点,涉及编译器和 cpu 特征。
    cpu位宽、非对齐访问以及对应的编译器知识。
  • 对于固定长度的指令来说,非常方便。
  • cpu执行效率非常高,跟数组方式的速度一致。
  • 写好结构体,数值填充顺序就跟协议内容无关了。
  • 很好理解,阅读无压力。
  • 对于读非固定格式数据来说,0灵活度。只能抽取相同部分做部分处理。非常头秃。
    (本文主体是写数据,详细讨论)

数据流

// https://github.com/NewLifeX/microCLib.git
#include "Stream.h"

int BuildByStream(MsgType_e type, byte seq, byte* payload, int payloadlen, byte* data, int len)
{
	if (data == NULL)return -1;
	// 判断缓冲区长度是否足够
	if (len < payloadlen + 4 + 3)return -1;

	// 初始化流
	Stream_t st;
	StreamInit(&st, data, len);
	// 包头
	StreamWriteBytes(&st, PktHead, sizeof(PktHead));
	// 长度
	StreamWriteByte(&st, payloadlen + 4);
	// 类型
	StreamWriteByte(&st, (byte)type);
	// 序列号
	StreamWriteByte(&st, seq);
	// 负载
	StreamWriteBytes(&st, payload, payloadlen);
	// 计算crc
	ushort crc = CaclcCRC16(st.MemStart, st.Position);
	// 写入crc
	StreamWriteBytes(&st, (byte*)&crc, sizeof(crc));

	return st.Position;
}
  • 上位机处理常规方式。算是面对对象编程的范畴了。
  • 阅读难度很小。
  • Stream 内部已做边界判断,基本不会出现bug。
  • 缺点,效率低。每个操作都是函数调用,此处产生大量消耗。

Stream 还定义了一些带扩容的方法。可以在外部不传入缓冲的情况下完成数据包构建。
由于内部使用了堆,所以需要手动释放内存。
自带扩容的方式,属于另一种使用方式了,这里不做对比。

对比总结

以下评判为个人经验判断,欢迎讨论。

执行速度:指针>结构体>数组>流
技术难度:指针>结构体>数组>流
写错可能性:指针>数组>结构体>流
易读性:结构体>流>数组>指针

内容来源于网络如有侵权请私信删除