有个做环境监测的项目,协议定得很简单:帧尾是 0x7E,接收端读到它就算一帧结束,数据原样往上传。跑了半年都正常,直到换了一款传感器。新传感器的采样值里出现了 0x7E,接收端读到这个字节就提前截断,把前半段当成完整帧交上去,后半段留在缓冲区里等下一个帧尾。

现象很迷惑:有时数据正常,有时数值跳变,有时整段日志错位。因为 0x7E 不是每帧都有,可能几十帧才出现一次,测试时根本抓不到。现场的人一度以为是传感器坏了,换了两台,问题照旧。

根因是协议用了「特殊字节定界」,却没规定「特殊字节出现在数据里怎么办」。这类问题只有两个正解:要么别用长度之外的标记定界,要么在发送前把特殊字节换掉,到接收端再换回来。前者是长度字段,后者叫转义。

这篇把长度字段和转义拆开讲,再用 Python 真跑一遍编码和解码。代码在本机 Python 3.15.0 上执行,输出原样贴出;真实串口上的波形、时序未在本机实测,文中只讨论字节层。

定长、变长,和它们各自的麻烦

定长帧是最省心的设计:每一帧都是固定字节数,接收端数够了就切。比如每帧固定 12 字节,读到 12 字节就解析,不需要长度字段,也不需要帧尾。实现简单,解析快,缓冲区大小固定。

麻烦在于它不灵活。今天传三个采样值,明天要加一个温度补偿系数,帧长就变了;一改长度,收发两端的代码、文档、测试全要跟着改。如果只传一种固定格式的数据,定长没问题;只要业务会长,定长迟早要动刀。

变长帧就得回答「这一帧有多长」。常见做法是加长度字段(length field),也就是在帧头后面明确写出后面跟多少字节。接收端读到长度,就知道还差多少,凑齐再解析。

定长和变长不是二选一。很多协议是「帧头 + 长度 + 固定部分 + 可变部分」,固定部分永远在,可变部分靠长度描述。这样既保留了结构稳定,又能扩展。

定长帧还有一个隐藏前提:接收端得知道从哪里开始数。链路中间只要丢了一个字节,后面每 12 字节切一刀都会切在错误的位置。所以定长帧通常也要配帧头,靠帧头重新对齐,而不是靠「第几个字节」。

判断该用哪种,可以先问三个问题:帧长会不会变、负载里会不会出现定界字节、对端有多少内存和 CPU。三个答案基本能定方向,剩下的才是细节。

长度字段的五个约定

长度字段看起来只是一个数字,实际有五个细节必须写死在文档里。任何一条含糊,接收端都可能算错边界。

第一,占几个字节。一字节最大 255,适合传感器短帧;两字节最大 65535,适合稍大的数据块;四字节通常给文件或大包。字段越宽,帧头开销越大,越界检查也越重要。

第二,算到哪为止。长度只算负载,还是把命令、校验也算进去?这两种写法都常见,但必须和发送端完全一致。文档里最好写一句「LEN 等于从 CMD 之后到 CRC 之前的字节数」,别只写「长度」两个字。

第三,大端还是小端。两字节长度 0x0005 按大端写是 00 05,按小端写是 05 00。接收端如果按反的顺序读,得到的是 1280,不是 5。这个错误不会报语法错,只会让边界离谱。

第四,上限是多少。协议要规定最大帧长,接收端据此分配缓冲、拒绝超限。没有上限的话,一个假的长度字段就能让程序去申请巨大内存,或者一直等一个永远凑不齐的帧。

第五,空负载怎么表示。长度 0 是合法值还是错误?心跳、查询这类命令可能真的没有负载,必须允许 0,并且让解析器正常交付空帧。

把这几条写进文档时,最好再附一帧真实示例。比如负载 3 字节时整帧是 AA 55 03 01 01 02 03 71 5D,接收端可以拿它对一遍自己的解析结果。示例帧比十句描述管用,两个人对着同一串字节,歧义会少很多。

还要分清「声明长度」和「实际收到字节数」。长度字段说的是发送方打算发多少,实际收到多少由链路决定。解析器要同时检查这两个数:声明的不能超过协议上限,实际的不能少于声明值。只信其中一个,都会在异常帧上出错。

长度字段放在帧头之后、命令之前,是最常见的位置。好处是接收端一找到帧头就能知道要收多少;坏处是长度字段本身坏了会立刻误导边界。放在帧尾也能定界,但接收端必须先收完才知道长度,等于没有提前量,一般不这么做。

转义:把特殊字节藏起来

转义(escaping)的思路很直白:既然负载里可能出现和帧尾相同的字节,那就在发送前把它换成一个不会冲突的序列,接收端收到后再换回来。

经典做法来自 SLIP 和 PPP:用 0x7E 当帧边界,用 0x7D 当转义符。负载里每遇到一个 0x7E,就写成 0x7D 0x5E;每遇到一个 0x7D,就写成 0x7D 0x5D。这里的 0x5E 是 0x7E 异或 0x20,0x5D 是 0x7D 异或 0x20。接收端看到 0x7D,就把下一个字节异或 0x20 还原。

转义在收发两端做的事
原始负载10 7E 20 7D 30,里面混着两个特殊字节
扫描逐字节检查是不是 7E 或 7D
插入转义7E 变 7D 5E,7D 变 7D 5D
加边界首尾各放一个 7E 作为帧标志
接收端还原见到 7D 就取下一字节异或 20

为什么用异或 0x20,而不是随便换成一个别的字节?因为异或 0x20 只翻转第六位,能保证结果不会又是 0x7E 或 0x7D,同时离原值不远,肉眼看日志时还能猜出原字节。这是一个工程上的小技巧,不是数学要求。

转义不是免费的。一个负载字节可能变成两个,最坏情况下整帧膨胀一倍;收发两端都要多一次扫描,接收端还要处理「转义符出现在帧尾」这种残缺情况。它对带宽和处理时间都有成本,在 9600 波特率、每秒几十帧的系统里,这笔账要算。

转义的范围也要约定。只转义负载,还是命令、参数、地址都转义?稳妥做法是「两个帧标志之间、除帧标志外的所有字节都参与转义」,这样以后新增字段时不会漏。反过来,如果只转义负载,将来某个控制字段出现 0x7E,同样会破帧。

接收端还原时还要处理残缺:最后一个字节是 0x7D,后面没有可还原的字节,说明这帧坏了,直接丢弃。不能把它当普通数据处理,否则会把下一帧的帧标志吃进来,错误继续往后传。

用 Python 真跑一遍

先看转义。下面这段代码实现 escape 和 unescape,输入一段同时包含 0x7E 和 0x7D 的负载:

FLAG = 0x7E
ESC = 0x7D

def escape(data):
    out = bytearray()
    for b in data:
        if b in (FLAG, ESC):
            out += bytes([ESC, b ^ 0x20])
        else:
            out.append(b)
    return bytes(out)

def unescape(data):
    out = bytearray()
    i = 0
    while i < len(data):
        if data[i] == ESC:
            i += 1
            out.append(data[i] ^ 0x20)
        else:
            out.append(data[i])
        i += 1
    return bytes(out)

payload = bytes([0x10, 0x7E, 0x20, 0x7D, 0x30])
print("escaped:", escape(payload).hex(" "))
print("back   :", unescape(escape(payload)).hex(" "))

本机实际输出:

payload        : 10 7E 20 7D 30 (5 bytes)
escaped payload: 10 7D 5E 20 7D 5D 30 (7 bytes)
expansion      : 40.0%
frame          : 7E 10 7D 5E 20 7D 5D 30 7E
unescape back  : 10 7E 20 7D 30 == 107e207d30

no escaping      : 7E 10 7E 20 7D 30 7E
split on 7E      -> [[], ['10'], ['20', '7D', '30'], []]
receiver got     -> 10 (truncated)
lost tail        -> 20 7D 30

五个字节的负载里有两个特殊字节,编码后变成七个,膨胀 40%。如果不转义,接收端按 0x7E 切分,只拿到 10 一个字节,后面的 20 7D 30 被当成下一帧的内容。这就是开头那个现场问题的缩小版。

再看长度字段。同样的负载,改用两字节大端长度 + 负载 + 两字节校验:

import struct

def pack(payload):
    body = struct.pack(">H", len(payload)) + payload
    return body + struct.pack(">H", crc16_modbus(body))

def unpack(data):
    n = struct.unpack(">H", data[:2])[0]
    if n > len(data) - 4:
        return "REJECT: declared length exceeds received bytes"
    body = data[:2 + n]
    got = struct.unpack(">H", data[2 + n:4 + n])[0]
    if got != crc16_modbus(body):
        return "REJECT: crc mismatch"
    return "OK: " + body[2:].hex()

本机实际输出:

packed   : 00 05 10 7E 20 7D 30 30 E2
  len field = 5, data length = 9
unpack   : OK: 107e207d30
  len field = 0, data length = 4
empty    : OK: 
little-endian copy: 05 00 10 7E 20 7D 30 65 DD
  len field = 1280, data length = 9
unpack   : REJECT: declared length exceeds received bytes

最后两行是关键:同一段数据,长度字段按小端写成 05 00,按大端解析出来是 1280。接收端没有拿到「长度字段字节序不对」这种明确报错,它只知道「声明长度超过收到的字节数」,于是拒收。现场表现就是「每一帧都丢」,查起来很容易怀疑设备。

长度字段和转义都不解决「长度字段本身错了」的问题。前者会用错误的长度切帧,后者只保护特殊字节。真要兜底,还得靠校验,而且校验覆盖范围要把长度字段包含进去。

两种定界方式怎么选

长度字段

适合二进制负载、长度变化大、帧率高的场景。接收端读到长度就能预分配,不需要逐字节找帧尾。代价是字段本身的字节序、含义、上限要约定死,长度错了边界就错;实现上还要防越界,不能拿一个未经检查的长度去分配内存。

转义 + 帧尾

适合短文本、以可读性优先的协议,抓包时能直接看出帧边界。代价是负载膨胀,最坏翻倍;收发两端都要做编码解码;漏处理一个转义字节,后面整段错位。它不依赖长度字段,所以不会被一个假长度带偏。

如果帧长变化很大,长度字段更省事;如果帧都很短、又希望日志可读,转义加帧尾更直观。两者也能组合:长度字段负责定界,转义只用来保护帧尾这类特殊标记。组合会增加实现复杂度,除非确实需要,不然选一种就够。

还有第三种常见做法:命令定长、数据变长。查询类命令固定 4 字节,回复带长度字段。这样短命令没有长度开销,长数据又能扩展。选型不必一刀切,按消息类型分开设计更实际,前提是每种类型都有明确的识别方式。

判断依据可以简化成一句:如果接收端需要在「收到第一个字节」时就决定收多少,用长度字段;如果它愿意一直读到特殊标记,用转义。前者适合流式处理,后者适合调试友好。

还有一个实际因素:接收端是谁。如果对端是资源很小的单片机,转义要多一次全帧扫描,长度字段只读两个字节,后者更省 CPU。如果对端是 PC 上的脚本,两种都无所谓,选可读性好的那种。

如果长度字段和转义一起用,还要约定长度算编码前还是编码后。算编码前,接收端得先收集、再解码、再按长度校验;算编码后,接收端不解码就能定界。两种都成立,混用就会一直对不上,而且日志里看不出是谁算错了。

出问题时先看哪里

现象真实原因第一步查什么
数据里出现帧尾,帧被提前截断用帧尾定界但没有转义把原始字节和帧尾值比对,看负载第几个字节和它相同
转义后帧变长,缓冲不够用按原始长度分配的缓冲区没算转义开销按最坏情况(每个字节都要转义)预留空间,或先算编码后长度
长度字段字节序搞反发送端按大端写,接收端按小端读用一段已知长度 5 的帧,看解析出来的长度是 5 还是 1280
长度字段溢出,收到巨大数字字段位宽不够,或负数被当成无符号检查长度上限和字段类型,确认没有回绕
空负载的帧被当成错误解析器把长度 0 当成非法值看长度校验是不是写成了「必须大于 0」
转义漏掉一个字节,后半段全错编码时只处理了帧尾,没处理转义符本身检查 0x7D 是否也被转义,解码时是否处理连续转义
长度字段对,但校验总失败校验覆盖范围和发送端不一致确认 CRC 是否包含长度字段,两端用同一段数据各算一次

边界与代价

转义会增加带宽和处理时间。最坏情况每个字节都要转义,长度翻倍;平均情况取决于数据里特殊字节的比例。文本协议里 0x7E 几乎不出现,膨胀接近零;二进制采样值分布均匀,比例就接近 2/256。设计时要按最坏情况留缓冲,按平均情况算带宽。

长度字段要防越界,还要防「声明长度和实际数据不一致」。前者是安全边界,收到超限长度必须拒收;后者是协议边界,长度对了但内容不够,只能等或者按超时丢弃。两种都要有明确行为,不能靠「应该不会发生」。

校验覆盖范围也要跟着定。长度字段如果参与校验,它出错时多半能被发现;如果不参与,长度错一个字节,校验照样可能通过。大多数方案会把长度包进 CRC,代价只是多算一个字节。

定长简单但浪费。一帧固定 64 字节,实际只传 5 字节,剩下 59 字节的带宽就白花了。短帧高频的系统里,这个浪费会直接限制刷新率。

在小单片机上,转义的扫描成本不能忽略。9600 波特率下一帧 20 字节,解码多做几十次比较,对 8 位机是可观的负担;帧率再高,CPU 会被吃满。长度字段只多两次字节读取,代价小得多。

缓冲区的账也要算。转义最坏膨胀一倍,接收缓冲要按两倍预留;长度字段要按协议上限预留,但在真正收到数据之前,不能按声明长度去分配内存。

协议设计还要考虑未来字段。今天只有采样值,明天要加时间戳、状态位、设备编号,长度字段和帧结构能不能容纳?常见做法是留一个版本号或类型字段,新字段追加在负载末尾,老接收端按长度跳过不认识的尾巴。这样升级时不用改帧头。

最后,转义和长度字段都不是「可靠性机制」。它们只负责把边界说清楚,不负责发现内容错误。内容错不错,仍然要靠校验,下一篇就讲这个。

今天就能验证的五个练习

  1. 把上面的 escape 和 unescape 敲进一个文件,输入一段全是 0x7E 的负载,看编码后长度是不是正好翻倍。
  2. 用一段 100 字节的随机数据算转义膨胀率,多跑几次,看比例是否稳定在 2/256 附近。
  3. 把长度字段分别按大端和小端打包,再用相反的顺序解包,记录解析出的长度值。
  4. 给长度字段设一个 32 的上限,构造一个声明 200 的帧,确认解析器在分配缓冲之前就拒收。
  5. 拿你手上一个真实协议,数一数实现长度定界和转义定界各需要多少行代码,把两边的边界情况列出来对比。

小结

变长数据必须先回答「到哪结束」。长度字段用数字回答,转义用「把特殊字节换掉」回答。前者怕长度本身出错,后者怕漏转义;两者都要靠上限、越界检查和校验兜底。定长最省事,但只要业务会长,就得提前想好扩展方式。

下一篇讲校验和与 CRC。长度和转义只保证边界对,不保证内容对。现场真正会咬人的,是「边界完全正确、数据却错了一个比特」——那要靠校验来发现,而不同的校验算法,能发现的东西差别很大。