调试串口传文件,翻过车的人应该不少。有人用串口助手上传 4MB 固件,调到 115200 波特率等了半小时,最后卡在 98% 报错;有人拿着 SecureCRT 连嵌入式 Linux 板子,想传一个几百 KB 的配置文件,结果一发送全是乱码;还有人刚接触 STM32,想把 bin 文件烧进单片机,却发现除了用下载器,完全不知道串口侧该做什么。
出现这种局面的根本原因,不是串口本身难,而是很多人把串口当成了网线。串口(UART)真正的能力边界是字节流,它不认识“文件”,也不认识“目录”,更不含“文件名、大小、校验值”这些概念。字符串、二进制数据、文件内容,到 UART 上都只是人类可读或不可读的一串字节。要在字节流上可靠地传文件,必须主动在字节流之上构建一个协议,解决三件事:分段、校验、重传。
本文的核心判断是:串口传文件的重点不是波特率,而是协议。
文章会用一个主线带出三个典型的实操场景:PC 与嵌入式 Linux 之间用 lrzsz 走 ZMODEM 协议传文件;PC 与自制设备之间用 Python 写一个简单分帧协议传文件;STM32 侧用 XMODEM CRC 方式接收文件,做一个裸机引导加载程序的雏形。读完之后,你不仅知道“用什么工具”,还知道“为什么需要协议”“怎么选协议”,以及遇到数据丢失时从哪里开始排查。
1. 串口传文件,为什么绕不开这三类场景
先看用户分布。热搜词里反复出现 STM32、GD32、AT32、ESP8266、全志、串口调试助手、RS485、CH340 这些词,说明真正在做串口传文件的人,大概率落在以下三类场景里。
第一类是嵌入式 Linux 或开发板场景。板子已经能进系统,或者停在 U-Boot 下,需要把固件、根文件系统、配置文件从电脑传到板子上。板子没有网口,或者网络还没配好,串口就是唯一通道。这个场景标准解法是 lrzsz 工具,协议用 ZMODEM。
第二类是 PC 与自制终端设备或单片机场景。设备没有完整操作系统,比如 STM32、GD32 裸机程序,或者 ESP32 上跑的是自己写的固件。电脑需要把某个文件发给设备,比如升级包、配置文件、字库、音频资源。设备侧没有现成的 rz 命令,必须自己写接收协议。这就是需要实现 XMODEM 或者自定义帧协议的原因。
第三类是调试工具和烧录工具场景。比如 STM32 官方 CubeProgrammer 通过 UART 引导加载程序下载代码,或者 DSP28379 这种 DSP 通过串口下载程序。这类工具背后本质也是“串口传文件”,只是协议由芯片厂商定义好了,用户不直接看到。
这三类场景有个共同点:它们都发生在 UART 上,但要求完全不同。嵌入式 Linux 场景讲究“开箱即用”,所以选现成工具;单片机场景讲究“协议可控”,所以自己写;烧录场景讲究“厂商兼容”,所以直接调官方工具。
因此,与其问“串口怎么传文件”,不如先问自己:我要从哪一端,传到哪一端?两端分别是什么形态?搞清楚这个,工具选择和协议选择就清晰了。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. UART 传输文件的三个硬约束:速度、丢包与流控
串口传文件很容易踩坑,因为 UART 有天然约束。这些约束不是协议能消除的,只能通过协议去适应。
第一个约束是速度。UART 是异步串行通信,一次发一个字节,波特率决定了每秒能传多少位。115200 波特率是嵌入式领域最常见的配置之一,理论最大速率约 11520 字节每秒,扣掉起始位、停止位、帧间距,实际有效速率多数在 1KB/s 左右。传一个 1MB 的文件,按这个速度需要十几分钟。如果文件有几 MB,等待时间会非常明显。很多人在这一步失去耐心,想调高波特率到 921600 或者 1M,但高速率对线材、双方时钟精度、USB 转串口芯片的兼容性都有更高要求。数据丢失概率也随速率上升。
第二个约束是丢包。UART 本身没有重传机制,也不带确认机制。接收方收不到字节,就永远收不到。发送方只是把字节放进了发送缓冲,并不知道对端是否真的读走了。如果中间夹着 USB 转串口芯片,比如 CH340、CP2102、FTDI,还可能因为 USB 批量传输延迟、驱动缓冲区溢出而产生丢包。特别是数据量较大时,PC 端高速发送,单片机端处理不及时,DMA 还没搬完,UART 接收寄存器已经被新数据覆盖,就会丢字节。Linux 下可以从串口接收数据丢失,这在热搜词里出现得很多,本质就是用户态读取速度跟不上内核缓冲区,或者打开了错误的数据流控制方式。
第三个约束是流控。硬件流控需要 RTS/CTS 引脚,软件流控用 XON/XOFF 字符。很多 USB 转串口线默认不接 RTS/CTS,所以硬件流控不可用;软件流控在二进制数据传输时又容易误判,因为 0x11 和 0x13 可能出现可以数据中,导致收发双方误解。因此,在实际串口传文件时,更常见做法是不要依赖链路层流控,而是靠协议层的分块、确认、重传来保证可靠性。
这三个约束叠加起来,结论很直接:直接裸发一个文件是“碰运气”。文件小、速度快、环境干净的时候也许能成功,但只要有一个字节丢或者错,接收方得到的文件就坏了,而且经常到打开文件时才发现。这就是为什么必须引入协议。
3. 选对协议才不容易出错:XMODEM、YMODEM、ZMODEM 怎么选
如果你已经在一些终端软件中见过“发送 XMODEM”“发送 YMODEM”“发送 ZMODEM”这三个选项,但一直不清楚差别,这节就是为你写的。
XMODEM(Xmodem)是最早的,1981 年前后出现。它以 128 字节为一个数据块,块头包含起始符 SOH、块序号、块序号反码,块尾带校验码。接收方每收到一块,做校验,通过就回 ACK,失败就回 NAK,发送方重发当前块。传输结束用 EOT。它的优点是协议简单,适合单片机实现,缺点是有效载荷 128 字节太小,且早期版本没有文件名信息,不能传目录结构。
YMODEM(Ymodem)在 XMODEM 基础上做了扩展,数据块可以切成 1024 字节,还增加了块 0 用于传文件名、大小、时间戳等信息。STM32 的 IAP 场景非常常见,因为它能在一条命令里带文件名,接收端可以根据文件名选择保存位置或决定是否接收。百度、ST 官方很多串口 IAP 例程都基于 YMODEM。
ZMODEM(Zmodem)是更智能的版本,支持断点续传,支持文件名保留,恢复传输速度快,还支持自动发送。Linux 系统里 lrzsz 这套工具默认就是 ZMODEM。SecureCRT、Xshell 也支持 ZMODEM,用户只需要在终端执行 rz,然后等待 Windows 弹窗选择文件。它适合 PC 和嵌入式 Linux 之间传大文件,因为做续传时效率高很多。
三个协议适合的场景分别是什么?给你一张对比表。
| 协议 | 数据块大小 | 是否带文件名 | 断点续传 | 单片机实现难度 | 典型场景 |
|---|---|---|---|---|---|
| XMODEM | 128 字节 | 否 | 不支持 | 低 | 裸机 Bootloader、简单文件下载 |
| YMODEM | 128/1024 字节 | 是(块 0) | 不支持 | 中 | STM32 IAP、需要文件名的场景 |
| ZMODEM | 动态可变 | 是 | 支持 | 高 | 嵌入式 Linux 与 PC 互传文件 |
这个表可以直接作为选型依据。如果两端都是完整系统,优先 ZMODEM;如果一端是单片机裸机,优先 XMODEM 或 YMODEM;如果只需要把文件从 PC Push 到设备,XMODEM 最简单,因为协议短,出错的概率也小。
4. 场景一:PC 与嵌入式 Linux 之间用 lrzsz 传文件
这个场景是很多人的入门操作。板子上跑嵌入式 Linux,控制台是串口终端,串口终端只显示命令行。此时要把 PC 上的一个文件传到板子,最直接的做法就是用 lrzsz。
lrzsz 是一套 Unix 工具,包含 rz 和 sz。rz 表示“接收文件”(Receive Zmodem),sz 表示“发送文件”(Send Zmodem)。你在嵌入式 Linux 板子上的串口终端里执行 rz,然后从 PC 终端软件里选本地文件,板子就会通过串口把文件收下来。
4.1 两端准备
嵌入式 Linux 这一端,大多数基于 BusyBox 的根文件系统默认带了 rz/sz。如果没带,可以检查 BusyBox 配置里是否启用了 CONFIG_FEATURE_SEND_FILE、CONFIG_FEATURE_RX 这些选项,或者直接静态编译 lrzsz 放进板子。
PC 这一端,Windows 用户推荐 SecureCRT 或 Xshell。这两个终端都能识别 ZMODEM 信号并弹出文件选择窗口。Linux 桌面用户则可以直接用 minicom 配合 sz/rz 命令,也可以用 GTKTerm。
实际操作时要注意,执行 rz 的终端会话必须是纯文本终端,不能是调试器的串口监视器窗口。类似 SSCOM 这类纯串口调试助手多数不支持 ZMODEM,只能用来查看原始字节流。
4.2 执行传输流程
以 Windows + SecureCRT 连接板子为例。
bash复制# 板子串口终端执行,进入接收树洞
rz
如果板子端没有接外部存储,建议提前 cd 到要存放文件的目录,比如 /tmp 或者 /userdata。
终端执行 rz 后,SecureCRT 会弹出“发送文件”对话框。选择本地文件,协议默认是 ZMODEM,直接点击发送。此时串口线路里会出现 * 或 # 进度字符,终端窗口上方会显示文件名、大小、剩余时间。发送完成后,板子当前目录下会生成同名文件。
反向传,即板子向 PC 传文件,则执行下面命令。
bash复制sz /tmp/app.bin
同样的,SecureCRT 会弹窗询问保存位置,选择本地目录后保存。
4.3 为什么要先在板子上执行 rz
这里有个新手容易困惑的地方:为什么板子端执行 rz,而不是 PC 端执行 rz?因为 ZMODEM 是接收方主动进入接收模式,并发出一个起始字符串,发送方检测到这个字符串后自动开始后续握手。板子执行 rz 等于告诉 PC“我准备好了,准备接收”。如果顺序反了,通信双方的状态就错位,无法建立连接。
如果用的是 U-Boot,方式会有一点不同。U-Boot 里没有 rz,而是用 loady、loadb、loadx 分别代表 YMODEM、二进制模式、XMODEM。在 U-Boot 命令行执行 loady 0x80000000,然后从 SecureCRT 选择“发送 YMODEM”,就可以把文件下载到指定内存地址。U-Boot 场景也常用于烧录 Linux 镜像,只是走的不是完整系统,而是 bootloader 引导模式。
4.4 常见坑:终端协议“假死”
使用 lrzsz 时最容易遇到的现象是:执行 rz 后终端一直不动,长按回车也不出提示。绝大多数时候是因为 PC 终端没有开启 ZMODEM 支持,或者当前串口会话模式不对。可以先切到 SecureCRT 串口属性,确认“发送 ZMODEM 文件参数”已启用;也可以尝试退出 rz,用 Ctrl+XX 或多次 Ctrl+C,再重新进。
5. 场景二:Python 自建串口文件传输工具
很多自制设备没有操作系统,比如 STM32、GD32、AT32,或者板子上跑的是裸机程序。此时设备端想接收文件,最常见的做法是自己定义协议。Python 侧只是发送端,但协议设计直接决定接收端好不好写。
这一节用一个最小可跑通的方案演示:PC 用 Python pyserial 发送文件,设备端概念是逐帧收数据、做 CRC、答 ACK。这个协议比 XMODEM 更简单,但通信流程完整,适合用来理解串口传输的本质。
5.1 协议帧设计
一个典型的简单文件传输帧包含以下部分:
- 帧头 2 字节,固定为 0xAA 0x55,用来同步。
- 长度 2 字节,表示数据区字节数,这里限制最大 1024。
- 序号 2 字节,从 0 开始递增,接收端用来检测丢帧。
- 数据区,最多 1024 字节。
- CRC16 2 字节,对“序号 + 数据区”做校验。
帧结构如下。
text复制AA 55 | LEN_H LEN_L | SEQ_H SEQ_L | DATA[0...N-1] | CRC_H CRC_L
接收端对每个帧的处理逻辑是:先检查帧头,再检查长度,确认序号连续,再算 CRC。如果 CRC 正确,回答 ACK;如果 CRC 错误或长度异常,回答 NAK,发送端重发该帧。
5.2 PC 发送端 Python 实现
安装依赖。
bash复制pip install pyserial
下面是发送端完整代码。
python复制# 文件路径:send_file_uart.py
import serial
import struct
import sys
import time
def crc16(data: bytes) -> int:
crc = 0xFFFF
for b in data:
crc ^= b
for _ in range(8):
if crc & 1:
crc = (crc >> 1) ^ 0xA001
else:
crc >>= 1
return crc
def send_file(port: str, baudrate: int, filepath: str):
ser = serial.Serial(port, baudrate, timeout=1)
with open(filepath, "rb") as f:
data = f.read()
seq = 0
offset = 0
chunk_size = 1024
total = (len(data) + chunk_size - 1) // chunk_size
print(f"total chunks: {total}")
while offset < len(data):
chunk = data[offset:offset + chunk_size]
payload = struct.pack(">H", seq) + chunk
frame = b"\xAA\x55" + struct.pack(">H", len(payload)) + payload
frame += struct.pack(">H", crc16(payload))
# 发帧,等待 ACK,失败重发
for retry in range(5):
ser.write(frame)
ack = ser.read(1)
if ack == b"\x06": # ACK
break
else:
print(f"failed at seq {seq}")
return
seq += 1
offset += chunk_size
sys.stdout.write(f"\rprogress: {offset}/{len(data)}")
sys.stdout.flush()
# 发送结束标志 0xAA 0x55 0x00 0x00 0x00 0x00 0xAA 0xAA
ser.write(b"\xAA\x55\x00\x00\x00\x00\xAA\xAA")
ser.close()
print("\ndone")
if __name__ == "__main__":
send_file("COM3", 115200, "app.bin")
这段代码的关键逻辑有三点:一是把 seq 和 chunk 一起做 CRC,保证序号不会被篡改;二是等待 ACK 才发下一帧,天然实现停等协议;三是重试 5 次后仍无 ACK 则退出,避免无休止重发。
需要注意 struct.pack(">H", seq) 中的 H 是无符号 16 位整数,序号最大 65535,对应可传文件大小约 64MB,足够覆盖常见固件和配置。
5.3 设备端接收逻辑伪代码
如果你的设备是 MCU,接收端逻辑可以按这个流程实现。
c复制// 伪代码,示意帧处理流程
uint8_t rx_buf[MAX_FRAME];
if (find_frame_header(rx_buf) == true) {
uint16_t len = get_frame_len(rx_buf);
uint16_t seq = get_frame_seq(rx_buf);
uint16_t crc = get_frame_crc(rx_buf);
if (crc16(rx_buf + 4, len) == crc) {
if (seq == expected_seq) {
save_chunk(rx_buf + 6, len - 2);
expected_seq++;
send_byte(ACK);
} else {
// 序号不连续,说明中间丢了帧
// 在真实项目中这里需要回 NAK,并考虑是否请求重发
send_byte(NAK);
}
} else {
send_byte(NAK);
}
}
这个方案真正的价值不是造一个复杂协议,而是让你理解串口传输文件的最小闭环:封装、发送、校验、确认、重传。自己实现一遍后,再看 XMODEM 或 YMODEM,会发现它们只是把这个结构做得更完善。
6. 场景三:STM32 裸机接收 XMODEM 文件(固件升级雏形)
如果设备是 STM32 这类单片机,并且想做一个串口 IAP 功能,自己实现一套协议是可行的,但直接采用 XMODEM 更稳妥,因为网上能找到大量参考,而且很多现成上位机工具都支持 XMODEM 协议,比如 SecureCRT、Xshell、甚至一些小程序。
XMODEM 协议在接收侧的核心流程是:先发字符 C 表示希望用 CRC16 校验方式,然后进入收包循环。每一包 128 字节,接收到合法包后回 ACK,数据错误回 NAK,收到 EOT 表示发送结束。
下面是一个面向 STM32 的 XMODEM CRC 接收代码片段。它假设你已经实现了两个底层函数:uart_send_byte 和 uart_recv_byte,并且串口初始化完成。
c复制// 文件路径:xmodem_receiver.c
#define SOH 0x01
#define EOT 0x04
#define ACK 0x06
#define NAK 0x15
#define CAN 0x18
static uint8_t uart_read_byte(void)
{
while (UART_RX_BUFFER_EMPTY());
return UART_RX_DATA;
}
static uint16_t crc16_xmodem(const uint8_t *data, uint32_t len)
{
uint16_t crc = 0;
for (uint32_t i = 0; i < len; i++) {
crc ^= (uint16_t)data[i] << 8;
for (int j = 0; j < 8; j++) {
if (crc & 0x8000)
crc = (crc << 1) ^ 0x1021;
else
crc <<= 1;
}
}
return crc;
}
int xmodem_receive(uint8_t *out_buf, uint32_t max_len)
{
uint8_t block_no = 1;
uint32_t offset = 0;
// 发送 C,表示希望用 CRC 模式
uart_send_byte('C');
while (1) {
uint8_t cmd;
cmd = uart_read_byte();
if (cmd == CAN) {
return -1; // 取消
}
if (cmd == EOT) {
// 发送方通知结束,回 ACK 确认
uart_send_byte(ACK);
break;
}
if (cmd == SOH) {
uint8_t block_no_recv;
uint8_t block_no_neg;
uint8_t data[128];
uint8_t crc_h, crc_l;
uint16_t crc_recv, crc_calc;
block_no_recv = uart_read_byte();
block_no_neg = uart_read_byte();
if ((block_no_recv ^ block_no_neg) != 0xFF) {
uart_send_byte(NAK);
continue;
}
for (int i = 0; i < 128; i++)
data[i] = uart_read_byte();
crc_h = uart_read_byte();
crc_l = uart_read_byte();
crc_recv = ((uint16_t)crc_h << 8) | crc_l;
crc_calc = crc16_xmodem(data, 128);
if (crc_recv != crc_calc) {
uart_send_byte(NAK);
continue;
}
if (block_no_recv != block_no) {
// 序号不对,看场景决定是直接丢弃还是返回错误
uart_send_byte(NAK);
continue;
}
if (offset + 128 <= max_len) {
memcpy(out_buf + offset, data, 128);
offset += 128;
}
block_no++;
uart_send_byte(ACK);
}
}
return offset;
}
这个实现没有处理超时重传,实际产品中需要增加定时器来处理“发 C 后一直等不到 SOH”的情况。不过它已经能配合 SecureCRT 这类工具完成基本文件接收。如果要配合自己的上位机,发送端逻辑就是先发 C,然后按序号发 SOH 包,收 ACK 后继续下一包,全部结束后发 EOT,等最终 ACK。
注意,XMODEM 一次只传一个文件,且每个包只有 128 字节,传大文件时效率偏低。如果文件是几 MB 的固件,又要求速度,可以考虑改 YMODEM 的 1024 字节包模式,协议结构类似,只是 SOH 换成 STX,包大小换成 1024。
7. 传输完成后的校验与效果验证
文件传完之后,怎么知道传输是否成功?很多新手只看终端提示“文件已发送”,但实际文件可能已经损坏。稳妥的做法是二次校验。
在 PC 与嵌入式 Linux 的 ZMODEM 场景中,lrzsz 工具本身在发送完成后会打印最终状态,SecureCRT 窗口也会显示文件已接收。但即便如此,建议在板子上立刻用 md5sum 或 sha256sum 对比本地文件和板子文件的哈希值。
bash复制# PC 端计算
md5sum app.bin
# 板子端计算
md5sum /app/tmp/app.bin
两个哈希一致,说明字节内容完全相同。这个动作看起来多了一步,但能直接定位是协议问题还是文件本身问题。
在自建 Python 协议场景中,协议设计了 CRC16 校验,但发送端和接收端对数据区定义一致才能保证正确性。如果接收端看到 NAK 重发多次,建议先检查接收端缓冲区是否足够容纳最大帧,以及串口波特率是否匹配。更严格的做法是在文件末尾再附加一帧“整体校验值”,例如对整份文件计算 CRC32 或 MD5,接收端处理完所有帧后单独校验整个文件。
在 STM32 XMODEM 场景中,临时文件写入 flash 后,建议读出并回传校验。如果回传内容与原始 bin 哈希不一致,基本可以确定是 flash 写入函数的问题,而不是串口传输问题。
验证结果的判断标准可以统一为:字节一致。不要只看“有没有报错”,要看“内容对不对”。这是嵌入式文件传输里最容易被忽略的一环。
8. 常见问题与排查思路
串口传文件的报错方式千奇百怪,但归结起来不外乎几种。下面这张表总结了高频问题,按排查优先级排列。
| 问题现象 | 可能原因 | 排查方式 | 解决方案 |
|---|---|---|---|
| 终端执行 rz 后无反应 | 终端软件不支持 ZMODEM,或未进入正确协议 | 在 PC 端重新打开终端,检查软件协议设置 | 换 SecureCRT/Xshell,确认发送方式选 ZMODEM |
| 传输开始后立刻报超时 | 波特率不匹配或流控设置不一致 | 两端确认波特率、数据位、停止位、校验位 | 统一参数,尽量先关硬件流控 |
| 传大文件过程中卡住 | 没有协议重传机制,单字节丢失后无法恢复 | 查看丢包位置是否集中在某一段 | 改用 YMODEM/ZMODEM,或增加协议层 ACK/重传 |
| Linux 从串口接收数据丢失 | 用户态读取速度慢,内核缓冲区被覆盖 | 抓取原始字节流,查看丢失规律 | 使用 DMA 或提高读取线程优先级,减小单次读取延迟 |
| STM32 收包 CRC 频繁失败 | 发送端字节间有延迟,或接收帧状态机被错误字符干扰 | 加打印看异常字符值 | 增加帧头同步和字符超时机制 |
| USB 转串口调试时传文件很慢 | 转串口芯片驱动缓冲策略和 DMA 不匹配 | 检查设备管理器端口参数 | 调低波特率,或关闭 FIFO 缓冲 |
| U-Boot 执行 loady 后一直等待 | 上位机发送方式选择错误 | 确认选择 YMODEM 而非 XMODEM | 按 U-Boot 命令匹配协议发送 |
这里面有两个值得展开的问题。
第一个是 Linux 串口接收丢数据。内核把串口数据放进 tty 缓冲区,用户态读取必须及时。如果应用层用了 read 循环但处理速度慢,缓冲区溢出后数据被丢弃。解决思路包括:换成非阻塞 read 后及时搬运数据;在 MCU 侧使用 UART DMA 接收,减少 CPU 介入;在 PC 应用侧用独立线程读串口并做环形缓冲区。
第二个是波特率高了反而容易失败。921600 波特率下,USB 转串口的时序余量更小,PC 端调度抖动更容易造成字节间隙超时。如果自己的协议没有超时重传设计,出问题的概率会明显增加。稳妥做法是先用 115200 跑通,再逐步调高并反复验证。
9. 工程最佳实践与安全提醒
串口传文件看起来简单,但引入到实际项目里,有几个工程层面的经验值得沉淀。
第一,协议要预留版本和兼容能力。如果硬件设备出货后才发现协议需要调整,没有版本号会导致新旧固件和上位机互相不兼容。建议在协议帧中加入一个 version 字段,哪怕只用 1 字节,也能避免很多售后问题。
第二,接收端要防止缓冲区溢出。在 MCU 接收大文件时,如果直接用串口中断把数据拷进一个大数组,内存占用会很高。更合理的做法是配合 DMA,或设计双缓冲区,一块用于接收,一块用于写 flash 或处理业务。如果接收端速度慢,发送端必须等待 ACK,这是停等协议的另一个优势。
第三,生产环境的上传动作必须有确认机制。无论用哪种协议,建议在接收完成后回传一个文件 MD5 给上位机,上位机比对本地 MD5。这个功能多写很少的代码,但能显著降低“烧完固件板子起不来”的概率。
第四,涉及安全与权限时要注意边界。如果你在调试一台不属于自己的设备,或者要给在线设备升级,必须先确认权限和操作范围,不要在没有授权的情况下传输或替换文件。对生产环境做升级时,先在测试板上验证,确认可以回滚,再批量操作。涉及 flash 擦写、分区表修改、rootfs 替换等操作时,提前备份原始文件。哪怕只是用 U-Boot 的 loady 加载内核镜像,误擦错分区也可能导致系统无法启动。
第五,串口驱动的选择会影响传输稳定性。常见芯片里 CH340 便宜易用,CP2102 驱动更稳,FTDI 兼容性更好。如果项目量产,建议直接用带硬件流控引脚的接口,并预留 RTS/CTS,这样后续要支持复杂协议时不会受硬件限制。
第六,日志和调试嵌入点要想好。在传输协议里保留一两个调试字段,比如帧号、重传次数,能在现场快速定位问题。裸机设备上建议用 LED 闪烁不同次数表示不同错误码,PC 端则统一把串口日志输出到文件,方便事后分析。
10. 总结
回到开头的问题:串口怎么传文件?答案取决于两端形态。PC 和嵌入式 Linux 之间,直接用 lrzsz 走 ZMODEM,体验最好;MCU 和 PC 之间,要么移植现成 XMODEM/YMODEM,要么自己设计一个带帧头、序号、CRC 和确认重传的小协议;芯片烧录场景则直接调用厂商工具。
这篇文章没有给出一个“万能串口传文件方案”,因为串口本身不提供可靠性,可靠性必须由协议层补充。真正值钱的不是记住某一个命令,而是理解这一段判断逻辑:先看两端有没有操作系统,再决定选现成工具还是自建协议,然后确定校验方式,最后用哈希值验证结果。
建议你先照着场景一用 lrzsz 传一次文件,再对照场景二写一个简单的 Python 发送端,最后再考虑往 STM32 上移植 XMODEM。顺序是从“会用”到“理解”,再到“自己能实现”,这也是嵌入式开发里比较正确的进阶路径。下文可以继续深入的方向包括:YMODEM 块 0 的文件名解析、STM32 的 UART DMA 环形缓冲区、以及串口 IAP 的 flash 分区规划。
