Android 串口通信的粘包与半包:一个 0x7E 帧同步器怎么写
一个必然会发生的问题
只要用串口跟 MCU 通信超过一天,你一定会遇到这两种情况之一:
- 一条完整的帧被拆成两段到达(半包)——你在
onDataReceived(byte[] data)里只拿到前半截,length字段说 32 字节,实到 17 字节; - 两条帧的字节粘在一起到达(粘包)——一次回调里塞了两个完整帧。
这不是 bug,是串口的物理属性:UART 是字节流,没有消息边界。MCU 那边一次 write() 出去的 32 字节,到 Android 侧的 InputStream.read() 完全可能分成 17 + 15、8 + 24、甚至 1 + 31 ——取决于波特率、USB 转串口芯片的缓冲策略、驱动一次提交的 URB 大小,以及你读的时候内核缓冲区里恰好有多少数据。
我做过的一个咖啡机项目用的是 115200 8N1,主控上报状态帧 40 字节左右。早期代码是这么写的:
// ❌ 错误示范
override fun onDataReceived(data: ByteArray) {
val frame = parse(data) // 假设 data 就是一帧
handle(frame)
}
在小流量下它神奇地"能用"——因为每次回调恰好就是一帧。一旦 MCU 开始高频上报(比如同时上报水温、压力、萃取进度),它就开始间歇性解析失败。这类 bug 最难受的地方是复现不了:你加日志、降低频率、单步调试,全都正常;一上整机就偶发。
为什么不能靠 sleep / 延时读
最常见的两种"修复"都不对:
// ❌ 收到数据后 sleep 50ms 再读一次,赌它能凑齐
Thread.sleep(50)
val rest = inputStream.read(buffer)
这能掩盖一部分半包,但代价是所有命令延迟至少 50ms,而且遇到粘包依然无能为力。
// ❌ 按固定长度读
inputStream.read(buffer, 0, 40)
read() 的语义是"至少读到一个字节就返回",不是"读满 40 字节"。要读满必须循环,而且一旦某帧长度可变(比如带变长 payload),固定长度直接失效。
正确做法只有一个:在应用层做帧同步(framing)。串口只负责搬字节,边界由协议自己定义。
协议里怎么定义边界
三种主流做法,选一种写进协议文档:
| 方式 | 边界依据 | 优点 | 缺点 |
|---|---|---|---|
| 长度字段 | 固定头 + len |
解析快、可靠 | 头部必须定长,len 错了就崩 |
| 分隔符 | 结束符(如 \r\n、0x7E) |
实现简单 | payload 里不能出现该字节,需要转义 |
| 定长帧 | 每帧长度固定 | 最省事 | 只能传固定结构 |
我的项目用的是帧头 + 长度 + 校验 + 帧尾的混合式:
┌──────┬──────┬──────┬──────────┬───────┬──────┐
│ 0xAA │ 0x55 │ LEN │ PAYLOAD │ CRC16 │ 0x0D │
│ 1B │ 1B │ 1B │ N B │ 2B │ 1B │
└──────┴──────┴──────┴──────────┴───────┴──────┘
LEN = payload 长度(不含头尾校验)
选这套的原因很实际:0xAA 0x55 双字节头误命中概率低;LEN 让我们知道"还差多少字节才能解析";CRC16 能挡住传输错误;0x0D 帧尾是双保险,用于快速发现"头对了但长度字段被干扰"的情况。
关键点:LEN 必须在头部,且头部定长。 如果长度字段本身也可能被拆开,就先用状态机凑齐头部(3 字节),再按 LEN 凑齐剩余部分。
实现:环形缓冲 + 状态机
不要在回调里直接解析。回调只做一件事:把字节追加到缓冲区,然后尝试从缓冲区里提取完整帧。
class FrameDecoder(
private val onFrame: (ByteArray) -> Unit
) {
private val buf = ByteArrayOutputStream(1024)
@Synchronized
fun feed(chunk: ByteArray) {
buf.write(chunk)
drain()
}
private fun drain() {
var data = buf.toByteArray()
var offset = 0
while (true) {
// 1. 找头
val head = indexOfHeader(data, offset)
if (head < 0) {
// 没有任何头,丢掉(但保留最后一字节,可能是半个头)
offset = maxOf(offset, data.size - 1)
break
}
offset = head
// 2. 头部是否够 3 字节
if (data.size - offset < 3) break
// 3. 按 LEN 算整帧长度
val payloadLen = data[offset + 2].toInt() and 0xFF
val total = 3 + payloadLen + 2 + 1
// 4. 整帧是否到齐
if (data.size - offset < total) break
// 5. 取帧并校验
val frame = data.copyOfRange(offset, offset + total)
if (verifyCrc(frame) && frame[total - 1] == 0x0D.toByte()) {
onFrame(frame)
offset += total
} else {
// 校验失败:只前进 1 字节重新找头,避免吞掉下一帧
offset += 1
}
}
// 把未消费的尾巴写回缓冲
buf.reset()
if (offset < data.size) buf.write(data, offset, data.size - offset)
}
private fun indexOfHeader(d: ByteArray, from: Int): Int {
var i = from
while (i < d.size - 1) {
if (d[i] == 0xAA.toByte() && d[i + 1] == 0x55.toByte()) return i
i++
}
return -1
}
}
这段代码有几个刻意的设计,值得逐条说:
① 校验失败只前进 1 字节,不是整帧丢弃。 如果 CRC 错了就跳过 total 字节,恰好说明"这个 LEN 是假的"——真正的帧头可能就在后面的某个字节上。前进 1 字节重新找头,最坏情况是多扫几个字节,但不会把下一帧一起吞掉。
② offset = data.size - 1 的尾部保护。 缓冲区里剩一个 0xAA 时,它可能是下一帧的头的前半部分。如果直接清空,这一帧就永远解析不出来了。所以最多保留最后 1 字节(头部 2 字节的话)。
③ 不建议用 ByteArrayOutputStream,用环形缓冲更好。 上面的写法每次 feed 都要 toByteArray() 拷一份,40 字节一帧、每秒 20 帧的话,拷贝开销不大(那就够用了)。但如果帧长几 KB、频率又高,就换成预分配的环形缓冲(readIndex/writeIndex 两个游标 + 取模),避免反复分配和 GC。
④ read() 的返回值必须处理。
val n = inputStream.read(buffer)
if (n < 0) { /* 串口被拔掉 / 对端关闭 */ }
if (n > 0) decoder.feed(buffer.copyOf(n))
read() 返回 -1 表示流结束(USB 串口拔线、MCU 复位重启都可能触发),返回 0 在阻塞模式下基本不会出现。绝对不要把 -1 当成"读到 0 字节"继续循环——那样会死循环吃满 CPU。
三个只会在真机上出现的坑
坑一:CRC 对不上,但数据看起来是对的。
常见原因是软硬件字节序不一致。MCU 发的 CRC 是小端,你按大端算,结果当然不同。约定清楚:CRC 高字节在前还是低字节在前,写进协议文档,两端各写一个测试向量(比如 [0x01,0x02] → 0x3D0F)对齐。
另一个原因是 CRC 覆盖范围不一致:MCU 算的是 payload,你算的是 LEN + payload。这类问题在单测里发现不了,只能靠两端的测试向量比对。
坑二:低频偶发的"半个帧卡住"。
现象是通信正常,但每隔几分钟有一批帧解析不出来。原因通常是帧间隔太短:MCU 连发两帧,中间没有间隔,其中一帧被干扰破坏后,解析器找不到头就丢了后面所有字节,直到下一次空闲。
解法有两个:一是协议里加最小帧间隔(MCU 侧保证 ≥2ms),二是在解码器里加超时清空——如果 200ms 内没有新字节进来,且缓冲区里有不完整数据,就判定这次传输作废、清空缓冲重新同步。固件里叫"帧超时",串口协议里很常见。
坑三:串口线程和 UI 线程抢数据。
InputStream.read() 是阻塞的,必须放在单独的线程(SerialWorker 之类)。但解析出来的数据要更新 UI,必须切回主线程:
// 推荐:用回调把完整帧交给上层,线程切换由上层负责
decoder.onFrame = { frame ->
val cmd = parseCommand(frame) // 纯计算,不碰 UI
mainHandler.post { render(cmd) } // 切主线程
}
不建议在解码器里直接 post——那会让解码器依赖 Android 主线程,单元测试就跑不起来了。我自己的做法是:解码器只依赖 (ByteArray) -> Unit 这个函数类型,测试时传一个收集 list 的 lambda,完全脱离 Android。
怎么测
半包/粘包的逻辑,用 JVM 单测比真机调试快一百倍。核心思路是喂任意分片,输出必须一致:
@Test
fun `任意分片都应解析出同样的帧`() {
val frame = buildFrame(payload = byteArrayOf(1, 2, 3, 4))
val out = mutableListOf<ByteArray>()
val d = FrameDecoder { out.add(it) }
// 逐字节喂
frame.forEach { d.feed(byteArrayOf(it)) }
assertEquals(1, out.size)
assertArrayEquals(frame, out[0])
// 两个字符合并发
out.clear()
val d2 = FrameDecoder { out.add(it) }
d2.feed(frame + frame)
assertEquals(2, out.size)
// 垃圾字节 + 半帧 + 剩余
out.clear()
val d3 = FrameDecoder { out.add(it) }
d3.feed(byteArrayOf(0x00, 0x11))
d3.feed(frame.copyOfRange(0, 5))
d3.feed(frame.copyOfRange(5, frame.size))
assertEquals(1, out.size)
}
三条用例覆盖了 90% 的现场问题:逐字节喂(最极端的半包)、双帧粘连(粘包)、前缀垃圾 + 中途断开(重同步)。这三个都过了,真机上基本不会再出现解析类 bug。
小结
串口通信里,"收不到数据"是硬件问题,"收到了但解析不对"几乎都是把字节流当消息流用。协议层定义好边界(头 + 长度 + 校验 + 尾),应用层用"只追加、按帧提取"的解码器,再加上三条分片单测——这套东西不大,但能让后面所有功能都建立在可靠的地基上。
反过来,如果解码层是错的,上层写多少重试、多少超时补偿都没用:你补偿的是自己解析错误造成的假故障。
- 点赞
- 收藏
- 关注作者
评论(0)