有个升降机构,上位机下发「前进一米」,设备收到后开始动作,完成后回一个 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 解决。

这些参数最好集中配置:超时、重传上限、去重窗口、序号位宽,一处修改、一处查看。散落在代码里,现场调参时很容易漏掉某一段,结果就是「改了一个,另一个还在用旧值」。

最后,重传不是免费的可靠性。它把「可能丢」变成「大概率到」,代价是延迟、带宽和重复风险。设计时要先问:这条命令重复执行会怎样?答案决定了要不要序号、要不要幂等键。

今天就能验证的五个练习

  1. 把上面的模拟跑一遍,确认带序号和不带序号的 execs 差在哪一条命令上。
  2. 把 drop_data 和 drop_ack 分别调成 0.1、0.3、0.5,记录每种组合的发送次数和成功次数。
  3. 把 max_retry 从 4 改成 2,看哪些命令会提前放弃,想清楚放弃后上层该做什么。
  4. 给模拟里的命令加一个「任务 ID + 步骤号」的幂等键,让接收端跨重启也能去重,写下键存在哪里。
  5. 测你手上一条链路的 RTT:连续发 20 条查询,记录往返时间,算平均值和最大值,再定一个超时上限。

小结

不可靠链路上,重传是必要的,但重传本身会制造重复。序号让接收方分辨新旧,ACK 让发送方知道到达,去重和幂等让重复不产生副作用。超时要按 RTT 和抖动来定,重传要有上限,失败要能上报。

下一篇讲UART、SPI、I2C 各自适合什么。前面五篇讲的都是「字节怎么组织、怎么确认」,还没碰物理层。同样是接一个传感器,UART、SPI、I2C 的引脚数、速率、拓扑、距离完全不同,选错了,后面所有协议设计都要跟着别扭。