LCG元头像
串口数据总是粘包半包:先定帧再写解析器封面图

串口数据总是粘包半包:先定帧再写解析器

串口数据总是粘包半包:先定帧再写解析器

串口助手能看见数据,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.5serial.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.6v3.5macOS arm64400/4003.46 MB/s(289 ns/字节)500/500
3.11.13v3.5macOS arm64400/40010.96 MB/s(91 ns/字节)500/500
3.12.16v3.5Linux aarch64(容器)400/4005.49 MB/s(182 ns/字节)500/500
3.13.12v3.5macOS arm64400/40011.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 取值的实际行为差别很大,选错就是卡死或空转:

timeoutread(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_waiting10 ms 后说明
macOS + pty1616内核直通,字节立刻可读
Linux 容器 + pty016调度延迟,读到 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帧头 11 字节0xAA粗定位起点
1帧头 21 字节0x55二次确认,降低误判
2LEN1 字节0~200决定切点
3SEQ1 字节0~255 回绕查丢帧与重排
4PAYLOADLEN 字节遥测数据载荷
4+LENCRC162 字节小端判真伪

帧格式与三字段定位法

图 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不动缓冲,等下一次 feedleft
③ 假帧头LEN > 200丢 1 字节,重新找头dropped +1
④ 坏帧CRC 不符丢 1 字节,重新找头crc_err +1

七类样本与三个出口

图 2 把判定顺序画成四步:够不够 2 字节 → 是不是 AA 55 → LEN 是否合理且收齐 → CRC 对不对。每一步的「否」分支都指向一个明确的动作,这是解析器能被测试的前提。

3.3 七类样本跑一遍

样本不是随便造的:粘包、半包、坏 CRC、前置噪声、载荷内含假帧头、非法长度,这七类覆盖了现场九成以上的错位场景。

样本输入长度期望帧数关键计数说明
正常单帧11B1ok=1基线
粘包 3 帧36B3dropped=0一次 feed 三帧
半包(逐字节喂)36B3max_buf=13最坏切分
坏 CRC14B0crc_err=1,dropped=14整帧无人认领
前置噪声15B1dropped=4噪声被打掉
假帧头12B1dropped=0载荷里有 AA 55
长度越界12B1dropped=4LEN>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 实现的事实标准测试向量:

变体polyinit反射校验值(123456789)
CRC-16/CCITT-FALSE0x10210xFFFF否0x29B1
CRC-16/XMODEM0x10210x0000否0x31C3
CRC-16/MODBUS0xA0010xFFFF是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 0xFFFFinit 0x0000异或
temp=25.4(9B)0x67B20x7FC00x1872
\x01\x02\x03(3B)0xADAD0x61310xCC9C
0x00..0x0F(16B)0x3B370x513D0x6A0A

三个异或值都不是 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/行

CSV 落盘真跑输出

图 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 MHz960052.06259603.8+0.04%可用
8 MHz1152004.3125115942.0+0.64%可用
16 MHz1152008.6875115107.9−0.08%可用
25 MHz11520013.5625115207.4+0.01%可用
72 MHz11520039.0625115200.00.00%可用
8 MHz9216000.5625888888.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 了——这不是串口带宽,是测试脚本的节奏。看吞吐一定要说清「测的是哪一段」,否则数字没有意义。

pty 虚拟串口真跑输出

图 5 是这次运行的终端原始输出套框:命令、设备名、三组实验的全部数字都在图上,图注标了运行时间与环境版本。

7.3 Linux 容器里的两处不同

同一份脚本在 python:3.12-slim 里跑,功能全过,但两处数字不一样:

观察项macOS 宿主Linux 容器
写入后立刻 in_waiting160(10 ms 后变 16)
单次最大实收52B64B
端到端帧率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不要开始写解析
2LEN 设上限超过上限判假帧头缓冲会被一个假长度卡死
3校验范围含 LEN不含帧头,含 LEN/SEQ/载荷长度被改写时查不出来
4对标准校验值123456789 → 0x29B1实现错了,别往下走
5差分测试逐位法与查表法 0 不一致有一边写错
6四类样本粘包/半包/坏 CRC/假帧头缺一类就是没测
7计数器ok/left/dropped/crc_err出问题无法定位
8超时读超时 20~100 ms0 会空转,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
  • 嵌入式毕设资料清单与导航 —— 全部模板、脚本与文档的索引
  • 《嵌入式毕设从选题到答辩》专栏 —— 上位机、协议解析、答辩与文档成体系的合集

站内相关文章:

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/michael_jovi/article/details/171146596

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--