几年前调一台称重仪表,串口调试助手的窗口里刷出一行十六进制:00 FF 13 37 AA 55 03 01 01 02 03 71 5D ...。同事问我「从哪个字节开始解析」,我说第三个字节往后吧,看着像数据。结果换了一台设备,前面少了两个字节,整段解析全错。

后来写了个固定规则:找到 AA 55 就当帧头,往后数固定九个字节切一帧。这个规则跑了两个月没出事,直到某天设备重启,上一帧的尾巴里正好有一个 0xAA,接收端把它和紧随其后的 0x55 拼成了假帧头。后面十几分钟的数据全在错误的位置上切,日志里全是「校验失败」。

问题不在代码写得烂,在于协议从设计时就没把「一帧从哪里开始、到哪里结束」说清楚。帧头、帧尾这两个词大家都听过,但它们值多少字节、会不会在数据里重复出现、长度字段算不算帧头,这些细节没定下来,接收端就只能靠猜。

这篇先把帧拆开讲清楚,再给一个具体格式,然后用 Python 真跑一个解析器——输入里故意塞垃圾字节和假帧头,看它怎么重新对齐。代码在本机 Python 3.15.0 上跑过,输出原样贴出来;串口波形和电平未在本机实测,文中只谈字节层的逻辑。

帧是什么:一次完整消息的字节结构

帧(frame)就是「一次完整消息」在链路上的字节表示。你说一句「读传感器 1 的当前值」,这句话在线上不是一个字符串,而是一串有固定排列的字节。接收端必须能判断:这串字节从哪里开始、到哪里结束、中间每一段是什么。

常见的帧由六类字段拼成:

  • 帧头。一段固定的特征字节,用来告诉接收端「从这里开始是一帧」。长度不固定,常见一到四字节。
  • 帧尾。一段固定的结束标记。有的协议有,有的没有,靠长度字段收尾。
  • 魔数。就是那个固定的特征字节本身,比如 0xAA55。叫魔数是因为它没有业务含义,只负责「认出自己」。
  • 长度字段。明确写出后面还有多少字节。它把「到哪里结束」变成一道算术题。
  • 负载。真正要传的业务数据,命令码、参数、采样值都在这里。
  • 校验。CRC、累加和或异或值,用来判断这一帧在传输中有没有坏。

这六类字段不是每篇协议都必须齐全。短命令可以没有长度字段,固定长度的帧可以没有帧尾,但「接收端怎么知道边界」这件事必须有答案。没有答案的协议,等于把同步问题推给下一个人。

还有一个容易被忽略的点:帧里的每个字节都该有明确的归属。多留一个「保留字节」却不说怎么填,接收端就只能跳过它;跳过就意味着少一层校验,将来出问题也查不到。

为什么光有帧尾不够

很多人第一反应是「用帧尾定界最简单」:发一帧数据,末尾加一个 0x0D 或 0x7E,接收端读到这个字节就认为一帧结束。单看逻辑没错,问题出在负载里也可能出现同一个字节。

假设帧尾是 0x7E,传感器返回的原始数据里正好有一段 ... 0x7E ...。接收端读到它,提前把帧截断了,后面的字节被当成下一帧的开头。于是出现两种症状:要么解析出一段缺尾巴的数据,要么整段错位,之后每一帧都对不上。这不是「偶发」,只要数据分布够广,早晚会遇到。

帧头也有同样的问题,只是概率不同。两字节帧头 AA 55 在随机数据里出现的概率是 1/65536,听起来很小,但一秒钟几十帧、跑上几天,总会撞上。更麻烦的是,撞上之后接收端不会报错,它只会安静地解析出一个校验失败的假帧,然后继续往后错。

所以「帧头 + 帧尾」不是一套完整方案,它只是「边界标记」。要让边界真正可靠,还得配三样东西之一:转义、长度字段,或者「校验失败就重新同步」的规则。前者保证特殊字节不会出现在负载里,中者让结束位置可以算出来,后者承认会认错、但能退回去。

帧头越长越不容易误判,但每帧都要多传几个字节。两字节帧头在 9600 波特率下大约多花两毫秒,短命令频繁发送时这笔开销并不小。帧头长度是可靠性和吞吐之间的交换,不存在「越长越好」。

一个能落地的帧格式

下面这套格式在工业小设备里很常见,够简单,也够把边界说清楚:

AA 55 | LEN | CMD | PAYLOAD | CRC16 的字段顺序
AA 55两字节帧头,固定魔数,用来找起点
LEN一字节,只算 PAYLOAD 的字节数,最大 255
CMD一字节命令码,说明这帧要干什么
PAYLOAD0 到 255 字节业务数据
CRC16两字节校验,覆盖 LEN、CMD、PAYLOAD

几个决定要写死在文档里,不能靠默契。第一,LEN 只算负载,不含帧头、命令和校验;第二,CRC16 从 LEN 开始算,不覆盖帧头;第三,CRC 的两个字节按小端排列。这三条只要有任意一条双方理解不一致,接收端就会一直校验失败,而单看代码又看不出问题。

为什么校验不覆盖帧头?因为帧头是用来找起点的,找到之后它的值已经确定,再校验一遍只是多花时间。为什么长度不含帧头?因为发送方在拼帧时通常先填业务数据,再回头补长度;让长度只描述业务数据,代码里少一次加减,出错机会也少。

一帧最短是 6 字节(空负载),最长 261 字节(255 字节负载)。这两个数字要写进文档,接收端的缓冲区大小、最大帧长保护都按它来定。

写个解析器,让它自己找帧

下面这段代码构造了一段「垃圾字节 + 正常帧 + 假帧头 + 正常帧」的数据流,然后从任意位置开始扫描。它不假设数据从帧头开始,而是逐字节找 AA 55,找到后按长度取帧,再校验。

import struct

HEADER = b"\xAA\x55"

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 HEADER + body + struct.pack("<H", crc16_modbus(body))

garbage = b"\x00\xFF\x13\x37"
f1 = build(0x01, b"\x01\x02\x03")
fake = b"\xAA\x55\x00\x99"
f2 = build(0x81, b"HELLO")
stream = garbage + f1 + fake + b"\xDE\xAD" + f2

i = 0
skipped = 0
while i < len(stream) - 1:
    if stream[i:i + 2] != HEADER:
        i += 1
        skipped += 1
        continue
    ln = stream[i + 2]
    end = i + 6 + ln
    if end > len(stream):
        print("half frame at", i)
        break
    cmd = stream[i + 3]
    payload = stream[i + 4:i + 4 + ln]
    got = struct.unpack("<H", stream[i + 4 + ln:end])[0]
    calc = crc16_modbus(bytes([ln, cmd]) + payload)
    if got == calc:
        print("offset %2d: cmd=0x%02X payload=%s OK" % (i, cmd, payload.hex()))
        i = end
    else:
        print("offset %2d: crc %04X != %04X, resync" % (i, got, calc))
        i += 1
        skipped += 1

print("skipped bytes:", skipped)

本机实际运行输出:

raw stream (30 bytes):
00 FF 13 37 AA 55 03 01 01 02 03 71 5D AA 55 00 99 DE AD AA 55 05 81 48 45 4C 4C 4F 11 F0
frame1 = AA 55 03 01 01 02 03 71 5D
frame2 = AA 55 05 81 48 45 4C 4C 4F 11 F0

offset  4: cmd=0x01 payload=010203     crc=5D71/calc=5D71 -> OK
           accept, jump to offset 13
offset 13: cmd=0x99 payload=           crc=ADDE/calc=DAC1 -> BAD
           drop, resync from offset 14
offset 19: cmd=0x81 payload=48454c4c4f crc=F011/calc=F011 -> OK
           accept, jump to offset 30

skipped bytes: 10

这段输出里有两个值得看的点。第一个是假帧头:偏移 13 处确实有 AA 55,长度字段读出来是 0,命令是 0x99,CRC 却对不上。解析器没有把这段当数据交付,而是往前挪一个字节继续找。第二个是被丢弃的 10 个字节:开头 4 个垃圾、假帧头 1 个、中间的 DE AD 2 个,再加重新对齐时跳过的几个字节。

注意它没有「清空缓冲区重来」。清空会把假帧头后面那个真帧一起扔掉,下一次还得等新数据。正确的做法是只前进一个字节,让后面可能存在的真帧头重新暴露出来。这个细节决定了丢一帧还是丢一段。

不要用「找到第一个帧头就固定按 N 字节切」的写法。只要有一帧长度不对,后面所有帧的起点都会错,而且错得很安静——校验会一直失败,但你可能以为是设备坏了。

长度定界和帧尾定界怎么选

把边界说清楚,主流就两条路:用长度字段算结束位置,或者用帧尾标记结束位置。它们不是先进与落后的关系,是两种不同的代价。

长度字段定界

帧头之后紧跟长度,接收端一读到长度就知道该收多少字节。优点是解析快、不需要逐字节比较、负载里出现任何值都不影响边界。代价是长度字段本身可能错:错一个字节,整帧的起止位置全偏;长度字段还要防越界,收到 255 却只来了 3 个字节时不能直接分配缓冲区。

帧尾定界

发一帧,末尾放一个特殊字节。优点是实现直观,抓包时肉眼也能看出分界。代价是负载里不能出现这个字节,必须配合转义;转义会让数据变长,收发两端都要多一层编码解码,漏掉一个字节就整段错位。

怎么选?如果负载是二进制采样值、长度变化大,优先长度字段,它不关心数据内容。如果负载是短文本、可读性重要,帧尾加转义也行,调试时一眼能看懂。两者也可以一起用:长度字段定界,帧尾只作为额外的可读标记,但这时帧尾不能参与边界判断,否则等于把两套规则混在一起。

还有一个现实约束:长度字段占几个字节。一字节最多 255,对大多数传感器够用;两字节可以到 65535,但每帧多花一个字节;四字节通常是给文件传输或大数据块准备的。字段越宽,越要防「声明长度超过实际缓存」。

同步丢了以后怎么重新对齐

同步(synchronization)在这里指接收端和发送端对「当前读到第几个字节」达成一致。链路只要丢过一个字节,或者设备重启时缓冲里残留了半帧,同步就断了。重新对齐不是可选项,是协议必须写进文档的行为。

可以按下面四条落地,顺序不要乱:

第一,只在帧头处开始解析。缓冲区里找不到帧头,就丢弃最早的字节,直到找到为止;不要从中间随便挑一个位置开始按固定长度切。

第二,帧头之后先读长度。长度字段本身不可信,所以先检查它是否超过协议上限。超了就当这个帧头是假的,前进一个字节继续找。

第三,数据不够就等,不要报错。收到半帧是正常现象,链路是字节流,不可能保证一次读到的正好是一帧。等到够长再校验,等不到就等下一次读。

第四,校验失败只前进一个字节。前进一个字节的代价是多扫几次,但它保证不会跳过藏在假帧头后面的真帧头。清空整个缓冲区看似干脆,实际会把好数据一起扔掉。

这四条合起来,本质是一个「悲观假设」:默认链路上任何位置都可能有垃圾,默认任何帧头都可能是假的,默认任何长度都可能错。只有校验通过的那一帧才值得相信。

出问题时先看哪里

现象真实原因第一步查什么
不知道从哪一字节开始解析协议没定义帧头,或帧头被前面的垃圾字节冲掉抓一段原始字节,确认帧头的具体值和长度,再从第一个完整帧头开始对齐
帧尾出现在负载里,帧被提前截断用帧尾定界但没有转义看被截断那帧的负载里有没有和帧尾相同的字节
帧头在数据里重复出现帧头太短,负载里恰好有同样的字节组合统计一段日志里假帧头的出现频率,再决定加长帧头还是加长度字段
长度字段读错,整帧错位长度含义没约定清楚(是否含帧头、含不含校验)对照收发两端的打包代码,确认长度从哪一字节算到哪一字节
设备重启后第一帧丢失重启前缓冲区里残留半帧,重启后被当成新数据看接收端有没有在超时或端口重连时清空缓冲
一次读到两帧,只解析了第一帧代码假设「一次读到的就是一帧」检查读取循环有没有把剩余字节留在缓冲区里继续解析
校验一直失败但数据看着对CRC 覆盖范围或字节序和发送端不一致用同一段已知数据在两端各算一次 CRC,比对中间值

边界与代价

帧头越长越可靠,这是直觉,但代价是每帧的固定开销。两字节帧头加一字节长度加两字节校验,固定开销就是 5 字节。如果一帧只传 4 字节数据,开销比数据还大。短命令密集的系统里,这个比例直接决定链路能跑多快。

长度字段能定界,但它自己也会错。错一个字节,接收端可能把后面三帧当成一帧,也可能把一帧切成两半。防它的办法不是「相信长度」,而是「长度加上限、超限就当假帧头」,再用校验兜底。

帧尾可读性好,抓包时一眼能看出边界,但它要求负载里不能出现同一个字节。转义解决了这个问题,代价是数据膨胀和编解码复杂度;一个转义字节漏处理,后面整段都错。文本协议里这点膨胀无所谓,高频采样数据里就要算带宽。

同步策略不能假设链路干净。实验室里USB转串口短线、设备一直在线,可能几个月都不出问题;到了现场,长线、干扰、热插拔、设备重启,任何一样都会让字节流出现垃圾。协议要在设计时就承认这件事,而不是等现场出问题再补。

最后一条代价是调试成本。帧头、长度、校验都加上以后,一帧出错可能是四个环节中的任意一个。所以协议文档里要写清楚每个字段的含义和覆盖范围,最好再配一段固定的示例帧。没有示例帧的协议,两个人理解不一致的概率很高。

不要把「校验通过」当成「数据正确」。CRC 只能发现它覆盖范围内的比特错误,覆盖范围之外、或者协议字段语义理解错了,校验照样通过。第 3 篇会专门算这件事。

今天就能验证的五个练习

  1. 拿你手上一条真实的串口消息,把每个字节画成字段,标出帧头、长度、命令、负载、校验,写清长度算不算帧头。画不出来,说明协议还没定清楚。
  2. 用上面那段 Python 解析器,把 stream 换成你自己抓的一段带垃圾字节的数据,看它跳过多少字节、在哪重新对齐。
  3. 故意把某一帧的长度字段改大 1,再跑一次,观察它是报半帧、还是把下一帧的开头吃进来。
  4. 算一下你的协议里固定开销占比:帧头加长度加校验的字节数,除以整帧字节数。超过三成就要考虑是不是帧头太长。
  5. 写一条重新同步规则,明确「校验失败后前进几个字节」「缓冲区最大多少」「超时多久清空」,然后拿假帧头数据测一遍。

小结

帧是一串有结构的字节,帧头负责找起点,长度字段负责算终点,校验负责判断这一帧值不值得信。帧尾能用,但不能单用;帧头能找,但不能假设它只出现一次。同步丢了以后,正确动作是前进一字节重新找,而不是清空重来。

下一篇讲长度字段与转义。这一篇里长度字段只说了「要防越界」,还没说变长数据到底怎么排、转义具体怎么做、0x7E 出现在负载里时编码器要插入什么字节。那些细节才是协议真正落地的地方。