有台设备偶尔会多走一段。指令是「前进一米」,现场看日志,每条指令都带着校验,校验还是「所有字节异或」。接收端算出的异或值和帧里带的一致,就把指令交给执行机构。可实际位置多了一米,而且只在少数几次出现,复现不了。

后来抓了很久的原始数据才看明白:出错那帧里有两个比特同时翻了,而且翻在同一个位上。异或的特性是,同一个位翻转两次会抵消,异或结果和原值一模一样。校验说「没坏」,数据其实已经坏了,电机就多转了一圈。

这不是异或校验写得不对,是它本来就只能发现一部分错误。校验算法不是「有就行」,不同算法能发现什么、漏什么,差别很大。这篇把常见的几种摆出来,然后用 Python 真跑一遍:同一段数据,单比特翻转、双比特翻转、字节交换,看异或和 CRC 各自能不能发现。

本文代码在本机 Python 3.15.0 上执行,输出原样贴出。计算部分与硬件无关,结论可以复现;串口上的实际误码率、信号完整性未在本机实测,文中不编造波形和现场日志。

异或校验为什么不够

先看最简单的几种校验。

奇偶校验(parity)只加一个比特,保证一帧里 1 的个数是奇数或偶数。它只能发现奇数个比特错误;两个比特同时翻转,奇偶性不变,它看不出来。它便宜到几乎不占带宽,但能力也就这么多,通常只用在最底层的字节传输上。

累加和(checksum)把所有字节相加,取低若干位。它能发现很多错误,但加法有进位,某些组合会互相抵消。比如一个字节加 1、另一个字节减 1,和不变。溢出回绕也会让远处的错误撞在一起。

异或校验把所有字节按位异或。它比累加和更「线性」:每个比特位独立计算,一个位翻两次就抵消。它还有一个特点,结果与字节顺序无关——把两个字节换个位置,异或值完全不变。所以「字节顺序错了」这类错误,它根本发现不了。

这三种的共同问题是:它们都只看「某种汇总值」,没有把数据的位置信息混进去。CRC 不一样,它把整段数据当成一个多项式,用除法把位置和内容一起卷进余数里。

顺序无关这一点可以用两个字节验证:01 02 和 02 01 的异或值都是 03,接收端无法区分。累加和也有类似的抵消:一帧里两个字节 0x10 和 0xF0 相加是 0x100,取低八位是 0x00;它们各变成 0x20 和 0xE0,和仍然是 0x100。校验看不到变化,业务数据已经变了。

CRC 的基本思想

CRC(Cyclic Redundancy Check,循环冗余校验)的名字听起来吓人,做法可以用一句话说完:把数据看成一个很大的二进制数,除以一个约定的「生成多项式」,把余数附在数据后面。接收端用同样的多项式再除一次,余数对得上就认为没坏。

这里的除法不是普通除法,是模 2 除法:没有借位,加减都等于异或。所以实现起来不需要真的做长除法,只需要移位和异或。一个 16 位 CRC,本质就是一个 16 位的移位寄存器,每进来一个字节就移位八次,遇到最高位为 1 就异或多项式。

举个最小的例子:数据 1101 后面补三个 0 变成 1101000,用生成多项式 1011 做模 2 除法,余数是 001。发送方把 001 附在数据后面,接收端拿 1101001 再除一次,余数应为 0。CRC-16 只是把这个过程放大到 16 位。

余数的位数等于多项式位数减一,所以 16 位 CRC 的余数正好 16 位,附在帧尾就是两个字节。生成多项式的最高位和最低位都必须是 1,否则等于少算一位,检错能力会下降。

CRC-16 的计算流程
装初值寄存器设为 0xFFFF(或协议约定的初值)
取一个字节和寄存器低八位异或
移位八次每次看最低位,是 1 就异或 0xA001
下一个字节重复直到数据结束
输出按协议决定是否反射、是否异或 0xFFFF

真正让人踩坑的是参数。同一个「CRC-16」,生成多项式不同、初值不同、输入输出是否反射不同、最后是否再异或一个值不同,算出来的结果就完全不同。行业里把这些组合固定成了标准参数,比如 CRC-16/MODBUS 用多项式 0x8005 的反射形式 0xA001、初值 0xFFFF、输入输出都反射、最后不异或;CRC-16/CCITT-FALSE 用 0x1021、初值 0xFFFF、不反射。

所以对接第三方设备时,光问「你们用 CRC16 吗」没有用,要问「哪一组参数」。这也是为什么同一个数据在两边算出来的值不一样,却都自称 CRC-16。

把参数写进协议文档,比在代码里写一句「用 CRC16」有用得多。文档里至少要有四项:多项式、初值、输入输出是否反射、最后的异或值,再补一句 CRC 覆盖哪几个字段。

常见参数一览

名称多项式初值反射输出异或典型用途
CRC-8/MAXIM0x310x00是0x00单总线器件、短帧
CRC-16/MODBUS0x8005(反射 0xA001)0xFFFF是0x0000Modbus RTU、工业串口
CRC-16/CCITT-FALSE0x10210xFFFF否0x0000XMODEM、部分无线协议
CRC-16/XMODEM0x10210x0000否0x0000文件传输
CRC-32/ISO-HDLC0x04C11DB7(反射 0xEDB88320)0xFFFFFFFF是0xFFFFFFFFZIP、PNG、以太网

注意 CRC-16/CCITT-FALSE 和 CRC-16/XMODEM 的多项式一样,初值不同,结果就不同。所以「多项式对了」不等于「参数对了」。现场遇到「校验永远失败」,先怀疑参数,而不是先怀疑硬件。

位宽怎么选?8 位适合几十字节以内的短帧,16 位是工业串口的常见选择,32 位用于文件和大数据块。位宽越大,随机错误撞上正确余数的概率越低,但计算和字段开销也越大。

CRC 字段本身的字节序也要约定。同样算出 0xCDC5,有的协议先发低字节 C5 再发 CD,有的反过来。字节序错了,接收端算出的余数其实是对的,只是拼装顺序不对,表现仍然是校验失败。

用 Python 真跑一遍

下面这段代码实现异或校验、CRC-16/MODBUS,并直接调用标准库算 CRC-32。然后构造三种错误:翻一个比特、翻两个同位的比特、交换前两个字节。

import binascii

def xor_sum(data):
    x = 0
    for b in data:
        x ^= b
    return x

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

base = bytes([0x01, 0x06, 0x00, 0x64, 0x00, 0xC8])
single = bytes([base[0] ^ 0x01]) + base[1:]
double = bytes([base[0] ^ 0x08, base[1] ^ 0x08]) + base[2:]
swap = bytes([base[1], base[0]]) + base[2:]

for name, data in [("original", base), ("1 bit", single),
                   ("2 bits", double), ("swap 2B", swap)]:
    print("%-9s xor=%02X crc16=%04X" % (name, xor_sum(data), crc16_modbus(data)))

本机实际输出:

base data: 01 06 00 64 00 C8
xor      : AB
modbus   : 83C9
ccitt    : 99DA
crc32    : 2FBFAED8

case       data                               xor        crc16
original   0106006400c8                       AB/same     83C9/same
1 bit      0006006400c8                       AA/diff     52C8/diff
2 bits     090e006400c8                       AB/same     0A29/diff
swap 2B    0601006400c8                       AB/same     F47D/diff

这四行就是整篇的核心。翻一个比特,异或从 AB 变成 AA,能发现;翻两个同位的比特,异或还是 AB,完全看不出;交换两个字节,异或还是 AB,也看不出。CRC-16 在这三种情况下都变成了不同的值,都能发现。

再看 CRC-32。同一段数据,CRC-32 是 2FBFAED8,CRC-16 是 83C9,CCITT 是 99DA。三种算法结果完全不同,正好说明「参数和算法必须双方一致」。

还能从异或值看出一点规律:翻一个比特时异或从 AB 变成 AA,说明有一个比特变了;异或完全不变时,要么没错,要么错了偶数个同位比特。CRC 没有这种「看得出错在哪」的能力,它只给一个余数,对不上就整帧丢弃。

实际项目里更常用的是 CRC-16,两个字节、够短帧用;文件传输才上 CRC-32。位宽不是越大越好,帧只有 10 字节时,32 位校验的固定开销已经超过数据的三成。

校验值只能证明「这段数据在传输中没有发生它能够发现的错误」,不能证明「数据是发送方原本想发的」。如果发送方自己算错了,接收端校验照样通过。校验管链路,不管业务。

查表法和逐位算法

逐位算法最好理解,也最慢:每个字节移位八次,每次判断、异或。查表法(table-driven)把「一个字节进来后寄存器怎么变」预先算成 256 个值,运行时只做一次查表和一次异或。

本机实测同一段 6 字节数据,跑 30 万次,一次运行里逐位 604.2 毫秒,查表 105.3 毫秒,快 5.74 倍。计时会随机器负载波动,复跑数值略有差别,但量级稳定;C 里的差距通常更明显,因为查表省掉的是分支和循环。

逐位计算

代码短,容易对照协议文档一步步验证,出问题时好调试。占的存储几乎为零。适合只在启动时算一次、或者数据量很小的场景。

查表法

速度快,适合高频收发。代价是要一张 256 项的 16 位表,占几百字节到 1KB;生成表的代码也要写对,表错了所有校验都错,而且不好一眼看出来。

查表法还有一个变体:一次查 4 位(半字节表),表只有 16 项,速度介于逐位和整字节查表之间。资源极紧的单片机常用这个折中。

生成表的代码通常是一个双层循环,拿 0 到 255 逐个移位。生成完要拿几个已知值核对,比如 CRC-16/MODBUS 表的前两项是 0x0000 和 0xC0C1。表里任何一项错了,只有对应字节的帧会出错,更难查。

不管用哪种,最终都要用标准测试向量对一遍。比如 CRC-16/MODBUS 对 01 03 00 00 00 0A 算出的余数是 0xCDC5,按低字节先发就是线上的 C5 CD。先把这个对上,再去接设备。自己写的实现对不上标准值,接上设备只会得到「校验永远失败」。

CRC 能发现什么,不能发现什么

CRC 的检错能力有明确的数学边界。以 16 位 CRC 为例,在常见参数下,它能发现所有单比特错误、所有长度不超过 16 位的突发错误、所有奇数个比特错误;对更长的突发错误和随机错误,漏检概率大约是 1/65536。

「漏检」不是「一定漏」,而是「撞上正确余数的概率」。CRC 的余数空间是 2 的 16 次方,随机错误落在这个空间里,只有一种余数会被误认为正确。所以 16 位 CRC 的漏检率量级是六万分之一,32 位是四十亿分之一。

这也是为什么长帧要配更宽的 CRC。帧越长,出错组合越多,16 位余数空间相对就越大;对几十万字节的文件,16 位 CRC 的漏检概率会明显高于短帧。选型时按帧长和可接受的风险算,不要一律用 8 位。

举个突发错误的例子:一段连续 12 个比特被干扰成随机值,CRC-16 仍能发现,因为突发长度没有超过 16;如果干扰持续 20 个比特,就进入概率区间,漏检率约六万分之一。这也是长线、强干扰环境下要考虑更宽校验的原因。

把 CRC 当哈希用也不合适。哈希要求雪崩效应,输入改一个比特,输出面目全非;CRC 是线性的,改一个比特只是给余数加上一个固定的值。它适合检错,不适合做索引,更不适合防篡改。

CRC 不是加密,也不防篡改。它是线性运算,知道多项式的人可以构造一段数据,让任意指定的 CRC 通过。如果对手能改数据,CRC 帮不上忙;防篡改要用带密钥的消息认证码。CRC 的目标只有一个:发现链路上的意外错误。

还有一个常见误解:CRC 通过就代表数据对。它只覆盖算法覆盖到的字节。如果长度字段不在 CRC 范围里,长度错了 CRC 也可能通过;如果协议字段的语义理解错了,CRC 更是完全管不着。

两个设备「都用了 CRC-16」但对不上,九成是参数差异:初值、反射、输出异或、覆盖范围、字节序。先拿标准测试向量比一遍,比对着寄存器猜快得多。

出问题时先看哪里

下面这些现象在串口项目里很常见。按表里的顺序排查,别一上来就换硬件。

现象真实原因第一步查什么
偶发错包,校验却通过异或或累加和遇到多个比特抵消换 CRC-16,并确认校验覆盖范围包含所有会变的字段
两个比特翻转没被发现异或校验对同位双翻转免疫用 CRC 重算同一帧,比对结果
字节顺序变了,校验仍通过异或和累加和与顺序无关换 CRC,并检查协议有没有把字段顺序写死
同一帧两端 CRC 不同参数不一致:初值、反射、输出异或用标准测试向量分别算一遍,逐项核对参数
CRC 通过但数据明显不对校验未覆盖长度字段,或字段语义理解错确认 CRC 覆盖范围,检查长度和负载的解析
长帧偶发漏检CRC 位宽不够,或帧太长按帧长评估 16 位是否够,必要时换 32 位
查表法和逐位算出来不一样表生成错了,或表的反射方向不对用标准测试向量对照两种实现的中间值

边界与代价

CRC 有计算开销。逐位算法在低端单片机上,一帧几十字节可能占用几十微秒;高频收发时要评估 CPU 占用,必要时用查表或硬件 CRC 外设。很多 MCU 自带 CRC 单元,但它的参数是固定的,常见的是以太网 CRC-32 或 CRC-16/CCITT。外设算出的值和软件实现不一致时,先确认初值、反射和输出异或能不能配,配不了就只能软件算。

查表法占空间。256 项 16 位表大约 512 字节,对只有几 KB RAM 的单片机不算小。可以用半字节表压缩到 16 项,或者把表放进 Flash 而不是 RAM。

帧越长,CRC 的计算时间也线性增长。一帧 4KB、每秒上百帧的场景,逐位算法会明显拖慢;这时候查表或硬件外设不是优化,是必需。

CRC 不能防恶意篡改。线性算法可以被构造,攻击者只要知道算法就能算出通过校验的数据。需要防篡改时,用带密钥的 MAC,CRC 只当链路检错用。

参数配置不一致会导致「永远校验失败」。这是现场最常见的问题,而且很容易被误判成硬件故障。对接前先把标准测试向量跑通,比在现场换线、换设备省时间。

最后,CRC 只覆盖你让它覆盖的字节。帧头、长度、命令、负载、校验本身,哪些参与计算必须写进文档。覆盖范围不一致,双方算出来的值永远对不上。

位宽还要和链路条件匹配。误码率很低的板内短距链路,8 位 CRC 就够;长线、强干扰的环境,16 位起步。校验太宽浪费带宽,太窄等于在赌,按实际误码率算比凭感觉选靠谱。

今天就能验证的五个练习

  1. 把上面的 CRC-16/MODBUS 代码敲进去,对 01 03 00 00 00 0A 算一次,确认余数是 0xCDC5,即线上低字节在前、发成 C5 CD。
  2. 把初值从 0xFFFF 改成 0x0000,再算同一段数据,看结果差多少。
  3. 构造一个双比特翻转,分别用异或和 CRC 检查,记录哪一个漏了。
  4. 用 time.perf_counter 对比逐位和查表两种实现跑十万次的时间,算出加速比。
  5. 找一台你手上设备的协议文档,确认它的 CRC 参数四项:多项式、初值、反射、输出异或。

小结

异或校验便宜,但它对双比特翻转和字节顺序不敏感;累加和也类似。CRC 把位置信息卷进余数,能发现绝大多数链路错误,代价是多一点计算和参数约定。它不是加密,不防篡改,也不保证业务语义正确。

下一篇讲分包与粘包。校验解决了「这一帧内容对不对」,但还有个更前置的问题:你收到的那几个字节,到底是不是一整帧?一次读到两帧半的时候,校验再强也没用,因为切帧的位置已经错了。