1. 为什么说 CH341 编程器不是“烧录器”,而是你手边最硬核的 I2C 黑匣子调试工具?
刚接手某工业传感器模组的故障复现任务时,我卡在了一个看似简单的问题上:上位机发指令后,从设备(一颗 24C02 EEPROM)始终返回 0xFF,但用逻辑分析仪抓波形,SCL/SDA 上明明有完整起始、地址、应答、数据帧——信号全对,设备却像没听见。折腾两天后,我换了个思路:不用上位机,也不碰主控芯片,直接把 CH341 插进电脑 USB 口,用它当“人肉 I2C 主机”,手动构造每一帧、逐字节验证通信链路。结果三分钟就定位到问题根源:是设备地址左移后没清最低位读/写位,导致写操作发成了读请求,而 24C02 对非法读帧只沉默拉高 SDA。那一刻我才真正明白,CH341 的价值根本不在“烧 Flash”,而在它能把 I2C 协议从抽象时序还原成可触摸、可拆解、可重放的字节流——它是一把能捅开嵌入式底层通信黑箱的螺丝刀,而不是一个点一下就完事的傻瓜烧录器。本文不讲驱动安装、不讲 GUI 界面操作,只聚焦一个实战闭环:用 CH341DLL + Python 脚本,完成 24C02 的可靠读写、页边界规避、地址设置与随机读验证。适合正在调试 I2C 外设、手头只有 CH341 编程器、不想被逻辑分析仪价格劝退的嵌入式工程师、硬件联调人员和固件开发新手。所有代码均来自真实产线调试脚本,参数、错误码、行为差异全部实测标注。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. CH341 作为 I2C 主机的本质:理解 DLL 接口设计与物理层映射关系
CH341 芯片本身不直接支持 I2C 协议栈,它靠 USB 接口模拟 GPIO,再由上位机软件通过精确控制 SCL/SDA 引脚电平变化来“软实现”I2C 时序。这个事实决定了它的使用逻辑和传统 I2C 主机(如 STM32 的硬件 I2C 外设)有本质区别:它没有“总线仲裁”“自动应答检测”“内置地址寄存器”这些概念,一切协议细节都压在你的代码里。CH341DLL 就是把这种底层电平控制能力封装成几个关键函数,让你跳过时序计算,但绝不替你做协议决策。理解这层关系,是写出稳定脚本的前提。
2.1 CH341DLL 的核心 I2C 函数族及其语义边界
官方 DLL 提供的 I2C 相关函数中,真正用于数据收发的是 CH341StreamI2C,它是唯一能一次传输多字节、支持起始/停止/重复起始的“原子操作”函数。但它的行为高度依赖你传入的字节流结构,且不同版本 DLL 对“重复起始”的触发逻辑存在差异。其他函数如 CH341SetStreamI2C 仅用于配置时序参数(如 SCL 高低电平持续时间),CH341ReadData / CH341WriteData 则是纯 GPIO 模式,需手动拼接起始、地址、数据、应答等所有帧,已基本被弃用。因此,整个调试流程必须围绕 CH341StreamI2C 展开,且必须明确:它只负责按你给的字节序列执行电平翻转,不校验 ACK,不判断地址是否有效,不处理跨页写回卷——这些全是你的责任。
提示:不要试图用
CH341StreamI2C一次性完成“写地址+读数据”的全流程。很多初学者误以为传入[dev_addr_w, mem_addr, dev_addr_r]就能触发重复起始并开始读,这是对 DLL 行为的最大误解。实际中,该函数只会在字节流开头发一次起始,在结尾发一次停止;中间的dev_addr_r字节只是被当成普通数据发送出去,并不会自动切换为读模式。真正的重复起始必须由两次独立的CH341StreamI2C调用触发,且第二次调用前需确保第一次已完全结束(即总线已释放)。
2.2 设备地址、存储地址与字节流构造的三重映射
I2C 通信中,7 位设备地址(如 24C02 的 0x50)和 8 位存储地址(如 0x10)必须被正确编码进字节流,否则从设备根本无法识别。这个过程不是简单拼接,而是严格遵循 I2C 协议规范:
- 设备地址字节:7 位地址左移 1 位,最低位为 R/W 位(0=写,1=读)。所以
0x50写操作地址是0x50 << 1 | 0x00 = 0xA0,读操作地址是0x50 << 1 | 0x01 = 0xA1。 - 存储地址字节:对于 24C02 这类单字节地址的 EEPROM,就是你要访问的内存位置,如
0x10。 - 字节流结构:写操作流为
[dev_addr_w, mem_addr, data0, data1, ...];随机读操作流则必须拆成两步:第一步写流[dev_addr_w, mem_addr]设置地址指针,第二步读流[dev_addr_r]启动读取。
这个映射关系必须硬编码进脚本,不能依赖任何“自动识别”功能。下面这段代码清晰体现了三重映射的强制性:
python复制# 设备地址(7位)和读写位的显式计算,杜绝 magic number
DEV_ADDR_7BIT = 0x50
DEV_ADDR_WRITE = (DEV_ADDR_7BIT << 1) | 0x00 # 0xA0
DEV_ADDR_READ = (DEV_ADDR_7BIT << 1) | 0x01 # 0xA1
# 存储地址(24C02为单字节)
MEM_ADDR = 0x10
# 构造写操作字节流:[设备地址(写), 存储地址, 数据字节...]
write_buffer = (ctypes.c_ubyte * (2 + len(data)))()
write_buffer[0] = DEV_ADDR_WRITE
write_buffer[1] = MEM_ADDR
for i, v in enumerate(data):
write_buffer[2 + i] = v
# 构造读操作第一步字节流:仅设置地址指针
setup_buffer = (ctypes.c_ubyte * 2)()
setup_buffer[0] = DEV_ADDR_WRITE
setup_buffer[1] = MEM_ADDR
# 构造读操作第二步字节流:启动读取(仅设备地址+读位)
read_buffer = (ctypes.c_ubyte * 1)()
read_buffer[0] = DEV_ADDR_READ
这段代码的关键在于:所有地址计算都在 Python 层完成,字节流内容完全透明可控。当你看到 write_buffer[0] = 0xA0 时,你知道这就是协议要求的写地址字节;当你看到 read_buffer[0] = 0xA1 时,你知道 DLL 将向总线发送这个字节并等待从设备应答。这种“所见即所得”的控制力,正是 CH341 作为调试工具的核心优势。
2.3 为什么必须手动管理页边界?24C02 的硬件限制与脚本应对策略
24C02 的页大小(Page Size)是 8 字节,这是由其内部存储结构决定的硬件约束,与软件无关。当你尝试一次写入超过 8 字节(如 10 字节)时,芯片不会报错,而是将第 9、10 字节“回卷”(wrap around)写入当前页的起始地址(即 0x00、0x01),导致数据错位。例如,向地址 0x07 开始写入 [0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A],结果是:0x07~0x0F 写入 0x01~0x09,而 0x0A 被写入 0x00。这种“静默失败”是 I2C 调试中最难排查的坑之一。
脚本必须主动拆分写操作以规避此问题。策略很简单:计算起始地址所在页的剩余空间,将大数据块切分为多个 ≤8 字节的子块,每个子块单独调用 CH341StreamI2C。以下函数实现了这一逻辑:
python复制def write_eeprom_page_safe(dll, handle, dev_addr_write, start_addr, data_bytes):
"""
安全写入EEPROM,自动按页(8字节)拆分
:param dll: CH341DLL实例
:param handle: 设备句柄
:param dev_addr_write: 设备写地址(如0xA0)
:param start_addr: 起始存储地址(0x00~0xFF)
:param data_bytes: 待写入的字节列表
"""
addr = start_addr
offset = 0
total_len = len(data_bytes)
while offset < total_len:
# 计算当前页剩余空间:页首地址 = addr & 0xF8,页尾 = 页首 + 7
page_start = addr & 0xF8
page_remaining = 8 - (addr - page_start)
# 本次写入长度:取剩余空间和剩余数据的最小值
chunk_len = min(page_remaining, total_len - offset)
# 构造字节流:[dev_addr, mem_addr, data...]
buffer_len = 2 + chunk_len
buffer = (ctypes.c_ubyte * buffer_len)()
buffer[0] = dev_addr_write
buffer[1] = addr
for i in range(chunk_len):
buffer[2 + i] = data_bytes[offset + i]
# 执行写入
ret = dll.CH341StreamI2C(handle, buffer_len, buffer)
if ret == 0:
raise RuntimeError(f"写入失败:地址 0x{addr:02X},长度 {chunk_len}")
# 更新地址和偏移
addr += chunk_len
offset += chunk_len
# 页写入后必须延时(24C02 典型写周期 5ms)
time.sleep(0.005)
# 使用示例:向 0x10 地址写入 12 字节,自动拆为 0x10-0x17(8字节)和 0x18-0x1B(4字节)两次操作
data_12 = list(range(0x01, 0x0D))
write_eeprom_page_safe(dll, handle, DEV_ADDR_WRITE, 0x10, data_12)
这个函数的价值在于:它把硬件限制转化为可编程的、确定性的逻辑分支。每次调用都明确知道写入多少字节、写到哪个地址、是否需要延时。当你看到 page_remaining = 8 - (addr - page_start) 这行代码时,你就知道脚本正在和芯片的物理页结构进行精确对话,而不是在赌运气。
3. 从零构建可复用的 CH341 I2C 调试脚本:初始化、读写封装与错误处理
一个能投入实战的脚本,绝不能是“写完就扔”的一次性代码。它需要清晰的模块划分、健壮的错误处理、以及面向调试场景的易用接口。本节将基于前两章的原理,构建一个生产级可用的 ch341_i2c.py 模块,覆盖设备打开、基础读写、页安全写、随机读验证等核心能力,并重点处理那些让脚本“突然失效”的典型异常。
3.1 设备初始化与连接状态的主动探测
CH341OpenDevice(0) 返回 0 并不绝对代表失败,它可能意味着设备未插入、驱动未安装、或端口被其他进程占用。更隐蔽的问题是:设备虽已打开,但后续 CH341StreamI2C 调用却因 USB 总线干扰、供电不足等原因返回 0。因此,初始化阶段必须包含主动探测环节——向一个已知存在的从设备(如 24C02)发送一个最简写操作(如向地址 0x00 写入 0x00),并检查返回值。这比单纯检查句柄更可靠。
python复制def init_ch341_and_probe_i2c():
"""
初始化CH341并探测I2C总线连通性
:return: (dll, handle) 元组,失败则抛出RuntimeError
"""
try:
dll = ctypes.WinDLL("CH341DLL.dll")
except OSError as e:
raise RuntimeError(f"加载CH341DLL失败:{e}. 请确认DLL文件存在且为正确版本(32/64位匹配)")
handle = dll.CH341OpenDevice(0)
if handle == 0:
raise RuntimeError("CH341OpenDevice失败:设备未找到、驱动未安装或端口被占用")
# 主动探测:向24C02 0x00地址写入0x00(一个无害的测试操作)
probe_buffer = (ctypes.c_ubyte * 3)()
probe_buffer[0] = 0xA0 # 24C02写地址
probe_buffer[1] = 0x00 # 存储地址
probe_buffer[2] = 0x00 # 数据
ret = dll.CH341StreamI2C(handle, 3, probe_buffer)
if ret == 0:
# 尝试读取设备ID(如果支持)或换一个地址再试,此处简化为报错
raise RuntimeError("I2C总线探测失败:CH341能打开但无法与24C02通信。请检查接线、电源、上拉电阻(通常4.7kΩ)")
return dll, handle
# 使用方式:在脚本开头调用
try:
dll, handle = init_ch341_and_probe_i2c()
print("CH341初始化成功,I2C总线连通")
except RuntimeError as e:
print(f"初始化失败:{e}")
exit(1)
这段代码的关键改进在于:它把“设备存在”和“I2C 通信正常”两个维度的健康检查合并为一个原子操作。probe_buffer 的构造完全复用前文的地址映射逻辑,确保探测行为本身也是协议合规的。当它失败时,错误信息直接指向物理层问题(接线、电源、上拉),而非模糊的“打不开设备”,极大缩短了排障路径。
3.2 基础读写函数的封装与参数化设计
将重复的字节流构造、DLL 调用、错误检查封装成函数,是提升脚本可维护性的第一步。但更重要的是参数化:让函数接受“业务语义”参数(如 device_addr_7bit, mem_addr, data),而非原始字节流。这样,调用者无需关心 0xA0 是怎么算出来的,只需传递 0x50 和 True(表示写)即可。
python复制def i2c_write(dll, handle, device_addr_7bit, mem_addr, data_bytes):
"""
I2C写操作封装:自动计算设备地址,构造字节流
:param device_addr_7bit: 7位设备地址(如0x50)
:param mem_addr: 存储地址(单字节,0x00~0xFF)
:param data_bytes: 待写入的字节列表
:return: True if success
"""
dev_addr_write = (device_addr_7bit << 1) | 0x00
buffer_len = 2 + len(data_bytes)
buffer = (ctypes.c_ubyte * buffer_len)()
buffer[0] = dev_addr_write
buffer[1] = mem_addr
for i, v in enumerate(data_bytes):
buffer[2 + i] = v
ret = dll.CH341StreamI2C(handle, buffer_len, buffer)
if ret == 0:
raise RuntimeError(f"I2C写失败:设备0x{device_addr_7bit:02X},地址0x{mem_addr:02X}")
return True
def i2c_read_random(dll, handle, device_addr_7bit, mem_addr, read_len):
"""
I2C随机读操作封装:先写地址,再读数据
:param device_addr_7bit: 7位设备地址
:param mem_addr: 目标存储地址
:param read_len: 要读取的字节数
:return: 读取到的字节列表
"""
dev_addr_write = (device_addr_7bit << 1) | 0x00
dev_addr_read = (device_addr_7bit << 1) | 0x01
# 步骤1:设置地址指针
setup_buffer = (ctypes.c_ubyte * 2)()
setup_buffer[0] = dev_addr_write
setup_buffer[1] = mem_addr
ret = dll.CH341StreamI2C(handle, 2, setup_buffer)
if ret == 0:
raise RuntimeError(f"I2C地址设置失败:设备0x{device_addr_7bit:02X},地址0x{mem_addr:02X}")
# 步骤2:读取数据
read_buffer = (ctypes.c_ubyte * (1 + read_len))()
read_buffer[0] = dev_addr_read # 第一个字节是设备读地址
ret = dll.CH341StreamI2C(handle, 1 + read_len, read_buffer)
if ret == 0:
raise RuntimeError(f"I2C读失败:设备0x{device_addr_7bit:02X},地址0x{mem_addr:02X}")
# 返回实际读取的数据(跳过第一个地址字节)
return list(read_buffer[1:1+read_len])
这两个函数的设计哲学是:隐藏协议细节,暴露业务意图。调用者只需写 i2c_write(dll, handle, 0x50, 0x10, [0x11,0x22]),就能完成一次标准写操作,而无需记忆 0xA0 或构造缓冲区。这种封装让脚本逻辑更贴近硬件工程师的思维习惯(“我要往 24C02 的 0x10 地址写两个数”),而非底层驱动工程师的思维(“我要发三个字节,分别是 0xA0、0x10、0x11…”)。
3.3 错误码的深度解析与分层处理策略
CH341StreamI2C 的返回值只有 0(失败)和非 0(成功)两种,但它掩盖了多种失败原因。仅靠 if ret == 0 报错,无法区分是“设备没响应”还是“USB 通信超时”。为了精准排障,必须结合上下文和现象做分层处理:
| 现象 | 可能原因 | 解决方案 |
|---|---|---|
CH341OpenDevice 返回 0 |
驱动未安装、设备未插入、USB 端口冲突 | 检查设备管理器,重装驱动,换 USB 口 |
CH341StreamI2C 在写地址后返回 0 |
从设备地址错误、SCL/SDA 接反、无上拉电阻 | 用万用表测 SDA/SCL 电压,确认上拉电阻存在且阻值正确(4.7kΩ) |
CH341StreamI2C 在读操作后返回 0,但写操作成功 |
从设备未正确进入读模式、重复起始未触发 | 确认读操作严格分为两步,且两步间无延时(DLL 内部已处理) |
CH341StreamI2C 偶尔失败(非必现) |
USB 供电不足、线缆过长、电磁干扰 | 换短而粗的 USB 线,加 USB 集线器(带外置供电),远离电机/继电器 |
脚本中,我们不追求捕获所有底层错误码(CH341DLL 不提供),而是将错误处理聚焦在可操作、可验证的层面。例如,当读操作失败时,脚本不应只报“读失败”,而应提示用户:“请用万用表测量 SDA 引脚在空闲时是否为高电平(约 3.3V),若为低电平,则上拉电阻未焊接或阻值过大”。
4. 避坑 / 常见问题 / 排查:CH341 I2C 调试中踩过的五个真实血泪坑
CH341 的 I2C 调试不是一蹴而就的线性过程,而是在反复失败、观察、假设、验证中逼近真相。以下是我在多个项目中踩过的、最具迷惑性和破坏性的五个坑,每一个都附带当时的现象、根因分析和最终解决方案。它们不是理论推演,而是从产线日志和调试笔记里抠出来的硬核经验。
4.1 现象:写操作总是成功,但读回来全是 0xFF,逻辑分析仪显示 SDA 始终被从设备拉低
原因:24C02 的写保护引脚(WP)被意外拉低。24C02 的 WP 引脚为低电平时,所有写操作(包括页写、字节写、写地址指针)均被禁止,但从设备仍会正常响应地址帧(ACK),导致写操作 CH341StreamI2C 返回成功,而后续读操作因地址指针未更新,永远读取默认值(0xFF)。这是一个典型的“静默拒绝”错误,逻辑分析仪只能看到 ACK,却看不到写保护生效。
解决:用万用表测量 24C02 的 WP 引脚对地电压。正常工作时应为高电平(VCC)。若为低电平,检查原理图中 WP 是否被下拉电阻接地,或 PCB 上是否有焊锡短路。解决方案是断开下拉电阻,或将 WP 改为悬空或上拉。教训:任何 I2C 设备的写保护、休眠、复位引脚,都必须在调试前用万用表逐一确认电平状态,不能假设它“应该”是高电平。
4.2 现象:向地址 0x00 写入数据后,读 0x00 成功,但读 0x01 却返回 0xFF;向 0x07 写入后,0x07~0x0F 有数据,0x10 却是 0xFF
原因:24C02 的地址指针在写操作后自动递增,但仅限于单字节写或页内连续写。当你向 0x00 写入一个字节后,指针自动变为 0x01;但如果你向 0x07 写入 8 字节(0x07~0x0E),指针会递增至 0x0F,此时再读 0x10 就是新地址,而 0x10 从未被写过,故为 0xFF。更隐蔽的是,如果一次写入 9 字节(0x07~0x13),由于页回卷,0x0F 会被写为第 9 字节,而 0x10 依然为空。这种“指针跳跃”让开发者误以为写操作丢失了。
解决:永远不要依赖地址指针的自动递增来读取连续数据。正确的随机读流程必须是:每读一个地址,都先发一次“写地址”帧([dev_addr_w, mem_addr])来设置指针,再发“读”帧。脚本中必须为每一次读操作都调用完整的 i2c_read_random 函数,而不是试图用一次设置指针后连续读多个字节(除非你确认从设备支持且你已查阅其 datasheet)。教训:把“地址指针”当作一个需要显式管理的变量,而不是一个可以忽略的后台机制。
4.3 现象:脚本在自己的电脑上运行完美,拷贝到同事电脑上却 CH341OpenDevice 失败,而同事的 IAR 软件却能正常使用 CH341
原因:CH341DLL 的位数(32/64)与 Python 解释器位数不匹配。CH341 官方 DLL 有 CH341DLL.dll(32位)和 CH341DLL64.dll(64位)两个版本。如果你的 Python 是 32 位(常见于从 python.org 下载的默认安装包),就必须使用 32 位 DLL;如果是 64 位 Python(常见于 Anaconda),则必须用 64 位 DLL。同事电脑上的 IAR 是 32 位软件,自带 32 位 DLL,所以能用,但这并不意味着你的 Python 脚本也能用。
解决:首先确认 Python 位数:在命令行运行 python -c "import platform; print(platform.architecture())"。然后下载对应位数的 CH341DLL(官网或驱动包中均有),并确保 ctypes.WinDLL("CH341DLL.dll") 中的文件名与实际 DLL 名称一致(64位版可能是 CH341DLL64.dll)。教训:在团队协作中,必须将 DLL 文件与脚本一起打包,并在 README 中明确注明所需 Python 位数,否则“在我机器上好好的”将成为最高频的甩锅话术。
4.4 现象:CH341StreamI2C 调用后程序卡死(hang),CPU 占用率飙升,必须强制结束进程
原因:CH341DLL 的 CH341StreamI2C 函数在遇到总线严重错误(如 SDA 被外部器件永久拉低)时,会陷入内部死循环等待超时,而这个超时时间极长(数秒甚至数十秒)。这不是脚本 bug,而是 DLL 的固有缺陷。当你的硬件电路存在短路(如 SDA 与 GND 短接)、或从设备损坏(内部 SDA 输出级击穿)时,就会触发此现象。
解决:在调用 CH341StreamI2C 前,必须用 CH341GetUsbPort 或 CH341GetDeviceInfor 等函数快速探测设备状态,但这并不能预防 hang。最可靠的方案是:在 Python 层使用 threading.Timer 或 concurrent.futures.TimeoutError 对 DLL 调用设置硬性超时(如 1 秒)。一旦超时,立即终止线程并报错,避免整个脚本瘫痪。虽然这增加了复杂度,但在产线调试中,这是防止“调试变死锁”的必要保险。
4.5 现象:用官方 CH341Prog.exe 工具能成功读写 24C02,但用自己写的 Python 脚本却频繁失败,且失败模式随机
原因:官方工具内部对 CH341StreamI2C 的调用进行了大量容错和重试。例如,当一次写操作返回失败时,它会自动重试 3 次,并在每次重试前插入微秒级延时;当读操作失败时,它会先发一个“总线复位”命令(通过 GPIO 模式模拟),再重试。而你的脚本是“一锤子买卖”,失败即报错,没有重试逻辑。
解决:为关键 I2C 操作添加指数退避重试(Exponential Backoff Retry)。例如,i2c_write 函数可改写为:
python复制import time
import random
def i2c_write_with_retry(dll, handle, device_addr_7bit, mem_addr, data_bytes, max_retries=3):
for attempt in range(max_retries):
try:
return i2c_write(dll, handle, device_addr_7bit, mem_addr, data_bytes)
except RuntimeError as e:
if attempt == max_retries - 1:
raise e
# 指数退避:第一次 10ms,第二次 20ms,第三次 40ms...
delay = (2 ** attempt) * 0.01 + random.uniform(0, 0.005)
time.sleep(delay)
return False
教训:不要迷信“官方工具能行,我的代码就一定没问题”。官方工具的健壮性,往往藏在你看不见的重试、延时、复位逻辑里。把它们抄过来,就是你脚本走向生产可用的第一步。
5. 进阶技巧:用 CH341 脚本构建自动化 EEPROM 校验流水线
当调试从“单次验证”升级为“批量出厂检验”时,脚本的价值就从“救火工具”跃升为“质量守门员”。本节展示如何将前述所有模块组合起来,构建一条全自动的 EEPROM 校验流水线:它能按预设模板生成测试数据、写入指定地址、逐字节读回比对、生成 HTML 报告,并在发现任何一字节偏差时立即停机报警。这不是炫技,而是某传感器模组产线正在运行的真实流程。
5.1 测试数据模板与地址映射表:让校验逻辑可配置、可追溯
硬编码测试数据会让脚本失去灵活性。我们采用 JSON 配置文件定义“校验项”,每个项包含地址、长度、数据模式(固定值、递增序列、CRC 校验值等)和预期用途。例如 eeprom_test_config.json:
json复制{
"device": {
"addr_7bit": 80,
"page_size": 8
},
"test_items": [
{
"name": "产品序列号",
"address": 0,
"length": 8,
"pattern": "fixed",
"value": [0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38],
"description": "ASCII '12345678'"
},
{
"name": "校准参数",
"address": 8,
"length": 16,
"pattern": "incremental",
"start_value": 100,
"step": 1,
"description": "100,101,...,115"
},
{
"name": "CRC32校验码",
"address": 24,
"length": 4,
"pattern": "crc32",
"source_range": [0, 24],
"description": "对地址0-23字节计算CRC32"
}
]
}
脚本读取此配置,动态生成待写入数据,并在读回后按相同规则重新计算 CRC 进行比对。这种“配置即代码”的方式,让产线工程师无需修改 Python 源码,只需编辑 JSON,就能新增、删除、修改任意校验项,且所有配置变更都有 Git 历史可追溯。
5.2 自动化校验核心逻辑:写入、读回、比对、报告一体化
以下函数是流水线的引擎,它串联了初始化、页安全写、随机读、CRC 计算和 HTML 报告生成:
python复制import json
import zlib
from datetime import datetime
def run_eeprom_validation(config_path):
"""
运行完整的EEPROM校验流水线
:param config_path: 配置文件路径
"""
# 1. 加载配置
with open(config_path, 'r') as f:
config = json.load(f)
# 2. 初始化CH341
dll, handle = init_ch341_and_probe_i2c()
# 3. 生成待写入的完整数据块(按配置项顺序填充)
full_data = [0xFF] * 256 # 24C02共256字节,初始化为0xFF
for item in config["test_items"]:
addr = item["address"]
length = item["length"]
if item["pattern"] == "fixed":
data_to_write = item["value"]
elif item["pattern"] == "incremental":
data_to_write = [item["start_value"] + i * item["step"] for i in range(length)]
elif item["pattern"] == "crc32":
# CRC32项不写入数据,留空,后续计算
continue
else:
raise ValueError(f"未知数据模式: {item['pattern']}")
# 填充到full_data
for i, v in enumerate(data_to_write):
if addr + i < 256:
full_data[addr + i] = v & 0xFF
# 4. 页安全写入
write_eeprom_page_safe(dll, handle,
(config["device"]["addr_7bit"] << 1) | 0x00,
0, full_data)
# 5. 逐项读回并比对
results = []
for item in config["test_items"]:
addr = item["address"]
length = item
