有个升降机构,上位机下发「前进一米」,设备收到后开始动作,完成后回一个 ACK。某次现场反馈位置不对,查日志发现同一条指令发了三次:第一次设备收到了,也执行了,但 ACK 在返回途中丢了;上位机等不到确认,超时重发;设备又执行了两次。一米变三米。
这类问题在实验室几乎测不出来。短线、低干扰、设备响应快,ACK 很少丢,重传逻辑看起来完全正确。到了现场,长线、电机干扰、设备忙,ACK 偶尔丢一次,重复执行就发生了。
更麻烦的是,重传本身没有错。链路不可靠,丢了就得重发,否则命令永远到不了。问题在于:发送方怎么知道「对方是没收到」还是「收到了但确认丢了」?接收方又怎么知道「这是新命令」还是「上次那条又来了」?
这篇讲停等协议、序号、确认、超时和去重,然后用 Python 模拟一条会丢数据、也会丢 ACK 的链路,看带序号和不带序号两种写法各自执行了几次。模拟在本机 Python 3.15.0 上跑,输出原样贴出。它是链路逻辑模拟,不是硬件实测;真实链路的丢包率、RTT 抖动未在本机实测,要在现场测。
不可靠链路上,重传会制造新问题
先定义一个词。ACK(acknowledgement,确认)是接收方回给发送方的一个短消息,意思是「你刚才那条我收到了」。发送方发出命令后启动一个计时器,在超时之前收到 ACK 就算成功,收不到就重发。
这套机制叫停等协议(stop-and-wait):发一条,等确认,确认到了再发下一条。它简单、好实现,适合命令频率不高的设备控制。代价是链路利用率低,一条命令一个来回,RTT 越长,吞吐越低。
停等协议有一个绕不开的漏洞:确认本身也可能丢。发送方超时重发时,它无法区分两种情况——接收方根本没收到原命令,或者收到了、执行了,但 ACK 丢了。如果是后者,重发就会让同一条命令执行第二次。
所以「超时重传」不能单独存在,它必须配「序号」和「去重」。序号让接收方分辨新旧,去重让重复包不再触发动作。缺了这两样,重传越积极,重复执行越严重。
序号、ACK、NAK 各自管什么
序号(sequence number)是每条命令带的一个编号,通常一字节或两字节,循环使用。接收方记住「上一条处理过的序号」,新包序号和它不同才执行;相同就认为是重传,只回 ACK,不再动作。
序号不需要全局唯一,只要「相邻两条不重复」就够。一字节序号 0 到 255 循环,连续发 256 条才会撞一次;实际设备命令很少这么密集。用两字节更稳,代价是多一个字节。
ACK 有两种常见形式: cumulative(累计确认),回一个「我收到了序号 N 及之前的全部」;individual(单独确认),每收到一条回一条。停等协议用单独确认就够,滑动窗口才需要累计确认。
NAK(negative acknowledgement,否定确认)是接收方明确告诉发送方「这条坏了,请重发」。它能加快恢复,因为不用等超时;但 NAK 本身也可能丢,所以不能只靠 NAK,超时仍然是兜底。
确认还要带上下文。只回一个「OK」,发送方不知道对应哪条命令;回「序号 3 已执行」,发送方才敢把这条从待确认队列里删掉。确认消息越短越好,但必须能对应到具体命令。
ACK 帧自己也要校验。没有校验的 ACK 可能因为干扰变成一段「看起来像确认」的字节,发送方误以为成功,实际命令没执行。ACK 至少要带帧头、序号和 CRC,长度可以很短,但不能省校验。
超时时间怎么估
超时(timeout)是发送方愿意等多久。它必须大于「正常往返时间」,否则会把正常的慢包当成丢包,频繁重传,反而加重链路负担。
往返时间 RTT(round-trip time)是「发出去到收到确认」的时间。它不是一个固定值,会随链路长度、设备处理时间、重传队列变化。工程上常用「测几次,取平均,再加几倍偏差」的办法,而不是拍一个固定数字。
一个实用的起点是:超时 = 平均 RTT × 2 到 3,再按最大抖动留余量。比如实测平均 RTT 20 毫秒,抖动 ±10 毫秒,超时可以设在 60 到 80 毫秒。设完要在现场连续跑一段时间,看误重传率。
重传间隔通常用指数退避(exponential backoff):第一次超时后等 T,第二次等 2T,第三次等 4T。链路拥塞时,固定间隔重传会让所有设备同时重发,越堵越糟;退避能把发送压力摊开。
重传次数要有上限。无限重传会让一条坏命令永远占着队列,还会在链路恢复时集中爆发。常见上限是 3 到 5 次,超过就报错,让上层决定是重试、降级还是提示人工。
测量 RTT 还有一个坑:重传包的确认到底对应哪一次发送?如果按「收到 ACK 的时间减去最后一次发送时间」算,会把超时估短。工程上常忽略重传样本,只用「一次发送就确认」的样本估 RTT,避免把重传的额外延迟混进去。
用 Python 模拟一条会丢包的链路
下面这段代码模拟三条命令的下发过程。链路有两个丢包点:数据可能丢,ACK 也可能丢。发送方带序号、超时重传;接收方记住上一条序号,重复包只回 ACK 不执行。
import random
def run(use_seq, drop_data=0.35, drop_ack=0.30, max_retry=4, seed=20261106):
rng = random.Random(seed)
sends = recv = execs = acks_lost = 0
last_seq = -1
log = []
for cmd_id in range(3):
ok = False
for attempt in range(1, max_retry + 1):
seq = cmd_id
sends += 1
if rng.random() < drop_data:
log.append("cmd%d try%d seq=%d DATA LOST" % (cmd_id, attempt, seq))
continue
recv += 1
duplicate = use_seq and seq == last_seq
if duplicate:
log.append("cmd%d try%d seq=%d duplicate, no execute, ACK sent"
% (cmd_id, attempt, seq))
else:
execs += 1
if use_seq:
last_seq = seq
log.append("cmd%d try%d seq=%d executed (exec #%d)"
% (cmd_id, attempt, seq, execs))
if rng.random() < drop_ack:
acks_lost += 1
log.append("cmd%d try%d ACK LOST, sender waits" % (cmd_id, attempt))
continue
log.append("cmd%d try%d ACK ok" % (cmd_id, attempt))
ok = True
break
if not ok:
log.append("cmd%d GIVE UP after %d tries" % (cmd_id, max_retry))
return log, dict(sends=sends, recv=recv, execs=execs, acks_lost=acks_lost)
log, st = run(True)
print("=== with sequence + ACK + dedup ===")
for line in log:
print(" ", line)
print("sends=%d recv=%d execs=%d acks_lost=%d"
% (st["sends"], st["recv"], st["execs"], st["acks_lost"]))
log, st = run(False)
print("=== same link, no seq, blind resend x3 ===")
for line in log:
print(" ", line)
print("sends=%d recv=%d execs=%d" % (st["sends"], st["recv"], st["execs"]))
for p in (0.1, 0.35, 0.6):
_, st = run(True, drop_data=p, drop_ack=p)
print("drop=%.2f -> sends=%d execs=%d (should be 3)"
% (p, st["sends"], st["execs"]))
本机实际输出:
=== with sequence + ACK + dedup ===
cmd0 try1 seq=0 executed (exec #1)
cmd0 try1 ACK LOST, sender waits
cmd0 try2 seq=0 DATA LOST
cmd0 try3 seq=0 duplicate, no execute, ACK sent
cmd0 try3 ACK ok
cmd1 try1 seq=1 executed (exec #2)
cmd1 try1 ACK ok
cmd2 try1 seq=2 DATA LOST
cmd2 try2 seq=2 DATA LOST
cmd2 try3 seq=2 DATA LOST
cmd2 try4 seq=2 DATA LOST
cmd2 GIVE UP after 4 tries
sends=8 recv=3 execs=2 acks_lost=1
=== same link, no seq, blind resend x3 ===
cmd0 try1 seq=0 executed (exec #1)
cmd0 try1 ACK LOST, sender waits
cmd0 try2 seq=0 DATA LOST
cmd0 try3 seq=0 executed (exec #2)
cmd0 try3 ACK ok
cmd1 try1 seq=1 executed (exec #3)
cmd1 try1 ACK ok
cmd2 try1 seq=2 DATA LOST
cmd2 try2 seq=2 DATA LOST
cmd2 try3 seq=2 DATA LOST
cmd2 try4 seq=2 DATA LOST
cmd2 GIVE UP after 4 tries
sends=8 recv=3 execs=3
drop=0.10 -> sends=6 execs=3 (should be 3)
drop=0.35 -> sends=12 execs=2 (should be 3)
drop=0.60 -> sends=12 execs=2 (should be 3)
两段用的是同一条链路、同一个随机种子,发送次数都是 8 次。区别在 execs:带序号时总共执行 2 次,不带序号时执行 3 次。多出来的那一次,就是 cmd0 在 ACK 丢失后被重发、接收方又执行了一遍——也就是开头那个「多走一米」。
注意带序号那组也只执行了 2 次,不是 3 次。原因是 cmd2 连续四次都被链路丢了,发送方放弃。这提醒一件事:重传能提高到达率,但不能保证到达;重传次数上限一到,命令就是失败了,上层必须知道怎么处理失败。
把丢包率调到 0.10,三组命令都能在重传上限内完成;调到 0.35 和 0.60,结果取决于随机序列。这个模拟的意义不是预测你的现场,而是让你看清「不带序号」时,多执行是怎么发生的。
同一组参数下还有一组汇总:丢包率 0.10 时发送 6 次、执行 3 次;0.35 时发送 12 次、执行 2 次;0.60 时发送 12 次、执行 2 次。发送次数封顶在 12,是因为三条命令各 4 次重传上限。链路越差,发送次数先撞上限,然后命令失败,而不是「一直重试直到成功」。
两种写法,代价差在哪
无 ACK,盲重发三次
实现最简单,发送方定时重发固定次数。代价是无法知道对方收没收到,重复执行几乎必然发生;接收方也无法分辨新命令和重传。只适合幂等操作,比如「查询当前温度」——执行三次和一次结果一样。
序号 + ACK + 去重
能分辨「没收到」和「确认丢了」,重传不会导致重复执行。代价是每帧多一个序号字段,接收方要维护状态,发送方要维护待确认队列和计时器;超时和重传次数还要按现场调,调不好会频繁重传或响应变慢。
选择取决于命令的语义。查询、读状态这类天然幂等的操作,盲重发也能用,简单直接。控制类命令——前进、开关、写寄存器——重复执行会改变物理状态,必须带序号和去重,不能省。
还有第三种做法:ACK 里带「执行结果」,而不只是「收到」。比如回「序号 3,执行成功」或「序号 3,参数越界」。这样发送方不仅知道到达,还知道执行结果,重传逻辑也更清楚:执行失败要不要重试,由业务决定。
幂等:最后一道防线在业务层
幂等(idempotent)的意思是,同一个操作执行一次和执行多次,结果一样。查询是幂等的,读三次温度不会让温度变三倍;「前进一米」不是幂等的,执行三次就走三米。
协议层的去重能挡住大部分重复包,但不是全部。比如接收方重启,把「上一条序号」的内存状态丢了,重启后收到一个重传包,可能又执行一次。要彻底解决,得让业务层也参与。
常见做法是给命令带一个业务幂等键,比如「任务 ID + 步骤号」。设备执行前先查这个键有没有执行过,执行过就直接回成功,不再动作。键要持久化,重启后还能查;只放内存,重启就失效。
幂等键会增加存储和查询开销。对简单的设备,可能只在 NVM 里记「最近执行的任务 ID」,重启后比一次;对复杂系统,需要一个小的执行记录表。值不值得,取决于重复执行的代价:多走一米和重复读一次温度,完全不是一个量级。
去重窗口也有大小。只记「最近一条序号」,能挡住连续重传;如果旧包延迟很久才到,可能绕过窗口。可以把最近 N 条的序号都记下来,N 取「最大重传次数加链路最大延迟内可能的重传数」。窗口越大,内存越多,但能挡住的乱序重复也越多。
滑动窗口和半双工冲突
停等协议一条一条发,链路空闲时间多。滑动窗口(sliding window)允许发送方连续发多条,不等每条的 ACK,用一个窗口限制「已发未确认」的数量。窗口越大,吞吐越高,但接收端缓冲和序号空间也越大。
设备控制里很少用大窗口。命令之间有依赖,前一条没执行完,后一条不该发;窗口开了反而增加乱序和冲突。滑动窗口更多出现在数据采集、文件传输这类「连续块」场景。
窗口大小还受序号位宽限制。一字节序号最多 256 个值,窗口不能超过 255,否则新旧包无法区分;实际工程里窗口通常远小于这个上限,留出安全余量。
半双工链路(比如 485)还要考虑方向切换。发送方发完命令要切回接收,等 ACK;如果切换太慢,ACK 的前几个字节会丢;切换太快,自己的发送还没结束,会把总线拉坏。这个时序问题在协议层看不出来,要靠驱动和硬件配合。
还有广播命令。广播没有明确的对象,不能要求每条都回 ACK,否则总线上全是确认。常见做法是广播只发一次,靠业务层的状态上报来间接确认;或者广播带一个组号,组内设备错开时间回复。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 重发后设备执行了两次 | 没有序号去重,ACK 丢失触发重传 | 看命令帧里有没有序号,接收端有没有记住上一条 |
| ACK 丢了,发送方一直重发 | 确认没有超时兜底,或超时太短 | 抓两端日志,确认接收方是否回过 ACK,发送方是否收到 |
| 超时太短,频繁重传 | 超时小于正常 RTT 或抖动余量 | 统计正常往返时间,按 2 到 3 倍 RTT 重设 |
| 序号回绕后旧包被当成新包 | 接收端用「递增」判断新旧,回绕时失效 | 改成「和上一条不同」判断,或扩大序号位宽 |
| 链路延迟抖动大,时好时坏 | 固定超时不适应抖动 | 记录 RTT 分布,按最大值加余量,或用退避 |
| 半双工切换时 ACK 丢失 | 方向切换时序不对,或总线冲突 | 看驱动切换延时和总线占用,必要时加大间隔 |
| 重传多次仍失败 | 链路持续中断,或对端已经离线 | 看重传上限和失败上报,确认对端状态 |
边界与代价
重传增加延迟和带宽。停等协议每条命令至少一个 RTT,重传一次就翻倍;链路差的时候,响应时间会明显变长。控制类系统要把这个延迟算进节拍,不能假设命令立即生效。
序号占字段。一字节序号让每帧多一个字节,两字节多两个;对短命令来说,这是实打实的开销。序号位宽还要够用,太小会频繁回绕,太大浪费带宽。
幂等需要业务设计。协议层只能去重到「最近一条」,跨重启、跨设备、跨任务的重复,需要业务层有幂等键。这是协议和业务一起做的事,不能只丢给通信层。
超时值依赖场景。实验室的 RTT 和现场不一样,同一套参数换条线就可能失效。上线前要在目标环境测,运行中要有监控,不能设完就不管。
确认机制不能修复所有错误。它能处理丢包、重复、部分乱序,但处理不了「命令语义错了」「设备执行失败」「机械卡住」。这些要靠业务层的状态上报和错误码,别指望 ACK 解决。
这些参数最好集中配置:超时、重传上限、去重窗口、序号位宽,一处修改、一处查看。散落在代码里,现场调参时很容易漏掉某一段,结果就是「改了一个,另一个还在用旧值」。
最后,重传不是免费的可靠性。它把「可能丢」变成「大概率到」,代价是延迟、带宽和重复风险。设计时要先问:这条命令重复执行会怎样?答案决定了要不要序号、要不要幂等键。
今天就能验证的五个练习
- 把上面的模拟跑一遍,确认带序号和不带序号的
execs差在哪一条命令上。 - 把
drop_data和drop_ack分别调成 0.1、0.3、0.5,记录每种组合的发送次数和成功次数。 - 把
max_retry从 4 改成 2,看哪些命令会提前放弃,想清楚放弃后上层该做什么。 - 给模拟里的命令加一个「任务 ID + 步骤号」的幂等键,让接收端跨重启也能去重,写下键存在哪里。
- 测你手上一条链路的 RTT:连续发 20 条查询,记录往返时间,算平均值和最大值,再定一个超时上限。
小结
不可靠链路上,重传是必要的,但重传本身会制造重复。序号让接收方分辨新旧,ACK 让发送方知道到达,去重和幂等让重复不产生副作用。超时要按 RTT 和抖动来定,重传要有上限,失败要能上报。
下一篇讲UART、SPI、I2C 各自适合什么。前面五篇讲的都是「字节怎么组织、怎么确认」,还没碰物理层。同样是接一个传感器,UART、SPI、I2C 的引脚数、速率、拓扑、距离完全不同,选错了,后面所有协议设计都要跟着别扭。