前面六篇的代码,如果真拿去用,第一版很可能会变成这样:一个函数里五六个 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 字节收完,立刻做校验和交付,然后回到起点。

一帧的解析路径
WAIT_H1等 0xAA,不是就丢掉
WAIT_H2等 0x55,不是就回退
WAIT_LEN读长度,超限就丢弃
WAIT_CMD读命令字节
WAIT_PAYLOAD按长度收负载
WAIT_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 端的计数和状态。

四层结构:字节流、缓冲、状态机、应用

应用层处理命令、更新业务状态、决定回什么
状态机识别帧、校验、计数、丢弃错帧
接收缓冲按最大帧长分配,处理半帧和分片
字节流TCP 或串口,一次读到的长度不固定

分层的意义是每层只关心自己的事。字节流层不管帧,状态机不管业务,应用层不管字节怎么拼。出了问题时,先看哪一层的计数异常:字节流层丢弃多,可能是链路;状态机 CRC 错多,可能是干扰或参数;应用层处理失败多,可能是命令语义。

很多项目把四层揉在一个函数里,短期省事,长期没法定位。分开以后,单元测试也能按层写:字节流用假数据,状态机用构造帧,应用层用假状态机。

日志也按层打。字节流层记每次读到的长度,状态机层记状态和计数,应用层记命令和执行结果。三层日志时间对齐,才能判断「是没收到、收到了没解析、还是解析了没执行」。

出问题时先看哪里

现象真实原因第一步查什么
错帧之后整段错位丢弃后没有回到找帧头的状态检查每个错误分支最后把状态设成了什么
只收到半帧,后面不动缺少超时 flush,状态停在中间看半帧有没有计时器和清理入口
CRC 错帧被交付校验分支写反,或没校验就 append确认 CRC 比较和交付的先后顺序
长度超限导致越界按声明长度分配或写入,没有上限检查看长度检查是否在写缓冲之前
状态机卡死某个状态没有默认转移,或事件没覆盖列出状态和事件的全部组合,找空洞
模糊测试崩溃数组越界、除零、未初始化读取用最小可复现输入定位,再补边界用例
统计数字对不上丢弃计数口径不一致,或漏计核对每个计数在哪些分支增加

边界与代价

状态机代码量更大。七个状态、每条转移几行,加起来比一版 if/else 长;但它的分支是显式的,改一个字段只动相关状态,长期维护成本更低。

缓冲有上限。固定数组省内存、可预测,但超过上限的帧只能丢。上限要按协议最大帧长设,不能为了「以后可能变大」留一个巨大的数组,把 RAM 吃光。

错误恢复策略要选。CRC 错就丢整帧,还是保留部分数据?长度错就回到起点,还是前进一个字节?不同选择影响丢帧率和恢复速度,没有统一答案,要写进文档并测试。

模糊测试覆盖有限。随机变异能发现崩溃和越界,但发现不了「语义错误」,比如命令解析对了、业务处理错了。它也不能替代真实链路测试,电气层的丢位、毛刺、共模干扰,只有上板才看得到。

最后,状态机解决的是「字节怎么变成帧」,不解决「帧为什么错」。CRC 错多,要回头查线缆、波特率、电平;重传多,要查链路延迟和超时。协议层和物理层是两件事,别在一个地方找所有答案。

恢复策略最好写成一张表:哪种错误、丢弃多少字节、回到哪个状态、计数加在哪个字段。写不出这张表,说明状态机还有分支没想清楚,测试也覆盖不到。

今天就能验证的五个练习

  1. 把文章里的 Parser 原样敲进一个文件,跑三帧数据,确认输出是两帧交付、一帧坏 CRC。
  2. 把帧头从 AA 55 改成 55 AA,只改状态机里两个比较,看测试用例哪些会失败,体会「帧头写死」的耦合。
  3. 注入一个 CRC 故意错的帧,确认它被计数、被丢弃,且下一帧仍能正常交付。
  4. 把分片大小改成 1 字节,再改成 7 字节,确认输出帧数不变,统计不变。
  5. 给状态机加一个「当前状态」输出,喂半帧后打印它停在哪个状态,再调用 flush 看是否回到 WAIT_H1。

收束:协议组到这里,硬件才刚开头

这一组七篇,从帧的边界讲到长度和转义,再到校验、粘包、重传、总线,最后落到一个能跑的状态机。它们解决的是同一类问题:怎么让两端对「现在读到哪、这一帧是什么、该不该信」达成一致。

放到硬件方向整体看,这只是四组里的一组。芯片组讲算力和架构,存储组讲数据和持久化,嵌入式组讲外设和寄存器,协议组讲设备之间怎么说话。四组不是并列的知识点,而是同一个系统的四层:芯片跑程序,存储留数据,外设接世界,协议让设备和设备连起来。

如果是从这一组进来的,建议接着看芯片组的第一篇:CPU、GPU、NPU、MPU 到底差在哪。先把「算力从哪来」搞清楚,再回头看协议,会更容易明白为什么一个小小的帧头能影响整个系统的稳定性。