数据包解析是不同设备（如电脑、ESP32 等嵌入式设备）之间通信的核心环节。简单说，就是把收到的 "一串数据" 翻译成双方都能理解的 "具体信息"（比如温度、湿度、命令等）。下面介绍几种常见的数据包格式，以及 Python 和 ESP32（基于 Arduino 框架）的解析代码，尽量用通俗的语言解释。
一、文本格式（最容易理解）
文本格式的数据包由字符串组成，人类可以直接看懂，适合简单场景。常见的有CSV 格式和JSON 格式。
1. CSV 格式（逗号分隔值）
特点：用逗号（或其他符号）分隔不同字段，结构简单，类似表格。
适用场景：传感器批量数据（如温度、湿度、时间）、简单配置信息。
示例数据包："25.6,60.2,202310011200"（温度 = 25.6℃，湿度 = 60.2%，时间 = 2023-10-01 12:00）
Python 解析代码：
用内置的split函数分割字符串即可。
# 假设收到的CSV数据包
recv_data = "25.6,60.2,202310011200"# 解析步骤
fields = recv_data.split(',') # 用逗号分割
if len(fields) == 3: # 检查字段数量是否正确temperature = float(fields[0])humidity = float(fields[1])time = fields[2]print(f"温度：{temperature}℃，湿度：{humidity}%，时间：{time}")
else:print("数据格式错误")
ESP32 解析代码：
ESP32 通过串口 / 网络收到字符串后，用strtok函数分割（类似 Python 的 split）。
#include <Arduino.h>void setup() {Serial.begin(115200); // 初始化串口
}void loop() {if (Serial.available()) { // 检查是否有数据String recv_str = Serial.readStringUntil('\n'); // 读取一行数据（假设以换行结束）recv_str.trim(); // 去掉首尾空格和换行// 用逗号分割字符串char* data_ptr = strtok((char*)recv_str.c_str(), ","); // 第一个字段float temperature, humidity;String time_str;int count = 0;while (data_ptr != NULL) {if (count == 0) {temperature = atof(data_ptr); // 转成浮点数（温度）} else if (count == 1) {humidity = atof(data_ptr); // 转成浮点数（湿度）} else if (count == 2) {time_str = String(data_ptr); // 时间字符串}data_ptr = strtok(NULL, ","); // 下一个字段count++;}if (count == 3) { // 确认解析到3个字段Serial.printf("温度：%.1f℃，湿度：%.1f%，时间：%s\n", temperature, humidity, time_str.c_str());} else {Serial.println("CSV格式错误");}}
}
2. JSON 格式（键值对结构）
特点：用{键:值}的结构表示数据，支持嵌套（比如数组、对象），适合复杂数据。
适用场景：API 接口、带层级的配置信息（如 "设备信息 + 传感器数据"）。
示例数据包：{"device_id":"esp32_01","data":{"temp":25.6,"hum":60.2},"time":"202310011200"}
Python 解析代码：
用内置的json模块直接转成字典，方便取值。
import json# 假设收到的JSON数据包
recv_data = '{"device_id":"esp32_01","data":{"temp":25.6,"hum":60.2},"time":"202310011200"}'try:# 解析JSON字符串为字典data_dict = json.loads(recv_data)# 提取数据device_id = data_dict["device_id"]temp = data_dict["data"]["temp"]hum = data_dict["data"]["hum"]time = data_dict["time"]print(f"设备：{device_id}，温度：{temp}℃，湿度：{hum}%，时间：{time}")
except json.JSONDecodeError:print("JSON格式错误")
except KeyError as e:print(f"缺少字段：{e}")
ESP32 解析代码：
需要用ArduinoJson库（需在 Arduino 库管理器中安装），处理 JSON 结构。
#include <Arduino.h>
#include <ArduinoJson.h> // 引入JSON库void setup() {Serial.begin(115200);
}void loop() {if (Serial.available()) {String recv_str = Serial.readStringUntil('\n');recv_str.trim();// 分配JSON缓冲区（根据数据大小调整，这里用1024字节）StaticJsonDocument<1024> doc;// 解析JSONDeserializationError error = deserializeJson(doc, recv_str);if (error) { // 解析失败Serial.printf("JSON解析错误：%s\n", error.c_str());return;}// 提取数据（注意判断字段是否存在）if (doc.containsKey("device_id") && doc.containsKey("data") && doc.containsKey("time")) {const char* device_id = doc["device_id"];float temp = doc["data"]["temp"];float hum = doc["data"]["hum"];const char* time_str = doc["time"];Serial.printf("设备：%s，温度：%.1f℃，湿度：%.1f%，时间：%s\n", device_id, temp, hum, time_str);} else {Serial.println("JSON缺少必要字段");}}
}
二、二进制格式（更高效）
文本格式虽然易读，但占空间大（比如数字 "25.6" 要占 4 个字符），传输效率低。二进制格式直接用字节存储数据（比如 25.6℃可以用 2 个字节存储），更适合嵌入式设备（如 ESP32）之间的高速通信。常见的有固定长度格式和TLV 格式。
1. 固定长度格式
特点：每个字段的长度固定（比如温度占 2 字节，湿度占 2 字节），解析时按固定位置取数据，速度快。
适用场景：实时性要求高的场景（如传感器每秒传输一次数据）。
示例数据包结构（共 5 字节）：
| 字段 | 长度（字节） | 说明 |
|---|---|---|
| 温度 | 2 | 用 int16_t 存储（实际值 = 存储值 / 10，比如 0x00FA=250 → 25.0℃） |
| 湿度 | 2 | 同上（0x0258=600 → 60.0%） |
| 状态 | 1 | 0 = 正常，1 = 异常 |
对应的二进制数据：0x00 0xFA 0x02 0x58 0x00（即温度 25.0℃，湿度 60.0%，状态正常）
Python 解析代码：
用struct模块解析二进制数据（需要知道每个字段的类型和顺序）。
import struct# 假设收到的二进制数据（5字节）
recv_bytes = b'\x00\xFA\x02\x58\x00'if len(recv_bytes) == 5: # 检查长度是否正确# 解析：2字节温度（int16）、2字节湿度（int16）、1字节状态（uint8）temp_raw, hum_raw, status = struct.unpack('>hhu', recv_bytes)# 转换为实际值（除以10）temperature = temp_raw / 10.0humidity = hum_raw / 10.0print(f"温度：{temperature}℃，湿度：{humidity}%，状态：{'正常' if status == 0 else '异常'}")
else:print("二进制数据长度错误")
（>hhu表示：>大端模式，hint16，hint16，uuint8）
ESP32 解析代码：
直接操作字节数组，按固定位置取数据。
#include <Arduino.h>// 定义数据包结构（5字节）
struct DataPacket {int16_t temp_raw; // 温度原始值（2字节）int16_t hum_raw; // 湿度原始值（2字节）uint8_t status; // 状态（1字节）
};void setup() {Serial.begin(115200);
}void loop() {if (Serial.available() >= 5) { // 至少收到5字节uint8_t recv_buf[5];Serial.readBytes(recv_buf, 5); // 读取5字节到缓冲区// 解析数据（大端模式：高位字节在前）DataPacket data;data.temp_raw = (recv_buf[0] << 8) | recv_buf[1]; // 第0-1字节 → 温度data.hum_raw = (recv_buf[2] << 8) | recv_buf[3]; // 第2-3字节 → 湿度data.status = recv_buf[4]; // 第4字节 → 状态// 转换为实际值float temperature = data.temp_raw / 10.0;float humidity = data.hum_raw / 10.0;Serial.printf("温度：%.1f℃，湿度：%.1f%，状态：%s\n",temperature, humidity, (data.status == 0) ? "正常" : "异常");}
}
2. TLV 格式（Type-Length-Value）
特点：每个字段由 "类型（Type）+ 长度（Length）+ 值（Value）" 组成，字段数量和长度可以不固定，灵活性高。
适用场景：需要扩展的协议（比如有时传温度，有时传温度 + 湿度 + 电量）。
示例数据包：
| 类型（1 字节） | 长度（1 字节） | 值（n 字节） | 说明 |
|---|---|---|---|
| 0x01 | 0x02 | 0x00 0xFA | 温度（25.0℃） |
| 0x02 | 0x02 | 0x02 0x58 | 湿度（60.0%） |
对应的二进制数据：0x01 0x02 0x00 0xFA 0x02 0x02 0x02 0x58
Python 解析代码：
循环解析每个 TLV 单元（先读类型，再读长度，再读对应的值）。
def parse_tlv(data):parsed = {}index = 0while index < len(data):if index + 2 > len(data): # 至少需要类型（1）+长度（1）breaktype_ = data[index] # 类型（1字节）length = data[index + 1] # 长度（1字节）index += 2if index + length > len(data): # 检查值是否完整breakvalue = data[index:index + length] # 值（length字节）index += length# 解析具体值（根据类型转换）if type_ == 0x01: # 温度temp_raw = (value[0] << 8) | value[1]parsed["temperature"] = temp_raw / 10.0elif type_ == 0x02: # 湿度hum_raw = (value[0] << 8) | value[1]parsed["humidity"] = hum_raw / 10.0return parsed# 假设收到的TLV二进制数据
recv_bytes = bytes([0x01, 0x02, 0x00, 0xFA, 0x02, 0x02, 0x02, 0x58])
result = parse_tlv(recv_bytes)
print(f"解析结果：{result}") # 输出：{'temperature': 25.0, 'humidity': 60.0}
ESP32 解析代码：
同样循环读取每个 TLV 单元，按类型处理值。
#include <Arduino.h>void parseTLV(uint8_t* data, int len) {int index = 0;float temp = -1, hum = -1;while (index < len) {if (index + 2 > len) break; // 不够类型+长度的字节uint8_t type = data[index];uint8_t length = data[index + 1];index += 2;if (index + length > len) break; // 不够值的字节// 解析值（根据类型）if (type == 0x01 && length == 2) { // 温度（2字节）int16_t raw = (data[index] << 8) | data[index + 1];temp = raw / 10.0;} else if (type == 0x02 && length == 2) { // 湿度（2字节）int16_t raw = (data[index] << 8) | data[index + 1];hum = raw / 10.0;}index += length;}// 打印结果if (temp != -1) Serial.printf("温度：%.1f℃ ", temp);if (hum != -1) Serial.printf("湿度：%.1f% ", hum);Serial.println();
}void setup() {Serial.begin(115200);
}void loop() {// 假设收到8字节TLV数据if (Serial.available() >= 8) {uint8_t recv_buf[8];Serial.readBytes(recv_buf, 8);parseTLV(recv_buf, 8);}
}
三、自定义格式（最灵活，适合嵌入式）
实际项目中，常自定义格式（结合文本或二进制），并加入帧头、帧尾、校验位（防止数据错乱）。比如：
格式定义：帧头（0xAA） + 数据长度（1字节） + 数据内容 + 校验和（1字节） + 帧尾（0x55）
- 帧头 / 帧尾：标记数据包的开始和结束（比如 0xAA 开始，0x55 结束）。
- 数据长度：告诉接收方 "数据内容" 有多少字节，方便解析。
- 校验和：所有数据字节的和（取低 8 位），用于检查数据是否传输错误。
示例数据包（数据内容是温度 25.0℃，即 0x00FA）：
0xAA 0x02 0x00 0xFA 0xFA 0x55
- 帧头：0xAA
- 数据长度：0x02（数据内容占 2 字节）
- 数据内容：0x00 0xFA（温度原始值）
- 校验和：0x00 + 0xFA = 0xFA
- 帧尾：0x55
Python 解析代码：
先找帧头，再验证帧尾和校验和，最后解析数据。
def parse_custom(data):index = 0while index < len(data):# 找帧头（0xAA）if data[index] != 0xAA:index += 1continue# 检查是否有足够的字节（帧头+长度+校验+帧尾至少4字节）if index + 4 > len(data):breaklength = data[index + 1] # 数据长度# 检查总长度是否足够（帧头+长度+数据+校验+帧尾）total_len = 2 + length + 1 + 1 # 2=帧头+长度，1=校验，1=帧尾if index + total_len > len(data):index += 1continue# 提取数据内容content = data[index + 2 : index + 2 + length]# 提取校验和checksum = data[index + 2 + length]# 提取帧尾tail = data[index + 2 + length + 1]# 验证帧尾和校验和if tail != 0x55:index += 1continue# 计算校验和（数据内容的和）calc_checksum = sum(content) & 0xFFif calc_checksum != checksum:index += 1continue# 解析数据内容（这里是温度）if length == 2:temp_raw = (content[0] << 8) | content[1]temperature = temp_raw / 10.0print(f"解析成功：温度={temperature}℃")# 移动到下一个数据包index += total_lenreturn# 假设收到的自定义格式数据
recv_bytes = bytes([0xAA, 0x02, 0x00, 0xFA, 0xFA, 0x55])
parse_custom(recv_bytes) # 输出：解析成功：温度=25.0℃
ESP32 解析代码：
逻辑和 Python 类似，先找帧头，再验证校验和和帧尾。
#include <Arduino.h>void parseCustom(uint8_t* data, int len) {int index = 0;while (index < len) {// 找帧头0xAAif (data[index] != 0xAA) {index++;continue;}// 检查最小长度（帧头+长度+校验+帧尾=4字节）if (index + 4 > len) break;uint8_t length = data[index + 1]; // 数据长度uint16_t total_len = 2 + length + 1 + 1; // 总长度// 检查总长度是否足够if (index + total_len > len) {index++;continue;}// 提取各部分uint8_t* content = &data[index + 2]; // 数据内容uint8_t checksum = data[index + 2 + length]; // 校验和uint8_t tail = data[index + 2 + length + 1]; // 帧尾// 验证帧尾if (tail != 0x55) {index++;continue;}// 计算校验和uint8_t calc_checksum = 0;for (int i = 0; i < length; i++) {calc_checksum += content[i];}if (calc_checksum != checksum) {index++;continue;}// 解析数据（温度）if (length == 2) {int16_t temp_raw = (content[0] << 8) | content[1];float temperature = temp_raw / 10.0;Serial.printf("解析成功：温度=%.1f℃\n", temperature);}// 移动到下一个数据包index += total_len;}
}void setup() {Serial.begin(115200);
}void loop() {// 假设收到6字节自定义数据if (Serial.available() >= 6) {uint8_t recv_buf[6];Serial.readBytes(recv_buf, 6);parseCustom(recv_buf, 6);}
}
总结：如何选择格式？
- 简单场景（少量数据，需要人看懂）：用 CSV 或 JSON。
- 实时性高、数据量大（如传感器每秒 10 次传输）：用固定长度二进制。
- 需要灵活扩展（字段不固定）：用 TLV。
- 嵌入式设备通信（怕数据错乱）：用带帧头、校验的自定义格式。
核心原则：在 "易读性" 和 "效率 / 可靠性" 之间找平衡。
)
