#!/usr/bin/env python3 # -*- coding: utf-8 -*- """PDO 周期扫描：一次跑完多档，同时记「速度达成 / 故障率 / CPU 占用」三条曲线。 与 tools/ecat/rate_probe.py 的区别：rate_probe 只量速度达成率，本脚本把故障率与 CPU 一并采齐并落成机读 CSV，供 plot_ecat_sweep.py 画曲线。速率达成部分的 "cycles 与时刻同取同舍"纪律直接沿用 rate_probe（它注释里记过一次把 99.2% 误报 成 96% 的实踩教训：分子取末次 cycles、分母却在循环退出后才算，dt 多出一次 sleep）。 必须绕开的四件事（均由 Phase 0 现场标定确认，不是照抄文档）： 1 u16 回绕：bridge.drop 在 4000/s 下 16s 绕一圈，首尾相减必错 → 高频逐次累加， 且单次增量 >32768 视为绕圈、该点作废并计数暴露采样率不足。 2 rx_torn / pdo_reentry 是**饱和**计数（到 65535 停），不能按回绕算 → 走 delta_saturate，封顶即标注"下界"而不是报精确值。 3 周期能被 localStorage 劫持：任何开着的电机页标签在 ensureStarted 时会把总线 周期拽回存量值（transport-ecat.js:227-228）→ 每档下发后回读 period_ms 确认 真的生效，不一致就把该档标记为被劫持。 4 λ（CAN 到帧率）取 u32 的 head.global_seq，不取 u16 的 bridge.rx_count。 本次实测到关键分界：1ms/0.5ms 档 λ=4000/s、GD32 负载 44%/77%；0.25ms/0.125ms 档 GD32 顶到 99.5%/99.3%，λ 塌到 149/s —— 从站主循环被 PDO 填充吃光、CAN 接收 停摆。而主站达成率反而仍很高（0.125ms 实测 7780Hz），所以瓶颈在从站不在主站： 只看达成率会把这条线整个看漏。 用法： python scripts/sweep_ecat_rate.py # 默认六档 × 60s python scripts/sweep_ecat_rate.py --periods 0.25,0.5,1 --dwell 30 python scripts/sweep_ecat_rate.py --restore 1 --out lab/ecat_sweep.csv python scripts/sweep_ecat_rate.py --dry-run # 只走一遍不下发周期 结束后一定把周期恢复到脚本启动前的原值（含 Ctrl-C / 异常）。 """ import argparse import csv import os import signal import sys import time sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from calibrate_ecat_metrics import (cadence_rings, find_native_pid, firmware_identity, ensure_loop) from ecat_sweep_common import delta_saturate, delta_wrap, percentile, post DEFAULT_PERIODS = "0.125,0.25,0.5,1,2,4" COLS = ["period_ms", "set_period_ms", "hijacked", "native_pid", "pid_stable", "measured_hz", "achieve_pct", "can_lambda_per_s", "drop_per_s", "drop_pct_of_lambda", "drop_untrusted", "lambda_u16_crosscheck", "rxb_count_mode_per_cycle", "rxb_lost_max", "rxb_pending_max", "skip_per_s", "skip_delta", "motors_online", "online_frac", "motor_refresh_per_s", "torn_per_s", "torn_cum", "torn_capped", "reentry_per_s", "reentry_cum", "reentry_capped", "wkc", "expected_wkc", "wr", "cyc_p50_us", "cyc_p90_us", "cyc_max_us", "cyc_duty_pct", "gd32_load_pct", "gd32_load_samples", "gd32_load_stale", "host_cpu_1core_pct", "host_cpu_total_pct", "logical_cpus", "samples", "errors", "dwell_s", "note"] def sample_period(url, ms, dwell, hz, substr, autostart, dry): """在给定周期档上采 dwell 秒，返回一行 CSV 记录。""" note = [] pid0, perr = find_native_pid(url) st0 = post(url, "/api/motor/state") if not (st0.get("ok") and st0.get("cycles")): st0, how = ensure_loop(url, autostart, substr) note.append("起循环:" + how) orig = st0.get("period_ms") if dry: return {"period_ms": ms, "note": "dry-run 未下发"} r = post(url, "/api/motor/period", {"period_ms": ms}) if not r.get("ok"): return {"period_ms": ms, "note": "档位被拒:" + str(r.get("log"))[:80]} # 等周期真正生效（热调是异步落到循环线程的） eff, stable_iters = None, 0 t_deadline = time.perf_counter() + 3.0 while time.perf_counter() < t_deadline: time.sleep(0.2) eff = (post(url, "/api/motor/state")).get("period_ms") if eff is not None and abs(float(eff) - float(ms)) < 1e-6: stable_iters += 1 if stable_iters >= 3: break else: stable_iters = 0 hijacked = "no" if eff is None or abs(float(eff) - float(ms)) >= 1e-6: hijacked = "YES" note.append(f"下发 {ms}ms 但生效 {eff}ms（疑 localStorage 劫持或有他端在设）") interval = 1.0 / hz cyc_hz, drop_rate, rx_rate, gseq_rate, loads, hc1, hct = [], [], [], [], [], [], [] cyc_p50, cyc_p90, cyc_max = [], [], [] untrusted = torn_sum = reentry_sum = err = iters = load_stale = 0 torn_cap = reentry_cap = False torn_prev = re_prev = None torn_cum = re_cum = None node_seq = {} # node -> (t, seq)：上一拍的槽 seq，用于算电机数据刷新率 online_hits = online_tot = 0 refresh_rates = [] prev = prev_t = None wr0 = (post(url, "/api/motor/state")).get("wr") skip0 = (post(url, "/api/motor/dbg")).get("skip_total") proc = None try: import psutil if pid0: proc = psutil.Process(pid0) proc.cpu_percent(None) # 建立差分基线 except Exception as e: note.append(f"psutil 不可用({e.__class__.__name__})，主机 CPU 缺") t_end = time.perf_counter() + dwell while time.perf_counter() < t_end: tc = time.perf_counter() try: s = post(url, "/api/motor/state") L = post(url, "/api/app/load") except Exception: err += 1 time.sleep(interval) continue iters += 1 b = s.get("bridge") or {} cur = {"cycles": s.get("cycles"), "drop": b.get("drop"), "rx": b.get("rx_count"), "gseq": (s.get("head") or {}).get("global_seq")} if prev is not None and tc > prev_t: dt = tc - prev_t if cur["cycles"] is not None and prev["cycles"] is not None: h = (cur["cycles"] - prev["cycles"]) / dt if 0 < h < 1e6: cyc_hz.append(h) if cur["drop"] is not None and prev["drop"] is not None: d = delta_wrap(prev["drop"], cur["drop"], 16) if d < 32768: drop_rate.append(d / dt) else: untrusted += 1 # 已绕圈：该点作废，只计数不臆造速率 # λ 以 u32 的 head.global_seq 为准。u16 的 bridge.rx_count/drop 在快档 # 会失真（实测 0.25ms 档真值 149/s，两路 u16 与 u32 虽一致但增量已贴近 # 截断区），留作交叉核对：两者显著背离即说明该档 u16 不可信。 if cur["gseq"] is not None and prev["gseq"] is not None: d = delta_wrap(prev["gseq"], cur["gseq"], 32) if 0 <= d < (1 << 31): gseq_rate.append(d / dt) if cur["rx"] is not None and prev["rx"] is not None: d = delta_wrap(prev["rx"], cur["rx"], 32) if d < (1 << 31): rx_rate.append(d / dt) tn, rn = L.get("rx_torn"), L.get("pdo_reentry") if tn is not None: if torn_prev is not None and not torn_cap: dd, capped = delta_saturate(torn_prev, tn) torn_sum += dd torn_cap |= capped torn_prev = tn if rn is not None: if re_prev is not None and not reentry_cap: dd, capped = delta_saturate(re_prev, rn) reentry_sum += dd reentry_cap |= capped re_prev = rn # 从站停报时 load_perm 会保留最后一次的值（实测：从站楔死后 age_ms=214000 # 而 load_perm 仍报 992）。不加 age 闸就会把残值当实测写进结论。 if (L.get("valid") and L.get("load_perm") is not None and (L.get("age_ms") if L.get("age_ms") is not None else 1e9) < 1000): loads.append(L["load_perm"] / 10.0) else: load_stale += 1 cu = (s.get("cyc_us") or {}).get("total") or {} if cu.get("p50") is not None: cyc_p50.append(cu["p50"]) if cu.get("p90") is not None: cyc_p90.append(cu["p90"]) if cu.get("max") is not None: cyc_max.append(cu["max"]) if proc is not None: try: c = proc.cpu_percent(None) hc1.append(c) hct.append(c / max(1, os.cpu_count() or 1)) except Exception: pass # 电机在线标志与数据刷新率：快档塌陷必须能区分"从站算不过来"与"电机掉线" # —— 二者在 λ/seq 上长得一模一样，只有 online 标志能把它们切开。 for m in (s.get("motors") or []): nd = m.get("node") if nd is None: continue online_tot += 1 online_hits += 1 if m.get("online") else 0 sq = m.get("seq") if sq is None: continue pr = node_seq.get(nd) if pr and tc > pr[0]: d = delta_wrap(pr[1], sq, 32) if d < (1 << 31): refresh_rates.append(d / (tc - pr[0])) node_seq[nd] = (tc, sq) prev, prev_t = cur, tc time.sleep(max(0.0, interval - (time.perf_counter() - tc))) dur = max(1e-6, time.perf_counter() - (t_end - dwell)) stf = post(url, "/api/motor/state") tend = post(url, "/api/app/load") pid1, _ = find_native_pid(url) skip1 = (post(url, "/api/motor/dbg")).get("skip_total") cad = cadence_rings(url) torn_cum, re_cum = tend.get("rx_torn"), tend.get("pdo_reentry") lam = percentile(gseq_rate, 0.5) or 0 # u32 gseq 口径，主用 lam_u16 = percentile(rx_rate, 0.5) or 0 # u16 rx_count 口径，仅作交叉核对 dropr = percentile(drop_rate, 0.5) or 0 hz_meas = percentile(cyc_hz, 0.5) or 0 eff_ms = float(stf.get("period_ms") or ms) cad_hist = cad.get("count_hist") or {} mode_cnt = max(cad_hist, key=lambda k: cad_hist[k]) if cad_hist else None rec = { "period_ms": ms, "set_period_ms": eff_ms, "hijacked": hijacked, "native_pid": pid0, "pid_stable": "yes" if pid0 == pid1 else "NO", "measured_hz": round(hz_meas, 1), "achieve_pct": round(hz_meas / (1000.0 / eff_ms) * 100, 1) if eff_ms else None, "can_lambda_per_s": round(lam, 1), "lambda_u16_crosscheck": round(lam_u16, 1), "drop_per_s": round(dropr, 1), "drop_pct_of_lambda": round(dropr / lam * 100, 2) if lam else None, "drop_untrusted": untrusted, "rxb_count_mode_per_cycle": mode_cnt, "rxb_lost_max": cad.get("lost_max"), "rxb_pending_max": cad.get("pending_max"), "motors_online": sum(1 for m in (stf.get("motors") or []) if m.get("online")), "online_frac": round(online_hits / online_tot, 3) if online_tot else None, "motor_refresh_per_s": round(percentile(refresh_rates, 0.5) or 0, 1), "skip_per_s": round(((skip1 or 0) - (skip0 or 0)) / dur, 2), "skip_delta": (skip1 or 0) - (skip0 or 0), "torn_per_s": round(torn_sum / dur, 3), "torn_cum": torn_cum, "torn_capped": "yes" if torn_cap else "no", "reentry_per_s": round(reentry_sum / dur, 3), "reentry_cum": re_cum, "reentry_capped": "yes" if reentry_cap else "no", "wkc": stf.get("wkc"), "expected_wkc": stf.get("expected_wkc"), "wr": f"{wr0}->{stf.get('wr')}", "cyc_p50_us": round(percentile(cyc_p50, 0.5) or 0, 1), "cyc_p90_us": round(percentile(cyc_p90, 0.9) or 0, 1), "cyc_max_us": round(max(cyc_max), 1) if cyc_max else None, "cyc_duty_pct": round((percentile(cyc_p50, 0.5) or 0) / (eff_ms * 1000) * 100, 1), "gd32_load_pct": round(percentile(loads, 0.5) or 0, 1) if loads else None, "gd32_load_samples": len(loads), "gd32_load_stale": load_stale, "host_cpu_1core_pct": round(percentile(hc1, 0.5) or 0, 1), "host_cpu_total_pct": round(percentile(hct, 0.5) or 0, 2), "logical_cpus": os.cpu_count(), "samples": iters, "errors": err, "dwell_s": round(dur, 1), "note": "; ".join(note)} return rec def main(): ap = argparse.ArgumentParser(description="ECAT 周期-故障率-CPU 扫描") ap.add_argument("--url", default="http://127.0.0.1:8090") ap.add_argument("--periods", default=DEFAULT_PERIODS, help="逗号分隔周期(ms)") ap.add_argument("--dwell", type=float, default=60.0, help="每档采样秒数") ap.add_argument("--hz", type=float, default=10.0, help="HTTP 采样频率；u16 drop 在 4000/s 下 16s 绕一圈，须够高") ap.add_argument("--restore", type=float, default=None, help="测完恢复到的周期(ms)") ap.add_argument("--substr", default="I210") ap.add_argument("--no-autostart", action="store_true") ap.add_argument("--out", default=os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "lab", "ecat_rate_sweep.csv")) ap.add_argument("--dry-run", action="store_true") a = ap.parse_args() st = post(a.url, "/api/motor/state") if not (st.get("ok") and st.get("cycles")) and a.no_autostart: print("循环没跑且 --no-autostart：", st.get("log")) return 2 orig = st.get("period_ms") pid0, _ = find_native_pid(a.url) periods = [float(x) for x in a.periods.split(",")] print(f"服务 {a.url} · native PID {pid0} · 原周期 {orig}ms · 档位 {periods} · " f"每档 {a.dwell}s @ {a.hz:g}Hz") fw = firmware_identity() print(f"固件台账 {str(fw.get('ledger'))[:16]}… 匹配={fw.get('match') or fw.get('error') or '无'}") print("提示：确认没有任何电机页标签开着，否则周期会被 localStorage 拽回去\n") rows, interrupted = [], False signal.signal(signal.SIGINT, lambda *_: None) try: for ms in periods: try: rec = sample_period(a.url, ms, a.dwell, a.hz, a.substr, not a.no_autostart, a.dry_run) except Exception as e: print(f"{ms}ms 档异常: {type(e).__name__}: {e}") break rows.append(rec) if rec.get("note") == "dry-run 未下发": print(f"[dry-run] {ms}ms 将下发，未执行") continue print(f"{ms:>7}ms 生效={rec['set_period_ms']} 劫持={rec['hijacked']} " f"{rec['measured_hz']}Hz/{rec['achieve_pct']}% λ={rec['can_lambda_per_s']} " f"drop={rec['drop_per_s']}/s({rec['drop_pct_of_lambda']}%) " f"skip={rec['skip_per_s']}/s GD32={rec['gd32_load_pct']}% " f"host={rec['host_cpu_1core_pct']}% wkc={rec['wkc']}/{rec['expected_wkc']}") if rec["note"]: print(f" note: {rec['note']}") if rec["pid_stable"] == "NO": print(" !! native PID 变了，该档及之后数据作废，停止扫描") break if rec["wkc"] != rec["expected_wkc"]: print(" !! wkc 不达预期（从站丢帧/掉 OP 前兆），停止继续加压") break except KeyboardInterrupt: interrupted = True print("\n收到 Ctrl-C，正在恢复原周期…") finally: restore = a.restore if a.restore is not None else orig if restore is not None and not a.dry_run: try: post(a.url, "/api/motor/period", {"period_ms": float(restore)}) back = (post(a.url, "/api/motor/state")).get("period_ms") print(f"\n已恢复周期 -> 设定 {restore}ms，实际回读 {back}ms") except Exception as e: print(f"\n!! 恢复周期失败({e})，请手动确认总线周期") if not rows or a.dry_run: return 0 os.makedirs(os.path.dirname(os.path.abspath(a.out)), exist_ok=True) with open(a.out, "w", newline="", encoding="utf-8") as f: w = csv.DictWriter(f, fieldnames=COLS, extrasaction="ignore") w.writeheader() w.writerows(rows) print(f"扫描数据 {len(rows)} 档 -> {a.out}") if interrupted: print("（本次为中断后的部分数据）") return 0 if __name__ == "__main__": sys.exit(main())