目录
串口数据总是粘包半包:先定帧再写解析器
串口助手能看见数据,Python 写的上位机却总拿到半帧;加一句 time.sleep(0.1) 好像好了,换个波特率又坏。这类现象九成不是「接收函数写错了」,而是在还没定义「一帧长什么样」的时候就开始解析。
read() 只承诺「返回不超过 n 个字节」,不承诺「凑满 n 个字节」;操作系统只承诺「字节按顺序到达」,不承诺「一次到达一帧」。所以粘包和半包不是异常,是默认行为。先把帧格式定死,再写解析器,剩下的问题才变成可以逐条排查的工程问题。
这篇给一条完整的链:帧头/LEN/CRC 三字段怎么定位、缓冲切片怎么处理半包、CRC16 两种初值与两种实现怎么对表、CSV 落盘的真实吞吐、以及 16 倍过采样下 ±2.5% 这个波特率容差是怎么算出来的。所有脚本都能在本机跑,本文贴出的每个数字都来自终端原始输出,运行环境与设备边界在文末如实标注。
适用环境与版本
本文的宿主侧代码只依赖标准库与 pyserial,不涉及 MCU 工程;串口设备用 pty 虚拟串口代替真实 USB 转串口,这一点在第七节和失效边界里反复说明。
| 项 | 本文取值 | 说明 |
|---|---|---|
| 主机 | macOS 26.5.2(Darwin 25.5.0),arm64 | 所有终端输出在此环境产生 |
| 解释器 | Python 3.9.6(系统自带)、3.11.13、3.13.12 | 同一套脚本横跑,见版本矩阵 |
| 容器侧 | python:3.12-slim,Linux aarch64 | 用于跨平台行为对照,不是性能基线 |
| 串口库 | pyserial v3.5 | serial.Serial 的 read、in_waiting、timeout 语义以该版本为准 |
| 串口设备 | pty 虚拟串口(/dev/ttysNNN) | 走真实 termios 路径,背后不是 USB 转串口芯片 |
| 帧格式 | 0xAA 0x55 + LEN + SEQ + PAYLOAD + CRC16 | 自定义协议,字段位置可换,定位顺序不变 |
先把环境准备好,后面每条输出都可以照着重跑:
pip3 install pyserial==3.5 # 本机实际安装的是 3.5
python3 frame_parser.py # 六类样本,逐条断言
python3 crc16_compare.py # 校验值与差分测试
python3 csv_sink.py 100000 # 10 万帧落盘
python3 pty_link.py # pty 虚拟串口三组实验
python3 baud_budget.py # 波特率容差与分频实算
预期输出是每段末尾的汇总行,形如:
== 汇总:400/400 帧解析正确
== 总体:ALL PASS
行尾归一后一致:PASS
总体:ALL PASS (pty 虚拟串口,非 USB 转串口)
版本矩阵按「同一份脚本、不同解释器」跑,每一项都是实际执行结果,不是推测兼容:
| 解释器 | pyserial | 平台 | 帧解析 | CRC 查表吞吐 | pty 500 帧 |
|---|---|---|---|---|---|
| 3.9.6 | v3.5 | macOS arm64 | 400/400 | 3.46 MB/s(289 ns/字节) | 500/500 |
| 3.11.13 | v3.5 | macOS arm64 | 400/400 | 10.96 MB/s(91 ns/字节) | 500/500 |
| 3.12.16 | v3.5 | Linux aarch64(容器) | 400/400 | 5.49 MB/s(182 ns/字节) | 500/500 |
| 3.13.12 | v3.5 | macOS arm64 | 400/400 | 11.11 MB/s(90 ns/字节) | 500/500 |
表里有一处需要解释:同样是纯 Python 的查表循环,系统自带 3.9 只有 3.46 MB/s,3.13 有 11.11 MB/s。这不是代码差异,是解释器差异——Apple 自带的 Python 编译选项更保守,而 3.11 之后的自适应解释器对这类小循环优化明显。结论只用在同版本内部做横向比较,不要拿跨版本的绝对值当性能承诺。
一、先认清串口给你的是什么
1.1 三个必须接受的事实
第一,串口是字节流,没有「消息」这个概念。你写 10 个字节,对方可能分 3 次收到,也可能和其他写入合并成一次。
第二,read(n) 的返回值长度小于 n 是合法行为。pyserial 3.5 官方文档对 read(size) 的说明是「读取 size 个字节;若设了 timeout,则最多等 timeout 秒,超时后返回已读到的部分」——注意它没说「读满或抛异常」。
第三,缓冲里「有没有数据」与「有没有一整帧」是两件事。in_waiting 只能回答前者,用它判断能不能解析,就等于用「有几块砖」判断「墙砌好没有」。
三种 timeout 取值的实际行为差别很大,选错就是卡死或空转:
| timeout | read(n) 行为 | 适用场景 |
|---|---|---|
| 0 | 非阻塞,立刻返回缓冲里已有的字节,可能是 0 字节 | 自己控制循环节拍 |
| 0.05 | 最多等 50 ms,返回这段窗口里收到的字节 | 独立读线程(本文取这个) |
| None | 一直阻塞到凑满 n 字节 | GUI 线程里等于自杀 |
四种现象的分工,先摆在一起看,后面逐节展开:
| 现象 | 你看到的样子 | 根因 | 正确做法 |
|---|---|---|---|
| 粘包 | 一次 read 里含两帧半 | 字节流没有消息边界 | 按 LEN 切,循环取帧 |
| 半包 | 帧长不够就解析,CRC 必错 | read 不保证读满 | 不够就留在缓冲 |
| 坏帧 | 偶发几帧数据乱跳 | 噪声或波特率误差 | CRC 兜底并计数 |
| 错位 | 之后所有帧都错 | 坏帧被整段丢弃 | 只丢 1 字节重扫 |
1.2 read(n) 的两种写法
下面这段是最常见的错误写法:把一次 read 的结果直接当一帧。
# 错误:把 read(64) 的返回值当一整帧
chunk = port.read(64)
frame = parse(chunk) # 半包时这里拿到的是半帧
正确写法是把「收字节」和「拼帧」分开,解析器自己维护缓冲:
# 正确:有多少读多少,剩下的交给解析器
n = port.in_waiting
chunk = port.read(n if n else 1)
frames = parser.feed(chunk) # 不完整就留在缓冲里,等下一次
这两种写法在 pty 上的差别是可以量出来的。把一帧 14 字节拆成 7 + 7,中间隔 50 ms,然后调 read(64):
[B] 帧 14B 拆成 7B + 7B,中间隔 50 ms
read(64) #1 实收 7B 用时 50.2 ms in_waiting 剩余 0
read(64) #2 实收 7B 用时 54.1 ms
两段拼起来 = 14B,CRC 校验 PASS
预期输出就是上面这样:请求 64 字节,实际只回 7 字节,用时约等于一个 timeout 窗口(50 ms)。如果代码里写的是 if len(chunk) == 64,这一帧永远不会被处理——而串口上没有 64 字节的帧,这个条件本身就是错的。
1.3 in_waiting 与 timeout 的真实关系
in_waiting 读的是驱动缓冲里已经到达的字节数,它不预测未来。所以「写完立刻查 in_waiting」这件事,在两种平台上的结果不一样:
| 平台 | 写入后立刻 in_waiting | 10 ms 后 | 说明 |
|---|---|---|---|
| macOS + pty | 16 | 16 | 内核直通,字节立刻可读 |
| Linux 容器 + pty | 0 | 16 | 调度延迟,读到 0 不代表没数据 |
这不是 pyserial 的 bug,是「已到达」这个定义在不同实现下的粒度差异。真实 USB 转串口更极端:FTDI 类芯片默认 latency timer 是 16 ms,意味着即使只有 1 个字节,也可能要等到下一个 USB 帧才交给你。所以任何「收到 0 字节就判定链路断开」的逻辑都必须带时间窗,不能用一次采样下结论。
注意:把 timeout 设成 0 会让 read 变成非阻塞,返回 0 字节是常态;设成 None 则会一直等,GUI 线程会卡死。工程上一般取 20~100 ms,让读线程有退出机会。
二、定帧:三字段各管一件事
2.1 帧格式
本文用的帧格式只有 6 字节开销,字段位置随意,但三个字段的职责固定:
| 偏移 | 字段 | 宽度 | 本文取值 | 职责 |
|---|---|---|---|---|
| 0 | 帧头 1 | 1 字节 | 0xAA | 粗定位起点 |
| 1 | 帧头 2 | 1 字节 | 0x55 | 二次确认,降低误判 |
| 2 | LEN | 1 字节 | 0~200 | 决定切点 |
| 3 | SEQ | 1 字节 | 0~255 回绕 | 查丢帧与重排 |
| 4 | PAYLOAD | LEN 字节 | 遥测数据 | 载荷 |
| 4+LEN | CRC16 | 2 字节 | 小端 | 判真伪 |

图 1 的读法是看那条字节标尺:总长 6+LEN,切点由偏移 2 的 LEN 决定,CRC 从偏移 4+LEN 开始占 2 字节。图注里的每个数字(6 字节开销、200 上限、校验范围 LEN+2 字节)都能在图上直接读到。
2.2 为什么帧头要两个字节
单字节帧头 0xAA 在二进制载荷里出现的概率是 1/256;两字节 0xAA 0x55 降到 1/65536。这不是玄学,是纯概率:每 65,536 个随机字节才会误命中一次帧头。
即便如此也不能只靠帧头。误命中之后还有一个 LEN 字段做二次筛选(大于 200 直接判假),最后才是 CRC 兜底。三层筛子的误判率相乘,才降到工程可接受的水平。只靠一个 0xAA 就切帧的协议,在噪声里必然频繁错位,这不是解析器能补救的。
2.3 LEN 的作用是定切点,不是装饰
LEN 只有一个用途:算出这一帧到哪里结束。它必须满足两个条件才可信——不大于协议上限,且缓冲里确实已经收齐 6+LEN 字节。
前一个条件防的是「假帧头 + 垃圾长度」:如果收到 LEN=250(超过 200 上限),正确反应是只丢 1 个字节再重新找帧头,而不是按 256 字节去等。后者会让缓冲一直等一个永远不来的帧,表现为「串口卡住、越收越慢」。
后一个条件是半包的唯一正确出口:字节不够就原样留在缓冲里,等下一次 feed。这一条写错,就会出现「半帧被当坏帧丢掉,下一帧的帧头又对不上」的连锁错位。
2.4 校验范围为什么不含帧头
CRC 覆盖 LEN、SEQ、PAYLOAD 共 LEN+2 字节,不含两个帧头字节。原因是帧头的职责是「找到起点」,一旦进了校验,任何帧头被噪声改写的帧都会先被当成错位、再被重扫,多绕一圈。
副作用是:帧头自身没有校验保护,如果 0xAA 被改成 0xAB,这帧会被当成噪声丢掉。这是有意的取舍——宁可丢一帧,也不要把后面的数据全部错位。真要保护帧头,就把帧头也算进 CRC,代价是重同步路径要多一条分支。
三、解析器:一个缓冲加四个出口
3.1 为什么用缓冲切片,不用状态机枚举
教科书常把解析器写成状态机:SEEK_H1 → SEEK_H2 → LEN → PAYLOAD → CRC。这样写没错,但每加一个字段就要改一次枚举,而且「帧头误命中后回退」的逻辑要写两遍。
缓冲切片的写法只有一个循环:找到帧头就量长度,长度够了就校验,校验过了就切走,任何一步不满足都有明确出口。代码量更少,回退也只有一条路径。
3.2 核心循环
下面这 30 多行是整个解析器的全部逻辑,四个出口分别对应成帧、等续传、丢噪声、丢一个字节重扫:
def feed(self, chunk: bytes):
self.buf += chunk
self.max_buf = max(self.max_buf, len(self.buf))
out = []
while True:
if len(self.buf) < 2:
break # 出口②:等
if self.buf[0] != H1: # 找下一个 0xAA
idx = self.buf.find(bytes([H1]))
if idx < 0:
self.dropped += len(self.buf); self.buf.clear(); break
self.dropped += idx; del self.buf[:idx]; continue
if self.buf[1] != H2: # 0xAA 后面不是 0x55
idx = self.buf.find(bytes([H1]), 1)
if idx < 0:
self.dropped += len(self.buf); self.buf.clear(); break
self.dropped += idx; del self.buf[:idx]; continue
if len(self.buf) < 3:
break # 出口②:等 LEN
length = self.buf[2]
if length > MAX_PAYLOAD: # 出口③:假帧头
self.dropped += 1; del self.buf[:1]; continue
total = OVERHEAD + length
if len(self.buf) < total:
break # 出口②:半包
cand = bytes(self.buf[:total])
crc_rx = cand[-2] | (cand[-1] << 8)
if crc16_ccitt(cand[2:4 + length]) != crc_rx:
self.crc_err += 1 # 出口④:坏帧
self.dropped += 1; del self.buf[:1]; continue
self.ok += 1
out.append(Frame(cand[3], cand[4:4 + length]))
del self.buf[:total] # 出口①:成帧
return out
四个出口对应四个计数器:ok、left(缓冲剩余)、dropped(重同步丢的字节)、crc_err。这四个数如果不打日志,等于没测过——出问题时你只知道「没数据」,不知道是没收到、收到半帧、还是 CRC 全错。
| 出口 | 触发条件 | 动作 | 计数器 |
|---|---|---|---|
| ① 成帧 | 帧头对、长度够、CRC 对 | 切走 6+LEN 字节 | ok +1 |
| ② 等待 | 不足 2 字节,或不足 6+LEN | 不动缓冲,等下一次 feed | left |
| ③ 假帧头 | LEN > 200 | 丢 1 字节,重新找头 | dropped +1 |
| ④ 坏帧 | CRC 不符 | 丢 1 字节,重新找头 | crc_err +1 |

图 2 把判定顺序画成四步:够不够 2 字节 → 是不是 AA 55 → LEN 是否合理且收齐 → CRC 对不对。每一步的「否」分支都指向一个明确的动作,这是解析器能被测试的前提。
3.3 七类样本跑一遍
样本不是随便造的:粘包、半包、坏 CRC、前置噪声、载荷内含假帧头、非法长度,这七类覆盖了现场九成以上的错位场景。
| 样本 | 输入长度 | 期望帧数 | 关键计数 | 说明 |
|---|---|---|---|---|
| 正常单帧 | 11B | 1 | ok=1 | 基线 |
| 粘包 3 帧 | 36B | 3 | dropped=0 | 一次 feed 三帧 |
| 半包(逐字节喂) | 36B | 3 | max_buf=13 | 最坏切分 |
| 坏 CRC | 14B | 0 | crc_err=1,dropped=14 | 整帧无人认领 |
| 前置噪声 | 15B | 1 | dropped=4 | 噪声被打掉 |
| 假帧头 | 12B | 1 | dropped=0 | 载荷里有 AA 55 |
| 长度越界 | 12B | 1 | dropped=4 | LEN>200 被识破 |
真实终端输出(python3 frame_parser.py,原样抄录):
== 场景 1:一次 feed 全部字节(默认用法)
[OK ] 正常单帧 输入 11B 期望 1 帧 实得 1 帧 crc_err=0 dropped=0 left=0
[OK ] 粘包 3 帧 输入 36B 期望 3 帧 实得 3 帧 crc_err=0 dropped=0 left=0
[OK ] 半包 1 字节 输入 36B 期望 3 帧 实得 3 帧 crc_err=0 dropped=0 left=0
[OK ] 坏 CRC 输入 14B 期望 0 帧 实得 0 帧 crc_err=1 dropped=14 left=0
[OK ] 前置噪声 输入 15B 期望 1 帧 实得 1 帧 crc_err=0 dropped=4 left=0
[OK ] 假帧头 输入 12B 期望 1 帧 实得 1 帧 crc_err=0 dropped=0 left=0
[OK ] 长度越界 输入 12B 期望 1 帧 实得 1 帧 crc_err=0 dropped=4 left=0
只看「一次喂全部」是不够的,因为真实串口的切点是随机的。所以还有第二组:每次只喂 1 字节(最坏切分),和第三组:按 1~7 字节随机切分、每个样本跑 40 轮。
== 场景 2:每次只 feed 1 字节(最坏切分,模拟极度碎片化)
[OK ] 粘包 3 帧 输入 36B 期望 3 帧 实得 3 帧 max_buf=13 left=0
[OK ] 坏 CRC 输入 14B 期望 0 帧 实得 0 帧 max_buf=14 left=0
== 场景 3:7 字节随机切分各跑 40 次(切点随机)
粘包 3 帧 40 轮中失败 0 轮
== 汇总:400/400 帧解析正确
max_buf=13 是这里最值得看的一个数:36 字节的粘包,逐字节喂进去,缓冲峰值只有 13 字节。说明解析器不会因为切分变碎而囤积数据——这一点直接决定长时间运行会不会内存泄漏。
四、CRC16:两种实现、两种初值
4.1 逐位法与查表法
逐位法每字节算 8 次移位,占用 ROM 少,适合 MCU 端;查表法一次生成 256 项表,之后每字节只查一次,适合 PC 端。两者必须给出同一结果,否则就是有一边写错了。
def crc16_bitwise(data: bytes, init: int = 0xFFFF) -> int:
crc = init
for b in data:
crc ^= b << 8
for _ in range(8):
crc = ((crc << 1) ^ 0x1021) & 0xFFFF if crc & 0x8000 else (crc << 1) & 0xFFFF
return crc
TABLE = make_table() # 256 项,一次生成
def crc16_table(data: bytes, init: int = 0xFFFF) -> int:
crc = init
for b in data:
crc = ((crc << 8) & 0xFFFF) ^ TABLE[((crc >> 8) ^ b) & 0xFF]
return crc
查表法的 ((crc >> 8) ^ b) & 0xFF 是这张表的核心:把当前余数的高字节和新字节异或,得到表索引,再把余数左移 8 位后与之异或。写错一个括号,结果就和不查表版本对不上,所以差分测试是第一道关。
4.2 先对已知校验值,再谈实现
不管用哪种写法,先用标准校验值对一遍。字符串 "123456789" 的 CRC 是所有 CRC 实现的事实标准测试向量:
| 变体 | poly | init | 反射 | 校验值(123456789) |
|---|---|---|---|---|
| CRC-16/CCITT-FALSE | 0x1021 | 0xFFFF | 否 | 0x29B1 |
| CRC-16/XMODEM | 0x1021 | 0x0000 | 否 | 0x31C3 |
| CRC-16/MODBUS | 0xA001 | 0xFFFF | 是 | 0x4B37 |
== 1. 已知校验值(任何实现都必须对上)
CRC-16/CCITT-FALSE 计算 0x29B1 标准 0x29B1 PASS
CRC-16/XMODEM 计算 0x31C3 标准 0x31C3 PASS
CRC-16/MODBUS 计算 0x4B37 标准 0x4B37 PASS
三个都 PASS 之后才敢做差分测试:20,000 组随机负载,长度 0~64 字节,初值在 0xFFFF 与 0x0000 之间随机取。
== 2. 差分测试:逐位法 vs 查表法,20000 组随机负载
不一致 0 组 / 共 20000 组 → PASS
== 4. 吞吐:20000 组、每组 64 字节(python3 解释执行)
逐位法 0.86 MB/s 1164.4 ns/字节 用时 1490.4 ms
查表法 5.60 MB/s 178.4 ns/字节 用时 228.4 ms
查表法快 6.5 倍
6.5 倍这个数字说明一件事:如果帧率是 700 帧/秒、平均 16 字节,逐位法要花 700 × 18 × 1164 ns ≈ 14.7 ms/秒,占 1.5% 的 CPU;查表法只占 0.2%。单看都不致命,但它在读线程里是持续开销,和 GUI 抢 GIL 的时候会被放大。
4.3 初值差一位,结果全不同
两套初值不能混用,混了就是「所有帧都 CRC 错」。同一份载荷,换初值的结果如下:
| 载荷 | init 0xFFFF | init 0x0000 | 异或 |
|---|---|---|---|
temp=25.4(9B) | 0x67B2 | 0x7FC0 | 0x1872 |
\x01\x02\x03(3B) | 0xADAD | 0x6131 | 0xCC9C |
0x00..0x0F(16B) | 0x3B37 | 0x513D | 0x6A0A |
三个异或值都不是 0,说明两套初值没有「碰巧相等」的载荷。现场最典型的故障就是:固件用 XMODEM 初值,上位机按 CCITT-FALSE 校验,结果帧率正常、数据全丢,日志里只有一行 crc_err 持续增长。遇到「收得到但全判错」,第一件事是把两端的 poly 和 init 抄出来对一遍,不要在解析逻辑里找原因。
五、CSV 落盘:10 万帧的真实数字
5.1 三种写法,同一份数据
落盘这件事容易被过度设计。先看三个写法的实测:csv.writer 默认缓冲、手工拼字符串、csv.writer 每行 flush。
with open(path, "w", newline="", encoding="utf-8") as f:
w = csv.writer(f)
w.writerow(COLS)
for row in gen_frames(n):
w.writerow(row)
== 100,000 帧 / 7 列 → .../serial/out/
csv.writer 181.0 ms 552,355 行/秒 3166.1 KB 32.4 B/行
手工拼串 f.write 126.0 ms 793,679 行/秒 3068.5 KB 31.4 B/行
csv.writer + 每行flush(20,000) 113.8 ms 175,821 行/秒 624.5 KB 32.0 B/行

图 6 是这次落盘的终端原始输出:三种写法同一份数据、同一目录,行/秒与文件大小都在图上,图注标了命令与运行时间。它与图 5 是两条独立证据——一条证明解析能跑通,一条证明落盘不拖后腿。
三个数要分开读。csv.writer 55 万行/秒,手工拼串 79 万行/秒,差 1.44 倍;每行 flush 掉到 17.6 万行/秒,只有默认缓冲的 31.8%。
这个差距的成因值得说清:flush 把用户态缓冲交给内核,每行一次系统调用。10 万行就是 10 万次 write,而默认缓冲是攒到 8 KB 才交一次。所谓「实时落盘」并不需要每行 flush——掉电丢最后 8 KB 和丢最后 1 行,对遥测数据没有本质区别,但前者快 3 倍。
5.2 那个 100,001 字节的差
同一份数据,两个文件的大小不一样:3,166.1 KB 与 3,068.5 KB,差 100,001 字节。原因不是内容不同,而是行尾。
原始字节:a=3,242,121B b=3,142,120B 差 100,001B(≈ 100,000 行 × 1B 的 CRLF)
行尾归一后一致:PASS
a.csv 行尾 CRLF 计数:100,001;b.csv 行尾 LF 计数:100,001
csv 模块按 RFC 4180 写 \r\n,手工拼串写 \n;文件头一行也带行尾,所以是 100,001 而不是 100,000。两件事值得记:一是对比文件不要直接按字节比,会被行尾坑;二是 Linux 上生成的 CSV 拿到 Windows 的 Excel 里打开,如果中文乱码,加 BOM 就行。
utf-8-sig 前三字节:EF BB BF(EF BB BF = BOM)
encoding="utf-8-sig" 会写入 3 字节 BOM,Excel 双击打开时中文列名不再是乱码。这三字节对其他工具通常是透明的,但用 pandas.read_csv 读时要留意第一列名可能带 \ufeff。
5.3 吞吐只有量级意义
同一台机器连跑多次,csv.writer 落在 32 万 ~ 87 万行/秒之间,手工拼串 79 万 ~ 122 万行/秒。波动接近 3 倍,来自文件系统缓存与 CPU 调度,不是脚本不稳定。

图 4 是这张对数轴上的四段:115200 8N1 的线速 11.5 KB/s、pty 端到端 8.6 KB/s、CRC 查表 11.1 MB/s、CSV 落盘 17.9 MB/s(按 3,242,121 字节 ÷ 181.0 ms 算)。三者差三个数量级,结论很直接——落盘从来不是瓶颈,串口才是。 把 CSV 放独立线程的理由不是它慢,而是它会在写盘瞬间阻塞读线程与 GUI 线程。
线速换算值得单独写一行:115200 bit/s ÷ 10 bit/字节(8N1 每字节 1 起始 + 8 数据 + 1 停止)= 11,520 字节/秒。按本文平均 16 字节一帧算,理论上限是 720 帧/秒。这个数才是上位机该按什么频率刷新的依据。
六、波特率误差:±2.5% 是怎么来的
6.1 9.5 个位时间的推导
接收端的采样点在每一位的中间:起始沿被检测到之后,等 1.5 个位时间采第 0 位,之后每 1 个位时间采一位。8N1 一帧 10 位,停止位的采样点在起始沿之后 9.5 个位时间。
设收发两端的波特率相对误差为 ε,则到停止位时累计漂移是 9.5ε 个位宽。要求漂移不超过半个位宽,解出 ε < 0.5 / 9.5 = 5.26%。
16 倍过采样再加一层损耗:常用做法是在采样点附近连取 3 个 tick 做三取二表决,采样窗左右各占 1.5 tick = 3/16 的一半 ≈ 0.094 个位宽,极限收紧到 (0.5 − 0.094) / 9.5 = 4.28%。
工程上还要给两端的晶振各留一份,把 5.26% 对半分是 ±2.14%,再留温漂与布线余量,业界惯例取 ±2.5%。这就是那个数的全部出处——不是经验值,是 9.5 个位时间除出来的。
== 1. 容差推导(8N1,16 倍过采样,三取二表决)
极限:漂移 0.5 位 / 9.5 位 = 5.26%
采样窗收窄 3/16 位后:4.28%
收发对半预算:±2.14% → 工程取 ±2.5%
6.2 8 MHz 下的 115200:两种命运
同样是 8 MHz 主频跑 115200,有没有小数分频,结果完全不同:
| 主频 | 目标波特率 | BRR | 实际波特率 | 误差 | 判定 |
|---|---|---|---|---|---|
| 8 MHz | 9600 | 52.0625 | 9603.8 | +0.04% | 可用 |
| 8 MHz | 115200 | 4.3125 | 115942.0 | +0.64% | 可用 |
| 16 MHz | 115200 | 8.6875 | 115107.9 | −0.08% | 可用 |
| 25 MHz | 115200 | 13.5625 | 115207.4 | +0.01% | 可用 |
| 72 MHz | 115200 | 39.0625 | 115200.0 | 0.00% | 可用 |
| 8 MHz | 921600 | 0.5625 | 888888.9 | −3.55% | 不可用 |
有 4 位小数分频时,8 MHz 跑 115200 的 BRR 可以取 4.3125,误差 +0.64%,完全够用。这个「4 位小数」不是估算:STM32F103 参考手册 RM0008 的 USART_BRR 寄存器里,DIV_Fraction 就是 4 位,16 倍过采样下实际波特率 = fCK / (16 × BRR),本文的实算就是照这条公式写的。但如果 MCU 的分频器只有整数位:
== 4. 只有整数分频的 MCU(BRR 小数位不可用)
8 MHz / 9600 DIV=52 实际 9615.4 +0.16% 可用
8 MHz / 115200 DIV=4 实际 125000.0 +8.51% 不可用
12 MHz / 115200 DIV=7 实际 107142.9 -6.99% 不可用
72 MHz / 115200 DIV=39 实际 115384.6 +0.16% 可用
8.51% 意味着什么?按 0.5 / 0.0851 算,漂到半个位宽只需要 5.88 个位时间——连第 8 个数据位都采不到,一帧必然错。这就是「8 MHz 晶振 + 115200 通信不稳」的经典成因,和代码无关,和线材无关。

图 3 把 0.5%、2.5%、4.28%、5.26%、8.51% 五个点放在同一条轴上:绿区可用、黄区临界、红区必错。8 MHz 整数分频的 8.51% 落在红区最右端,图上能直接读到。
== 3. 一个误差能撑多少位(漂移到半个位宽就采错)
误差 2.50% → 20.00 位后漂移半个位宽 撑得过 10 位帧
误差 5.26% → 9.51 位后漂移半个位宽 撑不过一帧
误差 8.51% → 5.88 位后漂移半个位宽 撑不过一帧
这份推导和 CAN 位定时的算法是同一套思路:先把时间额度算清楚,再决定参数能不能用。CAN 的 BRP、采样点与终端电阻怎么按同样顺序排查,站内 CAN 位定时算不通:BRP、采样点与终端电阻的排错顺序 里有完整的三步链路;ADC 侧「先算采样窗口再改配置」的同类算式见 ADC 读数为什么偏低。
七、真跑一遍:pty 虚拟串口
7.1 没有 socat 也能造串口
本机没装 socat,但 macOS 自带 pty。os.openpty() 返回一对主/从设备,pyserial 打开从设备的路径即可,走的是完整的 termios 路径:波特率设置、raw 模式、timeout、in_waiting 都是真的。
master, slave = pty.openpty()
name = os.ttyname(slave) # /dev/ttysNNN
port = serial.Serial(name, 115200, timeout=0.05)
os.write(master, frame_bytes) # 写主端 = 对端发数据
诚实口径先说清楚:pty 背后是内核内存,不是 USB 转串口芯片。它证明的是解析逻辑与 pyserial API 语义,不证明 USB 驱动、芯片 FIFO、线缆质量。这两件事的区别,在失效边界里单独列。
7.2 500 帧,read(64) 只回 7 字节
写线程按 1~40 字节随机切块、每块间隔 0.5~3 ms,共 500 帧;读线程只按 in_waiting 有多少读多少:
[A] 设备 /dev/ttys008 参数 115200 8N1 timeout=50ms 帧数 500 线缆字节 7979B
解析 500/500 帧 内容错 0 帧 crc_err=0 dropped=0 left=0
read 调用 740 次 平均请求 10.8B 单次最大实收 52B 「实收<请求」0 次 (0%)
端到端 7979B / 902 ms = 8.6 KB/s,554 帧/秒
500 帧全部还原,dropped=0 说明一次重同步都没发生。平均请求 10.8B 是这套写法的直接结果:请求量跟着 in_waiting 走,所以「实收 < 请求」是 0 次;一旦改成固定 read(64),这个比例立刻变成 100%(第 1.2 节已经量过)。
端到端 8.6 KB/s 远低于线速 11.5 KB/s,原因是写线程自己 sleep 了——这不是串口带宽,是测试脚本的节奏。看吞吐一定要说清「测的是哪一段」,否则数字没有意义。

图 5 是这次运行的终端原始输出套框:命令、设备名、三组实验的全部数字都在图上,图注标了运行时间与环境版本。
7.3 Linux 容器里的两处不同
同一份脚本在 python:3.12-slim 里跑,功能全过,但两处数字不一样:
| 观察项 | macOS 宿主 | Linux 容器 |
|---|---|---|
写入后立刻 in_waiting | 16 | 0(10 ms 后变 16) |
| 单次最大实收 | 52B | 64B |
| 端到端帧率 | 554 帧/秒 | 369 帧/秒 |
第一行是调度粒度差异,第二行说明容器里读线程被调度得更「整块」。这些差异不影响正确性,但会影响超时参数的选取:在 Linux 上按 macOS 的经验设 10 ms 超时,可能频繁读到 0 字节,从而误判链路异常。
八、失效边界
这一节是本文最该先读的部分。下面六条里任何一条成立,前面的结论都要打折。
8.1 pty 不等于 USB 转串口
pty 没有 USB 帧、没有芯片 FIFO、没有 latency timer,延迟在微秒级。真实 USB 转串口有 16 ms 量级的批量传输间隔,in_waiting 会出现「明明在发,读了三次都是 0」的窗口。用 pty 调通只说明逻辑对,不说明真机对。
8.2 半包超时不能靠猜
如果对端发完一帧后断电,这半帧会永远留在缓冲里,left 一直大于 0。工程上要加一个「帧起始超时」:某个字节在缓冲里待超过 N 毫秒还没凑成帧,就整段丢弃并计数。N 取多少取决于协议的最小帧间隔,不能拍脑袋。
8.3 USB 缓冲会让 in_waiting 滞后
FTDI/CH340 这类芯片默认 latency timer 是 16 ms(FTDI 应用笔记 AN232B-04 的数据延迟章节给的就是这个默认值),意味着数据已经在芯片里,主机侧还看不见。把 timeout 设成 5 ms 的读循环会空转三次,CPU 占用上去、响应反而变慢。合理做法是 timeout 不小于 20 ms,或直接用事件回调。
8.4 Windows 与 Linux 的设备名不同
Linux 是 /dev/ttyUSB0、/dev/ttyACM0;Windows 是 COM3、COM10,超过 COM9 必须写 \\.\COM10,否则 Serial('COM10') 会报找不到端口。这个坑和解析逻辑无关,但会让「代码在本机好好的」变成「换台电脑就跑不起来」。
8.5 非标准波特率
115200 是标准值,250000、1000000 在部分芯片上分频误差会超标(见 6.2 的表)。pyserial 接受任意整数,但驱动可能悄悄取整到最近的可实现值——上位机设 250000,实际跑的可能是 249807,误差在 0.08%,通常没事;但如果驱动取整到 230769,误差 7.7%,必然出错。用之前先查芯片手册的分频公式。
8.6 吞吐数字只有量级意义
本文所有 MB/s 与行/秒都是「单机、单次、缓存命中」的结果,波动可达 3 倍。换成机械硬盘、网络盘、或加了 fsync,数量级会掉一到两个。拿这些数做容量规划前,必须在目标机器上重跑一遍。
九、一页清单
| 步骤 | 动作 | 判据 | 不满足时 |
|---|---|---|---|
| 1 | 定义帧格式 | 帧头 2 字节 + LEN + CRC | 不要开始写解析 |
| 2 | LEN 设上限 | 超过上限判假帧头 | 缓冲会被一个假长度卡死 |
| 3 | 校验范围含 LEN | 不含帧头,含 LEN/SEQ/载荷 | 长度被改写时查不出来 |
| 4 | 对标准校验值 | 123456789 → 0x29B1 | 实现错了,别往下走 |
| 5 | 差分测试 | 逐位法与查表法 0 不一致 | 有一边写错 |
| 6 | 四类样本 | 粘包/半包/坏 CRC/假帧头 | 缺一类就是没测 |
| 7 | 计数器 | ok/left/dropped/crc_err | 出问题无法定位 |
| 8 | 超时 | 读超时 20~100 ms | 0 会空转,None 会卡死 |
| 9 | 落盘 | 默认缓冲,不逐行 flush | 慢 3 倍且无收益 |
| 10 | 波特率 | 误差 ≤ ±2.5% | 一帧都收不全 |
写在最后
开头那个问题的答案是:粘包半包不是异常,是串口的默认行为。先定帧,再写解析器,这句话的顺序不能反——解析器的一切复杂度都来自「帧边界未知」,边界一旦由 LEN 和 CRC 确定,剩下的只是缓冲管理。
三个字段的分工再复述一遍:帧头负责「从哪开始」,LEN 负责「到哪结束」,CRC 负责「这段是不是真的」。三个职责任何一个被省略,都会在现场以「偶尔丢帧」的面目出现,而这种故障最难查,因为它不报错,只是少数据。
如果只能记住一个数,记 9.5:8N1 一帧 10 位,停止位的采样点在起始沿之后 9.5 个位时间,所有波特率容差都是从它除出来的。±2.5% 不是经验值,是 0.5 ÷ 9.5 ÷ 2 的结果。
延伸资料
配套脚本与输出按需取:
- 本文五个脚本(帧解析/CRC 对照/CSV 落盘/pty 实跑/波特率预算)都在同目录
serial/scripts/,一条命令可复现:for f in frame_parser crc16_compare csv_sink pty_link baud_budget; do python3 $f.py; done - 嵌入式毕设资料清单与导航 —— 全部模板、脚本与文档的索引
- 《嵌入式毕设从选题到答辩》专栏 —— 上位机、协议解析、答辩与文档成体系的合集
站内相关文章:
- CAN 位定时算不通:BRP、采样点与终端电阻的排错顺序 —— 同样是「先算时间额度再改参数」,串口容差与它同源
- ADC 读数为什么偏低:采样时间与源阻抗的一条算式 —— 采样窗口不够时的定量写法,可对照本文 6.1 的推导
- 毕设代码怎么交:把工程整理到评审五分钟能跑起来 —— 本文版本矩阵与「一条命令复现」的组织方式,和它同一套标准
- 嵌入式答辩 PPT 的 10 页结构 —— 把「现象—算式—验证—边界」搬到答辩页面上
- 毕设文档排版 40 条 —— 终端输出、表格与图注的排版细节
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/michael_jovi/article/details/171146596




