这篇能做出什么
目标很具体:一辆 1994 年的 Jeep(这一代大多属于 OBD-II 强制之前的年代,ECU 用的是厂家自定义的诊断协议),你要在不拆 ECU、不刷写、只做只读监听的前提下,走完这条链路:
1. 用万用表和逻辑分析仪找到诊断座上的总线引脚,确认空闲电平和通信时的波形;
2. 用一块 Arduino 或 ESP32 把总线上的电平跳变带时间戳记录下来,存成 CSV;
3. 用 Python 把“跳变时间序列”还原成比特流,反推出位宽(波特率)、帧边界、字节序;
4. 结合已知工况(怠速、踩油门、水温上升)把字节位置和物理量对应起来,猜出校验算法;
5. 生成一份可回放的验证代码,用另一段没有参与拟合的日志去检验你的解析器;
6. 把结论固化成 docs/protocol.md 加一组 pytest 用例。
Claude Code 和 Codex 在这条链路里的角色不是“替你逆向”,而是承担大量重复劳动:写采集固件、写分析脚本、扫参数空间、穷举校验算法、把结论写成文档和测试。判断和验证据由你完成——这一点在后面“常见坑”里会反复强调。
边界先说清楚:只监听,不发送任何写指令;只在自家车辆或台架上做;不在行驶中边开车边接线。
前置条件清单
硬件
- 一块开发板:Arduino Uno/Nano 够用(边沿时间戳法对 RAM 要求不高),ESP32 更宽裕(可用硬件定时器和更大缓冲);
- USB 逻辑分析仪(8 通道级别即可),用于先看清波形再决定采样策略;
- 万用表;
- 5V→3.3V 的电平处理:老车总线多为 5V 逻辑,ESP32 的 IO 不耐 5V,必须用电阻分压或专用电平转换芯片;
- 面包板、杜邦线、可选的车用破线夹(比针戳进连接器可靠);
- 一个稳定的 12V 电源或充满电的电瓶。
软件
- Arduino IDE 或 PlatformIO;
- Python 3 +
pyserial、numpy、matplotlib(画图看波形很有用); - Git(智能体改代码要能回滚,这一步不能省);
- Claude Code(在终端里跑,能读写仓库、执行命令);
- Codex(作为第二意见,用来生成单文件算法或对同一问题给出另一种实现)。
资料
- 你这台车的维修手册线束图与诊断座针脚定义。不同年款、不同发动机(4.0L 直六与其他配置)线束不同,以官方维修资料为准。
- 一点耐心:老车的连接器氧化、线束老化会显著影响信号质量。
背景知识提示:克莱斯勒车系在这一时期常用 SCI 单线串行总线(车身上另有 CCD 总线),公开资料里经常引用 7812.5 bps 这个速率。这只是给你一个搜索方向,真实位宽必须靠实测确认,不要拿它当结论。
分步骤
步骤 1:先把仓库搭成“智能体能住的房子”
智能体在结构清晰、约定明确的仓库里表现差别很大。开工前先建好目录和约定文件。
```text
jeep-ecu-re/
├── CLAUDE.md # 给 Claude Code 的项目约定
├── AI 词典:AGENTS.md">AGENTS.md # 给 Codex 的同类约定
├── firmware/
│ └── edge_logger/
├── logs/
│ ├── raw/ # 原始 CSV,只增不改
│ └── notes.md # 每次采集的工况说明
├── analysis/
│ ├── waveform.py
│ ├── frame.py
│ └── tests/
└── docs/
└── protocol.md
```
CLAUDE.md 里写清楚这几条,比写一堆形容词管用:
```markdown
项目约定
- logs/raw/ 下的文件是原始证据,禁止修改或覆盖。
- 日志格式:以 # 开头的注释行 + 数据行 "t_us,level",t_us 为微秒整数,level 为 0/1。
- 任何解析结论必须附一条验证命令,能在 analysis/ 下跑通。
- 禁止在代码里生成任何向总线写入的逻辑,本项目只读。
- 修改算法后必须跑 pytest,全部通过才算完成。
```
有了这份文件,你后面只需要说“按 CLAUDE.md 的约定,给 frame.py 加一个找帧头的函数”,不用每次重复背景。
步骤 2:定位总线引脚(不靠猜)
断电状态下先用万用表通断档找地和常电,再上电用直流档量每一针的静态电压。典型会看到 12V 常电、搭铁、5V 参考、以及一根空闲在 5V 左右的通信线。
判断“哪根是通信线”的可靠办法是让逻辑分析仪挂上去看:怠速时如果那根线上有间歇的脉冲串,基本就是它。记录成一张表:
```markdown
| 针脚 | 静态电压 | 上电后有脉冲 | 备注 |
|---|---|---|---|
| 4 | 0V | 否 | 搭铁 |
| 16 | 12.6V | 否 | 常电 |
| ? | 4.9V | 是 | 疑似总线,空闲高 |
```
注意:1994 年前后部分车型已经换用了 16 针的诊断座,但座子形状不等于协议,看到 16 针不要默认它就是 OBD-II 的 ISO 9141 或 CAN,还是要按波形判断。
步骤 3:Arduino 侧——把“跳变”忠实记下来
未知波特率时,最稳妥的思路不是“按猜测的速率采样”,而是记录每一次电平跳变的时刻。数据量小,精度也够:Arduino 的 micros() 分辨率约 4µs,对几千 bps 的总线(位宽上百微秒)绰绰有余。
```cpp
// firmware/edge_logger/edge_logger.ino
// 记录总线上的每一次电平跳变,带 micros() 时间戳
const uint8_t BUS_PIN = 2; // 必须是支持外部中断的引脚
const uint16_t MAX_EDGES = 4000; // 一次采集窗口的容量
uint32_t stamp[MAX_EDGES];
uint8_t level[MAX_EDGES];
volatile uint16_t count = 0;
volatile bool armed = false;
volatile bool done = false;
void onEdge() {
if (!armed || done) return;
if (count >= MAX_EDGES) { done = true; return; }
stamp[count] = micros();
level[count] = digitalRead(BUS_PIN);
count++;
}
void setup() {
Serial.begin(115200);
pinMode(BUS_PIN, INPUT);
attachInterrupt(digitalPinToInterrupt(BUS_PIN), onEdge, CHANGE);
}
void loop() {
if (!Serial.available()) return;
char c = Serial.read();
if (c == 'r') { // 开始记录
count = 0; done = false; armed = true;
} else if (c == 's') { // 停止记录
armed = false;
} else if (c == 'p') { // 打印
Serial.print(F("#EDGES "));
Serial.println(count);
for (uint16_t i = 0; i < count; i++) {
Serial.print(stamp[i]);
Serial.print(',');
Serial.println(level[i]);
}
Serial.println(F("#END"));
}
}
```
串口里输入 r 开始采集、s 停止、p 导出。不要在中断里调 Serial.print,那会丢边沿。
如果你更想用“等间隔过采样”的方式(比如 1MHz 采样存 0/1),也能做,但 ESP32 上更推荐用 PSRAM 开大缓冲。两种方式二选一即可,边沿法的优势是数据量小、便于人工核对。
电平那一段别省:5V 总线接 ESP32 之前,串一个分压网络(例如 10k + 20k 分压到 3.3V 附近),或者用现成的双向电平转换模块。这一步做错,代价是一个引脚甚至整块板。
步骤 4:采集工况,形成对照数据
一次采集只对应一个稳定工况,这是后面“对号入座”的前提。建议按这个顺序,每段 10~20 秒:
1. 冷车怠速(水温低,喷油脉宽大);
2. 水温正常后怠速;
3. 怠速 + 开空调(负荷变化,转速或脉宽会有响应);
4. 空挡稳住 2000 rpm;
5. 松油门回怠速。
每段单独存文件,命名带工况:logs/raw/20240501_idle_warm.csv。同时在 logs/notes.md 里写一行说明,例如“水温 90℃,环境温度 22℃,未开空调”。
这批“同一辆车、不同已知工况”的数据,就是你的训练集和验证集。用一半拟合,用另一半验证,这条纪律后面会救你。
步骤 5:让 Claude Code 做第一轮分析
进入仓库,把日志文件和分析任务一起交给它。提示词写得越像任务书,产出越可用:
```text
读 logs/raw/ 下所有 CSV。写 analysis/waveform.py,完成:
1) 解析 "#" 开头的注释行与 "t_us,level" 数据行;
2) 计算相邻跳变的时间间隔,输出直方图(按 1µs 分箱,打印出现次数最多的 20 个间隔值);
3) 生成一个 Waveform 类,提供 level(t) 方法:给定时刻返回电平,用二分查找实现;
4) 把结果存成 analysis/report.md,包含每一档重复出现的间隔值。
不要修改 logs/raw/ 下任何文件。
```
拿到间隔直方图后,最常见的那个小间隔通常就是 1 个位的时间。如果它落在 128µs 附近,对应约 7812 bps;落在 96µs 附近,对应约 10400 bps。这只是初判,下一步才做定论。
步骤 6:从边沿还原成比特,用“停止位”反推位宽
老车的单线总线,波形上往往非常像反相的 UART:空闲为高,起始位把线拉低,8 个数据位低位在前,停止位回到高。所以第一优先尝试的就是 8N1 解码。
关键技巧在这里:位宽猜得对不对,用“停止位是不是高电平”来打分。位宽正确时,每一帧第 10 个位位置上量到的电平绝大多数是 1;位宽错了,这个比例会掉下来。于是可以扫一遍候选位宽,取峰值。
```python
analysis/frame.py
import bisect
class Waveform:
def __init__(self, edges, idle_level=1):
self.t = [e[0] for e in edges]
self.v = [e[1] for e in edges]
self.idle = idle_level
def level(self, t):
i = bisect.bisect_right(self.t, t) - 1
if i < 0:
return self.idle
return self.v[i]
def load_edges(path):
edges = []
with open(path) as f:
for line in f:
line = line.strip()
if not line or line.startswith('#'):
continue
t, lv = line.split(',')
edges.append((int(t), int(lv)))
return edges
def find_start_bits(wf, bit_us, idle_bits=3.0):
"""找 高->低 且前面空闲足够长的跳变,视为起始位起点"""
starts = []
for i in range(1, len(wf.t)):
if wf.v[i - 1] == 1 and wf.v[i] == 0:
if wf.t[i] - wf.t[i - 1] >= idle_bits * bit_us:
starts.append(wf.t[i])
return starts
def sample_frame(wf, t0, bit_us, nbits=10):
"""在位中心采样,返回长度为 nbits 的电平列表"""
return [wf.level(t0 + (k + 0.5) * bit_us) for k in range(nbits)]
def stop_bit_score(wf, bit_us):
starts = find_start_bits(wf, bit_us)
total = ok = 0
for t0 in starts:
bits = sample_frame(wf, t0, bit_us)
if bits[0] != 0:
continue
total += 1
if bits[-1] == 1:
ok += 1
return (ok / total if total else 0.0), total
def sweep_bit_width(wf, lo=60, hi=200, step=0.5):
best = []
bw = lo
while bw <= hi:
score, n = stop_bit_score(wf, bw)
best.append((score, bw, n))
bw += step
best.sort(reverse=True)
return best[:10]
```
跑一遍 sweep_bit_width,如果前几名的得分明显贴近 1.0(比如 0.98 以上)并且样本数可观,位宽基本就确定了。这一步让 Claude Code 写成脚本、跑出表格,你只负责看结论对不对。
步骤 7:切帧、组字节、看结构
位宽定了之后,把每一帧的 10 个位转成一个字节加校验位:
```python
def bits_to_byte(bits):
"""bits[0] 为起始位,bits[1:9] 为 8 个数据位(低位在前),bits[9] 为停止位"""
val = 0
for i, b in enumerate(bits[1:9]):
val |= (b & 1) << i
return val, bits[9]
def frames_to_bytes(wf, bit_us):
out = []
for t0 in find_start_bits(wf, bit_us):
bits = sample_frame(wf, t0, bit_us)
if bits[0] != 0 or bits[-1] != 1:
continue # 起始位/停止位不合法,跳过
val, _ = bits_to_byte(bits)
out.append((t0, val))
return out
```
到这一步,你手上是一串 (时间, 字节)。把它按“帧间隔明显大于字节间隔”的规律切成帧——让 Claude Code 统计“相邻字节间隔”的分布,间隔大的地方就是帧边界。切完之后输出一个表格:
```text
帧长(字节) 出现次数
6 412
4 88
```
帧长稳定,说明切法对了。
步骤 8:结构还原——拿已知量去“对号入座”
这是整个项目里最像推理游戏的一步。你手里有一组已知的物理量(转速、水温、车速、节气门),以及同工况下的字节序列。
让 Codex 生成一份“按字节位置的取值统计”:
```python
analysis/stats.py:按帧内字节位置统计不同工况下的取值
import csv, collections
def load_frames(path, frame_len):
假设已由前面步骤抽出字节列表
...
def byte_table(frames):
"""返回 {位置: {字节值: 次数}}"""
pos = collections.defaultdict(collections.Counter)
for f in frames:
for i, b in enumerate(f):
pos[i][b] += 1
return pos
```
有了这张表,规律很直观:
- 某个位置在怠速时稳定在 A、2000 rpm 时稳定在 B,且随转速单调变化 → 转速高字节;
- 某位置在冷车时数值小、热车后变大 → 水温;
- 某位置在两个相邻字节上呈明显的高低字节关系(低字节满 255 进位到高字节)→ 16 位量。
转速这类量通常有比例系数。做法是:取两个已知转速点 800 rpm 和 2000 rpm,读出对应字节值 v1、v2,解一个线性方程得到 rpm = k * v + b。然后用第三个工况点(比如 1200 rpm)去验证,对不上就说明字节选错了。
步骤 9:校验算法——让智能体穷举,让你来判定
如果每帧末尾有一个字节在变,大概率是校验。常见候选是 sum8、xor8、CRC-8(多种多项式)。让 Claude Code 写穷举脚本:
```python
analysis/checksum.py
def crc8(data, poly, init=0x00):
crc = init
for b in data:
crc ^= b
for _ in range(8):
if crc & 0x80:
crc = ((crc << 1) ^ poly) & 0xFF
else:
crc = (crc << 1) & 0xFF
return crc
CANDIDATES = {
'sum8': lambda d: sum(d) & 0xFF,
'xor8': lambda d: __import__('functools').reduce(lambda a, b: a ^ b, d, 0),
'crc8_0x07': lambda d: crc8(d, 0x07),
'crc8_0x31': lambda d: crc8(d, 0x31),
'crc8_0x1D': lambda d: crc8(d, 0x1D),
'crc8_0x2F': lambda d: crc8(d, 0x2F),
}
def check(frames):
"""frames: [(bytes_without_checksum, checksum_byte), ...]"""
for name, fn in CANDIDATES.items():
hit = sum(1 for payload, chk in frames if fn(payload) == chk)
print(f"{name:12s} {hit}/{len(frames)}")
```
如果所有候选都命中率很低,再试几种变体:不含帧头的、含帧头的、累加后取反的、加固定偏移的。让智能体把变体列表铺开,它很擅长这件事。但判定权在你:命中率 100% 才算过,95% 说明还有边界情况没考虑到(比如某些帧不带校验)。
步骤 10:闭环验证
验证不是“再跑一遍同样的数据”,而是构造一段独立链路:
1. 拿一段没参与拟合的日志(步骤 4 里留下的验证集),跑你的解析器,看输出曲线是否物理合理:怠速时转速平、踩油门时上升、松油门回落。
2. 写一个回放器:另一块开发板按日志里的时间戳把电平重新打到总线上,让你的解码器去解,结果应与你对原始日志的解析一致。这一步能暴露时序和缓冲边界的问题。
3. 让 Claude Code 生成 pytest 用例,把几段真实日志作为“黄金样本”固化下来,之后每次改解析器都跑一遍。
```python
analysis/tests/test_frame.py
from frame import Waveform, load_edges, sweep_bit_width, frames_to_bytes
def test_bit_width_stable():
wf = Waveform(load_edges('logs/raw/idle_warm.csv'))
top = sweep_bit_width(wf)
score, bw, n = top[0]
assert score > 0.95, f"停止位一致率偏低: {score}"
assert n > 50, "有效帧太少,采集时长不够"
```
步骤 11:把结论写成别人能读的文档
docs/protocol.md 里至少写清:总线电气特性(空闲电平、速率、位序)、帧结构(帧头、长度、字段偏移)、已确认字段的换算公式、校验算法、以及哪些字段还是猜测。把“已确认”和“待确认”分开写,比写一篇看起来很完整的文档有用得多。
常见坑与排错
烧引脚。5V 逻辑直接接 3.3V 芯片是最常见的翻车点。上电前先用万用表确认总线空闲电压,再决定要不要分压。
共地与地环路。车和电脑必须共地,否则读数乱跳;但如果开发板由车上供电、USB 又插着笔记本,可能出现地环路,串一个 USB 隔离器会干净很多。
micros() 回绕。micros() 大约 70 分钟回绕一次,跨回绕的日志会出现巨大的负间隔。解析时先做一次展开(遇到时间倒退就加 2^32),或者干脆单次采集不超过 30 分钟。
中断里打印。在 ISR 里调 Serial.print 会丢边沿,症状是“日志看起来像被随机截断”。正确做法是缓冲到数组,回到 loop() 再输出。
点火瞬间采集。启动机工作的瞬间电压跌落和电磁干扰会让波形失真。避开这个窗口,从稳定怠速开始采。
误把扫描工具当 ECU。如果诊断座上插着扫描仪,总线上可能全是扫描仪的请求。采集时把其他设备都拔掉,先确认是 ECU 自己在说话。
过度信任智能体。这是这类项目里最容易犯的错。智能体很擅长给出“看起来很合理”的位宽、字节含义和校验算法,而这三样恰恰最需要证据。判断标准只有一个:在没参与拟合的数据上是否成立。它给出的每一条结论,你都要能指出对应的验证命令和验证数据。
一次让它改太多。让它“把整个解析器重写一遍”,你多半会拿到一份跑不通也看不懂的代码。正确节奏是小步:一次一个函数,跑测试,git diff 看一遍,提交,再下一步。
忽视连接器质量。老车的诊断座针脚氧化会导致间歇性丢帧。遇到“某些帧总是解析失败”时,先怀疑接触,再怀疑代码。
下一步建议
协议跑通之后,这个项目还有不少延伸方向:
- 把这套方法迁移到车身上的另一条总线(克莱斯勒车系的 CCD 是差分双线,电气特性不同,但帧分析的思路相通),练习差分信号采集;
- 用逻辑分析仪配合 sigrok 做长时捕获,把解码逻辑写成 sigrok 的解码器插件,让波形软件直接显示字段;
- 把解析器搬到 ESP32 上做实时解码,配一块小屏做车载仪表——这是很好的“闭环交付”练习;
- 系统性地对比 ISO 9141、J1850 PWM/VPW、CAN 这几种标准在电气层和帧结构上的差异,你会发现自定义协议里的很多设计其实是标准协议的简化版;
- 更重要的方法论沉淀:把“采集 → 假设 → 用留出数据验证 → 固化成测试”这套流程写成模板,下次遇到任何未知串行协议(工业设备、家电、传感器)都能直接套用。
编码智能体在这类任务里真正省下的,是写采集固件、扫参数空间、穷举校验、补测试这些体力活;而“这条总线上到底跑的是什么”这个判断,始终得由拿着万用表和示波器的你来下。
