很多人在用串口调试助手收发字符串时都会产生同一个疑问:串口一次只能发几十上百个字节,速度也只有 9600、115200 这种“古董级”速率,真的能用来传文件吗?
答案是可以,而且在实际项目中很常见。尤其是嵌入式设备没有网络、没有 USB、没有 SD 卡时,串口往往是唯一能跟外部交换数据的通道。Bootloader 升级固件、传感器固件烧录、配置参数下发、离线日志导出,这些场景都在用串口传文件。
不过,串口传文件和串口发字符串完全是两码事。字符串只需要保证“能看懂”,文件传输必须保证“一个字节都不错”。本文会从协议设计、环境准备、完整代码、踩坑排查几个方面,把串口传文件的完整思路讲清楚。
1. 串口传文件的背景与核心概念
1.1 什么是串口文件传输
串口文件传输,指的是通过 UART(Universal Asynchronous Receiver/Transmitter,通用异步收发器)接口,将一份完整的二进制文件或文本文件,从发送端(通常是 PC 上位机)传输到接收端(通常是单片机、开发板、工控设备),或者反向传输。
串口传输的本质是逐字节发送,物理层一次只发送一个起始位、若干个数据位、一个可选的校验位和一个停止位。以最常见的 8N1 格式为例,一帧就是 10 个 bit。波特率 115200 时,理论峰值速度大约是 11520 字节/秒,也就是约 11.25 KB/s。
这个速度放在今天当然不算快,但在很多场景下完全够用。比如一个 64KB 的固件包,用 115200 波特率传输,理想情况下大约 6 秒完成;如果用 460800 甚至 921600 波特率,时间还能再压缩。
1.2 典型应用场景
串口传文件在下面这些场景中非常常见:
- Bootloader 固件升级:STM32、ESP32、GD32 等芯片通过串口接收 bin 文件并写入 Flash。
- 配置文件下发:工业设备、PLC、传感器模块通过串口导入参数配置。
- 离线日志导出:设备运行日志存在 Flash 或外部存储中,通过串口导出到 PC 分析。
- 资源文件更新:字库、图片、音频等资源文件需要通过串口烧录到外部 Flash。
- 嵌入式调试:开发阶段需要把测试数据文件发送到设备,模拟真实输入。
从热搜词里也能看出,大家关心的串口 DMA、串口接收丢数据、STM32 串口调试、CH340 驱动、串口调试助手等,本质上都是串口传文件过程中会遇到的配套问题。
1.3 为什么不能直接把文件“扔”给串口
很多新手的第一反应是:把文件内容读出来,通过串口发送函数逐字节发过去,不就行了吗?
理论上可以,实际上问题很大。串口是流式传输,没有 TCP 那种天然的“消息边界”概念,接收端拿到的只是一串字节流。直接把文件字节往串口里塞,会遇到几个致命问题:
- 粘包与断包:接收端无法知道一包数据从哪里开始、到哪里结束。
- 数据错位:如果中间丢了一个字节,后面所有数据全部错位,文件直接损坏。
- 无法校验:接收端不知道收到的数据对不对,错误无法被发现。
- 无法续传:传输中断后只能从头再来。
- 速度不匹配:发送端发送速度超过接收端处理速度时,缓冲区溢出丢数据。
所以,串口传文件必须建立在“协议”之上。协议的作用就是解决上面这些问题:给数据划分边界、添加校验信息、提供确认和重传机制。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 环境准备与基础条件
在写代码之前,先把硬件、软件和参数准备好。串口传文件看似简单,实际排错时环境问题占了一半。
2.1 硬件环境
最基础的硬件组合就是:PC 端 USB 转串口工具 + 目标设备串口引脚。
PC 端常见的 USB 转串口芯片有:
- CH340:国产芯片,驱动通用,性价比高,很多开发板自带。
- CP2102:Silicon Labs 芯片,稳定性较好。
- FT232:FTDI 芯片,兼容性最好,但价格较高。
- PL2303:早期常用,新版驱动对旧芯片支持有问题,容易识别失败。
连接时注意:
- 开发板的 TX 接 USB 转串口工具的 RX。
- 开发板的 RX 接 USB 转串口工具的 TX。
- GND 必须共地,否则通信不稳定。
- 如果板子已经通过 USB 供电,通常不需要额外接电源线。
涉及 RS485 传输时,还要注意 A/B 线不要接反,且需要终端电阻匹配。
2.2 软件环境
本文示例以 Windows 为主,代码使用 Python 3,接收端示例覆盖 STM32 思路。
必备软件:
- Python 3.8 及以上版本。
- pyserial 库:
pip install pyserial - 串口调试助手(SSCOM、XCOM、MobaXterm Serial 等),用于快速验证链路。
- 芯片对应的 USB 转串口驱动,确保设备管理器中能看到 COM 口。
Linux 环境下,可以使用 ls /dev/ttyUSB* 或 ls /dev/ttyACM* 查看串口设备,使用 minicom 或 picocom 进行串口调试。
2.3 串口连接参数
两端必须一致的参数有:
- 波特率(Baud Rate)
- 数据位(Data Bits)
- 停止位(Stop Bits)
- 校验位(Parity)
- 流控(Flow Control)
最常见的组合是:115200 8 N 1,即波特率 115200、8 位数据位、无校验、1 位停止位、无流控。
注意:
- 如果传输文件较大,可以考虑更高波特率,但前提是双方硬件和线材质量都能稳定支持。
- 不要轻易开硬件流控(RTS/CTS),很多调试工具和开发板默认不接流控线,开了反而通信失败。
- 校验位不建议使用奇偶校验,串口奇偶校验只能检测单比特错误,对文件传输帮助有限,更可靠的做法是在协议层做 CRC 校验。
2.4 传输前检查清单
开始传文件之前,先用下面这几步快速验证链路是否正常:
- 在 PC 串口助手中打开对应 COM 口,参数设为 115200 8N1。
- 短接 TX 和 RX 引脚,打开串口助手“自发自收”功能,如果能收到自己发的数据,说明 USB 转串口工具本身没问题。
- 连接开发板后,发送
AT或任意测试字符串,观察开发板是否有响应。 - 用示波器或逻辑分析仪抓 TX 引脚波形,确认波特率是否正确。
链路确认正常后,再开始协议设计和代码工作。否则一旦传文件失败,很难判断是链路问题还是协议问题。
3. 串口文件传输的协议设计
串口文件传输的协议设计是整个方案的核心。好的协议要满足以下几个目标:
- 接收端能准确找到每一包数据的边界。
- 接收端能判断数据是否完整、是否正确。
- 发送端能知道接收端是否成功收到数据。
- 传输中断时能恢复或明确报错。
下面拆解协议的关键组成部分。
3.1 帧结构
帧(Frame)是串口文件传输的基本单位。每一帧通常包含以下几个字段:
| 字段 | 含义 | 推荐长度 |
|---|---|---|
| 帧头 | 标识一帧的开始 | 2 字节,如 0xAA 0x55 |
| 帧类型 | 区分命令帧、数据帧、确认帧 | 1 字节 |
| 数据长度 | 载荷数据的字节数 | 2 字节 |
| 帧序号 | 标识当前帧序号 | 2 字节 |
| 载荷数据 | 真正的文件内容 | 128/256/512 字节 |
| 校验值 | 对整帧做校验 | 2 字节 CRC16 |
以 128 字节载荷为例,一帧实际的传输大小大约是 2+1+2+2+128+2 = 137 字节。有效载荷率约为 93.4%,这个开销是可以接受的。
帧头的作用很关键。接收端通过检测帧头来“对表”,找到数据包的起始位置。帧头要尽量选择不常见的字节组合,比如 0xAA 0x55,避免文件数据中恰好出现相同组合导致误判。
3.2 校验算法
串口文件传输最常用的校验算法是 CRC16。
CRC(Cyclic Redundancy Check,循环冗余校验)是一种根据数据内容计算固定长度校验值的算法。相比累加和,CRC 能检测出更多类型的错误,包括多位错误和突发错误。
CRC16 的实现有很多变体,常见的有 CRC-16/MODBUS、CRC-16/CCITT、CRC-16/XMODEM。如果发送端和接收端使用不同变体,校验值会不一致,所以协议文档里必须明确指定用的是哪种 CRC16。
下面是一个标准的 CRC-16/MODBUS 校验函数:
python复制# 文件路径:crc16.py
def crc16_modbus(data: bytes) -> int:
crc = 0xFFFF
for byte in data:
crc ^= byte
for _ in range(8):
if crc & 0x0001:
crc = (crc >> 1) ^ 0xA001
else:
crc >>= 1
return crc
使用方式:
python复制data = b"hello serial"
crc = crc16_modbus(data)
print(hex(crc))
3.3 流控与缓冲
串口传输中,发送端和接收端的处理速度往往不一致。比如发送端以 115200 波特率持续发送数据,接收端单片机却需要时间把数据写入 Flash,或者需要时间解析协议。如果接收端缓冲区满了,后续数据就会丢失。
解决速度不匹配有三种常见方案:
- 协议层确认-重传机制:发送端发完一帧后等待接收端 ACK,收到确认才发下一帧,否则超时重传。这是最可靠的方式,也是本文推荐的方式。
- 硬件流控 RTS/CTS:依赖硬件引脚控制数据流,需要接线支持。
- 软件流控 XON/XOFF:通过发送特定字符暂停和恢复数据流,但二进制数据中可能恰好出现这些字符,不适合文件传输。
协议层确认机制的核心逻辑:
code复制发送端发送数据帧
接收端收到并校验
校验通过 -> 回复 ACK(确认帧)
校验失败 -> 回复 NAK(否定确认帧)
发送端收到 NAK 或超时未收到 ACK -> 重发当前帧
3.4 重传与确认机制
重传机制需要处理两个问题:
问题一:ACK 丢失
发送端发出数据帧后,接收端成功收到并回复 ACK,但 ACK 在回传过程中丢失了。发送端超时后会重发同一个数据帧。接收端怎么知道这是重复帧?靠帧序号。接收端保存一个“期望收到的帧序号”,收到重复序号时,不写入文件数据,但重新回复 ACK。
问题二:数据帧中途损坏
如果接收端校验失败,回复 NAK。发送端收到 NAK 后重发。接收端再次校验,成功则回复 ACK,并处理数据。
重传次数要有限制,建议设置最大重传次数,比如 5 次或 10 次。超过上限后,发送端主动中断传输并报告错误。否则在链路不稳定时,程序会陷入无限重传的死循环。
3.5 文件结束与完整性验证
所有数据帧发送完成后,发送端需要发送一个文件结束帧,包含:
- 文件总字节数。
- 整个文件的 CRC32 校验值。
- 总帧数。
接收端收到结束帧后,将所有收到的数据拼接成完整文件,计算整体 CRC32,与结束帧中的值比对。一致则回复完成确认,否则回复错误。这一步是为了防止“每一帧都通过 CRC16,但中间确实丢了一整帧且接收端未察觉”的极端情况。
有了上面的协议设计,串口传文件的正确性就有了保证。接下来进入实战环节。
4. 三种常用实现方案对比
串口传文件没有唯一的标准方案。根据项目复杂度、硬件资源和开发周期,可以选择不同的实现路径。
4.1 方案一:串口调试助手的“发送文件”功能
最简单的做法是使用现成的串口调试助手,如 XCOM、SSCOM。这类工具通常自带“发送文件”按钮,可以将任意文件按原始字节发送到串口。
这种方式适合什么场景呢?
- 接收端程序已经写好了,只按固定长度读取串口数据并写入存储。
- 文件是纯文本,接收端不需要做边界检测。
- 传输链路质量很好,几乎没有丢字节的可能。
缺点也很明显:
- 没有协议层校验,传错了无法发现。
- 没有重传机制,丢了字节只能重新传。
- 文件内容中如果包含特殊字节,可能被接收端误判为控制命令。
所以,这种方式只适合开发调试阶段的临时验证,不建议用于正式产品。
4.2 方案二:使用 XMODEM 协议
XMODEM 是经典的串口文件传输协议,诞生于 1977 年,至今仍在很多嵌入式 Bootloader 中使用。
XMODEM 的基本工作方式:
- 数据块固定为 128 字节。
- 每块数据带有块编号。
- 使用 1 字节累加和校验(XMODEM-CRC 使用 CRC16)。
- 接收端每收到一个块,回复 ACK 或 NAK。
- 发送端等待确认后发送下一块。
XMODEM 的优点是协议成熟、实现简单、网上资料丰富。缺点也很明显:
- 128 字节块较小,协议开销高。
- 没有文件名、文件大小信息。
- 没有断点续传功能。
- 累加和校验太弱,XMODEM-CRC 的 CRC16 也只是一个块一个校验,无法覆盖整体完整性。
如果设备 Bootloader 已经支持 XMODEM,直接使用是最省事的路线。比如很多 IAP 升级程序就是用 XMODEM 接收固件。但如果可以自定义协议,建议使用下面第三种方案。
4.3 方案三:自定义轻量协议(推荐)
自定义协议适合大多数工业设备和嵌入式项目。原因很直接:
- 可以灵活控制帧大小,适配接收端缓冲区。
- 可以携带文件名、文件大小、CRC32 等元信息。
- 可以设计多帧确认和批量重传策略。
- 实现难度不算高,几百行代码能搞定。
本文下一节给出的完整实战就是自定义协议方案。该方案结合了 XMODEM 的确认-重传思路,并补充了文件级完整性校验。
5. 完整实战:Python 上位机 + 串口自定义文件传输
这一节实现一个完整的串口文件传输方案。上位机用 Python 编写,接收端用伪代码描述 STM32 实现思路。读者拿到后可以改造为 C#、Java、C 等任意语言。
5.1 项目结构
code复制serial_file_transfer/
├── send.py # PC 端发送程序
├── receive.py # PC 端接收程序(用于测试接收逻辑)
├── crc16.py # CRC16 工具模块
├── crc32.py # CRC32 工具模块
└── test.bin # 测试用二进制文件
为简化实现,本实战将 crc16_modbus 和 crc32 集中在一个工具模块中。
5.2 协议定义
本实战定义的帧格式如下:
code复制帧头(2B) | 帧类型(1B) | 数据长度(2B) | 帧序号(4B) | 载荷(NB) | CRC16(2B)
帧类型取值:
0x01:握手帧0x02:数据帧0x03:结束帧0x80:ACK 帧0x81:NAK 帧0x82:完成确认帧
握手帧作用:
- 发送端发送文件名、文件大小、CRC32 校验值。
- 接收端确认后,才开始传输数据。
数据帧作用:
- 按顺序发送文件内容,默认每帧 256 字节载荷。
结束帧作用:
- 通知接收端文件传输完成,包含文件总帧数信息。
5.3 上位机发送端代码
先创建 CRC 工具模块。
python复制# 文件路径:crc16.py
def crc16_modbus(data: bytes) -> int:
"""计算 CRC-16/MODBUS 校验值"""
crc = 0xFFFF
for byte in data:
crc ^= byte
for _ in range(8):
if crc & 0x0001:
crc = (crc >> 1) ^ 0xA001
else:
crc >>= 1
return crc
python复制# 文件路径:crc32.py
import zlib
def crc32(data: bytes) -> int:
"""计算 CRC32 校验值(与 zlib 兼容)"""
return zlib.crc32(data)
接下来是核心的发送端代码。
python复制# 文件路径:send.py
import os
import time
import serial
from crc16 import crc16_modbus
from crc32 import crc32
# 协议常量
FRAME_HEADER = 0xAA55
FRAME_HANDSHAKE = 0x01
FRAME_DATA = 0x02
FRAME_END = 0x03
FRAME_ACK = 0x80
FRAME_NAK = 0x81
FRAME_DONE = 0x82
PAYLOAD_SIZE = 256
MAX_RETRY = 10
TIMEOUT = 2.0
def build_frame(frame_type: int, payload: bytes, seq: int = 0) -> bytes:
"""构造一帧数据:帧头 + 类型 + 长度 + 序号 + 载荷 + CRC16"""
frame_body = bytes([frame_type]) + len(payload).to_bytes(2, 'big') + seq.to_bytes(4, 'big') + payload
crc = crc16_modbus(frame_body)
frame = FRAME_HEADER.to_bytes(2, 'big') + frame_body + crc.to_bytes(2, 'big')
return frame
def send_frame(ser: serial.Serial, frame_type: int, payload: bytes, seq: int = 0) -> bool:
"""发送一帧并等待 ACK/NAK,返回是否发送成功"""
frame = build_frame(frame_type, payload, seq)
for attempt in range(MAX_RETRY):
ser.write(frame)
ser.flush()
start = time.time()
while time.time() - start < TIMEOUT:
if ser.in_waiting >= 5:
resp = ser.read(5)
if resp[0] == FRAME_HEADER.to_bytes(2, 'big')[0] and resp[1] == FRAME_HEADER.to_bytes(2, 'big')[1]:
if resp[2] == FRAME_ACK:
return True
elif resp[2] == FRAME_NAK:
break
# 超时或收到 NAK,继续重试
return False
def send_file(port: str, baudrate: int, file_path: str):
filename = os.path.basename(file_path)
file_size = os.path.getsize(file_path)
with open(file_path, 'rb') as f:
file_data = f.read()
file_crc = crc32(file_data)
ser = serial.Serial(port, baudrate, timeout=0.1)
# 1. 发送握手帧
payload = file_size.to_bytes(4, 'big') + file_crc.to_bytes(4, 'big') + filename.encode('utf-8')
print(f"发送握手帧:文件名={filename}, 大小={file_size}, CRC32=0x{file_crc:08x}")
if not send_frame(ser, FRAME_HANDSHAKE, payload, seq=0):
print("握手失败,请检查接收端程序是否已启动")
ser.close()
return
# 2. 分帧发送数据
seq = 1
total_frames = (file_size + PAYLOAD_SIZE - 1) // PAYLOAD_SIZE
for seq in range(1, total_frames + 1):
offset = (seq - 1) * PAYLOAD_SIZE
chunk = file_data[offset:offset + PAYLOAD_SIZE]
if not send_frame(ser, FRAME_DATA, chunk, seq=seq):
print(f"第 {seq}/{total_frames} 帧发送失败")
ser.close()
return
if seq % 50 == 0:
print(f"已发送 {seq}/{total_frames} 帧")
# 3. 发送结束帧
end_payload = total_frames.to_bytes(4, 'big')
if send_frame(ser, FRAME_END, end_payload, seq=total_frames + 1):
# 等待接收端完成确认(固定 8 字节:帧头+类型+CRC16)
start = time.time()
while time.time() - start < TIMEOUT * 2:
if ser.in_waiting >= 5:
resp = ser.read(5)
if resp[0] == 0xAA and resp[1] == 0x55 and resp[2] == FRAME_DONE:
print("文件传输完成,接收端确认成功")
ser.close()
return
print("发送结束帧成功,但未收到完成确认")
else:
print("结束帧发送失败")
ser.close()
if __name__ == '__main__':
send_file('COM3', 115200, 'test.bin')
这段代码有几点需要留意:
build_frame负责统一的组帧逻辑,所有帧共用一套结构。send_frame内部实现了重传机制:收到 NAK、超时未响应都会重发。- 帧序号从 1 开始递增,接收端用它判断是否收到重复帧。
5.4 上位机接收端代码
为了方便在没有单片机时测试协议,下面给一个 PC 端接收程序。它的作用是把串口收到的数据帧还原成文件。
python复制# 文件路径:receive.py
import serial
from crc16 import crc16_modbus
from crc32 import crc32
FRAME_HEADER = 0xAA55
FRAME_HANDSHAKE = 0x01
FRAME_DATA = 0x02
FRAME_END = 0x03
FRAME_ACK = 0x80
FRAME_NAK = 0x81
FRAME_DONE = 0x82
PAYLOAD_SIZE = 256
def read_exact(ser: serial.Serial, n: int) -> bytes:
"""读取精确字节数"""
data = b''
while len(data) < n:
chunk = ser.read(n - len(data))
if not chunk:
raise TimeoutError("读取超时")
data += chunk
return data
def receive_file(port: str, baudrate: int, save_path: str):
ser = serial.Serial(port, baudrate, timeout=2.0)
buffer = b''
file_data = b''
expected_seq = 1
file_size = 0
file_crc = 0
def send_ack():
payload = b''
body = bytes([FRAME_ACK]) + (0).to_bytes(2, 'big') + (0).to_bytes(4, 'big') + payload
crc = crc16_modbus(body)
frame = FRAME_HEADER.to_bytes(2, 'big') + body + crc.to_bytes(2, 'big')
ser.write(frame)
def send_nak():
payload = b''
body = bytes([FRAME_NAK]) + (0).to_bytes(2, 'big') + (0).to_bytes(4, 'big') + payload
crc = crc16_modbus(body)
frame = FRAME_HEADER.to_bytes(2, 'big') + body + crc.to_bytes(2, 'big')
ser.write(frame)
print("等待发送端握手...")
while True:
if ser.in_waiting >= 4:
header = ser.read(4)
if header[0] == 0xAA and header[1] == 0x55:
# 已经读到帧头前2字节,后面是类型和长度
# 这里简化处理:回退重建解析
buffer = header[2:4]
break
else:
continue
# 解析握手帧:长度(2B) + 序号(4B) + 载荷
type_byte, data_len = buffer[0], int.from_bytes(buffer[1:3], 'big') if len(buffer) >= 3 else 0
# 简化处理:等待完整握手帧
# 实际实现中需要以帧头为状态机状态,这里按最简流程
ser.reset_input_buffer()
while True:
try:
header = read_exact(ser, 4)
if header[0] != 0xAA or header[1] != 0x55:
continue
ftype = header[2]
data_len = int.from_bytes(header[3:], 'big')
# 修正:前面读了4字节,其中2字节是帧头,所以这里只需读 1+4+payload+2
remaining = 1 + 4 + data_len + 2
rest = read_exact(ser, remaining)
seq_bytes = rest[1:5]
payload = rest[5:5 + data_len]
crc_recv = int.from_bytes(rest[5 + data_len:], 'big')
body = bytes([ftype]) + data_len.to_bytes(2, 'big') + seq_bytes + payload
crc_calc = crc16_modbus(body)
if crc_calc != crc_recv:
send_nak()
continue
if ftype == FRAME_HANDSHAKE:
file_size = int.from_bytes(payload[0:4], 'big')
file_crc = int.from_bytes(payload[4:8], 'big')
print(f"收到握手:大小={file_size}, CRC32=0x{file_crc:08x}")
send_ack()
expected_seq = 1
elif ftype == FRAME_DATA:
seq = int.from_bytes(seq_bytes, 'big')
if seq == expected_seq:
file_data += payload
expected_seq += 1
send_ack()
else:
# 重复帧:说明 ACK 丢失,重新发 ACK
send_ack()
elif ftype == FRAME_END:
total_frames = int.from_bytes(payload[0:4], 'big')
if len(file_data) == file_size and crc32(file_data) == file_crc:
with open(save_path, 'wb') as f:
f.write(file_data)
print(f"文件保存成功:{save_path}")
# 发送完成确认
payload = b''
body = bytes([FRAME_DONE]) + (0).to_bytes(2, 'big') + (0).to_bytes(4, 'big') + payload
crc = crc16_modbus(body)
frame = FRAME_HEADER.to_bytes(2, 'big') + body + crc.to_bytes(2, 'big')
ser.write(frame)
break
else:
send_nak()
except TimeoutError:
continue
ser.close()
if __name__ == '__main__':
receive_file('COM3', 115200, 'received_test.bin')
这份接收代码是能跑的,但要注意其中的帧解析逻辑。我在代码中刻意保留了一个细节:帧头读取和状态机处理在真实项目中应该用“状态机”方式实现,回调函数会根据当前状态增量解析。上面的代码为了直观展示整个流程,采用了近似阻塞式的读取方式。
更健壮的做法是维护一个环形缓冲区,每次读进来的字节都喂给解析状态机。文章后面会讲这种处理思路。
5.5 STM32 接收端实现思路
嵌入式设备接收串口文件时,核心逻辑和 PC 接收端一致,但资源限制决定了实现方式更加精简。下面给出基于 HAL 库的 STM32 接收端伪代码思路。
c复制// 文件路径:main.c (STM32 串口接收核心逻辑示例)
// 注意:以下代码为思路示例,需根据具体芯片型号、时钟配置、HAL库版本调整
#define RX_BUF_SIZE 1024
#define PAYLOAD_SIZE 256
#define FRAME_HEADER_1 0xAA
#define FRAME_HEADER_2 0x55
uint8_t rx_buffer[RX_BUF_SIZE];
uint32_t rx_index = 0;
typedef enum {
STATE_WAIT_HEADER1,
STATE_WAIT_HEADER2,
STATE_WAIT_TYPE,
STATE_WAIT_LEN_H,
STATE_WAIT_LEN_L,
STATE_WAIT_SEQ,
STATE_WAIT_PAYLOAD,
STATE_WAIT_CRC
} parse_state_t;
parse_state_t parse_state = STATE_WAIT_HEADER1;
uint8_t frame_type = 0;
uint16_t frame_len = 0;
uint32_t frame_seq = 0;
uint8_t frame_payload[PAYLOAD_SIZE];
uint16_t payload_index = 0;
uint16_t crc_index = 0;
// 串口接收中断回调
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if (huart->Instance == USART1) {
uint8_t byte = rx_buffer[rx_index];
rx_index = (rx_index + 1) % RX_BUF_SIZE;
// 状态机处理每个字节
switch (parse_state) {
case STATE_WAIT_HEADER1:
if (byte == FRAME_HEADER_1) {
parse_state = STATE_WAIT_HEADER2;
}
break;
case STATE_WAIT_HEADER2:
if (byte == FRAME_HEADER_2) {
parse_state = STATE_WAIT_TYPE;
} else {
parse_state = STATE_WAIT_HEADER1;
}
break;
case STATE_WAIT_TYPE:
frame_type = byte;
parse_state = STATE_WAIT_LEN_H;
break;
case STATE_WAIT_LEN_H:
frame_len = byte << 8;
parse_state = STATE_WAIT_LEN_L;
break;
case STATE_WAIT_LEN_L:
frame_len |= byte;
payload_index = 0;
parse_state = STATE_WAIT_SEQ;
break;
case STATE_WAIT_SEQ:
// 4字节序号,这里简化为前2字节
frame_seq = byte << 24;
parse_state = STATE_WAIT_SEQ2;
break;
// 其余状态类似,省略代码
default:
break;
}
// 务必在中断服务函数中重新启动接收
HAL_UART_Receive_IT(&huart1, &rx_buffer[rx_index], 1);
}
}
说明:STC 上这段代码不是一个可直接编译的完整工程,但它展示了嵌入式接收端最关键的状态机设计思路。实际项目中,每一帧解析完成后,需要做 CRC 校验、ACK/NAK 回复、文件写入 Flash。关键点在于:
- 用状态机逐字节解析串口数据,不要用阻塞等待。
- 每收到一字节马上喂给状态机,避免缓冲区溢出。
- 收到完整一帧后才做 CRC 校验和处理,不要在中断里做耗时操作。
- 校验失败立即回复 NAK,发送端才能重传。
5.6 运行与验证
将 test.bin 放到项目目录下,先启动接收端:
code复制python receive.py COM3 115200
注意把 COM3 换成实际串口号。然后再启动发送端:
code复制python send.py
发送端输出示例:
code复制发送握手帧:文件名=test.bin, 大小=1024, CRC32=0x12345678
已发送 1/4 帧
已发送 2/4 帧
已发送 3/4 帧
已发送 4/4 帧
文件传输完成,接收端确认成功
接收端输出示例:
code复制等待发送端握手...
收到握手:大小=1024, CRC32=0x12345678
文件保存成功:received_test.bin
验证文件一致性:
code复制fc /b test.bin received_test.bin
如果两个文件完全一致,说明整个链路和协议都工作正常。
6. 常见问题与排查思路
串口传文件最容易在稳定性上翻车。下面整理高频问题、根因分析和排查思路。
6.1 常见问题速查表
| 问题现象 | 常见原因 | 解决思路 |
|---|---|---|
| 文件传完后内容不完整 | 发送端发送过快,接收端缓冲区溢出 | 降低载荷大小,或加入协议层 ACK 确认 |
| 接收端一直回 NAK | 帧格式定义不一致 | 两端的帧头、长度、序号、CRC 算法必须完全一致 |
| 开始传输几帧后卡死 | 接收端未及时回复 ACK,发送端超时重传 | 检查接收端中断处理是否占用太久,优化处理逻辑 |
| 偶发乱码或字节错位 | 波特率不匹配或干扰 | 用示波器/逻辑分析仪抓波形,检查波特率误差 |
| 大文件传输中途失败 | Flash 写入耗时导致数据覆盖 | 接收端采用“双缓冲”机制,边接收边写入 |
| 握手成功后无数据 | 帧序号错乱,接收端丢弃了后续帧 | 打印调试信息,核对序号递增逻辑 |
| 文件传输速度远低于理论值 | 每次只发一帧等一个 ACK,等待时间过长 | 适当增大每帧载荷长度,或实现滑动窗口批量发送 |
6.2 为什么文件传着传着就丢了数据
很多人在串口传文件时会遇到“发送端显示已发完,接收端文件却少了几个字节”的诡异现象。这通常是两个问题叠加的结果:
第一,发送端调用了 ser.write() 并不代表数据已经进入物理串口线。write() 只是把数据放进了操作系统驱动的发送缓冲区,真正发送需要时间。如果在 write() 之后立刻修改串口参数或关闭串口,某些数据会被丢弃。
第二,接收端在中断中处理数据时,如果 Flash 写入或其他耗时操作阻塞了中断,UART 硬件接收缓冲区就会溢出,后面的数据被覆盖。解决办法是接收一个字节后立刻把数据搬到用户层缓冲区,Flash 写入放到主循环里处理。
6.3 接收端粘包与帧头误判
串口是字节流,接收端必须自己找帧边界。如果文件内容中恰好出现了 0xAA 0x55 这样的组合,接收端会不会误判?
会。所以协议设计时要注意:
- 帧头不要只用两个固定字节,可以增加帧头后的帧类型判断,如果类型不在已知列表中,说明不是帧头。
- 解析状态机中,进入“等待帧头2”状态后,如果下一个字节不对,不要简单丢弃,而是重新比较当前字节是否是帧头1。这是状态机设计最容易错的点。
- 如果帧头误判导致解析错位,CRC 校验一定不通过,接收端会回 NAK。之后发送端重传同一帧,只要接收端能恢复正常状态,还是可以继续传。
6.4 Linux 下从串口接收数据丢失
热搜词里有一条“linux从串口接收数据丢失”,这是 Linux 下很典型的串口问题。原因通常是:
- 串口设备默认的接收缓冲区很小,应用程序读取不及时。
- 应用程序调用
read()时设置了超时,但处理逻辑耗时太长。
Linux 下建议设置串口为原始模式(raw mode),关闭行处理、回显等干扰:
bash复制stty -F /dev/ttyUSB0 115200 raw -echo
Python 端可以这样设置:
python复制import serial
ser = serial.Serial('/dev/ttyUSB0', 115200)
ser.reset_input_buffer()
如果数据量很大,建议改用线程读取串口数据:
python复制import threading
def read_serial():
while True:
data = ser.read(ser.in_waiting or 1)
if data:
process(data)
thread = threading.Thread(target=read_serial, daemon=True)
thread.start()
6.5 串口关闭导致传输中断
传输过程中千万不要关闭串口或拔掉 USB 转串口工具。很多调试工具在文件发送到一半时,如果界面刷新卡顿,用户会手动关闭再重新打开串口,结果是前功尽弃。
正确的做法是:发送期间保持串口打开,传输结束后再关闭。如果协议支持断点续传,异常关闭后可以从上次确认的帧序号继续。
7. 最佳实践与工程建议
串口传文件能做通不难,做稳定需要下面这些工程经验。
7.1 协议设计建议
- 帧头要足够长。 建议用 2 字节以上,并且帧头后紧跟帧类型,增加误判成本。
- 长度字段必须包含。 不要依赖读取超时判断一帧结束,二进制数据里什么都有可能。
- 必须做 CRC。 累加和只能检测简单的单字节错误,CRC16 是最低要求;文件整体校验用 CRC32。
- 序号字段要大。 用 2 字节最多支持 65535 帧,按 256 字节载荷算,最大 16MB 文件。对大文件建议用 4 字节序号。
- 协议要预留版本字段。 后续扩展时,两端都能识别协议版本,避免新旧版本混用导致解析错乱。
7.2 代码实现建议
- 发送端和接收端的协议常量和 CRC 算法必须抽成公共模块。 PC 端和单片机端的实现语言不同,但算法逻辑要对齐。
- 接收端状态机不要在主循环里做耗时操作。 Flash 写入、CRC 全文件校验都放到主循环,中断里只做字节搬运和帧边界检测。
- 发送端使用超时 + 重传机制。 不要发完就认为成功,必须等待接收端确认。
- 善用 DMA。 STM32 串口移植文件传输系统时,可以用 DMA + 空闲中断(IDLE Line Interrupt)接收不定长数据帧,能显著降低 CPU 占用。但不建议把 DMA 直接用做文件传输通道,还是在 DMA 之上做协议解析更稳。
7.3 传输参数建议
- 默认使用 115200 8N1 开始调试。链路稳定后再尝试提高波特率。
- 如果使用 460800 以上波特率,注意 USB 转串口芯片和线材质量。CH340 在高速下不如 FT232 稳定。
- 线材越短越好,最好控制在 1 米以内。长线传输会引入信号反射和干扰。
- 涉及工业现场,优先使用 RS485 接口。RS485 是差分信号,抗干扰能力强,传输距离可达数百米。
7.4 安全边界与生产环境注意
- 涉及固件升级时,接收端必须做版本校验和区域检查。 防止误刷不兼容固件导致设备变砖。
- Flash 写入前先备份当前固件和应用参数。 升级失败时可以回滚。
- 正式量产时,文件传输协议要加入加密或授权校验。 防止非法固件通过串口写入设备。
- 不要在未确认通信双方协议一致的前提下直接操作生产设备。 先在同一台设备上用测试固件验证完整流程。
8. 总结与学习路线
串口传文件是嵌入式开发绕不开的一个基本功。掌握了它,你就同时理解了协议设计、状态机解析、校验算法、流控机制和可靠传输的整体思路。这些能力不只用于串口,也能迁移到 CAN、SPI、网络 TCP 等几乎所有通信场景。
读完本文,你应该已经掌握了:
- 串口传文件和普通字符串传输的本质区别。
- 为什么要设计帧头、长度、序号、校验、ACK/NAK 这些字段。
- 如何在 PC 端用 Python 实现一个完整的文件发送程序。
- 如何在嵌入式接收端用状态机逐字节解析协议帧。
- 遇到丢数据、粘包、CRC 校验失败等问题时如何定位根因。
下一步可以做的练习和探索:
- 把协议改为“发送 N 帧后统一确认”的滑动窗口方式,观察吞吐量变化。
- 在 STM32 上实现完整的接收端逻辑,并将文件写入外部 Flash。
- 在协议中加入文件路径和文件名信息,支持按目录结构还原。
- 尝试在 Linux 下用
minicom和自定义工具完成同样的文件传输。 - 将协议移植到串口转 WiFi 模块(如 ESP8266 串口透传),实现远程文件下发。
关于串口传文件,最大的建议是:先定协议,再写代码;先小文件验证,再上大文件;先低速调通,再提升速率。 等你亲手完整走了一遍从组帧到校验到重传的流程,以后再遇到设备升级、日志导出、配置文件下发的需求,就会从容得多。如果本文对你有帮助,可以收藏备用,后续调试时翻出来对照排查。
