前面六篇的代码,如果真拿去用,第一版很可能会变成这样:一个函数里五六个 if,判断缓冲区够不够,判断帧头对不对,判断长度有没有超,判断 CRC 过不过。能跑,也能交付。可下一次协议要加一个「序号」字段,位置在长度和命令之间,整个函数从头改到尾,改完还要重新测所有分支。
更难受的是排查。现场偶发一帧错位,日志里只有「解析失败」四个字,不知道是帧头没找到、长度超了、还是 CRC 没过。把日志加细,又是一堆 if 里插打印,越插越乱。
这类问题的根源是「用顺序代码描述一个分步过程」。收字节是一个接一个来的,每一步该做什么、遇到意外该退到哪,本来就是一个状态机。写成状态机,每一步都显式,出问题能看见卡在哪,加字段也只是加一个状态。
这篇从零写一个完整可运行的解析器:帧头 0xAA55、长度、命令、负载、CRC-16/MODBUS,输入可以是任意字节片段;再写一个模糊测试循环,随机改字节,确认它不崩。代码在本机 Python 3.15.0 上跑过,输出原样贴出。C 版本只讲移植要点,未在本机实测,也不编造运行结果。
有限状态机是什么
有限状态机(FSM,finite state machine)由三样东西组成:一组状态、一组事件、一张转移表。状态是「现在处于哪一步」,事件是「收到了什么」,转移是「遇到这个事件,从当前状态去哪,做什么动作」。
解析协议时,状态就是「等帧头第一个字节」「等帧头第二个字节」「等长度」「读负载」「等 CRC」,事件就是「来了一个字节」,动作就是「存起来」「校验」「交付」「丢弃」。
状态机的关键约束是:任何时刻只在一个状态里,每个状态对每种事件都有明确反应。没有「其他情况再说」,也没有「这里应该不会发生」。做不到这一点,就不是状态机,只是穿了状态机外衣的 if/else。
好处很直接。状态可以枚举,测试可以逐个覆盖;卡住时打印当前状态就知道停在哪;加字段只改相关状态,不影响其他分支。
举个反例:用 if/else 写解析,「长度超限」的检查往往散落在好几个分支里,加一个字段就要在每处补一遍;状态机把它收在 WAIT_LEN 一个地方,改一次就够。两者的差别不在代码长短,在「同一个规则有几份实现」。
解析状态怎么划
这套帧格式需要七个状态。帧头两个字节,所以「等帧头」拆成两步;长度、命令、负载、CRC 各一步。最后一个 CRC 字节收完,立刻做校验和交付,然后回到起点。
状态划分有两个原则。第一,每个状态只做一件事,状态里的代码不超过几行;第二,每个状态都必须有「异常出口」,比如长度超限、帧头不对、CRC 不符,都要明确回到哪个状态。
这里把 CRC 的两个字节合并成一个 WAIT_CRC 状态处理,收第一个字节记下来,收第二个字节一起算。也可以拆成两个状态,代价是多一个状态、多一条转移。状态粒度没有标准答案,按「一个状态内的动作是否原子」来定。
注意帧头第二个字节的处理。如果收到 0xAA,说明可能是新的帧头开始,应该留在 WAIT_H2 而不是退回 WAIT_H1;如果收到别的字节,才退回。这个细节不写清楚,连续两个 AA 就会漏掉一个可能的帧头。
错误、超时和统计
错误处理不是「出错了就清空」。状态机要区分几类错误,分别计数,分别决定退到哪。
长度超限。长度字段超过协议上限,说明这个帧头可能是假的。丢弃当前已收的字节,回到 WAIT_H1,并且不要按声明长度分配内存。
CRC 不符。这一帧确实收完了,但内容坏了。整帧丢弃,回到 WAIT_H1。丢弃的字节数要记下来,方便判断是链路问题还是协议问题。
半帧超时。状态停在中间,很久没有新字节。超时后调用一个 flush,把当前半帧清掉,回到起点。超时时间要大于正常帧传输时间,否则慢包会被误杀。
统计至少要有五个计数:收到多少字节、成功多少帧、CRC 错多少、长度错多少、丢弃多少字节。没有这些数字,现场只能看到「通信不稳」,没法判断问题在哪一层。
计数的口径要写死:丢弃到底算字节还是算帧、交付字节数含不含帧头。口径不清,两边的日志对不上,排查时只会更乱。
WAIT_H1 重新找帧头,本身就是恢复动作。真正需要单独错误状态的是「需要人工介入、不能自动恢复」的场景,比如设备被锁定。完整实现,真的跑起来
下面的 Parser 每次 feed 接受任意长度的字节片段,内部只用一个状态变量和一个 bytearray。它不依赖外部缓存,缓冲区只存当前这一帧,收完就清。
import struct
def crc16_modbus(data):
crc = 0xFFFF
for b in data:
crc ^= b
for _ in range(8):
crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
return crc
def build(cmd, payload):
body = bytes([len(payload), cmd]) + payload
return bytes([0xAA, 0x55]) + body + struct.pack(">H", crc16_modbus(body))
class Parser:
def __init__(self, max_payload=32):
self.state = "WAIT_H1"
self.max_payload = max_payload
self.frame = bytearray()
self.left = 0
self.stats = dict(bytes_in=0, frames_ok=0, bad_crc=0,
bad_len=0, discarded=0, bytes_out=0)
def flush(self):
if self.state != "WAIT_H1":
self.stats["discarded"] += 2 + len(self.frame)
self.frame = bytearray()
self.left = 0
self.state = "WAIT_H1"
def feed(self, chunk):
out = []
for b in chunk:
self.stats["bytes_in"] += 1
s = self.state
if s == "WAIT_H1":
if b == 0xAA:
self.state = "WAIT_H2"
else:
self.stats["discarded"] += 1
elif s == "WAIT_H2":
if b == 0x55:
self.frame = bytearray()
self.state = "WAIT_LEN"
elif b == 0xAA:
self.stats["discarded"] += 1
else:
self.state = "WAIT_H1"
self.stats["discarded"] += 1
elif s == "WAIT_LEN":
if b > self.max_payload:
self.stats["bad_len"] += 1
self.stats["discarded"] += 1
self.state = "WAIT_H1"
else:
self.frame.append(b)
self.left = b
self.state = "WAIT_CMD"
elif s == "WAIT_CMD":
self.frame.append(b)
self.state = "WAIT_CRC1" if self.left == 0 else "WAIT_PAYLOAD"
elif s == "WAIT_PAYLOAD":
self.frame.append(b)
self.left -= 1
if self.left == 0:
self.state = "WAIT_CRC1"
elif s == "WAIT_CRC1":
self.frame.append(b)
self.state = "WAIT_CRC2"
elif s == "WAIT_CRC2":
self.frame.append(b)
calc = crc16_modbus(bytes(self.frame[:-2]))
got = (self.frame[-2] << 8) | self.frame[-1]
if calc == got:
out.append((self.frame[1], bytes(self.frame[2:-2])))
self.stats["frames_ok"] += 1
self.stats["bytes_out"] += len(self.frame) + 2
else:
self.stats["bad_crc"] += 1
self.stats["discarded"] += len(self.frame)
self.state = "WAIT_H1"
else:
raise RuntimeError(self.state)
return out
good1 = build(0x01, b"\x01\x02\x03")
good2 = build(0x81, b"HELLO")
bad = bytearray(build(0x02, b"\x99"))
bad[-1] ^= 0xFF
stream = good1 + good2 + bytes(bad)
p = Parser()
out = []
for i in range(0, len(stream), 3):
out += p.feed(stream[i:i + 3])
print("frames:", [(hex(c), pl.hex()) for c, pl in out])
print("stats :", p.stats)
构造两帧正常数据,再加一帧故意改坏 CRC 的数据,总共 27 字节。按每片 3 字节喂进去,本机实际输出:
frames: [('0x1', '010203'), ('0x81', '48454c4c4f')]
stats : {'bytes_in': 27, 'frames_ok': 2, 'bad_crc': 1,
'bad_len': 0, 'discarded': 5, 'bytes_out': 20}
27 个字节里交付了两帧,坏 CRC 一帧,丢弃 5 个字节——正好是那帧去掉两个帧头之后的长度(长度 1 + 命令 1 + 负载 1 + CRC 2)。同一段数据改成一片一字节地喂,输出完全一致。这说明状态机的行为只取决于字节序列,不取决于读取的切分方式。
再看长度超限和半帧超时。喂 AA 55 FF 01 02,长度 255 超过上限(测试时把 max_payload 设成 16),状态机在 WAIT_LEN 就丢弃,不会进入读负载;半帧用例喂 AA 55 05 01 02,状态停在 WAIT_PAYLOAD,调用 flush 后丢弃 5 个字节,回到 WAIT_H1。
length over limit: frames: [] stats: {'bytes_in': 5, 'frames_ok': 0, 'bad_crc': 0, 'bad_len': 1, 'discarded': 3, 'bytes_out': 0}
before flush: WAIT_PAYLOAD {'bytes_in': 5, 'frames_ok': 0, 'bad_crc': 0, 'bad_len': 0, 'discarded': 0, 'bytes_out': 0}
after flush : WAIT_H1 {'bytes_in': 5, 'frames_ok': 0, 'bad_crc': 0, 'bad_len': 0, 'discarded': 5, 'bytes_out': 0}
这里的 discarded 有两种口径:长度超限时只算丢掉的那个长度字节,半帧 flush 时算上已经收到的帧头和半帧。工程上不必强求统一,但要在文档里写清楚每个计数代表什么,否则看日志的人会误判。
模糊测试:随机改字节,看它崩不崩
解析器最怕的不是正常数据,是畸形数据。构造畸形数据靠人想不全,交给随机变异更省事。做法是拿一段正常数据,随机改一到四个字节,再随机切片喂进去,跑上千轮,看有没有异常、有没有卡死。
import random
rng = random.Random(7)
base = good1 + good2 + bytes(bad)
p = Parser()
crashes = total_ok = 0
for _ in range(1500):
data = bytearray(base)
for _ in range(rng.randint(1, 4)):
data[rng.randrange(len(data))] = rng.randrange(256)
try:
for i in range(0, len(data), rng.randint(1, 7)):
total_ok += len(p.feed(data[i:i + rng.randint(1, 7)]))
except Exception:
crashes += 1
print("rounds=1500 crashes=%d frames_ok=%d" % (crashes, total_ok))
print("stats:", p.stats)
本机实际输出:
rounds=1500 crashes=0 frames_ok=61 bad_crc=2155 bad_len=800 discarded=49837
1500 轮里没有异常,说明状态机对随机字节流是健壮的;同时只解析出 61 帧,因为大部分变异把帧结构改坏了。这个结果符合预期:模糊测试的目标不是「解析出很多帧」,而是「无论输入什么都不要崩、不要卡、不要越界」。
随机种子要固定。固定种子才能复现同一批输入,出问题时能回放;如果每次换种子,崩溃了也不知道是哪一轮。种子和变异次数一起记进日志,比一句「偶发崩溃」有用得多。
注意这只是功能层面的健壮性。它不能证明真实链路不会因为电气干扰出错,也不能覆盖所有状态组合。模糊测试的价值在于把「人能想到的错」扩到「随机组合的错」,剩下的靠覆盖率分析和现场日志。
可测试性:三个必须能做的动作
状态机好用的前提是能测。下面三件事做不到,状态机就只是换了个写法的 if/else。
分片喂入。解析器的输入接口必须是「任意长度片段」,而不是「一整帧」。这样才能用 1 字节、3 字节、随机长度去测边界,也才能同时适配 TCP 和串口。
错帧注入。要能构造 CRC 错、长度错、帧头错、半帧截断的输入,逐个断言状态机的反应。断言不只看「有没有交付」,还要看「计数对不对」「回到哪个状态」。
边界值。长度 0、长度等于上限、长度比上限大 1、帧头正好在缓冲区末尾、CRC 只有一个字节,这些都是最容易出错的点。每个边界写一个用例,跑一次就覆盖了。
写测试时,状态机的状态是内部变量,不该直接暴露给业务代码。测试可以通过统计计数和交付结果来间接断言,也可以用「注入一个半帧后 flush,检查丢弃数」来验证恢复路径。
移植到 C 的要点
单片机上的写法和 Python 不一样,但状态划分可以原样搬过去。要点有五条。
状态用枚举,不用字符串。enum parser_state { WAIT_H1, WAIT_H2, WAIT_LEN, WAIT_CMD, WAIT_PAYLOAD, WAIT_CRC1, WAIT_CRC2 }; 编译期就能检查,比较也快。
缓冲固定大小。按协议最大帧长定义一个数组,加一个写位置和一个读位置,不做动态分配。收到的字节数超过数组长度就拒绝,绝不越界写。
CRC 用查表。把 256 项表放在 const 数组里,进 Flash 不进 RAM。表的生成用脚本离线做,运行时只查表。
表的生成最好放在构建阶段,不要每次上电算。生成脚本和标准测试向量一起提交,别人拿到代码能复算一遍;表错了,所有帧都会校验失败,但现象看起来像「设备不兼容」。
解析函数不阻塞。feed 只做状态转移和缓冲操作,不等待、不延时、不打日志。所有耗时动作交回主循环,避免中断里解析太久。
可重入和中断安全。如果 feed 在中断里调用,主循环读统计时要关中断或者用原子读;如果放主循环,中断只负责把字节塞进环形缓冲,解析和业务隔离。
这一节只讲结构,不在本机编译和运行 C 版本,也不给 C 的输出。真要上板,先拿 Python 版生成的标准帧和错帧做对照,再逐条核对 C 端的计数和状态。
四层结构:字节流、缓冲、状态机、应用
分层的意义是每层只关心自己的事。字节流层不管帧,状态机不管业务,应用层不管字节怎么拼。出了问题时,先看哪一层的计数异常:字节流层丢弃多,可能是链路;状态机 CRC 错多,可能是干扰或参数;应用层处理失败多,可能是命令语义。
很多项目把四层揉在一个函数里,短期省事,长期没法定位。分开以后,单元测试也能按层写:字节流用假数据,状态机用构造帧,应用层用假状态机。
日志也按层打。字节流层记每次读到的长度,状态机层记状态和计数,应用层记命令和执行结果。三层日志时间对齐,才能判断「是没收到、收到了没解析、还是解析了没执行」。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 错帧之后整段错位 | 丢弃后没有回到找帧头的状态 | 检查每个错误分支最后把状态设成了什么 |
| 只收到半帧,后面不动 | 缺少超时 flush,状态停在中间 | 看半帧有没有计时器和清理入口 |
| CRC 错帧被交付 | 校验分支写反,或没校验就 append | 确认 CRC 比较和交付的先后顺序 |
| 长度超限导致越界 | 按声明长度分配或写入,没有上限检查 | 看长度检查是否在写缓冲之前 |
| 状态机卡死 | 某个状态没有默认转移,或事件没覆盖 | 列出状态和事件的全部组合,找空洞 |
| 模糊测试崩溃 | 数组越界、除零、未初始化读取 | 用最小可复现输入定位,再补边界用例 |
| 统计数字对不上 | 丢弃计数口径不一致,或漏计 | 核对每个计数在哪些分支增加 |
边界与代价
状态机代码量更大。七个状态、每条转移几行,加起来比一版 if/else 长;但它的分支是显式的,改一个字段只动相关状态,长期维护成本更低。
缓冲有上限。固定数组省内存、可预测,但超过上限的帧只能丢。上限要按协议最大帧长设,不能为了「以后可能变大」留一个巨大的数组,把 RAM 吃光。
错误恢复策略要选。CRC 错就丢整帧,还是保留部分数据?长度错就回到起点,还是前进一个字节?不同选择影响丢帧率和恢复速度,没有统一答案,要写进文档并测试。
模糊测试覆盖有限。随机变异能发现崩溃和越界,但发现不了「语义错误」,比如命令解析对了、业务处理错了。它也不能替代真实链路测试,电气层的丢位、毛刺、共模干扰,只有上板才看得到。
最后,状态机解决的是「字节怎么变成帧」,不解决「帧为什么错」。CRC 错多,要回头查线缆、波特率、电平;重传多,要查链路延迟和超时。协议层和物理层是两件事,别在一个地方找所有答案。
恢复策略最好写成一张表:哪种错误、丢弃多少字节、回到哪个状态、计数加在哪个字段。写不出这张表,说明状态机还有分支没想清楚,测试也覆盖不到。
今天就能验证的五个练习
- 把文章里的
Parser原样敲进一个文件,跑三帧数据,确认输出是两帧交付、一帧坏 CRC。 - 把帧头从
AA 55改成55 AA,只改状态机里两个比较,看测试用例哪些会失败,体会「帧头写死」的耦合。 - 注入一个 CRC 故意错的帧,确认它被计数、被丢弃,且下一帧仍能正常交付。
- 把分片大小改成 1 字节,再改成 7 字节,确认输出帧数不变,统计不变。
- 给状态机加一个「当前状态」输出,喂半帧后打印它停在哪个状态,再调用
flush看是否回到WAIT_H1。
收束:协议组到这里,硬件才刚开头
这一组七篇,从帧的边界讲到长度和转义,再到校验、粘包、重传、总线,最后落到一个能跑的状态机。它们解决的是同一类问题:怎么让两端对「现在读到哪、这一帧是什么、该不该信」达成一致。
放到硬件方向整体看,这只是四组里的一组。芯片组讲算力和架构,存储组讲数据和持久化,嵌入式组讲外设和寄存器,协议组讲设备之间怎么说话。四组不是并列的知识点,而是同一个系统的四层:芯片跑程序,存储留数据,外设接世界,协议让设备和设备连起来。
如果是从这一组进来的,建议接着看芯片组的第一篇:CPU、GPU、NPU、MPU 到底差在哪。先把「算力从哪来」搞清楚,再回头看协议,会更容易明白为什么一个小小的帧头能影响整个系统的稳定性。