zjk/H100PowerManger
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Compare commits

base: zjk/H100PowerManger:873a1a9b09293e892234ba3c01689bcd91cc3dfa
Branches Tags
zjk/H100PowerManger:main zjk/H100PowerManger:test-reports zjk/H100PowerManger:refactor-power-manager zjk/H100PowerManger:backup-20241022
zjk/H100PowerManger:latest
...
compare: zjk/H100PowerManger:main
Branches Tags
zjk/H100PowerManger:main zjk/H100PowerManger:test-reports zjk/H100PowerManger:refactor-power-manager zjk/H100PowerManger:backup-20241022
zjk/H100PowerManger:latest
10 Commits
873a1a9b09 ... main
Author SHA1 Message Date
zjk c61ac8ccb9 docs 新增 pPowerManger 代码审查与架构优化报告及电子负载 IT6000C 说明手册(PDF)
build-test-deploy / ci (push) Failing after 30s
Details
2026-09-09 20:52:15 +08:00
zjk f7d2b98dc1 脚本/mission 移除已废弃的 deploy.sh：clean-data/fetch-data/sync-board-time 帮助与报错文案改用 ssh-copy-id 指引，mission 注释同步改为 build-board.sh 部署，避免引用已删除脚本 2026-09-09 20:52:14 +08:00
zjk e59f7e3d2e pMotor 网页修复快照刷新导致输入光标跳动：页面改为加载时一次性构建静态骨架，WebSocket 快照到达后仅就地更新各数值叶节点（setH），不再整块 innerHTML 重建；输入框/按钮常驻 DOM，聚焦与光标不再被每秒推送打断，移除原 __lastSpeed 保值 hack
build-test-deploy / ci (push) Failing after 1h31m36s
Details
2026-09-09 20:50:31 +08:00
zjk c610190c54 pELoad 连接后从设备回读真实配置同步状态 
程序重启/刷新后页面状态与设备实际状态错配，导致按页面流程下发指令反馈错误。
新增 syncDeviceConfigOnce：连接建立进入远控后同步查询设备 OUTP/FUNC/FUNC:MODE
及各限值/设定值，以设备真实回读为准覆盖内存状态；设备输出仍为开时置
loadOn=true 并由 applyEnable 重新下发完整使能序列（接管恢复控制）。

- IT6000C 新增 7 个配置回读查询封装（CURR?/VOLT?/VOLT:LIM?/CURR:LIM?*2/POW:LIM?*2）
- ELoad 实现 syncDeviceConfigOnce 并接入 doControlCycle（连接后自动，覆盖重连/复位/本控→远控）
- 抽出 normFunc 辅助函数复用于 pollError；快照新增 cfgSynced/cfgSyncTime
- 页面卡2 增加设备配置同步状态显示
 2026-09-07 13:03:08 +08:00
zjk 237e17ea50 pELoad 新增功能模式(FUNC:MODE)远程切换与实时曲线页：切换带白名单校验/下发后立即回读确认（真实反馈驱动显示），模式名规范化兼容设备长格式回读（Fixed/LIST/BATTery/SOLar/CARProfile）；新增 /trend 实时曲线页（canvas 绘制 V/I/P 三曲线、窗口 30s~10min、历史按时间范围回填），WebSocket 快照推送提至 5Hz 2026-09-03 20:48:30 +08:00
zjk 91be306a92 pELoad 多处完善：测量改为 FETCh 读缓存（不触发测量、修复真实设备 MEAS 查询超时失败）+ 异步查询不阻塞 100ms 控制循环；CV 优先控制路径与 FUNC:MODE FIX 防护；sqlite 增加 volt_set/cmd_volt 列并支持旧库自动迁移；页面重构为静态骨架（输入框永不重建、聚焦不被打断）+ 指令确认/步骤引导/测量诊断；deploy.sh 服务列表补 pMotor/pELoad，missions/h100.moos 补 pELoad 新配置 2026-09-03 16:40:27 +08:00
zjk 2a34b79461 新增 pELoad 电子负载（IT6000C）控制程序：以太网 Raw Socket SCPI 直连设备，100ms 周期功率控制（订阅 MOOS 功率消息按 P/U 折算电流，CC/CV 双环路优先 + FUNC:MODE FIX 防护），网页人机交互（步骤引导/防误触确认），sqlite3 存储（100ms 高采样 V/I/P 测量表 meas_log + CSV 导出分析），并接入 scripts/build-board.sh 板卡部署与 systemd 服务、missions/h100.moos 配置 2026-09-03 12:26:02 +08:00
zjk 38c489caec pPowerManger SQLite 老库缺列自动迁移：按注册表对比现有列逐列 ALTER TABLE ADD COLUMN（协议演进新增字段后旧表可自动补齐），SCHEMA_VERSION 升至 2
build-test-deploy / ci (push) Successful in 30m10s
Details
2026-09-02 20:47:47 +08:00
zjk b77dc8cf5a pPowerManger 网页日志监控指向实际日志文件：HttpServer 新增 setLogFilePath，OnStartUp 与 loguru 共用同一路径（修复 systemd 工作目录下相对路径打开失败） 2026-09-02 20:47:47 +08:00
zjk b33312c547 pPowerManger 燃料电池页操控表单防误操作改造：滑块改为步进数字输入，提交前弹窗确认并高亮危险指令（停机/紧急停机/关机等）
build-test-deploy / ci (push) Successful in 30m21s
Details
2026-09-02 20:24:02 +08:00
35 changed files with 5606 additions and 458 deletions
Expand all files Collapse all files
.gitignore
+1
View File
@@ -253,6 +253,7 @@ bin/pCCU
bin/pccuTest
bin/pCanBridge
bin/pMotor
bin/pELoad
# CI test reports
reports/
docs/pPowerManger_代码审查与架构优化报告.html
+651
View File
@@ -0,0 +1,651 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>pPowerManger 代码审查与架构优化报告</title>
<style>
:root{
--bg:#0f1419; --panel:#171e26; --panel2:#1d2630; --border:#2a3642;
--text:#d8e0e8; --text-dim:#8fa0b0; --accent:#4da3ff; --accent2:#37c8a0;
--p0:#ff5c5c; --p1:#ffb347; --p2:#6fbf73; --code-bg:#101820;
}
*{margin:0;padding:0;box-sizing:border-box;}
body{background:var(--bg);color:var(--text);font-family:"Microsoft YaHei","PingFang SC","Segoe UI",sans-serif;line-height:1.75;font-size:15px;}
.layout{display:flex;max-width:1440px;margin:0 auto;}
nav{position:sticky;top:0;height:100vh;width:250px;flex-shrink:0;overflow-y:auto;padding:28px 18px;border-right:1px solid var(--border);background:var(--panel);}
nav h3{font-size:13px;color:var(--text-dim);letter-spacing:2px;margin-bottom:14px;}
nav a{display:block;color:var(--text-dim);text-decoration:none;padding:5px 10px;border-radius:6px;font-size:13.5px;border-left:2px solid transparent;}
nav a:hover{color:var(--accent);background:var(--panel2);}
main{flex:1;padding:44px 56px 120px;max-width:1140px;}
header.cover{border-bottom:1px solid var(--border);padding-bottom:30px;margin-bottom:36px;}
header.cover .tag{color:var(--accent);font-size:13px;letter-spacing:3px;}
header.cover h1{font-size:30px;margin:10px 0 8px;font-weight:600;}
header.cover .meta{color:var(--text-dim);font-size:13.5px;}
h2{font-size:22px;margin:52px 0 18px;padding-left:14px;border-left:4px solid var(--accent);font-weight:600;}
h3{font-size:17px;margin:30px 0 12px;color:var(--accent);font-weight:600;}
h4{font-size:15.5px;margin:20px 0 8px;color:var(--text);}
p{margin:10px 0;color:var(--text);}
.card{background:var(--panel);border:1px solid var(--border);border-radius:10px;padding:20px 24px;margin:16px 0;}
table{width:100%;border-collapse:collapse;margin:14px 0;font-size:13.5px;}
th{background:var(--panel2);color:var(--accent);text-align:left;padding:9px 12px;border:1px solid var(--border);font-weight:600;white-space:nowrap;}
td{padding:8px 12px;border:1px solid var(--border);vertical-align:top;}
tr:nth-child(even) td{background:rgba(255,255,255,0.02);}
code{font-family:Consolas,"Courier New",monospace;background:var(--code-bg);color:#9fd3ff;padding:1px 6px;border-radius:4px;font-size:13px;}
pre{background:var(--code-bg);border:1px solid var(--border);border-radius:8px;padding:14px 18px;overflow-x:auto;margin:12px 0;}
pre code{background:none;padding:0;color:#c8d8e8;font-size:13px;line-height:1.6;}
.badge{display:inline-block;padding:1px 10px;border-radius:10px;font-size:12px;font-weight:600;margin-right:6px;white-space:nowrap;}
.p0{background:rgba(255,92,92,.15);color:var(--p0);border:1px solid var(--p0);}
.p1{background:rgba(255,179,71,.12);color:var(--p1);border:1px solid var(--p1);}
.p2{background:rgba(111,191,115,.12);color:var(--p2);border:1px solid var(--p2);}
.loc{color:var(--text-dim);font-size:12.5px;font-family:Consolas,monospace;}
ul,ol{margin:8px 0 8px 24px;}
li{margin:5px 0;}
.flow{display:flex;align-items:center;flex-wrap:wrap;gap:8px;margin:14px 0;font-size:13px;}
.node{background:var(--panel2);border:1px solid var(--accent);border-radius:8px;padding:8px 14px;color:var(--text);}
.node.green{border-color:var(--accent2);}
.node.orange{border-color:var(--p1);}
.arrow{color:var(--accent);font-weight:bold;}
.note{border-left:3px solid var(--accent2);background:rgba(55,200,160,.06);padding:12px 18px;border-radius:0 8px 8px 0;margin:14px 0;font-size:14px;}
.warn{border-left:3px solid var(--p1);background:rgba(255,179,71,.06);padding:12px 18px;border-radius:0 8px 8px 0;margin:14px 0;font-size:14px;}
.danger{border-left:3px solid var(--p0);background:rgba(255,92,92,.07);padding:12px 18px;border-radius:0 8px 8px 0;margin:14px 0;font-size:14px;}
.grid2{display:grid;grid-template-columns:1fr 1fr;gap:16px;}
.kpi{display:grid;grid-template-columns:repeat(4,1fr);gap:14px;margin:18px 0;}
.kpi .item{background:var(--panel);border:1px solid var(--border);border-radius:10px;padding:16px;text-align:center;}
.kpi .num{font-size:26px;font-weight:700;color:var(--accent);}
.kpi .lbl{font-size:12.5px;color:var(--text-dim);margin-top:4px;}
.phase{border-left:3px solid var(--accent);padding:6px 0 6px 20px;margin:18px 0;position:relative;}
.phase::before{content:"";position:absolute;left:-7px;top:12px;width:11px;height:11px;border-radius:50%;background:var(--accent);}
.phase h4{margin:0 0 4px;color:var(--accent);}
.small{font-size:13px;color:var(--text-dim);}
@media (max-width:1000px){nav{display:none;}main{padding:24px;}.kpi{grid-template-columns:repeat(2,1fr);}.grid2{grid-template-columns:1fr;}}
</style>
</head>
<body>
<div class="layout">
<nav>
<h3>目录</h3>
<a href="#s1">1 审查概述</a>
<a href="#s2">2 现状架构分析</a>
<a href="#s3">3 代码审查意见</a>
<a href="#s3-1">3.1 确定性缺陷（Bug 级）</a>
<a href="#s3-2">3.2 状态机与控制逻辑</a>
<a href="#s3-3">3.3 通信逻辑</a>
<a href="#s3-4">3.4 故障码体系</a>
<a href="#s3-5">3.5 数据管理与并发</a>
<a href="#s3-6">3.6 上位机与 Web 服务</a>
<a href="#s3-7">3.7 构建工程与配置管理</a>
<a href="#s4">4 架构优化方案</a>
<a href="#s4-1">4.1 目标分层架构</a>
<a href="#s4-2">4.2 状态机重构</a>
<a href="#s4-3">4.3 通信层重构</a>
<a href="#s4-4">4.4 故障码统一方案</a>
<a href="#s4-5">4.5 上位机/下位机管理</a>
<a href="#s5">5 设备上电管理与状态机转移重构详细设计</a>
<a href="#s6">6 特性一致性保障策略</a>
<a href="#s7">7 测试方案</a>
<a href="#s8">8 实施路线图</a>
<a href="#s9">9 附录：问题清单</a>
</nav>
<main>
<header class="cover">
<div class="tag">CODE REVIEW &amp; ARCHITECTURE OPTIMIZATION</div>
<h1>pPowerManger 电源管理软件<br>代码审查与架构优化报告</h1>
<div class="meta">项目：H100PowerManger（UUV 复合能源功率管理）&nbsp;|&nbsp;范围：src/pPowerManger、src/pPowerMangerHost、test、ci&nbsp;|&nbsp;日期：2026-09-03&nbsp;|&nbsp;版本：V1.0</div>
</header>
<!-- ================= 1 ================= -->
<h2 id="s1">1 审查概述</h2>
<p>pPowerManger 是 H100 水下无人航行器复合能源系统的电源管理进程，运行于 MOOS 中间件之上，承担上位机指令接收、下位机（CCU/配电）设备管理、14 工况状态机调度、故障检测与上报、数据持久化及本地 Web 监视等职责。本次审查覆盖下位机核心代码约 2.4 万行（不含第三方 mongoose 库约 2.8 万行），重点评估代码架构、控制逻辑、通信逻辑、故障管理与测试体系，并给出以保持外部特性严格一致为前提的优化方案。</p>
<div class="kpi">
<div class="item"><div class="num">14</div><div class="lbl">工况状态（tinyfsm）</div></div>
<div class="item"><div class="num">4</div><div class="lbl">并发线程（无统一模型）</div></div>
<div class="item"><div class="num">3</div><div class="lbl">套互不统一的故障编码</div></div>
<div class="item"><div class="num">0</div><div class="lbl">状态机 / 上位机测试用例</div></div>
</div>
<div class="card">
<h4>总体结论</h4>
<p>现有代码功能可用，但工程化程度不足，核心问题集中在五条主线：</p>
<ol>
<li><b>存在多个确定性缺陷</b>：Lifting（起吊准备）状态永远无法到达；浮力调节状态反馈因赋值误写为比较而永不更新；MOOS 邮件偏斜检查导致整批邮件被丢弃等（见 3.1）。</li>
<li><b>状态机退化</b>：tinyfsm 仅被用作事件路由外壳，真正的转移逻辑集中在基类两个巨型 switch 中；无 guard 条件；故障检测与 FaultState 完全脱钩。</li>
<li><b>通信层职责混杂</b>：协议知识（JSON 键名、设备 ID、帧格式）散落在 Driver、UpperCommManager、udpComm 三处；4 个线程对共享数据加锁纪律不一致，存在数据竞争与忙等阻塞。</li>
<li><b>故障码体系三分天下</b>：电池故障表、配电故障表、0xLSSS 系统故障魔数三套编码并存，双故障存储导致单一事实源被破坏，上报与显示映射脱节。</li>
<li><b>测试存在三大空白</b>：状态机迁移、故障注入、上位机链路均无测试，重构缺乏安全网。</li>
</ol>
<p>优化应以"先建测试基线、再做特性等价重构"为总原则，分四个阶段实施（见第 7、8 章）。</p>
</div>
<!-- ================= 2 ================= -->
<h2 id="s2">2 现状架构分析</h2>
<h3>2.1 进程与通信拓扑</h3>
<div class="flow">
<span class="node green">Web 页面（浏览器）</span><span class="arrow">⇄ WebSocket</span>
<span class="node green">pPowerMangerHost（上位机桥）</span><span class="arrow">⇄ MOOSDB (TCP:9000, JSON 字符串变量)</span>
<span class="node">pPowerManger（本进程）</span><span class="arrow">⇄ UDP 二进制帧 (5001↔7000)</span>
<span class="node orange">pCCU / pCanBridge</span><span class="arrow">⇄ CAN</span>
<span class="node orange">电池 / 燃料电池 / 配电设备</span>
</div>
<p>另有两条旁路：pPowerManger 内嵌 HTTP 服务（端口 8000/8090）直读内部对象提供本地监视页面；上位机 HostSim 自带 Web 服务（端口 18080）+ SQLite 历史库。上位机与下位机之间<b>不存在直接 socket 连接</b>，全部交互以 MOOSDB 上的 JSON 字符串变量为协议载体（<code>uPower_*_cmd</code> 下行、<code>uPower_*_fb</code> 上行）。</p>
<h3>2.2 下位机内部模块</h3>
<table>
<tr><th>模块</th><th>文件</th><th>规模</th><th>实际职责</th><th>主要问题</th></tr>
<tr><td>主应用</td><td class="loc">PowerManger.h/.cpp</td><td class="loc">~680 行</td><td>MOOSApp 框架、线程拉起、全局对象持有</td><td>上帝对象，持有全部管理器指针并被 FSM 反向穿透</td></tr>
<tr><td>状态机</td><td class="loc">fsm/PowerManagerFsm.cpp + 14 状态</td><td class="loc">~3700 行</td><td>事件路由 + 设备指令处理 + 故障编码 + 状态拷贝</td><td>上帝类；转移逻辑退化到基类 switch；无 guard</td></tr>
<tr><td>上位机通信</td><td class="loc">UpperCommManager.cpp</td><td class="loc">261 行</td><td>MOOS 邮件 JSON 解析、周期状态广播</td><td>解析失败误报 Unknown key；无连接管理</td></tr>
<tr><td>下位机通信</td><td class="loc">LowerCommManager.cpp</td><td class="loc">890 行</td><td>UDP 监听线程、帧校验入队、状态注入、断路器闭环操作</td><td>回调直改全局数据；忙等最长约 7 s；35 个操作函数重复</td></tr>
<tr><td>协议编解码</td><td class="loc">udpcomm/udpComm.cpp, ccuUdpMsg.h</td><td class="loc">~600 行</td><td>UDP 二进制帧打包/解析、校验</td><td>硬编码帧长；死分支；每帧堆分配</td></tr>
<tr><td>设备策略表</td><td class="loc">driver.cpp</td><td class="loc">1094 行</td><td>68 字段 DriverTable、9 张工况设备表、JSON 编解码</td><td>9 张表约 600 行逐字段重复赋值；错误码形同虚设</td></tr>
<tr><td>系统数据</td><td class="loc">systemData.h, pmSysvariable.h</td><td class="loc">~2250 行</td><td>协议镜像结构体 + 全局数据池单例</td><td>头文件内实现；百字段全局池；锁纪律不一致</td></tr>
<tr><td>故障码</td><td class="loc">faultCode.h</td><td class="loc">125 行</td><td>电池 54 项 + 配电 45 项故障表</td><td>与第三套 0xLSSS 魔数并存；上报/显示映射脱节</td></tr>
<tr><td>本地 Web</td><td class="loc">httpserver/（mongoose + 内嵌页面）</td><td class="loc">~7000 行</td><td>dashboard/日志/测试注入/电池/燃料电池页面</td><td>与上位机 Web 重复建设；HTTP 回调越权直改状态</td></tr>
</table>
<h3>2.3 线程模型</h3>
<table>
<tr><th>线程</th><th>周期</th><th>主要工作</th><th>风险</th></tr>
<tr><td>MOOS 主线程</td><td>4 Hz</td><td>OnNewMail → 指令解析 → FSM dispatch；Iterate → CycleTriggeredEvent → 故障检测</td><td>断路器闭环忙等约 7 s 会卡住整个邮件循环</td></tr>
<tr><td>commLoop 线程</td><td>1 Hz</td><td>心跳/周期指令下发、队列清理</td><td>内含 usleep/MOOSPause；与监听线程并发清队列</td></tr>
<tr><td>UDP 监听线程</td><td>阻塞读</td><td>收帧 → 校验入队 → 出队写 systemData / SQLite</td><td>直接写业务数据；退出时可能挂在 recv 上</td></tr>
<tr><td>HTTP 线程</td><td>事件驱动</td><td>Web 页面与 REST</td><td>/fcs/control 回调里加锁直改 PowerManger 状态</td></tr>
</table>
<p>共享数据 <code>m_msCmd</code>、<code>m_depth</code>、<code>m_insData</code>、<code>m_thrustRpm</code> 等由 MOOS 线程无锁写、其余线程读；<code>m_stateMutex</code> 仅保护部分字段；<code>updateSystemData</code> 持 <code>m_dataMutex</code> 再取 <code>faultCodeMutex</code>，锁顺序仅靠注释约定（<span class="loc">PowerManger.h:92-93</span>）。整体属"能跑但不具备可论证的线程安全性"。</p>
<!-- ================= 3 ================= -->
<h2 id="s3">3 代码审查意见</h2>
<h3 id="s3-1">3.1 确定性缺陷（Bug 级，建议立即修复）</h3>
<p>以下问题经逐行核对确认，均有明确代码证据，与架构无关，应在重构前先以最小改动修复并补充回归用例。</p>
<table>
<tr><th>#</th><th>级别</th><th>问题</th><th>位置</th><th>影响与修复建议</th></tr>
<tr>
<td>B1</td><td><span class="badge p0">P0</span></td>
<td><b>Lifting（起吊准备）状态永远无法到达</b>：<code>handleWorkCmd</code> 的 case 12 只有日志，缺少 <code>transit&lt;Lifting&gt;()</code> 与 <code>break</code>，直接坠入 default</td>
<td class="loc">fsm/PowerManagerFsm.cpp:2934-2936</td>
<td>上位机"起吊准备"指令被静默吞掉，Lifting 为死状态。补 <code>transit&lt;Lifting&gt;(); break;</code>。</td>
</tr>
<tr>
<td>B2</td><td><span class="badge p0">P0</span></td>
<td><b>赋值误写为比较</b>：<code>s.buoyage == 1;</code>（共 4 处，值 1/3/2/0），语句无副作用</td>
<td class="loc">fsm/PowerManagerFsm.cpp:1471,1475,1482,1486</td>
<td>浮力调节（buoyage）状态反馈永远不更新，上报恒为初值。改为 <code>=</code>。</td>
</tr>
<tr>
<td>B3</td><td><span class="badge p0">P0</span></td>
<td><b>MOOS 邮件整批丢弃</b>：OnNewMail 中任一邮件偏斜超差即 <code>return true</code>，同批其余邮件全部丢失</td>
<td class="loc">PowerManger.cpp:121-125</td>
<td>网络抖动时会成片丢失上位机指令。改为跳过该条、继续处理后续邮件。</td>
</tr>
<tr>
<td>B4</td><td><span class="badge p1">P1</span></td>
<td><b>JSON 键名不匹配导致指令静默丢失</b>：发送端键 <code>"mastLiftingServo_uint8"</code>，接收端解析键 <code>"mastLiftingServo_uint8_uint8"</code></td>
<td class="loc">driver.cpp:844 vs 924</td>
<td>桅杆升降舵指令永远解析失败。统一键名，并增加"未知键/未命中"告警日志。</td>
</tr>
<tr>
<td>B5</td><td><span class="badge p1">P1</span></td>
<td><b>故障检测函数重复执行</b>：<code>basicNavigationFault(); extendedNavigationFault();</code> 连续调用两遍</td>
<td class="loc">fsm/PowerManagerFsm.cpp:52-55</td>
<td>4 Hz 下双倍开销，且对带副作用的故障逻辑是隐患。删除重复行。</td>
</tr>
<tr>
<td>B6</td><td><span class="badge p1">P1</span></td>
<td><b>三个断路器故障永不上报</b>：fbReserved/tyzReserved/reserved 调用的是无 faultCode 参数的重载，disfaultMap 中 code 10-12 成死码</td>
<td class="loc">systemData.h:1026-1028</td>
<td>补齐故障码入参，或删除死码并同步前端映射。</td>
</tr>
<tr>
<td>B7</td><td><span class="badge p1">P1</span></td>
<td><b>数组越界风险</b>：故障注入 <code>batfaultMap[e.eventId].code</code> 对来自外部的 eventId 无边界检查；<code>systemData.h:524</code> 循环 <code>i&lt;2</code> 越界访问 <code>reserved2[1]</code>（cppcheck error 级）</td>
<td class="loc">fsm/PowerManagerFsm.cpp:3053；systemData.h:524</td>
<td>注入接口可被越界触发，属安全隐患。加边界校验；修正循环上界。</td>
</tr>
<tr>
<td>B8</td><td><span class="badge p1">P1</span></td>
<td><b>TestEvent 故障注入 switch 缺 break</b>：case 15 坠入 default；另有 <code>react(TestEvent)</code> 直接构造 FaultEvent 调故障函数，绕过事件机制</td>
<td class="loc">fsm/PowerManagerFsm.cpp:2988-2989, 3084-3092</td>
<td>注入 15 号故障时行为未定义。补 break，统一走事件派发。</td>
</tr>
<tr>
<td>B9</td><td><span class="badge p2">P2</span></td>
<td><b>未初始化返回</b>（cppcheck error 级）：<code>uPlan_taskStart.h:29</code> 返回未初始化 <code>mission</code>；<code>uExternComm_setDeviceSwitch.h:39</code> 可能返回未初始化 <code>cmd.cmd</code>；<code>uPower_pmState.h:14</code> 对含 <code>std::vector</code> 的结构体 memset</td>
<td class="loc">upmsg/ 多个头文件</td>
<td>协议层偶发脏数据。统一在结构体定义处给默认值，禁止对非 POD memset。</td>
</tr>
<tr>
<td>B10</td><td><span class="badge p2">P2</span></td>
<td><b>注释与代码不符</b>：FaultState.cpp:46 注释"5 秒超时"实为 20 秒（:53），且与 Lifting.cpp:40、PowerManagerFsm.cpp 内 5 处同逻辑代码的 5 秒超时不一致；同一段超时代码共复制 7 份</td>
<td class="loc">FaultState.cpp:46/53 等</td>
<td>误导维护且各副本超时阈值漂移。随重构统一为命名常量。</td>
</tr>
<tr>
<td>B11</td><td><span class="badge p1">P1</span></td>
<td><b>模板残留致每条正常指令误报 "Unhandled Mail"</b>：OnNewMail 的 for 循环内保留了 MOOS 模板代码 <code>if(key=="FOO")...else if(key!="APPCAST_REQ") reportRunWarning(...)</code>，除 APPCAST_REQ 外的所有邮件（含已正常处理的 uPower_*_cmd/fb）都被计入 run warning</td>
<td class="loc">PowerManger.cpp:142-146</td>
<td>AppCast 告警计数被污染、日志刷屏。删除该模板残留，仅在 processUpperMsg 返回 false 时告警。</td>
</tr>
<tr>
<td>B12</td><td><span class="badge p1">P1</span></td>
<td><b>畸形 JSON 可致崩溃</b>：<code>loadDriverIdFromJson</code> 对 <code>root[field].asUInt()</code> 无类型检查（<code>JSON_USE_EXCEPTION=1</code>），调用处无 try/catch；<code>SafeReadUInt</code> 用 <code>std::cerr</code> 报错而非日志框架</td>
<td class="loc">driver.cpp:935-936；UpperCommManager.cpp:48</td>
<td>恶意/畸形指令使 jsoncpp 抛异常向上传播。统一走 SafeReadUInt 并捕获异常、改走日志。</td>
</tr>
<tr>
<td>B13</td><td><span class="badge p1">P1</span></td>
<td><b>HTTP 服务在配置就绪前启动</b>：<code>m_httpServer->start()</code> 在构造函数调用，此时 mission 配置未加载、<code>m_db</code> 为 nullptr、UDP 未 bind，控制接口（/fcs/control 等）已对外可访问</td>
<td class="loc">PowerManger.cpp:83-87</td>
<td>存在"配置生效前已暴露控制面"窗口。将 start() 移到 OnStartUp 末尾（DB/端口就绪后）。</td>
</tr>
<tr>
<td>B14</td><td><span class="badge p2">P2</span></td>
<td><b>死代码与孤儿成员</b>：<code>FsmLoop()</code>/<code>_FsmCB</code> 无任何线程启动；<code>m_deviceCmdQuenue</code> 及 push/pop/isEmpty 三接口无消费者；<code>buildReport()</code> 为 MOOS 模板占位；<code>SKEW_TOLERANCE 5</code> 宏未用而 <code>m_skew=10</code> 硬编码</td>
<td class="loc">PowerManger.cpp:18/339；PowerManger.h:48/121</td>
<td>误导维护。随阶段 3 一并清理，SKEW 阈值统一为命名常量。</td>
</tr>
</table>
<h3 id="s3-2">3.2 状态机与控制逻辑</h3>
<h4>3.2.1 现状转移关系（经代码还原）</h4>
<table>
<tr><th>源状态</th><th>事件</th><th>目标状态</th><th>说明</th></tr>
<tr><td>InitState</td><td>entry() 内直接切换</td><td>StandbyState</td><td>初始化完成即转</td></tr>
<tr><td>任意状态</td><td>MasterCommandEvent（workCMD 1~11）</td><td>Standby / ShoreBasedReady / WaterBasedReady / RemoteControl / Cruise / HighSpeed / FloatDown / FloatAdjust / UnderwaterSurvey / SurfaceSurvey / DJMode</td><td class="loc">PowerManagerFsm.cpp:2887-2941；workCMD=12 无效（B1）</td></tr>
<tr><td>任意状态</td><td>TaskStartEvent</td><td>THROW_LOAD→FaultState；FLOAT_UP/SAT_COMM 等→FloatDown；RECYCLE/SAIL→CruiseMode；HOVER→FloatAdjust；TOUR→UnderwaterSurvey</td><td class="loc">PowerManagerFsm.cpp:948-985</td></tr>
<tr><td>任意状态</td><td>TaskStopEvent</td><td>RemoteControl</td><td class="loc">基类 react，cpp:13</td></tr>
<tr><td>StandbyState</td><td>StandbyEvent</td><td>StandbyState（自切换）</td><td>语义存疑</td></tr>
<tr><td>FaultState</td><td>—（无显式出口）</td><td>—</td><td>仅能借基类 handleWorkCmd 间接跳出</td></tr>
</table>
<h4>3.2.2 主要架构问题</h4>
<div class="danger">
<b>A1 状态机退化为"事件路由壳"。</b>真正的状态转移表不在各状态类中，而集中在基类 <code>handleWorkCmd</code> 与 <code>react(TaskStartEvent)</code> 两个巨型 switch；14 个状态类的 <code>react(MasterCommandEvent)</code> 是完全相同的复制粘贴。tinyfsm 提供的 <code>transit&lt;S&gt;(action, condition)</code> guard 重载（tinyfsm.hpp:151）全项目零使用——<b>任何状态下都可经 workCMD 直接跳进任何工况</b>（如巡航中直接切起吊），无任何合法性检查。
</div>
<div class="danger">
<b>A2 故障检测与 FaultState 完全脱钩。</b>8 个 <code>xxxFault()</code> 检测函数只写故障码集合，从不触发状态迁移；FaultState 唯一入口是"抛载任务"（TaskStartEvent::THROW_LOAD），即 3 级故障（如深度失效 0x1302）发生时系统仍停留在原工况。FaultState 无显式出口、无故障恢复确认、无故障码清除联动。FaultEvent 无任何 dispatch 点，基类 <code>react(FaultEvent)</code> 为死代码。
</div>
<div class="warn">
<b>A3 entry() 内长阻塞。</b>WaterBasedReady.cpp:50 与 Lifting.cpp:10 在 entry() 中 <code>MOOSPause(10000)</code>；ShoreBasedReady.cpp:24-35 while 轮询等待约 10 s；断路器操作闭环在事件处理路径上忙等约 7 s。状态迁移期间 FSM 无法响应任何新事件，上位机指令被积压在邮件队列。
</div>
<div class="warn">
<b>A4 上帝类与全局穿透。</b>PowerManagerFsm.cpp（3096 行）集中了 10 个高度重复的设备指令处理函数、10 个 getXxxStatus 状态拷贝函数、8 组故障编码函数（约 200 个 0xLSSS 魔法故障码）。状态代码经 <code>static PowerManger* pm</code> 裸指针直接读写宿主几十个公有成员、直接操作断路器、直接 sendNotification，单向依赖原则被彻底打破。
</div>
<ul>
<li><b>A5 语义错位</b>：FloatDown 实际承载"上浮/下潜/卫星通信/卫星标定"四种业务；<code>handelPowerCmd</code>、<code>underWterDevices</code>、<code>mergencyLithiumBattery</code> 等拼写错误已进入接口。</li>
<li><b>A6 死代码</b>：<code>PowerSystemState</code> 枚举（hpp:21）、<code>DeviceCmd</code> 事件（hpp:41）、<code>handleDeviceCmd</code> 空壳（cpp:2966）、<code>m_currentDriver</code>（hpp:87）、<code>checkError()</code> 被注释掏空（PowerManger.cpp:344-356）。</li>
<li><b>A7 日志混乱</b>：基类兜底 react 用 <code>std::cout &lt;&lt; "No Idear"</code>（hpp:94）；entry/exit 大量使用 RTTI demangle + ANSI 转义打印，嵌入式目标上属无效开销；<code>printState</code> 用 <code>desp.find("故障")</code> 字符串匹配决定日志级别（PowerManger.cpp:359），极其脆弱。</li>
</ul>
<h3 id="s3-3">3.3 通信逻辑</h3>
<div class="warn">
<b>C1 上位机连接无管理。</b><code>LowerCommManager::m_connectState</code>（h:131）与 <code>PowerManger::connectState</code>（h:136）声明后从未使用；上位机方向无心跳、无在线检测、无断线告警，仅靠 MOOS 库自动重连。下位机方向有 30 s 超时检测（systemData.h:752-761），但超时后仅置标志位，未与故障系统联动。
</div>
<div class="warn">
<b>C2 协议知识三处散养。</b>JSON 键名与设备 ID 映射（协议层知识）写在 Driver（业务策略层）里，与发送端 driver.cpp 各维护一份，已造成 B4 键名失配；UDP 帧格式在 udpComm，设备 ID 0-61 在 driver.cpp:908-930 与 DeviceId 枚举重复硬编码。<code>Driver</code> 实例在 PowerManger 与 UpperCommManager 各持一份，表状态易不一致。
</div>
<ul>
<li><b>C3 校验与错误处理形同虚设</b>：<code>loadDriverTableFromJson</code> 的 error_code 每次被覆盖、从不检查，恒返回 0（driver.cpp:962-1093）；<code>sendCcuSetParmCmd</code> 无论发送成败都 return true（udpComm.cpp:609-619）；帧长硬编码 18/6/8 且旁边就是 TODO（udpComm.cpp:467/491/515/539）。</li>
<li><b>C4 死分支与静默吞帧</b>：<code>CCU_UDPMSG_START1 == DIS_MSG_HEAD1 == 0x40</code>，udpComm.cpp:47-56 两个 else-if 完全等价；未知 id 走 default 后仍 return true（udpComm.cpp:344-347）。</li>
<li><b>C5 高频路径低效</b>：每帧堆分配（udpComm.cpp:462 等 5 处）、每个 UDP 包 cout 打印一次（LowerCommManager.cpp:381）、发送函数失败后仍 return true（LowerCommManager.cpp:142-144）。</li>
<li><b>C6 废弃函数藏错误数据</b>：<code>sendDisSysCommand</code> 对 bus3 无视入参硬编码 <code>0x55/0xAA</code>（LowerCommManager.cpp:183-189），若被误用将下发错误指令。</li>
<li><b>C7 双 Web 重复建设</b>：下位机 httpserver（8000）与上位机 HostSim Web（18080）都用 mongoose + /ws + 内嵌页面提供状态监视；下位机 /fcs/control 在 HTTP 回调中直改状态（httpserver.cpp:150），绕过 MOOS 消息机制，属越权控制通道。</li>
</ul>
<h3 id="s3-4">3.4 故障码体系</h3>
<table>
<tr><th>编码方案</th><th>定义位置</th><th>格式</th><th>使用方</th><th>问题</th></tr>
<tr><td>电池故障表</td><td class="loc">faultCode.h:17-76，batfaultMap[54]</td><td>单字节 0x01-0xC9，带 1-4 级</td><td>仅故障注入使用</td><td>level 字段与描述矛盾（:35）；注入越界风险（B7）</td></tr>
<tr><td>配电故障表</td><td class="loc">faultCode.h:78-124，disfaultMap[45]</td><td>十进制 1-45</td><td>断路器故障上报</td><td>code 10-12 死码（B6）</td></tr>
<tr><td>系统故障码</td><td class="loc">无定义文件，散落在 PowerManagerFsm.cpp:1676 起</td><td>16 位魔数 0xLSSS（高半字节=等级）</td><td>8 个检测函数 + getFaultLevel</td><td>约 200 个裸字面量无注释无枚举；等级提取依赖位运算巧合</td></tr>
</table>
<ul>
<li><b>F1 双重故障存储</b>：真实故障进 <code>SystemData::sysFaultCodes</code>（set，自恢复即自动清除，无锁存/确认）；注入故障进 <code>PowerManger::faultCode</code>（vector，不去重、只能整体 clear）。<code>getFaultLevel()</code>（PowerManger.cpp:448）与上报用的 <code>data.getFaultCodeLevel()</code>（uPower_pmState.h:50）读的是<b>不同集合</b>，同一件事故障等级可能不一致。</li>
<li><b>F2 死赋值</b>：UpperCommManager.cpp:240 把 <code>getFaultCodes()</code> 赋给 state，但 <code>uPower_pmState.h:41-73 buildMsg()</code> 忽略该赋值，改用 <code>data.getFaultCode()</code>。</li>
<li><b>F3 映射脱节</b>：故障码→中文描述的映射 C++ 侧仅用于注入，上报只发数字码；显示文本由前端 JS 重写一份（httpserver/fuelcell.h:834-840）；0xLSSS 系统故障码<b>没有任何文本映射</b>。</li>
<li><b>F4 条件编译陷阱（经核实比初版更严重）</b>：<code>DEBUG</code> 宏在全部构建中均未被定义（CMake 无 <code>-DDEBUG</code>），而 systemData.h:776 的 <code>#ifdef DEBUG</code> 依赖它——因此燃料电池 4 级故障字 <code>fc_fault_level_1..4</code> 在<b>所有构建</b>下都永不更新（恒为 0），并非仅"发布版"；systemData.h:7 的 <code>#define DEBUFG</code> 是拼写错误且定义了无用宏。同理 <code>#ifdef _DEBUG</code>（UpperCommManager.cpp 全篇）在 Linux 下也永不生效，其调试追踪成员均为死代码。</li>
<li><b>F5 无故障事件持久化</b>：SQLite 仅随帧存原始故障字段，无独立故障事件表，故障发生/恢复时间不可追溯，无法支撑事后分析。</li>
</ul>
<h3 id="s3-5">3.5 数据管理与并发</h3>
<ul>
<li><b>D1 全局数据池</b>：SystemData（systemData.h，1219 行头文件内实现）是百字段单例，字段基本是 pmSysvariable 协议镜像的 float 转换副本，<code>updateSystemData()</code> 逐字段拷贝数百行——协议每改一处需同步三处（pmSysvariable / systemData / updateSystemData）。构造函数 60+ 项手工初始化（:660-690）。</li>
<li><b>D2 锁纪律不一致</b>：提供了部分加锁访问器（:694-733），但 FSM 大量裸读绕过锁（PowerManagerFsm.cpp:1813/1920/1930）；TestEvent 直接无锁写 <code>fc_fault_level_1</code>（:3060）；<code>msg_*_Update_time</code> 无锁写、另一把锁下读（LowerCommManager.cpp:229-233）。</li>
<li><b>D3 整数截断风险</b>：对 double 使用未限定的 <code>abs()</code>（systemData.h:757），可能解析为 C 的 <code>int abs</code> 截断时间差，应使用 <code>std::fabs</code>。</li>
<li><b>D4 双重时间基准</b>：commLoop 每 1 s <code>clearMsgQueue()</code>（LowerCommManager.cpp:124）与监听线程并发清队列，语义冗余且可能丢未消费帧。</li>
</ul>
<h3 id="s3-6">3.6 上位机与 Web 服务</h3>
<p>上位机 HostSim 的设计相对干净：网页指令经 WebSocket 入 <code>m_cmdQueue</code>、Iterate 中 <code>drainCommands()</code> 转发 MOOSDB（HostSim.cpp:213-228）；上行订阅 12 个反馈变量，dirty 后 <code>broadcast(buildSnapshot())</code> 推送，并以 SQLite 表 <code>fb_log</code> 保留 24 h 历史（FeedbackStore.cpp:62-69），提供 <code>/api/history</code>、<code>/api/rawlog</code>。可作为重构时"松耦合桥"的保留样板。</p>
<ul>
<li><b>H1 功能重叠</b>：与下位机 httpserver 在状态监视上重复；建议下位机 Web 退化为纯调试用途（仅本机回环监听），状态监视统一归上位机。</li>
<li><b>H2 越权通道</b>：下位机 /fcs/control 直改内部状态，破坏"一切控制经 MOOS 指令"的单入口原则，应迁移为向 MOOSDB 发指令或加鉴权。</li>
<li><b>H3 页面硬编码</b>：1912 行 data.h 等 7 个页面以 <code>R"(...)"</code> 字符串嵌在头文件，无构建期资源管线（上位机已有 webassets_gen.h 方案可复用）。</li>
</ul>
<h3 id="s3-7">3.7 构建工程与配置管理</h3>
<ul>
<li><b>E1 编译告警默认关闭、无 sanitizer 门禁</b>：CMakeLists 仅加 <code>-fPIC -g -Wdeprecated-declarations</code>，<code>-Wall</code> 需手动开 WALL_ON 且写法含语法错误（<code>"-Wall" -C++11</code>，CMakeLists.txt:86）；Release 依赖 CMake 默认 <code>-O3</code> 未显式声明；无 ASan/UBSan/TSan 构建类型。建议：开启 <code>-Wall -Wextra</code> 并清零告警，新增 sanitizer 构建目标，测试二进制输出到 build 目录。</li>
<li><b>E2 依赖不可复现、GLOB 反模式</b>：<code>FILE(GLOB ...)</code> 收集头/库目录（CMakeLists.txt:49/53），新增文件不触发重配；mongoose/sqlite3/loguru/jsoncpp 以源码 vendor 进 src 且无版本号与许可证记录；<code>CMAKE_MINIMUM_REQUIRED(VERSION 3.5)</code> 过老。建议 GLOB 改显式列表，第三方库固定版本并登记 LICENSE。</li>
<li><b>E3 配置解析无校验</b>：OnStartUp 用 <code>atoi</code> 解析 ccuport/iport（PowerManger.cpp:229/233），非法值静默为 0，端口无 1-65535 范围检查；缺配置块仅 warning。建议显式校验非法值并告警。</li>
<li><b>E4 SQLite 高频路径重复 prepare</b>：<code>insertGeneric</code> 每次插入重拼 SQL 并 prepare（SQLite.cpp:610-625），<code>onFrame</code> 每帧同样 prepare；建议缓存 prepared statement，故障事件表纳入 SCHEMA_VERSION 迁移机制。</li>
<li><b>E5 日志/错误输出三套并存</b>：loguru、<code>std::cerr</code>（driver.cpp:887/904/957）、<code>std::cout</code>（LowerCommManager.cpp:373/381）混用，无法按级别关停。建议统一 loguru，cout/cerr 清零。</li>
</ul>
<!-- ================= 4 ================= -->
<h2 id="s4">4 架构优化方案</h2>
<p>优化总原则：<b>外部特性严格不变</b>（MOOS 变量名与 JSON 契约、UDP 帧格式、Web 接口、故障码取值、状态迁移外部可观测序列均保持），<b>内部结构彻底重整</b>。所有重构以第 6 章的一致性保障与第 7 章的测试基线为前提。</p>
<h3 id="s4-1">4.1 目标分层架构</h3>
<div class="card">
<pre><code>┌─────────────────────────────────────────────────────────────┐
│ 接口层 (Interface) UpperCommManager │ HttpServer(调试) │ ← 只做协议适配，不含业务判断
├─────────────────────────────────────────────────────────────┤
│ 应用层 (Application) PowerManagerApp │ ← 协调者：指令→校验→派发到领域服务
│ ├─ CommandService（指令接收、校验、应答） │
│ ├─ FaultManager （故障检测、锁存、上报、事件持久化） │
│ └─ StateMachineService（工况状态机，表驱动 + guard） │
├─────────────────────────────────────────────────────────────┤
│ 领域层 (Domain) DeviceRegistry │ PowerPolicy(Driver表) │ ← 纯 C++，无 MOOS/网络依赖，可单测
│ SystemState(线程安全的状态仓储) │
├─────────────────────────────────────────────────────────────┤
│ 基础设施层 (Infra) UdpLink(收发) │ ProtocolCodec(编解码) │ ← 唯一知道帧格式/JSON键名的地方
│ SQLiteStore │ MoosGateway │
└─────────────────────────────────────────────────────────────┘</code></pre>
</div>
<ul>
<li><b>依赖方向单向化</b>：接口层 → 应用层 → 领域层 ← 基础设施层（依赖倒置）。状态机不再持有 <code>PowerManger*</code> 裸指针，改为构造时注入 <code>ISystemState</code>、<code>IDeviceCommand</code>、<code>IFaultSink</code> 三个窄接口。</li>
<li><b>线程模型统一</b>：确立"单线程事件循环 + 生产者队列"模型——UDP 监听线程、HTTP 线程只做<b>收包→解析→投递事件队列</b>，所有业务处理（FSM dispatch、故障检测、状态写入）在 MOOS Iterate 所在线程串行执行，从根上消除数据竞争。断路器闭环操作改为异步状态（发送→等待反馈事件→超时事件），消灭 7 s 忙等。</li>
<li><b>Driver 拆分</b>：模式设备策略表（领域层 PowerPolicy）与 JSON 键名/设备 ID 映射（基础设施层 ProtocolCodec）分离；Driver 单例化并归属 CommandService，消除双实例不一致。</li>
</ul>
<h3 id="s4-2">4.2 状态机重构方案</h3>
<h4>4.2.1 转移表显式化</h4>
<p>将隐藏在两个 switch 中的转移逻辑提取为<b>静态转移表 + guard 函数</b>，作为唯一事实源，并据此生成文档与测试用例：</p>
<pre><code>// fsm/TransitionTable.h —— 唯一事实源（示例，迁移时须以现状代码逐条核对生成）
struct TransitionRule {
StateId from; // ANY 表示任意源状态
EventId event;
StateId to;
GuardFn guard; // nullptr 表示无条件（保持现状语义）
const char* comment; // 对应原代码位置，便于审计
};
static const TransitionRule kRules[] = {
{ ANY, EV_WORK_CMD, STANDBY, nullptr, "workCMD=1 Fsm.cpp:2891" },
{ ANY, EV_WORK_CMD, LIFTING, nullptr, "workCMD=12 Fsm.cpp:2934（修复B1后生效）" },
{ ANY, EV_TASK_START, FAULT, GuardThrowLoad, "THROW_LOAD Fsm.cpp:953" },
{ FAULT, EV_FAULT_CLEARED, REMOTE_CTRL, GuardFaultAcked, "新增：故障确认后恢复" },
...
};</code></pre>
<p>guard 第一阶段全部保持现状（无条件），仅把"可迁移性"显式化；第二阶段再与总体组确认后补充工况互斥规则（如 HighSpeed 与 DJMode 互斥需先回 Standby）。</p>
<h4>4.2.2 FaultState 与故障系统联动</h4>
<ol>
<li><b>入口</b>：FaultManager 检测到 3 级及以上故障（或抛载任务）→ 投递 <code>FaultEvent</code> → FSM 迁移 FaultState，保持现有"抛载进 FaultState"路径不变。</li>
<li><b>entry 动作异步化</b>：断路器断开序列改为 FaultState 内部的子步骤计时状态（step + deadline），每拍 Iterate 推进，取代 MOOSPause(10000) 与 20 s 忙等；超时阈值统一为命名常量并修正注释。</li>
<li><b>出口</b>：显式定义恢复路径——故障码集合清空且收到上位机确认指令（workCMD=4 RemoteControl，保持现有指令集不变）→ 退出 FaultState。该路径当前已可经基类 handleWorkCmd 间接实现，重构只是将其显式化并纳入转移表，<b>不改变外部行为</b>。</li>
</ol>
<h4>4.2.3 代码组织</h4>
<ul>
<li>PowerManagerFsm.cpp 拆分：<code>DeviceCommandHandlers.cpp</code>（10 个设备指令函数，提取公共模板消除重复）、<code>StatusSnapshot.cpp</code>（10 个 getXxxStatus）、<code>FaultEncoding.cpp</code>（故障编码，配合 4.4 迁移到 FaultManager）。</li>
<li>14 个状态类删除重复的 <code>react(MasterCommandEvent)</code>，统一由基类按转移表处理；状态类只保留 entry/exit 与状态特有事件。</li>
<li>命名修正（handelPowerCmd→handlePowerCmd 等）仅在内部接口进行，MOOS 变量名、JSON 键名等外部标识<b>一律不改</b>。</li>
</ul>
<h3 id="s4-3">4.3 通信层重构方案</h3>
<h4>4.3.1 协议单一事实源</h4>
<p>建立 <code>protocol/</code> 目录，以一份定义文件同时生成/校验编解码两侧，杜绝键名失配（B4）类问题：</p>
<ul>
<li><code>protocol/MoosVariables.def</code>：全部 MOOS 变量名 + JSON schema（键名、类型、取值范围），UpperCommManager 与 Driver 的 JSON 编解码均引用之；增加"未知键/解析失败"统一告警（修复 C3、B4 的静默丢失）。</li>
<li><code>protocol/DeviceId.h</code>：设备 ID 唯一枚举，driver.cpp:908-930 的 0-61 硬编码与 DeviceId 枚举合并；UDP 帧长由结构体 sizeof 计算，删除 18/6/8 魔法数。</li>
<li>修正 udpComm.cpp:47-56 等价死分支与 default 静默吞帧：未知帧计入统计并日志告警。</li>
</ul>
<h4>4.3.2 上下行链路管理</h4>
<table>
<tr><th>链路</th><th>现状</th><th>优化后</th><th>外部行为变化</th></tr>
<tr><td>上位机（MOOS）</td><td>无连接管理，1 s 周期广播状态</td><td>启用已声明未使用的 connectState：以"周期广播正常发出 + 收到上位机任何邮件"维护在线标志；掉线仅记录与上报，不触发控制动作</td><td>无（只新增可观测性）</td></tr>
<tr><td>下位机（UDP）</td><td>30 s 超时置 isTimeout，超时母线发清零指令</td><td>超时事件接入 FaultManager（通信类故障码，新增码段，不占用现有码值）；清零指令逻辑保持不变</td><td>故障上报新增通信超时码（经总体确认后启用）</td></tr>
<tr><td>断路器闭环</td><td>事件路径忙等约 7 s + 600 ms 复位</td><td>异步化：发送→注册期望反馈→超时定时器，状态机以子状态跟踪；指令时序与重发次数严格保持现状</td><td>无（时序一致，仅不再阻塞线程）</td></tr>
<tr><td>Web 通道</td><td>下位机 8000 全功能 + /fcs/control 越权直改</td><td>下位机 Web 保留页面但控制类接口改为转发 MOOS 指令（等价于上位机下发）；上位机 Web 方案不变</td><td>接口路径与参数不变，仅内部实现改道</td></tr>
</table>
<h4>4.3.3 工程细节修复</h4>
<ul>
<li>发送路径消除每帧堆分配（栈对象 + sendto）；删除每包 cout（LowerCommManager.cpp:381），统一走 loguru 并按级别可关。</li>
<li>UDP 监听线程退出改为 socket 超时 + quit 标志，保证进程可干净退出。</li>
<li>移除 <code>sendDisSysCommand</code> 废弃函数（含 0x55/0xAA 硬编码），或修正后纳入 ProtocolCodec。</li>
</ul>
<h3 id="s4-4">4.4 故障码统一方案</h3>
<div class="card">
<h4>目标：一套编码、一个存储、一处映射</h4>
<p><b>1. 统一故障码定义文件 <code>fault/FaultCodeDef.h</code></b>（生成式，唯一事实源）：</p>
<pre><code>// 每条故障一行：枚举名, 码值(保持现有取值不变), 等级, 来源域, 中文描述
FAULT_DEF(BAT_CELL_OVERVOLT_L1, 0x01, 1, DOMAIN_BATTERY, "单体过压1级")
FAULT_DEF(DIS_BREAKER_TRIP_MAIN, 1, 2, DOMAIN_DIS, "主断路器脱扣")
FAULT_DEF(SYS_DEPTH_INVALID_L3, 0x1302, 3, DOMAIN_SYSTEM, "深度数据失效")
// 0xLSSS 系统码约 200 个字面量全部收编为枚举，码值、等级语义与现状逐条核对一致</code></pre>
<p>由此单文件自动生成：C++ 枚举、码值→描述映射表（供上报与前端共用，替代 fuelcell.h:834 的 JS 重写）、测试用的完整性校验数据。电池 0x01-0xC9、配电 1-45、系统 0xLSSS 三段码值全部原样保留，<b>上位机与前端所见故障码不变</b>。</p>
<p><b>2. 合并故障存储为 FaultManager 单一集合</b>：</p>
<ul>
<li>统一存放真实故障与注入故障（注入故障带 source 标记区分），上报接口（uPower_pmState）与等级查询（getFaultLevel）改为读同一集合，消除 F1/F2 的双源不一致；对外 JSON 字段名与格式不变。</li>
<li>锁存语义保持现状（自恢复即自动清除），但 FaultManager 内部记录"发生/恢复"事件并写入 SQLite 新增 <code>fault_event(ts, code, level, event, source)</code> 表——<b>新增表不影响现有表结构</b>。</li>
<li>故障码访问统一加 <code>faultCodeMutex</code>，消除 TestEvent 无锁写。</li>
</ul>
<p><b>3. 修复编码层缺陷</b>：删除 systemData.h:776 的 <code>#ifdef DEBUG</code>（发布版也更新燃料电池 4 级故障字）、修正 DEBUFG 拼写、补齐 B6 三个断路器的故障码入参、faultCode.h:35 的 level 字段与描述对齐。</p>
</div>
<h3 id="s4-5">4.5 上位机 / 下位机管理方案</h3>
<table>
<tr><th>主题</th><th>职责划分（优化后）</th></tr>
<tr><td>控制通道</td><td><b>唯一入口</b>：一切控制指令（网页、调试页、测试注入）最终都变为 MOOSDB 上的 <code>uPower_*_cmd</code> JSON，由 CommandService 统一校验、应答、记录。下位机 HTTP 控制接口仅做转发。</td></tr>
<tr><td>状态监视</td><td>上位机 HostSim 为主（跨机、带历史库 /api/history）；下位机 Web 退化为本机调试页（日志查看、测试注入保留），dashboard/data 等监视页标注"调试用"。</td></tr>
<tr><td>指令校验</td><td>CommandService 对 workCMD/powerCMD/modCMD 做范围校验 + 当前状态下合法性校验（按转移表），非法指令回执拒绝原因（新增 JSON 字段，缺省不发送，兼容旧上位机）。</td></tr>
<tr><td>指令清空哨兵</td><td>workCMD=99 等魔法哨兵改为命名常量 <code>CMD_NONE=99</code>，取值不变，仅消除魔法数。</td></tr>
<tr><td>页面资源</td><td>下位机 7 个硬编码页面迁移到 CMake 资源管线（复用上位机 webassets_gen.h 方案），HTML 独立成文件，便于前端维护；URL 与页面功能不变。</td></tr>
</table>
<!-- ================= 5（新增详细设计章） ================= -->
<h2 id="s5">5 设备上电管理与状态机转移重构详细设计</h2>
<h3>5.1 总体设计判断</h3>
<p>设备上电/管理与状态机转移是同一个问题的两面——<b>"声明"与"执行"混在一起</b>。9 张工况设备表（driver.cpp 约 600 行逐字段赋值）本质是"数据"，却写成了代码；状态 entry() 里的上电时序本质是"流程"，却硬编码成一串串 <code>setDeviceState + MOOSPause + operate_*_Breaker</code>；状态转移本质是"一张表"，却隐式埋在 <code>handleWorkCmd</code>/<code>react(TaskStartEvent)</code> 两个 switch 里。重构的共同方向：<b>把数据从代码里剥离出来，把流程交给统一执行器，把转移显式化</b>。</p>
<h3>5.2 设备上电与管理重构</h3>
<h4>5.2.1 现状代码证据</h4>
<ul>
<li><b>工况表即代码</b>：<code>Driver::getSTANDBYTable()</code>（driver.cpp:151-228）等 9 个函数，每个约 70 行 <code>driverTable->depth1 = 1;</code> 式逐字段赋值，<code>getCRUISE/getHIGH_SPEED/getASCEND_DESCEND</code> 内容几乎一致，且混用裸 0/1 与 <code>DRIVER_*</code> 宏。</li>
<li><b>上电时序硬编码且阻塞</b>：<code>CruiseMode::entry()</code> 的典型模式是：查当前设备状态 → <code>operate_HVA_actuatorCircuit_Breaker(0)</code>（内部忙等最长 6 s）→ <code>MOOSPause(3)</code> → 连续 6 次 <code>setDeviceState</code> → 上报，每个状态 entry 都是这段逻辑的变体手写。</li>
<li><b>断路器闭环时序散落</b>：<code>operateBreakerGeneric</code>（LowerCommManager.cpp:843-890）的"首次发包 → 100 ms 等待 → 轮询反馈 → 200 ms 重发 → 6 s 超时 → 3×200 ms 复位"被 35 个 <code>operate_*</code> 函数复用，但在事件处理路径上同步执行，阻塞 MOOS 线程。</li>
<li><b>校验逻辑十份复制</b>：<code>WaterBasedReady::react(DevCmdExt)</code> 中的校验链（Debug 模式豁免 → 深度上电保护 → 前视声纳先关机再断电并 MOOSPause(10000) → 写设备状态）在 10 个 <code>handleXxxCmd</code> 中各有变体，细微偏差正是 B4（桅杆键名失配）类缺陷的温床。</li>
</ul>
<h4>5.2.2 目标结构</h4>
<div class="card">
<pre><code>现状（分散） 目标（收敛）
┌──────────────────────────────┐ ┌────────────────────────────────┐
│ 9 张工况表 = 600 行赋值函数 │ │ ① 设备描述表 DeviceDef │
│ entry() 硬编码时序+忙等6~20s │ 收敛 │ 68 设备 × 属性（域/断路器通道/ │
│ 10 个 handleXxxCmd 校验复制 │ ───────────► │ 保护规则/9 工况默认值） │
│ 35 个 operate_*_Breaker │ │ ② 功率时序执行器 PowerSequencer │
└──────────────────────────────┘ │ 声明式步骤，异步分步执行 │
│ ③ 统一指令管线：模式校验→深度 │
│ 保护→前置动作→执行→回执 │
│ ④ DeviceManager 唯一写口 │
│ m_subDisSysCmd 只经它修改 │
└────────────────────────────────┘</code></pre>
</div>
<h4>5.2.3 重构四件事</h4>
<ol>
<li><b>工况表从函数变成数据。</b>9 个 <code>getXxxTable()</code> 函数替换为静态二维表 <code>kModeDeviceTable[9][68]</code>（或按设备分组的声明式定义），查表替代函数调用。迁移时用程序把现有 9 个函数的输出快照为 golden data，重构后逐字节比对——这是"特性严格一致"最直接的保证。</li>
<li><b>上电时序从阻塞硬编码变成声明式步骤 + 异步执行器。</b>每个工况声明一个步骤序列，例如 CruiseMode：<code>[条件:任一bowCover≠0] → 断启闭机构断路器(超时6s) → 延时3s → 批量下电bowCover1~6 → 上报</code>。PowerSequencer 每拍 Iterate 推进一步，<code>operateBreakerGeneric</code> 的时序参数（100 ms 首等、200 ms 重发、6 s 超时、3×200 ms 复位）原样保留为步骤属性，但不再阻塞线程；entry() 只提交序列即返回，状态机始终可响应事件。</li>
<li><b>设备指令校验收敛为一条管线。</b>所有设备指令走同一链路：模式校验（Normal 禁操作）→ 域保护（水下设备深度检查，Debug 豁免）→ 设备专属前置动作（forwardSonar 先关机再断电等，注册在设备描述表）→ 经 Sequencer 执行 → 回执。各状态只声明"本状态允许操作哪些设备域"，不再各写一份校验。</li>
<li><b>设备状态唯一写口。</b><code>m_subDisSysCmd</code> 现在被 FSM、HTTP 回调、测试注入直接修改，重构后只能经 DeviceManager 写入；外部可观测的写序列（日志、上报、SQLite 落库）保持一致。</li>
</ol>
<h3>5.3 状态机转移重构</h3>
<h4>5.3.1 核心问题：转移关系隐式化</h4>
<p>转移关系不存在于任何一张表中，而是从两个 switch 的行为里"涌现"出来的——这正是 case 12 漏写 <code>transit</code> 导致 Lifting 不可达（B1）这类缺陷的结构性根源。重构目标是把转移机制从"隐式 switch"变为"显式表驱动"：</p>
<div class="card">
<pre><code>现状：隐式转移 目标：显式转移
MasterCommandEvent 到达 事件统一规范化
│ │
handleWorkCmd 巨型 switch 查转移表 TransitionRule[]
（14 状态 × 14 份复制 react） （源状态×事件→目标，唯一事实源）
│ │
无 guard 直接 transit guard 校验
（case 12 漏写 = Lifting 死状态） （一期空 guard 记日志，二期补互斥）
│ │
entry() 阻塞上电 CHANING 过渡子状态
（期间 FSM 不响应任何事件） （上电序列异步执行，完成即落定）
│ │
FaultState 孤岛 FaultEvent 显式迁移
（故障检测不触发迁移，无出口） （3 级以上故障进入，确认后退出）</code></pre>
</div>
<h4>5.3.2 重构五步走</h4>
<ol>
<li><b>把转移关系从代码里"挖"出来变成表。</b>逐行核对 <code>handleWorkCmd</code>（workCMD 1~12）、<code>react(TaskStartEvent)</code>（THROW_LOAD/FLOAT_UP/RECYCLE/SAIL/HOVER/TOUR 等）、<code>react(TaskStopEvent)</code> 与 InitState 自迁移，生成 <code>TransitionRule[]</code> 静态表，每行标注原代码位置（如 <code>workCMD=5 → CruiseMode, Fsm.cpp:2903</code>）。该表同时是实现、文档与测试基准。<code>handleWorkCmd</code> 的 switch 删除，14 个状态中复制粘贴的 <code>react(MasterCommandEvent)</code> 全部删除，统一由基类查表处理；workCMD=99 清空哨兵语义保留，仅改为命名常量。</li>
<li><b>guard 分两期落地。</b>一期所有 guard 为 nullptr（无条件），<b>严格保持现状转移语义</b>——这是特性一致的红线；基类在每次迁移时记录"源状态→事件→目标"日志。二期依据日志与总体组确认应禁止的迁移（如巡航中直接切 DJMode），再逐步补 guard。重构本身不引入行为变化，行为收紧是另一个独立、可评审的决策。</li>
<li><b>entry() 阻塞上电改为 CHANING 过渡子状态。</b>现状代码已有雏形——每个 entry 开头 <code>workCondition = CHANING</code>、干完活才置为目标工况，只是"干活"方式是阻塞的。重构将其正式化：迁移发生时进入目标状态的过渡形态，上电序列交 PowerSequencer 异步执行，序列完成事件使状态落定；期间 FSM 照常响应事件（如 FaultEvent 可打断上电）。上位机看到的 workCondition 变化序列与现状完全一致。</li>
<li><b>FaultState 接入主转移图。</b>故障检测发现 3 级以上故障 → FaultManager 派发 FaultEvent → 转移表新增 <code>ANY × FaultEvent → FaultState</code> 规则（保留现有 THROW_LOAD 入口不变）；FaultState 增加显式出口：故障码集合清空 + 上位机确认（复用现有 workCMD=4 指令，不新增协议）→ RemoteControl；FaultState 内的断路器断开序列同样改为 Sequencer 步骤，消灭 20 s 忙等。</li>
<li><b>状态类只做"差异"。</b>状态类只保留本状态特有内容：entry 提交的上电序列、特有事件处理（如 DJMode 专属指令）、exit 清理；公共行为上收基类。CruiseMode/HighSpeedMode 等任务态的共性（均响应 TaskStopEvent→RemoteControl）通过继承 MissionStateBase 表达，利用 tinyfsm 原生支持的状态继承。</li>
</ol>
<h3>5.4 两块重构的衔接与线程模型</h3>
<div class="note">
衔接点在 CHANING 子状态：<b>状态机管"去哪里"，PowerSequencer 管"到了之后按什么时序上电"，DeviceManager 管"每一笔设备状态怎么写"</b>。三者通过事件队列串行协作，全部运行在 MOOS 主线程上，从根上消除现有四个线程交叉读写全局数据的问题。UDP 监听线程与 HTTP 线程退化为纯生产者：收包→解析→投递事件队列，不再直接触碰业务状态。
</div>
<h3>5.5 迁移顺序与一致性验证</h3>
<ol>
<li><b>快照基线</b>：采集 9 张工况表输出、标准指令脚本下的状态上报时序，作为 golden data；</li>
<li><b>设备描述表与指令管线</b>（风险最低，先行）；</li>
<li><b>PowerSequencer 替换阻塞上电</b>；</li>
<li><b>转移表替换 switch</b>。</li>
</ol>
<p>每一步均以 golden data diff 为空为通过条件，diff 非空则不进入下一步。B1（Lifting 不可达）等已确认缺陷在挖掘转移表时即会暴露，按第 6 章约定单独登记为行为变更点修复。</p>
<!-- ================= 6 ================= -->
<h2 id="s6">6 特性一致性保障策略</h2>
<p>"优化后与原代码特性严格一致"需要通过可执行的基线来保证，而不是靠评审印象。建议按以下四层契约冻结外部行为：</p>
<table>
<tr><th>契约层</th><th>冻结内容</th><th>验证手段</th></tr>
<tr><td>MOOS 接口契约</td><td>全部订阅/发布变量名、JSON 键名与类型、周期广播频率（1 s）、应答时序</td><td>契约测试：录制现有系统真实 MOOS 流量为"黄金报文集"，重构后回放比对（键集合、类型、取值范围）</td></tr>
<tr><td>UDP 帧契约</td><td>6 类反馈帧 ID、帧头 0x40 0x40、#pragma pack(1) 布局、校验算法、帧长</td><td>字节级编解码往返测试（现有 udp_feeder/full_feeder 扩展为参数化用例）；结构体 static_assert 尺寸断言</td></tr>
<tr><td>行为契约</td><td>状态迁移外部可观测序列（指令→状态上报序列）、断路器操作时序（重发间隔、6 s 超时、600 ms 复位）、故障码取值与上报内容</td><td>黄金主测试：对现状系统跑标准指令脚本，录制 <code>uPower_currentState_st</code> 等上报时序为基线；重构后同脚本回放，时序逐拍比对</td></tr>
<tr><td>Web/存储契约</td><td>URL 路由、REST 参数、SQLite 现有表结构</td><td>HTTP 接口冒烟用例；数据库 schema 比对脚本</td></tr>
</table>
<div class="note">
<b>已知缺陷的处理约定</b>：3.1 节 B1-B10 属"现状特性"的一部分还是"应修复的缺陷"，须逐项与总体确认。建议原则：外部可观测且显然错误的行为（如 buoyage 恒不更新、Lifting 不可达、桅杆指令丢失）按缺陷修复并在报告中显式登记"行为变更点"；纯内部问题（重复调用、死代码）直接修复，行为不变。所有行为变更点单独列入变更清单，重构完成时逐项回归确认。
</div>
<!-- ================= 7 ================= -->
<h2 id="s7">7 测试方案</h2>
<h3>7.1 测试金字塔与补齐重点</h3>
<table>
<tr><th>层级</th><th>现状</th><th>补齐内容</th><th>框架/工具</th></tr>
<tr><td>单元测试</td><td>GTest 56 例：Driver 表、SystemData、故障码表、upmsg 往返、UDP 校验和、pack 布局</td><td>① 状态机迁移测试：转移表全覆盖（每个规则至少 1 例）+ guard 边界；② FaultManager：检测→锁存→上报→清除全链路，含 B6/B7 回归；③ ProtocolCodec：JSON 键名完整性（防 B4 复发）、帧编解码参数化</td><td>GTest；领域层零 MOOS 依赖后可脱离 MOOSDB 运行</td></tr>
<tr><td>集成测试</td><td>udp_feeder/full_feeder 字节级仿真 CCU+4 路配电 + check_db.py 验证落库</td><td>① 故障注入 feeder：丢包、坏校验和、越界值、故障位置位、30 s 静默（超时路径）；② MOOS 端到端：上位机指令→状态迁移→上报序列黄金比对（第 6 章基线）；③ 断路器闭环时序仿真</td><td>Python 脚本 + 现有 feeder 扩展；MOOSDB 冒烟沿用</td></tr>
<tr><td>系统/回归</td><td>CI 有构建+冒烟，但集成失败不阻塞（build-test.sh:181），已知 std::bad_alloc 被容忍</td><td>① 集成失败纳入 ALL_OK 阻塞；② cppcheck/clang-tidy 接入 CI（error 级清零）；③ 测试二进制输出改到 build 目录，清理 test/ 下 in-source 构建残留</td><td>Gitea Actions 现有流水线扩展</td></tr>
<tr><td>上位机测试</td><td>零</td><td>HostSim 指令队列 drain、FeedbackStore 落盘/24 h 清理、/api/history 时序提取、WS 快照广播</td><td>GTest（队列/存储）+ Python（HTTP/WS 接口）</td></tr>
</table>
<h3>7.2 关键专项测试</h3>
<ul>
<li><b>状态机迁移矩阵</b>：以 4.2.1 转移表为基准自动生成用例骨架——14 状态 × 11 事件全组合标注"允许/拒绝/保持"，重构前后两轮运行，输出 diff 必须为空（除已登记的行为变更点）。</li>
<li><b>故障注入矩阵</b>：覆盖三级来源——UDP 层（坏帧/丢帧/超时）、设备层（断路器脱扣、绝缘低、BMS 各级故障位）、系统层（深度失效、功率不足等 0xLSSS 码）；断言故障码上报内容、FaultState 迁移、SQLite fault_event 落库三处一致。</li>
<li><b>并发压力</b>：UDP 监听线程 100 Hz 灌包 + MOOS 指令并发注入，ThreadSanitizer 构建跑 10 min，数据竞争报告清零；队列上限 100 的溢出行为固定为"丢最旧 + 计数告警"并测试。</li>
<li><b>长稳</b>：feeder 连续 24 h 正常流量 + 周期故障注入，监控内存（消除每帧 new/delete 后应无增长）、句柄、落库行数。</li>
</ul>
<h3>7.3 验收标准</h3>
<ol>
<li>黄金报文比对：MOOS/UDP 契约测试 100% 通过，diff 为空；</li>
<li>状态迁移矩阵：除已登记变更点（B1 修复后 Lifting 可达等）外零差异；</li>
<li>新增单测覆盖率：fsm/、FaultManager、ProtocolCodec 行覆盖 ≥ 80%；</li>
<li>cppcheck error 级清零，TSan 报告清零；</li>
<li>CI 全链路（构建→单测→集成→黄金比对）绿灯且失败阻塞。</li>
</ol>
<!-- ================= 8 ================= -->
<h2 id="s8">8 实施路线图</h2>
<div class="phase">
<h4>阶段 0：缺陷修复与测试基线（先行，约 2 周）</h4>
<p class="small">最小改动修复 B1-B14 并逐项登记行为变更；开启 <code>-Wall -Wextra</code> 清零告警、接入 sanitizer 构建目标与 cppcheck（error 级阻塞）；配置项端口校验；搭建黄金报文基线与状态迁移矩阵录制工具。<b>产出：行为基线库 + 变更清单 + 可运行的安全网。</b></p>
</div>
<div class="phase">
<h4>阶段 1：故障码与数据层统一（约 2-3 周）</h4>
<p class="small">落地 FaultCodeDef.h 生成式定义；合并双故障存储为 FaultManager；新增 fault_event 持久化表；修复条件编译与死码。该阶段相对独立、风险最低，先行可立即改善可维护性。<b>产出：统一故障子系统 + 故障注入测试矩阵。</b></p>
</div>
<div class="phase">
<h4>阶段 2：通信层与线程模型（约 3-4 周）</h4>
<p class="small">建立 protocol/ 单一事实源；UDP 监听线程改为纯生产者；断路器闭环异步化；连接状态管理启用；下位机 HTTP 控制接口改道 MOOS。<b>产出：单线程事件循环模型 + 契约测试全绿。</b></p>
</div>
<div class="phase">
<h4>阶段 3：状态机重构（约 3-4 周）</h4>
<p class="small">转移表显式化；PowerManagerFsm 上帝类拆分；状态类去重；FaultState 出入路径显式化；entry 阻塞消除。每步以迁移矩阵 diff 为空为准入。<b>产出：表驱动状态机 + 迁移矩阵零差异报告。</b></p>
</div>
<div class="phase">
<h4>阶段 4：上位机与收尾（约 2 周）</h4>
<p class="small">上位机测试补齐；下位机页面资源管线迁移；长稳与并发压力测试；文档更新（转移表自动生成状态图）。<b>产出：完整测试体系 + 验收报告。</b></p>
</div>
<div class="warn">
<b>风险控制</b>：每阶段结束必须 CI 全绿（含黄金比对）方可合并；协议/故障码/状态序列的任何外部可见变更必须已在变更清单登记并经确认；保持 pCCU、pMotor、pELoad 等周边进程接口不动，重构范围严格限定在 pPowerManger 与 pPowerMangerHost。
</div>
<!-- ================= 9 ================= -->
<h2 id="s9">9 附录：问题清单汇总</h2>
<table>
<tr><th>编号</th><th>级别</th><th>类别</th><th>问题摘要</th><th>位置</th><th>处置</th></tr>
<tr><td>B1</td><td><span class="badge p0">P0</span></td><td>Bug</td><td>Lifting 状态不可达（case 12 无 transit/break）</td><td class="loc">PowerManagerFsm.cpp:2934</td><td>阶段0修复（行为变更登记）</td></tr>
<tr><td>B2</td><td><span class="badge p0">P0</span></td><td>Bug</td><td>s.buoyage == 赋值误写为比较 ×4</td><td class="loc">PowerManagerFsm.cpp:1471-1486</td><td>阶段0修复（行为变更登记）</td></tr>
<tr><td>B3</td><td><span class="badge p0">P0</span></td><td>Bug</td><td>邮件偏斜 return 导致整批丢弃</td><td class="loc">PowerManger.cpp:121-125</td><td>阶段0修复</td></tr>
<tr><td>B4</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>桅杆升降舵 JSON 键名失配，指令静默丢失</td><td class="loc">driver.cpp:844/924</td><td>阶段0修复（行为变更登记）</td></tr>
<tr><td>B5</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>故障检测函数重复调用两遍</td><td class="loc">PowerManagerFsm.cpp:52-55</td><td>阶段0修复</td></tr>
<tr><td>B6</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>3 个断路器故障码死码</td><td class="loc">systemData.h:1026-1028</td><td>阶段0修复</td></tr>
<tr><td>B7</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>故障注入数组越界 + systemData.h:524 越界</td><td class="loc">PowerManagerFsm.cpp:3053</td><td>阶段0修复</td></tr>
<tr><td>B8</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>TestEvent switch 缺 break；绕过事件机制</td><td class="loc">PowerManagerFsm.cpp:3084</td><td>阶段0修复</td></tr>
<tr><td>B9</td><td><span class="badge p2">P2</span></td><td>Bug</td><td>协议结构体未初始化返回 / memset 非 POD</td><td class="loc">upmsg/ 多处</td><td>阶段0修复</td></tr>
<tr><td>B10</td><td><span class="badge p2">P2</span></td><td>规范</td><td>超时常量与注释不符（FaultState 20s vs 其余 5s），复制 7 份</td><td class="loc">FaultState.cpp:46/53 等</td><td>阶段3统一</td></tr>
<tr><td>B11</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>模板残留致每条正常指令误报 "Unhandled Mail" run warning</td><td class="loc">PowerManger.cpp:142-146</td><td>阶段0修复</td></tr>
<tr><td>B12</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>畸形 JSON 类型致 jsoncpp 抛异常（asUInt 无类型检查、无 catch）</td><td class="loc">driver.cpp:935 / UpperCommManager.cpp:48</td><td>阶段0修复</td></tr>
<tr><td>B13</td><td><span class="badge p1">P1</span></td><td>Bug</td><td>HTTP 服务在配置/DB 就绪前于构造函数启动，提前暴露控制面</td><td class="loc">PowerManger.cpp:83-87</td><td>阶段0修复</td></tr>
<tr><td>B14</td><td><span class="badge p2">P2</span></td><td>规范</td><td>FsmLoop/_FsmCB、m_deviceCmdQuenue 无消费者；buildReport 占位；SKEW_TOLERANCE 宏未用</td><td class="loc">PowerManger.h:48/121 等</td><td>阶段3清理</td></tr>
<tr><td>A1</td><td><span class="badge p0">P0</span></td><td>架构</td><td>状态机退化为路由壳，转移逻辑集中在基类 switch</td><td class="loc">fsm/ 全局</td><td>阶段3重构</td></tr>
<tr><td>A2</td><td><span class="badge p0">P0</span></td><td>架构</td><td>故障检测与 FaultState 脱钩；FaultState 无出口</td><td class="loc">PowerManagerFsm.cpp:948-953</td><td>阶段1+3</td></tr>
<tr><td>A3</td><td><span class="badge p1">P1</span></td><td>架构</td><td>entry() 内 MOOSPause/忙等最长 10-20 s</td><td class="loc">WaterBasedReady.cpp:50 等</td><td>阶段3异步化</td></tr>
<tr><td>A4</td><td><span class="badge p1">P1</span></td><td>架构</td><td>3096 行上帝类；static pm 裸指针全局穿透</td><td class="loc">PowerManagerFsm.hpp:86</td><td>阶段3拆分</td></tr>
<tr><td>A5-A7</td><td><span class="badge p2">P2</span></td><td>规范</td><td>语义错位/拼写错误/死代码/日志混乱</td><td class="loc">多处</td><td>阶段3清理</td></tr>
<tr><td>C1</td><td><span class="badge p1">P1</span></td><td>通信</td><td>上位机无连接管理，connectState 死字段</td><td class="loc">LowerCommManager.h:131</td><td>阶段2启用</td></tr>
<tr><td>C2</td><td><span class="badge p1">P1</span></td><td>通信</td><td>协议知识三处散养；Driver 双实例</td><td class="loc">driver.cpp / UpperCommManager.h:93</td><td>阶段2收敛</td></tr>
<tr><td>C3-C6</td><td><span class="badge p1">P1</span></td><td>通信</td><td>错误码虚设/死分支/硬编码帧长/废弃函数错误数据</td><td class="loc">udpComm.cpp / driver.cpp</td><td>阶段2修复</td></tr>
<tr><td>C5</td><td><span class="badge p2">P2</span></td><td>性能</td><td>每帧堆分配、每包 cout</td><td class="loc">udpComm.cpp:462 等</td><td>阶段2优化</td></tr>
<tr><td>C7</td><td><span class="badge p1">P1</span></td><td>架构</td><td>双 Web 重复建设；/fcs/control 越权直改状态</td><td class="loc">httpserver.cpp:150</td><td>阶段2+4</td></tr>
<tr><td>F1</td><td><span class="badge p0">P0</span></td><td>故障</td><td>双重故障存储，等级查询与上报读不同集合</td><td class="loc">PowerManger.cpp:448 / uPower_pmState.h:50</td><td>阶段1合并</td></tr>
<tr><td>F2</td><td><span class="badge p1">P1</span></td><td>故障</td><td>上报死赋值</td><td class="loc">UpperCommManager.cpp:240</td><td>阶段1清理</td></tr>
<tr><td>F3</td><td><span class="badge p1">P1</span></td><td>故障</td><td>三套编码并存；系统码无文本映射；前端 JS 重写映射</td><td class="loc">faultCode.h / fuelcell.h:834</td><td>阶段1统一</td></tr>
<tr><td>F4</td><td><span class="badge p1">P1</span></td><td>故障</td><td>DEBUG 宏全构建未定义，4 级故障字恒为 0；DEBUFG 拼写；_DEBUG 死代码</td><td class="loc">systemData.h:7,776 等</td><td>阶段0修复</td></tr>
<tr><td>F5</td><td><span class="badge p2">P2</span></td><td>故障</td><td>无故障事件持久化表</td><td class="loc">SQLite 层</td><td>阶段1新增</td></tr>
<tr><td>D1-D4</td><td><span class="badge p1">P1</span></td><td>并发</td><td>全局数据池/锁纪律不一致/abs 截断/并发清队列</td><td class="loc">systemData.h 等</td><td>阶段2统一线程模型</td></tr>
<tr><td>H1-H3</td><td><span class="badge p2">P2</span></td><td>上位机</td><td>功能重叠/越权通道/页面硬编码</td><td class="loc">HostSim / httpserver</td><td>阶段4</td></tr>
<tr><td>E1</td><td><span class="badge p1">P1</span></td><td>构建</td><td>-Wall 未启用且写法错误；无 sanitizer；测试输出残留</td><td class="loc">CMakeLists.txt:80-86</td><td>阶段0接入</td></tr>
<tr><td>E2</td><td><span class="badge p2">P2</span></td><td>构建</td><td>GLOB 反模式；第三方库无版本/许可证记录；CMAKE 版本过老</td><td class="loc">CMakeLists.txt:9,49,53</td><td>阶段0接入</td></tr>
<tr><td>E3</td><td><span class="badge p1">P1</span></td><td>配置</td><td>ccuport/iport atoi 无校验、无范围检查</td><td class="loc">PowerManger.cpp:229/233</td><td>阶段0修复</td></tr>
<tr><td>E4</td><td><span class="badge p2">P2</span></td><td>性能</td><td>SQLite insertGeneric/onFrame 高频重复 prepare</td><td class="loc">SQLite.cpp:610-625</td><td>阶段1优化</td></tr>
<tr><td>E5</td><td><span class="badge p2">P2</span></td><td>规范</td><td>日志/错误输出三套并存（loguru/cerr/cout）</td><td class="loc">driver.cpp / LowerCommManager.cpp</td><td>阶段3统一</td></tr>
<tr><td>T1</td><td><span class="badge p0">P0</span></td><td>测试</td><td>状态机/故障注入/上位机三大测试空白</td><td class="loc">test/</td><td>阶段0起持续</td></tr>
<tr><td>T2</td><td><span class="badge p1">P1</span></td><td>CI</td><td>集成失败不阻塞；cppcheck 未接入；in-source 构建残留</td><td class="loc">ci/build-test.sh:181</td><td>阶段0</td></tr>
</table>
<p class="small" style="margin-top:40px;border-top:1px solid var(--border);padding-top:16px;">
本报告基于 2026-09-03 工作区代码静态审查生成，所有问题均标注文件与行号，关键缺陷（B1、B2、B3、B5）已经人工逐行复核。报告未对任何源代码做修改。
</p>
</main>
</div>
</body>
</html>
docs/电子负载说明手册/1_3_1_IT6000C User Manual-CN.pdf
BIN
View File
Binary file not shown.
docs/电子负载说明手册/IT6000C-Programming-Guide.pdf
BIN
View File
Binary file not shown.
missions/h100.moos
+46 -5
View File
@@ -1,8 +1,8 @@
// MOOS file
// 板卡 (RK3588 / Ubuntu 20.04) 专用 mission 配置
// 六个 systemd 服务（moosdb / pPowerManger / pPowerMangerHost / pCCU / pCanBridge / pMotor）
// 共用本文件。
// 由 scripts/deploy.sh 推送到板卡 /root/work/h100/missions/h100.moos
// 七个 systemd 服务（moosdb / pPowerManger / pPowerMangerHost / pCCU /
// pCanBridge / pMotor / pELoad）共用本文件。
// 由 scripts/build-board.sh 同步到板卡 /root/work/h100/missions/h100.moos
ServerHost = localhost
ServerPort = 9000
@@ -13,9 +13,9 @@ ProcessConfig = pPowerManger
AppTick = 4
CommsTick = 4
log_level = INFO
// 日志文件路径（目录需已存在，由 deploy.sh 创建）
// 日志文件路径（目录需已存在，由 build-board.sh 部署时创建）
logpath = /root/work/h100/data/pPowerManger.log
// 数据库存储路径（目录需已存在，由 deploy.sh 创建）
// 数据库存储路径（目录需已存在，由 build-board.sh 部署时创建）
dbpath = /root/work/h100/data/power_data.db
// CCU 地址（pPowerManger -> pCCU 的 UDP 链路）；不配置则默认 127.0.0.1:7000
ccuhost = 127.0.0.1
@@ -118,3 +118,44 @@ ProcessConfig = pMotor
logpath = /root/work/h100/data/pMotor.log
}
ProcessConfig = pELoad
{
AppTick = 10
CommsTick = 4
//======== 电子负载（IT6000C）以太网地址 ========
// 仪器 LAN 配置的 IP 与 Raw Socket 端口号（出厂默认 30000）
eload_ip = 192.168.200.100
eload_port = 30000
//======== 功率控制 ========
// MOOS 功率消息变量名（实时电机功率，W，正值=负载吸收）
power_var = MOTOR_POWER
ctrl_period_ms = 100
power_stale_sec = 3
current_sign = negative
nominal_volt = 500
max_power = 0
max_current = 0
slew_limit_wps = 0
func_priority = cc
// CV 优先时的目标电压(V)，func_priority=cv 时生效（恒压吸收）
volt_set = 0
//======== 数据存储 ========
dbpath = /root/work/h100/data/pELoad.db
log_keep_hours = 72
meas_log_period_ms = 100
// 测量命令来源：fetch=FETCh（读设备表头缓存，不触发测量，响应快，推荐）；
// meas=MEAS（每次触发设备重新测量，响应慢，易超时）
meas_source = fetch
//======== 网页（避开 8080/8090/18080/18081）========
web_port = 18082
web_enable = true
logpath = /root/work/h100/data/pELoad.log
}
scripts/build-board.sh
+28 -3
View File
@@ -7,7 +7,7 @@
#
# 用法:
# ./scripts/build-board.sh # 同步+编译+部署（不重启）
# ./scripts/build-board.sh --start # 编译后重启全部服务（含 pCanBridge/pMotor）
# ./scripts/build-board.sh --start # 编译后重启全部服务（含 pCanBridge/pMotor/pELoad）
# ./scripts/build-board.sh --clean # 板卡上重新 cmake 再编译
# ./scripts/build-board.sh --jobs 4 # 指定并行度（默认板卡 nproc）
#
@@ -68,7 +68,7 @@ DO_CLEAN=0
CCU_HOST=""
CCU_PORT=""
SERVICES=(moosdb pPowerManger pPowerMangerHost pCCU pCanBridge pMotor)
SERVICES=(moosdb pPowerManger pPowerMangerHost pCCU pCanBridge pMotor pELoad)
info() { printf '\033[1;36m[build-board]\033[0m %s\n' "$*"; }
ok() { printf '\033[1;32m[build-board]\033[0m %s\n' "$*"; }
@@ -212,7 +212,8 @@ ${SSH} "${SSH_TARGET}" "mkdir -p ${BOARD_BIN} && \
cp -f ${BOARD_SRC}/bin/pCCU ${BOARD_BIN}/pCCU && \
cp -f ${BOARD_SRC}/bin/pCanBridge ${BOARD_BIN}/pCanBridge && \
cp -f ${BOARD_SRC}/bin/pMotor ${BOARD_BIN}/pMotor && \
chmod +x ${BOARD_BIN}/pPowerManger ${BOARD_BIN}/pPowerMangerHost ${BOARD_BIN}/pCCU ${BOARD_BIN}/pCanBridge ${BOARD_BIN}/pMotor" \
cp -f ${BOARD_SRC}/bin/pELoad ${BOARD_BIN}/pELoad && \
chmod +x ${BOARD_BIN}/pPowerManger ${BOARD_BIN}/pPowerMangerHost ${BOARD_BIN}/pCCU ${BOARD_BIN}/pCanBridge ${BOARD_BIN}/pMotor ${BOARD_BIN}/pELoad" \
|| { err "部署产物失败"; exit 1; }
ok "产物已部署"
@@ -262,6 +263,30 @@ EOF
${SSH} "${SSH_TARGET}" "systemctl daemon-reload && systemctl reset-failed pMotor 2>/dev/null || true"
ok "pMotor.service 已安装"
#-------------------------------------------------------------------
# 4.7 安装/刷新 pELoad systemd unit（幂等）
# 电子负载（IT6000C）控制程序：以太网直连设备，不依赖 pCanBridge
#-------------------------------------------------------------------
info "安装 pELoad.service ..."
${SSH} "${SSH_TARGET}" "cat > /etc/systemd/system/pELoad.service" <<EOF
[Unit]
Description=pELoad Electronic Load (IT6000C) for H100 Power Manager
After=moosdb.service
Requires=moosdb.service
[Service]
Type=simple
WorkingDirectory=${BOARD_BIN}
ExecStart=${BOARD_BIN}/pELoad --alias=pELoad /root/work/h100/missions/h100.moos
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
EOF
${SSH} "${SSH_TARGET}" "systemctl daemon-reload && systemctl reset-failed pELoad 2>/dev/null || true"
ok "pELoad.service 已安装"
echo ""
ok "产物: ${BOARD_BIN}/pPowerManger (aarch64)"
${SSH} "${SSH_TARGET}" "file ${BOARD_BIN}/pPowerManger | cut -c1-60"
scripts/clean-data.sh
+2 -2
View File
@@ -25,7 +25,7 @@
# --stale 额外清理历史遗留的 bin/、src/bin/ 下旧数据库与日志
# -h, --help 显示帮助
#
# 前置: 板卡已配免密 SSH（见 scripts/deploy.sh setup-ssh）。
# 前置: 板卡已配免密 SSH（ssh-copy-id root@<host>）。
#=======================================================================
set -uo pipefail
@@ -90,7 +90,7 @@ SSH="ssh -o BatchMode=yes -o ConnectTimeout=5"
#-------------------------------------------------------------------
if ! ${SSH} "${SSH_TARGET}" 'true' 2>/dev/null; then
err "无法免密 SSH 到 ${SSH_TARGET}"
err "请先执行: ./scripts/deploy.sh setup-ssh"
err "请先配置免密登录: ssh-copy-id ${SSH_TARGET}"
exit 1
fi
ok "SSH 连接正常: ${SSH_TARGET}"
scripts/deploy.sh
-268
View File
@@ -1,268 +0,0 @@
#!/bin/bash
#=======================================================================
# FILE: scripts/deploy.sh
# DESC: 部署 mission + 5 个 systemd 服务（moosdb / pPowerManger /
# pPowerMangerHost / pCCU / pCanBridge）到目标板卡 (RK3588 /
# Ubuntu 22.04)。只安装服务 + daemon-reload，默认不启动、不自启。
#
# 注意：二进制由 ./scripts/build-board.sh 在板卡原生编译并部署到
# /root/work/h100/bin/（交叉编译已移除），本脚本不再推送二进制。
#
# 用法:
# ./scripts/deploy.sh setup-ssh 一次性：生成 ed25519 key + ssh-copy-id
# ./scripts/deploy.sh 默认：推送 mission + 装 5 个
# systemd 服务 + daemon-reload（不启动）
# ./scripts/deploy.sh --start 部署后按依赖顺序启动服务
# ./scripts/deploy.sh status 板卡各服务状态
# ./scripts/deploy.sh stop 停止各服务
# ./scripts/deploy.sh help 显示帮助
#
# 参数:
# --host <ip> 目标主机（默认 192.168.0.223）
# --user <user> 登录用户（默认 root）
# --board-dir <dir> 板卡部署根目录（默认 /root/work/h100）
# --start 部署后立即启动服务
# --ccu-host <ip> 覆盖 mission 中 pPowerManger 的 CCU 地址 (ccuhost)
# --ccu-port <n> 覆盖 mission 中 pPowerManger 的 CCU 端口 (ccuport)
#
# 板卡布局:
# /root/work/h100/bin/ 二进制（由 build-board.sh 板卡编译产出）
# /root/work/h100/missions/ 板卡 mission h100.moos
# /root/work/h100/data/ 数据库存储目录 (power_data.db 等)
# /etc/systemd/system/ moosdb.service / pPowerManger.service /
# pPowerMangerHost.service / pCCU.service /
# pCanBridge.service
#=======================================================================
set -uo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(dirname "${SCRIPT_DIR}")"
HOST="192.168.0.223"
USER="root"
BOARD_DIR="/root/work/h100"
DO_START=0
CCU_HOST=""
CCU_PORT=""
SERVICES=(moosdb pPowerManger pPowerMangerHost pCCU pCanBridge)
info() { printf '\033[1;36m[deploy]\033[0m %s\n' "$*"; }
ok() { printf '\033[1;32m[deploy]\033[0m %s\n' "$*"; }
warn() { printf '\033[1;33m[deploy]\033[0m %s\n' "$*"; }
err() { printf '\033[1;31m[deploy]\033[0m %s\n' "$*"; }
usage() {
sed -n '2,35p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
exit 0
}
#-------------------------------------------------------------------
# 参数解析
#-------------------------------------------------------------------
ACTION=""
while [ $# -gt 0 ]; do
case "$1" in
--host) [ $# -ge 2 ] || { err "--host 需要参数"; exit 1; }; HOST="$2"; shift 2 ;;
--user) [ $# -ge 2 ] || { err "--user 需要参数"; exit 1; }; USER="$2"; shift 2 ;;
--board-dir)[ $# -ge 2 ] || { err "--board-dir 需要参数"; exit 1; }; BOARD_DIR="$2"; shift 2 ;;
--start) DO_START=1; shift ;;
--ccu-host) [ $# -ge 2 ] || { err "--ccu-host 需要参数"; exit 1; }; CCU_HOST="$2"; shift 2 ;;
--ccu-port) [ $# -ge 2 ] || { err "--ccu-port 需要参数"; exit 1; }; CCU_PORT="$2"; shift 2 ;;
setup-ssh|status|stop|help|-h|--help) ACTION="$1"; shift ;;
"") shift ;;
*) err "未知参数: $1（见 help）"; exit 1 ;;
esac
done
[ -n "${ACTION}" ] || ACTION="deploy"
case "${CCU_PORT}" in
""|*[!0-9]*) [ -z "${CCU_PORT}" ] || { err "--ccu-port 必须是数字端口: ${CCU_PORT}"; exit 1; } ;;
esac
SSH_TARGET="${USER}@${HOST}"
SSH="ssh -o BatchMode=yes -o ConnectTimeout=5"
SCP="scp -o BatchMode=yes -o ConnectTimeout=5"
#-------------------------------------------------------------------
# 命令: setup-ssh
#-------------------------------------------------------------------
cmd_setup_ssh() {
local key="$HOME/.ssh/id_ed25519"
if [ ! -f "${key}" ]; then
info "未发现 SSH key，生成 ed25519 key ..."
mkdir -p "$HOME/.ssh" && chmod 700 "$HOME/.ssh"
ssh-keygen -t ed25519 -N '' -f "${key}"
fi
info "上传公钥到 ${SSH_TARGET}（会提示输入密码，仅此一次）..."
ssh-copy-id -o ConnectTimeout=5 "${SSH_TARGET}"
ok "免密 SSH 已配置。验证: ssh ${SSH_TARGET}"
}
#-------------------------------------------------------------------
# 前置检查
#-------------------------------------------------------------------
check_ssh() {
if ! ${SSH} "${SSH_TARGET}" 'true' 2>/dev/null; then
err "无法免密 SSH 到 ${SSH_TARGET}"
err "请先执行: ./scripts/deploy.sh setup-ssh"
return 1
fi
ok "SSH 连接正常: ${SSH_TARGET}"
}
#-------------------------------------------------------------------
# 生成 systemd unit（含板卡绝对路径）
#-------------------------------------------------------------------
gen_moosdb_unit() {
# MOOSDB 路径在板卡探测；探测失败给出提示
local moosdb_bin
moosdb_bin="$(${SSH} "${SSH_TARGET}" 'command -v MOOSDB || true' 2>/dev/null)"
if [ -z "${moosdb_bin}" ]; then
moosdb_bin="$(command -v MOOSDB || true)"
warn "板卡未在 PATH 找到 MOOSDB，回退本机路径 ${moosdb_bin:-"(未找到)"}"
[ -n "${moosdb_bin}" ] || { err "MOOSDB 路径未知，无法生成 moosdb.service"; return 1; }
fi
ok "MOOSDB 路径: ${moosdb_bin}" >&2
cat <<EOF
[Unit]
Description=MOOSDB for H100 Power Manager
After=network.target
[Service]
Type=simple
ExecStart=${moosdb_bin} --moos_no_colour ${BOARD_DIR}/missions/h100.moos
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
EOF
}
gen_app_unit() {
local app="$1" deps=""
[ "${app}" = "moosdb" ] || deps="After=moosdb.service\nRequires=moosdb.service"
cat <<EOF
[Unit]
Description=${app} for H100 Power Manager
$(printf '%b' "${deps}")
[Service]
Type=simple
WorkingDirectory=${BOARD_DIR}/bin
ExecStart=${BOARD_DIR}/bin/${app} --alias=${app} ${BOARD_DIR}/missions/h100.moos
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
EOF
}
#-------------------------------------------------------------------
# mission 中插入/替换 "key = value"（键已存在则替换，否则插到第一个
# 顶层 '}' 之前，即 pPowerManger 配置块末尾）
#-------------------------------------------------------------------
upsert_moos_param() {
local f="$1" key="$2" val="$3"
if grep -qE "^[[:space:]]*${key}[[:space:]]*=" "${f}"; then
sed -i -E "s|^([[:space:]]*)${key}[[:space:]]*=.*|\1${key} = ${val}|" "${f}"
else
awk -v kv=" ${key} = ${val}" \
'!d && /^[[:space:]]*}[[:space:]]*$/ { print kv; d=1 } { print }' \
"${f}" > "${f}.tmp" && mv "${f}.tmp" "${f}"
fi
}
#-------------------------------------------------------------------
# 命令: deploy
#-------------------------------------------------------------------
cmd_deploy() {
check_ssh || return 1
[ -f "${PROJECT_ROOT}/missions/h100.moos" ] || { err "缺少板卡 mission: missions/h100.moos"; return 1; }
# 1. 创建板卡目录 + 推送 mission
info "创建板卡目录 ${BOARD_DIR}/{bin,missions,data} ..."
${SSH} "${SSH_TARGET}" "mkdir -p ${BOARD_DIR}/bin ${BOARD_DIR}/missions ${BOARD_DIR}/data" || { err "创建目录失败"; return 1; }
info "推送 mission h100.moos ..."
local mission_src="${PROJECT_ROOT}/missions/h100.moos"
local mission_push="${mission_src}" tmp_moos=""
if [ -n "${CCU_HOST}" ] || [ -n "${CCU_PORT}" ]; then
tmp_moos="$(mktemp)"
cp "${mission_src}" "${tmp_moos}"
[ -n "${CCU_HOST}" ] && upsert_moos_param "${tmp_moos}" ccuhost "${CCU_HOST}"
[ -n "${CCU_PORT}" ] && upsert_moos_param "${tmp_moos}" ccuport "${CCU_PORT}"
mission_push="${tmp_moos}"
info "CCU 地址覆盖: ccuhost=${CCU_HOST:-<保持原值>} ccuport=${CCU_PORT:-<保持原值>}"
fi
${SCP} -q "${mission_push}" \
"${SSH_TARGET}:${BOARD_DIR}/missions/" || { err "推送 mission 失败"; [ -n "${tmp_moos}" ] && rm -f "${tmp_moos}"; return 1; }
[ -n "${tmp_moos}" ] && rm -f "${tmp_moos}"
ok "mission 已推送（二进制由 build-board.sh 在板卡编译部署）"
# 2. 生成并安装 4 个 systemd unit
local unit
for s in "${SERVICES[@]}"; do
info "生成 ${s}.service ..."
if [ "${s}" = "moosdb" ]; then
unit="$(gen_moosdb_unit)" || return 1
else
unit="$(gen_app_unit "${s}")"
fi
printf '%s\n' "${unit}" | ${SSH} "${SSH_TARGET}" "cat > /etc/systemd/system/${s}.service"
ok "${s}.service 已安装"
done
# 3. daemon-reload（不 enable，不自启）
info "systemctl daemon-reload ..."
${SSH} "${SSH_TARGET}" "systemctl daemon-reload && systemctl reset-failed ${SERVICES[*]} 2>/dev/null || true"
ok "服务已安装但未启用自启（systemctl is-enabled 应输出 disabled）"
# 4. 可选启动
if [ "${DO_START}" = "1" ]; then
cmd_start
else
echo ""
info "部署完成。手动启动（或加 --start）:"
echo " systemctl start moosdb pPowerManger pPowerMangerHost pCCU pCanBridge"
echo " 浏览器: http://${HOST}:18080 (上位机模拟)"
echo " http://${HOST}:8090 (pPowerManger)"
echo " http://${HOST}:8080 (pCCU)"
fi
}
#-------------------------------------------------------------------
# 命令: start / status / stop
#-------------------------------------------------------------------
cmd_start() {
info "启动服务 (moosdb -> pPowerManger / pPowerMangerHost / pCCU / pCanBridge) ..."
${SSH} "${SSH_TARGET}" "systemctl start moosdb && sleep 1 && \
systemctl start pPowerManger pPowerMangerHost pCCU pCanBridge" || { err "启动失败"; return 1; }
ok "服务已启动"
cmd_status
}
cmd_status() {
${SSH} "${SSH_TARGET}" "systemctl --no-pager status ${SERVICES[*]}" || true
}
cmd_stop() {
${SSH} "${SSH_TARGET}" "systemctl stop pCanBridge pPowerMangerHost pPowerManger pCCU moosdb" && \
ok "服务已停止" || err "停止服务失败"
}
#-------------------------------------------------------------------
# 命令入口
#-------------------------------------------------------------------
case "${ACTION}" in
deploy) cmd_deploy ;;
setup-ssh) cmd_setup_ssh ;;
status) cmd_status ;;
stop) cmd_stop ;;
help|-h|--help) usage ;;
*) usage ;;
esac
scripts/fetch-data.sh
+2 -2
View File
@@ -23,7 +23,7 @@
# --journal 额外导出各服务的 systemd journal 日志
# -h, --help 显示帮助
#
# 前置: 板卡已配免密 SSH（见 scripts/deploy.sh setup-ssh）。
# 前置: 板卡已配免密 SSH（ssh-copy-id root@<host>）。
#=======================================================================
set -uo pipefail
@@ -82,7 +82,7 @@ SCP="scp -o BatchMode=yes -o ConnectTimeout=5"
#-------------------------------------------------------------------
if ! ${SSH} "${SSH_TARGET}" 'true' 2>/dev/null; then
err "无法免密 SSH 到 ${SSH_TARGET}"
err "请先执行: ./scripts/deploy.sh setup-ssh"
err "请先配置免密登录: ssh-copy-id ${SSH_TARGET}"
exit 1
fi
ok "SSH 连接正常: ${SSH_TARGET}"
scripts/sync-board-time.sh
+2 -2
View File
@@ -20,7 +20,7 @@
# -h, --help 显示帮助
#
# 说明:
# - 需要 root 登录与免密 SSH（deploy.sh setup-ssh）。
# - 需要 root 登录与免密 SSH（ssh-copy-id root@<host>）。
# - 对时经 SSH 往返时延 (RTT) 折半补偿，精度约 ±0.1s（受网络抖动影响）。
# - 板卡若无可用 RTC，hwclock 失败仅告警；重启后时间可能回跳。
# - 对时会调整系统时钟，运行中的服务日志时间戳会跳变，属正常现象。
@@ -75,7 +75,7 @@ read_board_time() {
local t0 t1 out
t0="$(date +%s.%N)"
out="$(${SSH} "${SSH_TARGET}" 'date "+%s.%N|%F %T %Z"' 2>/dev/null)" || {
err "无法免密 SSH 到 ${SSH_TARGET}（先执行: ./scripts/deploy.sh setup-ssh）" >&2
err "无法免密 SSH 到 ${SSH_TARGET}（先配置免密: ssh-copy-id ${SSH_TARGET}）" >&2
return 1
}
t1="$(date +%s.%N)"
src/CMakeLists.txt
+1
View File
@@ -23,6 +23,7 @@ add_subdirectory(pPowerMangerHost)
add_subdirectory(pCCU)
add_subdirectory(pCanBridge)
add_subdirectory(pMotor)
add_subdirectory(pELoad)
##############################################################################
# END of CMakeLists.txt
##############################################################################
src/pELoad/CMakeLists.txt
+64
View File
@@ -0,0 +1,64 @@
#--------------------------------------------------------
# The CMakeLists.txt for: pELoad
# 电子负载（IT6000C 双向电源）控制程序：
# 以太网 SCPI 直连 <-> 100ms 功率控制 <- MOOSDB 功率消息
# 网页人机交互 + sqlite3 数据存储
#--------------------------------------------------------
if (${WIN32})
SET(SYSTEM_LIBS wsock32)
else (${WIN32})
SET(SYSTEM_LIBS m pthread)
endif (${WIN32})
# 复用仓库内 pPowerManger 的公共源码（相对路径引用，避免重复维护）
SET(PM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../pPowerManger)
SET(SHARED_SRC
${PM_DIR}/logc/loguru.cpp
${PM_DIR}/sqlit3/sqlite3.c
${PM_DIR}/httpserver/mongoose.c
)
SET(ELOAD_DRIVER_SRC
driver/ScpiClient.cpp
driver/IT6000C.cpp
)
SET(ELOAD_STORE_SRC
store/DbStore.cpp
)
SET(ELOAD_WEB_SRC
web/WebServer.cpp
)
SET(SRC
${SHARED_SRC}
${ELOAD_DRIVER_SRC}
${ELOAD_STORE_SRC}
${ELOAD_WEB_SRC}
ELoad.cpp
ELoad_Info.cpp
main.cpp
)
ADD_EXECUTABLE(pELoad ${SRC})
TARGET_INCLUDE_DIRECTORIES(pELoad PRIVATE
${PM_DIR}
${PM_DIR}/sqlit3
${PM_DIR}/httpserver
${PM_DIR}/logc
)
TARGET_LINK_LIBRARIES(pELoad
${MOOS_LIBRARIES}
apputil
mbutil
m
pthread
jsoncpp
dl
${SYSTEM_LIBS}
)
src/pELoad/ELoad.cpp
+1463
View File
File diff suppressed because it is too large Load Diff
src/pELoad/ELoad.h
+190
View File
@@ -0,0 +1,190 @@
#ifndef PELOAD_ELOAD_H
#define PELOAD_ELOAD_H
#define UNIX
#include "MOOS/libMOOS/Thirdparty/AppCasting/AppCastingMOOSApp.h"
#include "driver/ScpiClient.h"
#include "driver/IT6000C.h"
#include "store/DbStore.h"
#include "web/WebServer.h"
#include <mutex>
#include <thread>
#include <atomic>
#include <string>
#include <vector>
namespace eload {
//============================================================================
// ELoad：pELoad 程序主类（MOOS 应用外壳）——电子负载（IT6000C）控制程序。
//
// 数据流：
// 控制回路（独立线程，默认 100ms 周期）：
// MOOSDB 功率消息(power_var，实时电机功率 W) -> 目标功率 -> I = P/U
// -> SCPI CURR 指令 -> 以太网 Raw Socket(默认 30000) -> IT6000C
// （CC 优先模式，负电流=吸收电能，模拟电机负载特性）
// 测量回路：MEAS:VOLT?/MEAS:CURR?/MEAS:POW? 轮询 -> 状态快照
// 上行发布：ELOAD_STATUS（JSON，1Hz）、ELOAD_MEAS_POWER（double）
// 人机交互：网页（WebSocket 1Hz 快照 + /api/* 控制接口）
// 数据存储：sqlite3（eload_log 运行快照 + scpi_log 非常规指令记录）
//
// 设备说明见 docs/电子负载说明手册/
// （IT6000C User Manual-CN.pdf / IT6000C-Programming-Guide.pdf）。
//============================================================================
class ELoad : public AppCastingMOOSApp {
public:
ELoad();
~ELoad();
protected:
bool OnNewMail(MOOSMSG_LIST &NewMail);
bool Iterate();
bool OnConnectToServer();
bool OnStartUp();
bool buildReport();
void registerVariables();
private:
//---- 控制回路（独立 100ms 周期线程）----
void ctrlThreadFunc();
void processWebCmds();
void doControlCycle(double now);
void applyEnable(double now); // 使能序列：远控+模式+限值+开输出
void applyDisable(); // 关输出
double computeTargetPower(double now); // 目标功率（含超时/斜率处理）
double computeCmdCurrent(double targetP); // 功率折算电流（含限幅）
void syncDeviceConfigOnce(double now); // 连接后从设备回读真实配置并接管
void pollDevice(); // 异步测量轮询（不阻塞控制循环）
void pollError(double now); // 异步错误/FUNC 回读（1Hz 节流）
void requestFuncModeReadback(); // 异步回读 FUNC:MODE?（真实反馈驱动显示）
void dbPeriodic(double now); // 状态落库 + 历史清理
void pruneHistory(double now);
//---- 网页 ----
std::string buildSnapshot();
// 返回 (Content-Type, body)；body 空串表示 404
std::pair<std::string, std::string> handleApi(const std::string& uri, const std::string& query);
std::string handleCmdApi(const std::string& query);
bool getQueryParam(const std::string& query, const char* key, std::string& out);
//---- SCPI 收发落库过滤（例行测量不落库；cmd/resp 由 IO 线程配对）----
void scpiLogSink(const std::string& cmd, const std::string& resp);
//---- 网页指令 ----
enum WebCmdType {
WCMD_CONNECT, WCMD_DISCONNECT,
WCMD_OUTP_ON, WCMD_OUTP_OFF,
WCMD_REMOTE, WCMD_LOCAL,
WCMD_MODE_CC, WCMD_MODE_CV,
WCMD_CTRL_FOLLOW, WCMD_CTRL_MANUAL, WCMD_CTRL_CURRENT,
WCMD_CLEAR_PROT, WCMD_RESET_DEV, WCMD_IDENTIFY,
WCMD_SET_POWER, WCMD_SET_CURRENT, WCMD_SET_VOLT, WCMD_SET_VOLTLIM,
WCMD_SET_POWLIM, WCMD_SET_CURRLIM,
WCMD_FUNC_MODE // 功能模式 FUNC:MODE（text=模式名）
};
struct WebCmd {
WebCmdType type;
double value;
std::string text;
WebCmd() : type(WCMD_CONNECT), value(0) {}
};
bool queueWebCmd(WebCmdType t, double v, std::string& err);
bool queueWebCmd(WebCmdType t, const std::string& text, std::string& err);
private:
//---- 配置 ----
std::string m_host = "192.168.0.10";
long m_port = 30000; // Raw Socket 端口（出厂默认 30000）
std::string m_powerVar = "MOTOR_POWER";
int m_ctrlPeriodMs = 100; // 功率控制周期
double m_powerStaleSec= 3.0; // 功率消息超时（0=不判超时）
bool m_sinkNegative = true; // true=负电流吸收(负载模拟)
double m_nominalVolt = 500.0; // 无电压反馈时的折算电压 V
double m_maxPower = 0; // 主机侧功率限幅 W（0=不限）
double m_maxCurrent = 0; // 主机侧电流限幅 A（0=不限）
double m_slewLimitWps = 0; // 功率斜率限制 W/s（0=不限）
std::string m_dbPath = "pELoad.db";
std::string m_logPath = "pELoad.log";
int m_webPort = 18082;
bool m_webEnable = true;
double m_logKeepHours = 72; // 历史保留时长（0=永久）
int m_measLogPeriodMs = 100; // 测量落库周期（默认=控制周期100ms）
bool m_measUseFetch = true; // 测量命令用 FETCh（读缓存，快）；false=MEAS（触发测量，慢）
//---- 设备配置值（web/配置可改；>0 表示需要下发）----
double m_voltLimit = 0;
double m_currLimitPos = 0;
double m_currLimitNeg = 0;
double m_powLimitPos = 0;
double m_powLimitNeg = 0;
bool m_ccPriority = true; // true=CC 优先（负载模拟），false=CV 优先
//---- 组件 ----
ScpiClient m_scpi;
IT6000C m_dev;
DbStore* m_db = nullptr;
WebServer* m_web = nullptr;
//---- 共享状态（m_stateMutex 保护；控制线程写，MOOS/Web 线程读）----
mutable std::mutex m_stateMutex;
// 控制状态
std::string m_mode = "follow"; // follow / manual / current / volt
double m_manualPower = 0; // 手动功率目标 W
double m_manualCurrent = 0; // 手动电流目标 A
double m_voltSet = 0; // CV 优先目标电压 V
double m_moosPower = 0; // 最近 MOOS 功率消息
double m_moosPowerTime = 0; // 消息到达时刻(MOOSTime)
bool m_loadOn = false; // 期望输出状态（控制使能）
double m_appliedPower = 0; // 斜率处理后的实际下发功率
// 设备/链路状态
bool m_linkEnable = true; // 自动连接使能
std::string m_idn;
std::string m_lastError;
double m_measV = 0, m_measI = 0, m_measP = 0;
double m_measVTime = 0, m_measITime = 0, m_measPTime = 0;
// 测量查询诊断（定位"设备在输出但测量不更新"）
unsigned long m_measOk = 0; // 查询成功次数
unsigned long m_measFail = 0; // 查询失败次数
std::string m_lastMeasErr; // 最近一次失败原因
std::string m_devFunc; // FUNC? 回读：CURR / VOLT
std::string m_devFuncMode; // FUNC:MODE? 回读：FIX/LIST/...
bool m_funcModeFixWarn = false; // 回读非 FIX 时告警
std::string m_funcModeFeed; // 最近功能模式切换指令
bool m_funcModeFeedOk = false;
double m_funcModeFeedTime = 0;
double m_cmdCurrent = 0; // 最近下发的电流指令（CC）
double m_cmdVolt = 0; // 最近下发的电压指令（CV）
//---- 远控/本控状态（IT6000C 无 SYST:REM? 查询，按最近指令+发送结果推断）----
bool m_remoteRequested = true; // true=需要远控（每次连接自动发 SYST:REM）
std::string m_remoteState = "unknown"; // remote / local / unknown
std::string m_remoteFeed = "-"; // 最近远控/本控指令执行结果
double m_remoteFeedTime = 0; // 最近反馈时间
//---- 控制线程私有（无需加锁）----
bool m_remoteApplied = false;
bool m_cfgApplied = false;
bool m_devCfgSyncDone = false; // 连接后是否已回读设备真实配置
double m_devCfgSyncTime = 0; // 最近一次配置回读时刻
double m_lastSentCurrent = 0;
double m_lastSentVolt = 0;
double m_lastSendTime = 0;
double m_lastErrPoll = 0;
double m_lastDbWrite = 0;
double m_lastPrune = 0;
int m_measRotate = 0;
std::atomic<bool> m_measPending{false}; // 异步测量查询进行中（节流）
std::vector<WebCmd> m_webCmdQueue; // web 线程入队 -> 控制线程出队
std::atomic<bool> m_ctrlRunning{false};
std::thread m_ctrlThread;
//---- 统计 ----
unsigned long m_pubCount = 0;
};
} // namespace eload
#endif // PELOAD_ELOAD_H
src/pELoad/ELoad_Info.cpp
+117
View File
@@ -0,0 +1,117 @@
/****************************************************************/
/* NAME: ELoad_Info */
/* FILE: ELoad_Info.cpp */
/****************************************************************/
#include <cstdlib>
#include <iostream>
#include "ELoad_Info.h"
#include "ColorParse.h"
#include "ReleaseInfo.h"
using namespace std;
void showSynopsis() {
blk("SYNOPSIS: ");
blk("------------------------------------ ");
blk(" The pELoad application controls the IT6000C bi-directional ");
blk(" DC power supply / electronic load over Ethernet (raw socket ");
blk(" SCPI, default port 30000). It provides 100ms periodic power ");
blk(" control: subscribes the MOOS power variable (real-time motor ");
blk(" power published by other processes) and drives the load to ");
blk(" reproduce the motor power profile. A web page is provided ");
blk(" for human-machine interaction and measurements are stored ");
blk(" in SQLite. Device manual: ");
blk(" docs/电子负载说明手册 (IT6000C User Manual-CN / ");
blk(" IT6000C-Programming-Guide). ");
blk(" ");
}
void showHelpAndExit() {
blk(" ");
blu("=============================================================== ");
blu("Usage: pELoad file.moos [OPTIONS] ");
blu("=============================================================== ");
blk(" ");
showSynopsis();
blk(" ");
blk("Options: ");
mag(" --alias","=<ProcessName> ");
blk(" Launch pELoad with the given process name ");
blk(" rather than pELoad. ");
mag(" --example, -e ");
blk(" Display example MOOS configuration block. ");
mag(" --help, -h ");
blk(" Display this help message. ");
mag(" --interface, -i ");
blk(" Display MOOS publications and subscriptions. ");
mag(" --version,-v ");
blk(" Display the release version of pELoad. ");
blk(" ");
blk("Note: If argv[2] does not otherwise match a known option, ");
blk(" then it will be interpreted as a run alias. This is ");
blk(" to support pAntler launching conventions. ");
blk(" ");
exit(0);
}
void showExampleConfigAndExit() {
blk(" ");
blu("=============================================================== ");
blu("pELoad Example MOOS Configuration ");
blu("=============================================================== ");
blk(" ");
blk("ProcessConfig = pELoad ");
blk("{ ");
blk(" AppTick = 10 // 100ms MOOS 节拍 ");
blk(" CommsTick = 4 ");
blk(" ");
blk(" eload_ip = 192.168.0.10 // 电子负载 IP（LAN 配置） ");
blk(" eload_port = 30000 // Raw Socket 端口号 ");
blk(" power_var = MOTOR_POWER // MOOS 功率消息变量名(W) ");
blk(" ctrl_period_ms= 100 // 功率控制周期 ms ");
blk(" power_stale_sec = 3 // 功率消息超时秒数(0=不判超时) ");
blk(" current_sign = negative // negative=吸收(负载模拟) ");
blk(" nominal_volt = 500 // 无电压反馈时的折算电压(V) ");
blk(" max_power = 0 // 主机侧功率限幅(W)，0=不限 ");
blk(" max_current = 0 // 主机侧电流限幅(A)，0=不限 ");
blk(" slew_limit_wps= 0 // 功率斜率限制(W/s)，0=不限 ");
blk(" func_priority = cc // 环路优先：cc=电流型负载 / cv=恒压吸收 ");
blk(" volt_set = 0 // CV 优先目标电压(V)，func_priority=cv 时用 ");
blk(" dbpath = pELoad.db // SQLite 数据库路径 ");
blk(" log_keep_hours= 72 // 历史保留时长(小时，0=永久) ");
blk(" meas_log_period_ms = 100 // 实测V/I/P落库周期ms(0=仅1Hz快照) ");
blk(" meas_source = fetch // 测量命令: fetch=FETCh(快) / meas=MEAS(慢) ");
blk(" web_port = 18082 // 网页端口(避开8080/8090/18080/18081) ");
blk(" web_enable = true // 是否启用网页 ");
blk(" logpath = pELoad.log // 日志路径 ");
blk("} ");
blk(" ");
exit(0);
}
void showInterfaceAndExit() {
blk(" ");
blu("=============================================================== ");
blu("pELoad INTERFACE ");
blu("=============================================================== ");
blk(" ");
showSynopsis();
blk(" ");
blk("SUBSCRIPTIONS: ");
blk("------------------------------------ ");
blk(" MOTOR_POWER = 实时电机功率消息(W)，变量名可配置 ");
blk(" (power_var)，正值=负载吸收功率 ");
blk(" ");
blk("PUBLICATIONS: ");
blk("------------------------------------ ");
blk(" ELOAD_STATUS = 电子负载状态 JSON 串（1Hz） ");
blk(" ELOAD_MEAS_POWER = 实测功率 (W, double) ");
blk(" ");
exit(0);
}
void showReleaseInfoAndExit() {
showReleaseInfo("pELoad", "gpl");
exit(0);
}
src/pELoad/ELoad_Info.h
+15
View File
@@ -0,0 +1,15 @@
/****************************************************************/
/* NAME: ELoad_Info */
/* FILE: ELoad_Info.h */
/****************************************************************/
#ifndef ELOAD_INFO_HEADER
#define ELOAD_INFO_HEADER
void showSynopsis();
void showHelpAndExit();
void showExampleConfigAndExit();
void showInterfaceAndExit();
void showReleaseInfoAndExit();
#endif
src/pELoad/driver/IT6000C.cpp
+134
View File
@@ -0,0 +1,134 @@
#include "IT6000C.h"
#include <cstdio>
#include <cstdlib>
namespace eload {
//============================================================================
// 基础
//============================================================================
bool IT6000C::identify(std::string& idn) {
return m_scpi.query("*IDN?", idn, 300);
}
bool IT6000C::remote() {
// 连接建立后必须先进入远控，否则设置命令被面板本地态拒绝。
// 用 cmdConfirmed 等待真实写入结果，明确反馈成功/失败。
return m_scpi.cmdConfirmed("SYST:REM", 300);
}
bool IT6000C::local() {
return m_scpi.cmdConfirmed("SYST:LOC", 300);
}
bool IT6000C::reset() {
return m_scpi.cmd("*RST");
}
bool IT6000C::clearStatus() {
return m_scpi.cmd("*CLS");
}
bool IT6000C::opComplete() {
std::string r;
return m_scpi.query("*OPC?", r, 300);
}
bool IT6000C::nextError(std::string& err) {
return m_scpi.query("SYST:ERR?", err, 200);
}
//============================================================================
// 输出
//============================================================================
bool IT6000C::output(bool on) {
return m_scpi.cmd(on ? "OUTP 1" : "OUTP 0");
}
bool IT6000C::queryOutput(bool& on) {
std::string r;
if (!m_scpi.query("OUTP?", r, 200)) return false;
on = (r.find("1") != std::string::npos);
return true;
}
bool IT6000C::clearProtection() {
return m_scpi.cmd("OUTP:PROT:CLE");
}
//============================================================================
// 工作模式
//============================================================================
bool IT6000C::setFunctionCC() {
return m_scpi.cmd("FUNC CURR");
}
bool IT6000C::setFunctionCV() {
return m_scpi.cmd("FUNC VOLT");
}
bool IT6000C::queryFunction(std::string& func) {
return m_scpi.query("FUNC?", func, 200);
}
bool IT6000C::setFunctionModeFixed() {
return m_scpi.cmd("FUNC:MODE FIX");
}
bool IT6000C::queryFunctionMode(std::string& mode) {
return m_scpi.query("FUNC:MODE?", mode, 200);
}
//============================================================================
// 设定值
//============================================================================
bool IT6000C::setDouble(const char* scpi, double v) {
char buf[64];
std::snprintf(buf, sizeof(buf), "%s %.6f", scpi, v);
return m_scpi.cmd(buf);
}
bool IT6000C::setCurrent(double amp) { return setDouble("CURR", amp); }
bool IT6000C::setVoltage(double volt) { return setDouble("VOLT", volt); }
bool IT6000C::setVoltageLimit(double volt){ return setDouble("VOLT:LIM", volt); }
bool IT6000C::setCurrentLimitPos(double amp) { return setDouble("CURR:LIM", amp); }
bool IT6000C::setCurrentLimitNeg(double amp) { return setDouble("CURR:LIM:NEG", amp); }
bool IT6000C::setPowerLimitPos(double watt) { return setDouble("POW:LIM", watt); }
bool IT6000C::setPowerLimitNeg(double watt) { return setDouble("POW:LIM:NEG", watt); }
bool IT6000C::queryCurrent(double& amp) { return queryDouble("CURR?", amp); }
bool IT6000C::queryVoltage(double& volt) { return queryDouble("VOLT?", volt); }
bool IT6000C::queryVoltageLimit(double& volt) { return queryDouble("VOLT:LIM?", volt); }
bool IT6000C::queryCurrentLimitPos(double& amp) { return queryDouble("CURR:LIM?", amp); }
bool IT6000C::queryCurrentLimitNeg(double& amp) { return queryDouble("CURR:LIM:NEG?", amp); }
bool IT6000C::queryPowerLimitPos(double& watt) { return queryDouble("POW:LIM?", watt); }
bool IT6000C::queryPowerLimitNeg(double& watt) { return queryDouble("POW:LIM:NEG?", watt); }
//============================================================================
// 测量
//============================================================================
bool IT6000C::queryDouble(const char* scpi, double& v) {
std::string r;
if (!m_scpi.query(scpi, r, 150)) return false;
if (r.empty()) return false;
char* end = nullptr;
double d = std::strtod(r.c_str(), &end);
if (end == r.c_str()) return false;
v = d;
return true;
}
bool IT6000C::measureVoltage(double& v) { return queryDouble("MEAS:VOLT?", v); }
bool IT6000C::measureCurrent(double& i) { return queryDouble("MEAS:CURR?", i); }
bool IT6000C::measurePower(double& p) { return queryDouble("MEAS:POW?", p); }
bool IT6000C::fetchVoltage(double& v) { return queryDouble("FETCh:VOLT?", v); }
bool IT6000C::fetchCurrent(double& i) { return queryDouble("FETCh:CURR?", i); }
bool IT6000C::fetchPower(double& p) { return queryDouble("FETCh:POW?", p); }
} // namespace eload
src/pELoad/driver/IT6000C.h
+91
View File
@@ -0,0 +1,91 @@
#ifndef PELOAD_IT6000C_H
#define PELOAD_IT6000C_H
#include <string>
#include "ScpiClient.h"
namespace eload {
//============================================================================
// IT6000C：ITECH IT6000C 系列双向可编程直流电源（电子负载）SCPI 命令封装。
//
// 命令来源：docs/电子负载说明手册/IT6000C-Programming-Guide.pdf
// - 双向电源：正电流=输出电能(源)，负电流=吸收电能(负载模拟)；
// - 环路优先模式 FUNC CURR|VOLT：
// CC 优先：按设定电流调节，电压限值用 VOLT:LIM（电流型负载模拟）；
// CV 优先：按设定电压调节，电流限值用 CURR:LIM（恒压吸收）；
// - 功能模式 FUNC:MODE FIX|LIST|BATT|SOLAR|CARProfile：
// 实时功率控制必须保持 FIX，其余为瞬态/波形/电池测试模式；
// - 输出开关 OUTP 0|1；
// - 测量 MEAS:VOLT? / MEAS:CURR? / MEAS:POW?；
// - 远控 SYST:REM（连接后必须先发，否则面板锁定状态不接受设置）。
//============================================================================
struct IT6000CMeas {
double voltage;
double current;
double power;
IT6000CMeas() : voltage(0), current(0), power(0) {}
};
class IT6000C {
public:
explicit IT6000C(ScpiClient& scpi) : m_scpi(scpi) {}
// 基础
bool identify(std::string& idn); // *IDN?
bool remote(); // SYST:REM 进入远控
bool local(); // SYST:LOC 回面板控制
bool reset(); // *RST
bool clearStatus(); // *CLS
bool opComplete(); // *OPC?
bool nextError(std::string& err); // SYST:ERR?
// 输出
bool output(bool on); // OUTP 1|0
bool queryOutput(bool& on); // OUTP?
bool clearProtection(); // OUTP:PROT:CLE
// 工作模式
bool setFunctionCC(); // FUNC CURR（CC 优先，电流型负载模拟）
bool setFunctionCV(); // FUNC VOLT（CV 优先，恒压吸收）
bool queryFunction(std::string& func); // FUNC?
bool setFunctionModeFixed(); // FUNC:MODE FIX（实时控制须保持 FIX）
bool queryFunctionMode(std::string& mode); // FUNC:MODE?
// 设定值
bool setCurrent(double amp); // CURR（正=输出 / 负=吸收）
bool setVoltage(double volt); // VOLT（CV 模式设定值）
bool setVoltageLimit(double volt); // VOLT:LIM（CC 模式电压限值）
bool setCurrentLimitPos(double amp); // CURR:LIM
bool setCurrentLimitNeg(double amp); // CURR:LIM:NEG
bool setPowerLimitPos(double watt); // POW:LIM
bool setPowerLimitNeg(double watt); // POW:LIM:NEG
// 配置回读（程序重启/重连后从设备同步真实状态）
bool queryCurrent(double& amp); // CURR?
bool queryVoltage(double& volt); // VOLT?
bool queryVoltageLimit(double& volt); // VOLT:LIM?
bool queryCurrentLimitPos(double& amp); // CURR:LIM?
bool queryCurrentLimitNeg(double& amp); // CURR:LIM:NEG?
bool queryPowerLimitPos(double& watt); // POW:LIM?
bool queryPowerLimitNeg(double& watt); // POW:LIM:NEG?
// 测量
bool measureVoltage(double& v); // MEAS:VOLT?（触发一次测量，较慢）
bool measureCurrent(double& i); // MEAS:CURR?
bool measurePower(double& p); // MEAS:POW?
// 读取表头缓存测量值（不触发测量，响应快，适合 100ms 轮询）
bool fetchVoltage(double& v); // FETCh:VOLT?
bool fetchCurrent(double& i); // FETCh:CURR?
bool fetchPower(double& p); // FETCh:POW?
private:
bool setDouble(const char* scpi, double v);
bool queryDouble(const char* scpi, double& v);
ScpiClient& m_scpi;
};
} // namespace eload
#endif // PELOAD_IT6000C_H
src/pELoad/driver/ScpiClient.cpp
+437
View File
@@ -0,0 +1,437 @@
#include "ScpiClient.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <poll.h>
#include <unistd.h>
#include <fcntl.h>
#include <cerrno>
#include <cstring>
#include <iostream>
#include <chrono>
#include "MOOS/libMOOS/Utils/MOOSUtilityFunctions.h"
namespace eload {
namespace {
// 非阻塞 connect 超时（ms）
const int kConnectTOms = 2000;
// recv 读超时（s）：保证断线能及时检出、stop() 能及时退出
const int kRecvTimeoutS = 1;
// 连接失败后的重试间隔（ms）
const int kRetryInterval = 2000;
// 单条命令最大长度（防异常数据撑爆缓冲）
const size_t kMaxLineLen = 4096;
} // namespace
ScpiClient::ScpiClient() {
m_buf.reserve(4096);
}
ScpiClient::~ScpiClient() {
stop();
}
void ScpiClient::configure(const std::string& host, long port) {
m_host = host;
m_port = port;
}
void ScpiClient::setLogSink(LogSink cb) {
m_logSink = std::move(cb);
}
void ScpiClient::setStateCallback(StateCallback cb) {
m_stateCb = std::move(cb);
}
bool ScpiClient::start() {
if (m_running) return true;
if (m_host.empty() || m_port <= 0) {
std::cerr << "[ScpiClient] invalid target: " << m_host << ":" << m_port << std::endl;
return false;
}
m_running = true;
m_thread = std::thread([this]() { threadFunc(); });
std::cout << "[ScpiClient] started, target " << m_host << ":" << m_port << std::endl;
return true;
}
void ScpiClient::stop() {
if (!m_running) return;
m_running = false;
if (m_thread.joinable()) m_thread.join();
closeSocket();
}
//----------------------------------------------------------------------
// 连接一次目标（非阻塞 connect + poll 超时）
//----------------------------------------------------------------------
bool ScpiClient::connectOnce() {
m_fd = ::socket(AF_INET, SOCK_STREAM, 0);
if (m_fd < 0) return false;
// 非阻塞 connect，避免目标不可达时线程长时间卡死
int flags = ::fcntl(m_fd, F_GETFL, 0);
::fcntl(m_fd, F_SETFL, flags | O_NONBLOCK);
struct sockaddr_in addr;
std::memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(static_cast<uint16_t>(m_port));
if (::inet_pton(AF_INET, m_host.c_str(), &addr.sin_addr) != 1) {
std::cerr << "[ScpiClient] bad host: " << m_host << std::endl;
closeSocket();
return false;
}
int rc = ::connect(m_fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
if (rc < 0 && errno != EINPROGRESS) {
closeSocket();
return false;
}
if (rc < 0) {
struct pollfd pfd;
pfd.fd = m_fd;
pfd.events = POLLOUT;
int pr = ::poll(&pfd, 1, kConnectTOms);
if (pr <= 0) {
closeSocket();
return false;
}
int err = 0;
socklen_t elen = sizeof(err);
if (::getsockopt(m_fd, SOL_SOCKET, SO_ERROR, &err, &elen) < 0 || err != 0) {
closeSocket();
return false;
}
}
// 恢复阻塞模式 + 读超时 + 禁用 Nagle（100ms 控制环要求低延迟）
::fcntl(m_fd, F_SETFL, flags);
struct timeval tv;
tv.tv_sec = kRecvTimeoutS;
tv.tv_usec = 0;
::setsockopt(m_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
int one = 1;
::setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
m_connected = true;
++m_reconnectCount;
std::cout << "[ScpiClient] connected to " << m_host << ":" << m_port << std::endl;
if (m_stateCb) m_stateCb(true);
return true;
}
void ScpiClient::closeSocket() {
bool was = m_connected.exchange(false);
if (m_fd >= 0) {
::close(m_fd);
m_fd = -1;
}
if (was && m_stateCb) m_stateCb(false);
}
//----------------------------------------------------------------------
// 写一行 SCPI（LF 结尾），全部写出才算成功
//----------------------------------------------------------------------
bool ScpiClient::writeLine(const std::string& scpi) {
std::string frame = scpi;
if (frame.empty() || frame[frame.size() - 1] != '\n')
frame += '\n';
size_t sent = 0;
while (sent < frame.size()) {
ssize_t n = ::send(m_fd, frame.data() + sent, frame.size() - sent, MSG_NOSIGNAL);
if (n > 0) {
sent += static_cast<size_t>(n);
continue;
}
if (n < 0 && errno == EINTR) continue;
std::cerr << "[ScpiClient] send error: " << std::strerror(errno) << std::endl;
return false;
}
++m_txCount;
return true;
}
//----------------------------------------------------------------------
// 读一行（LF 结尾），deadlineMs 内未完成返回 false
//----------------------------------------------------------------------
bool ScpiClient::readLine(std::string& line, int deadlineMs) {
double t0 = MOOSTime(false);
while (m_running) {
// 先检查缓冲中是否已有完整行
for (size_t i = 0; i < m_buf.size(); ++i) {
if (m_buf[i] == '\n') {
line.assign(reinterpret_cast<const char*>(m_buf.data()), i);
m_buf.erase(m_buf.begin(), m_buf.begin() + (i + 1));
if (!line.empty() && line[line.size() - 1] == '\r')
line.erase(line.size() - 1);
++m_rxCount;
m_lastRxTime = MOOSTime(false);
// 收发记录由 runQueue 按“命令-响应”配对后统一回调
return true;
}
}
if (m_buf.size() > kMaxLineLen * 4) {
// 异常数据流，丢弃防止内存膨胀
std::cerr << "[ScpiClient] rx buffer overflow, reset" << std::endl;
m_buf.clear();
return false;
}
int elapsed = static_cast<int>((MOOSTime(false) - t0) * 1000.0);
int remain = deadlineMs - elapsed;
if (remain <= 0) return false;
struct pollfd pfd;
pfd.fd = m_fd;
pfd.events = POLLIN;
int pr = ::poll(&pfd, 1, remain < 20 ? remain : 20);
if (pr < 0) {
if (errno == EINTR) continue;
return false;
}
if (pr == 0) continue;
uint8_t tmp[1024];
ssize_t n = ::recv(m_fd, tmp, sizeof(tmp), 0);
if (n > 0) {
m_buf.insert(m_buf.end(), tmp, tmp + n);
} else if (n == 0) {
std::cerr << "[ScpiClient] connection closed by peer" << std::endl;
return false;
} else {
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) continue;
std::cerr << "[ScpiClient] recv error: " << std::strerror(errno) << std::endl;
return false;
}
}
return false;
}
//----------------------------------------------------------------------
// IO 线程：连接 -> 取队列 -> 写出 ->（查询时）等响应 -> 断线重连
//----------------------------------------------------------------------
void ScpiClient::threadFunc() {
while (m_running) {
if (!m_connected) {
if (!connectOnce()) {
++m_errorCount;
// 分片休眠，保证 stop() 能及时退出
for (int i = 0; i < kRetryInterval / 100 && m_running; ++i) {
struct timespec ts = {0, 100 * 1000 * 1000}; // 100ms
nanosleep(&ts, nullptr);
}
continue;
}
m_buf.clear();
}
runQueue();
if (!m_connected) continue;
// 无命令时短暂让出 CPU（poll 空转兼作断线检测）
struct pollfd pfd;
pfd.fd = m_fd;
pfd.events = POLLIN;
::poll(&pfd, 1, 10);
// 仪器主动上报的数据（一般没有）读出丢弃，防止缓冲堆积
uint8_t tmp[512];
ssize_t n = ::recv(m_fd, tmp, sizeof(tmp), MSG_DONTWAIT);
if (n > 0) {
m_buf.insert(m_buf.end(), tmp, tmp + n);
// 丢弃已完成的行（无查询对应的响应），仅保留可能存在的部分行
size_t lastLF = std::string::npos;
for (size_t i = m_buf.size(); i > 0; --i) {
if (m_buf[i - 1] == '\n') { lastLF = i - 1; break; }
}
if (lastLF != std::string::npos) {
m_buf.erase(m_buf.begin(), m_buf.begin() + (lastLF + 1));
}
} else if (n == 0) {
std::cerr << "[ScpiClient] connection closed by peer" << std::endl;
closeSocket();
} else if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) {
std::cerr << "[ScpiClient] recv error: " << std::strerror(errno) << std::endl;
closeSocket();
}
}
}
void ScpiClient::runQueue() {
while (m_running && m_connected) {
std::shared_ptr<Work> item;
{
std::unique_lock<std::mutex> lock(m_queueMutex);
if (m_queue.empty()) return;
item = m_queue.front();
m_queue.pop_front();
}
if (!writeLine(item->cmd)) {
// 发送失败：命令未送达，标记失败并视为断线
item->ok = false;
item->done = true;
++m_txErrorCount;
if (m_logSink) m_logSink(item->cmd, "<send failed>");
m_queueCv.notify_all();
// 异步回调（IO 线程内，注意不要在锁内调用）
if (item->cb) item->cb(false, "");
closeSocket();
return;
}
if (item->expectReply) {
std::string line;
if (readLine(line, 500)) {
item->resp = line;
item->ok = true;
if (m_logSink) m_logSink(item->cmd, line);
} else {
item->ok = false;
if (m_logSink) m_logSink(item->cmd, m_connected ? "<timeout>" : "<disconnected>");
if (!m_connected) {
item->done = true;
m_queueCv.notify_all();
if (item->cb) item->cb(false, "");
return;
}
}
} else {
item->ok = true;
if (m_logSink) m_logSink(item->cmd, "");
}
item->done = true;
m_queueCv.notify_all();
if (item->cb) item->cb(item->ok, item->resp);
}
}
//----------------------------------------------------------------------
// 对外接口
//----------------------------------------------------------------------
bool ScpiClient::cmd(const std::string& scpi) {
std::shared_ptr<Work> item(new Work());
item->cmd = scpi;
item->expectReply = false;
{
std::lock_guard<std::mutex> lock(m_queueMutex);
if (m_queue.size() >= 64) {
++m_txErrorCount;
return false;
}
m_queue.push_back(item);
}
m_queueCv.notify_all();
return true;
}
bool ScpiClient::cmdConfirmed(const std::string& scpi, int timeoutMs) {
std::shared_ptr<Work> item(new Work());
item->cmd = scpi;
item->expectReply = false;
{
std::lock_guard<std::mutex> lock(m_queueMutex);
if (m_queue.size() >= 64) {
++m_txErrorCount;
return false;
}
m_queue.push_back(item);
}
m_queueCv.notify_all();
// 等待 IO 线程处理完成：done 表示已尝试写入，ok 为写入结果
double t0 = MOOSTime(false);
{
std::unique_lock<std::mutex> lock(m_queueMutex);
while (!item->done) {
int elapsed = static_cast<int>((MOOSTime(false) - t0) * 1000.0);
int remain = timeoutMs - elapsed;
if (remain <= 0) break;
m_queueCv.wait_for(lock, std::chrono::milliseconds(remain < 5 ? 5 : remain));
}
if (!item->done) {
// 超时未处理：从队列移除（若仍存在），防止后续错配
for (std::deque<std::shared_ptr<Work> >::iterator it = m_queue.begin();
it != m_queue.end(); ++it) {
if (*it == item) {
m_queue.erase(it);
break;
}
}
++m_errorCount;
return false;
}
}
if (!item->ok) {
++m_txErrorCount;
return false;
}
return true;
}
bool ScpiClient::query(const std::string& scpi, std::string& resp, int timeoutMs) {
// 同一时刻仅一个同步查询（避免控制线程/网页线程交叉）
std::lock_guard<std::mutex> qlock(m_queryMutex);
std::shared_ptr<Work> item(new Work());
item->cmd = scpi;
item->expectReply = true;
{
std::lock_guard<std::mutex> lock(m_queueMutex);
if (m_queue.size() >= 64) return false;
m_queue.push_back(item);
}
m_queueCv.notify_all();
// 等待完成（含查询响应或失败标记）
double t0 = MOOSTime(false);
{
std::unique_lock<std::mutex> lock(m_queueMutex);
while (!item->done) {
int elapsed = static_cast<int>((MOOSTime(false) - t0) * 1000.0);
int remain = timeoutMs - elapsed;
if (remain <= 0) break;
m_queueCv.wait_for(lock, std::chrono::milliseconds(
remain < 5 ? 5 : remain));
}
if (!item->done) {
// 超时：从队列移除，防止幽灵响应错配
for (std::deque<std::shared_ptr<Work> >::iterator it = m_queue.begin();
it != m_queue.end(); ++it) {
if (*it == item) {
m_queue.erase(it);
break;
}
}
++m_errorCount;
return false;
}
}
if (!item->ok) {
++m_errorCount;
return false;
}
resp = item->resp;
return true;
}
bool ScpiClient::queryAsync(const std::string& scpi, QueryCallback cb) {
std::shared_ptr<Work> item(new Work());
item->cmd = scpi;
item->expectReply = true;
item->cb = std::move(cb);
{
std::lock_guard<std::mutex> lock(m_queueMutex);
if (m_queue.size() >= 64) return false;
m_queue.push_back(item);
}
m_queueCv.notify_all();
return true;
}
} // namespace eload
src/pELoad/driver/ScpiClient.h
+129
View File
@@ -0,0 +1,129 @@
#ifndef PELOAD_SCPI_CLIENT_H
#define PELOAD_SCPI_CLIENT_H
#include <cstdint>
#include <string>
#include <vector>
#include <deque>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <thread>
#include <functional>
namespace eload {
//============================================================================
// ScpiClient：IT6000C Raw Socket SCPI 客户端（TCP，LF 结尾，自动重连）。
//
// 协议要点（docs/电子负载说明手册/IT6000C User Manual-CN 2.5.2.3 使用套接字）：
// - 仪器提供 SCPI 套接字服务（Socket Port 可配置，出厂默认 30000）；
// - 所有命令必须以换行符（\n）结尾；查询响应同样以换行符结束；
// - 仪器最多同时允许 6 个套接字/telnet 连接。
//
// 线程模型：
// - 内部一个 IO 线程：负责连接/重连、命令写出、响应读取；
// - cmd() 非阻塞入队（写后无响应）；
// - query() 同步等待响应（同一时刻仅允许一个查询，互斥保护）；
// - 本线程不调用任何 MOOS 接口，跨线程数据仅通过回调投递。
//============================================================================
class ScpiClient {
public:
// SCPI 收发记录回调（落库用，IO 线程内调用）：
// 命令型：resp 为空；查询型：resp 为响应文本（含失败标记）
using LogSink = std::function<void(const std::string& cmd, const std::string& resp)>;
// 连接状态变化回调（IO 线程内调用）
using StateCallback = std::function<void(bool connected)>;
ScpiClient();
~ScpiClient();
void configure(const std::string& host, long port); // start 前调用
void setLogSink(LogSink cb); // start 前调用
void setStateCallback(StateCallback cb); // start 前调用
bool start(); // 启动 IO 线程（自动连接/重连）
void stop();
bool isConnected() const { return m_connected; }
// 写命令（无响应期待）。未连接/发送失败按错误计数并丢弃。
// 返回 true 仅表示"已入队"，不保证写入成功。
bool cmd(const std::string& scpi);
// 写命令并等待确认：阻塞到 IO 线程真正把命令写入 socket（或超时）。
// 用于需要明确成功/失败反馈的关键指令（如 SYST:REM / SYST:LOC）。
bool cmdConfirmed(const std::string& scpi, int timeoutMs = 300);
// 同步查询：发送 scpi 并等待一行响应。
// timeoutMs 建议不大于控制周期（100ms 循环里建议 <= 80）。
bool query(const std::string& scpi, std::string& resp, int timeoutMs = 200);
// 异步查询：发送 scpi，IO 线程收到响应后调用回调（IO 线程内）。
// 不阻塞调用线程——用于测量轮询，避免拖慢 100ms 功率控制循环。
// 回调注意：运行在 IO 线程，勿直接调用会阻塞的操作。
using QueryCallback = std::function<void(bool ok, const std::string& resp)>;
bool queryAsync(const std::string& scpi, QueryCallback cb);
// 统计
unsigned long txCount() const { return m_txCount; }
unsigned long txErrorCount() const { return m_txErrorCount; }
unsigned long rxCount() const { return m_rxCount; }
unsigned long errorCount() const { return m_errorCount; }
unsigned long reconnectCount() const { return m_reconnectCount; }
double lastRxTime() const { return m_lastRxTime; }
const std::string& host() const { return m_host; }
long port() const { return m_port; }
private:
struct Work {
std::string cmd;
bool expectReply;
std::string resp;
bool done;
bool ok;
QueryCallback cb; // 异步查询回调（IO 线程调用）
Work() : expectReply(false), done(false), ok(false) {}
};
void threadFunc();
bool connectOnce();
void closeSocket();
bool writeLine(const std::string& scpi);
// 从 socket 读一行（LF 结尾），deadlineMs 内未完成返回 false
bool readLine(std::string& line, int deadlineMs);
void runQueue();
std::string m_host;
long m_port = 30000;
int m_fd = -1;
std::atomic<bool> m_running{false};
std::atomic<bool> m_connected{false};
std::thread m_thread;
// 命令队列：cmd() 与 query() 共用；IO 线程逐条处理
std::mutex m_queueMutex;
std::condition_variable m_queueCv;
std::deque<std::shared_ptr<Work> > m_queue;
// 同一时刻仅允许一个同步查询
std::mutex m_queryMutex;
LogSink m_logSink; // 任意线程注册，IO 线程调用（start 前 set）
StateCallback m_stateCb;
std::vector<uint8_t> m_buf; // 流式接收缓冲（半包/粘包按 \n 切分）
std::atomic<unsigned long> m_txCount{0};
std::atomic<unsigned long> m_txErrorCount{0};
std::atomic<unsigned long> m_rxCount{0};
std::atomic<unsigned long> m_errorCount{0};
std::atomic<unsigned long> m_reconnectCount{0};
std::atomic<double> m_lastRxTime{0.0};
};
} // namespace eload
#endif // PELOAD_SCPI_CLIENT_H
src/pELoad/main.cpp
+54
View File
@@ -0,0 +1,54 @@
/************************************************************/
/* NAME: pELoad */
/* FILE: main.cpp */
/************************************************************/
#include <string>
#include "MBUtils.h"
#include "ColorParse.h"
#include "ELoad.h"
#include "ELoad_Info.h"
#include "../pPowerManger/logc/loguru.hpp"
using namespace std;
int main(int argc, char *argv[])
{
loguru::init(argc, argv);
string mission_file;
string run_command = argv[0];
// 默认以程序文件名（去掉路径）作为进程名，保证与 .moos 中 ProcessConfig 匹配
{
size_t slash = run_command.find_last_of('/');
if (slash != string::npos) run_command = run_command.substr(slash + 1);
}
for (int i = 1; i < argc; i++) {
string argi = argv[i];
if ((argi == "-v") || (argi == "--version") || (argi == "-version"))
showReleaseInfoAndExit();
else if ((argi == "-e") || (argi == "--example") || (argi == "-example"))
showExampleConfigAndExit();
else if ((argi == "-h") || (argi == "--help") || (argi == "-help"))
showHelpAndExit();
else if ((argi == "-i") || (argi == "--interface"))
showInterfaceAndExit();
else if (strEnds(argi, ".moos") || strEnds(argi, ".moos++"))
mission_file = argv[i];
else if (strBegins(argi, "--alias="))
run_command = argi.substr(8);
else if (i == 2)
run_command = argi;
}
if (mission_file == "")
showHelpAndExit();
LOG_F(INFO, "pELoad launching as %s", run_command.c_str());
eload::ELoad ELoad;
ELoad.Run(run_command.c_str(), mission_file.c_str());
return 0;
}
src/pELoad/pELoad.moos
+86
View File
@@ -0,0 +1,86 @@
// MOOS file
// pELoad 电子负载（IT6000C 双向可编程直流电源）控制程序 配置示例
//
// 功能：
// - 以太网 Raw Socket SCPI 直连 IT6000C（出厂默认 Socket Port 30000）
// - 100ms 周期功率控制：订阅 MOOS 功率消息（实时电机功率，W），
// 按功率/电压折算电流指令（CC 优先模式，负电流=吸收电能=负载模拟）
// - 网页人机交互（默认 18082 端口）
// - sqlite3 数据存储（eload_log 运行快照 + scpi_log 指令记录）
//
// 设备说明：docs/电子负载说明手册
ServerHost = localhost
ServerPort = 9000
Community = h100
ProcessConfig = pELoad
{
AppTick = 10
CommsTick = 4
//======== 电子负载以太网地址 ========
// 仪器 LAN 配置的 IP 与 Raw Socket 端口号
// （前面板 [Shift]+[P-set] -> System -> I/O -> LAN 查看配置）
eload_ip = 192.168.0.10
eload_port = 30000
//======== 功率控制 ========
// MOOS 功率消息变量名（其他程序发布的实时电机功率，单位 W，
// 正值=电机消耗功率/负载吸收，负值=电机回馈功率/负载释放）
power_var = MOTOR_POWER
// 功率控制周期 ms（需求：100ms）
ctrl_period_ms = 100
// 功率消息超时秒数：超时后目标功率归零（安全），0=不判超时
power_stale_sec = 3
// 电流符号约定：negative=负电流吸收（负载模拟，默认）；
// positive=正电流输出（电源模拟）
current_sign = negative
// 无电压测量反馈时用于功率->电流折算的电压（V），
// 运行后自动改用实测电压（MEAS:VOLT?）
nominal_volt = 500
// 主机侧安全限幅（0=不限；设备侧 POW:LIM/CURR:LIM 为第一道防线）
max_power = 0
max_current = 0
slew_limit_wps = 0
// 使能时下发的设备限值（0=不下发该项）
volt_limit = 0
curr_limit = 0
curr_limit_neg= 0
pow_limit = 0
pow_limit_neg = 0
// 工作模式优先级：cc=CC 优先（负载/电流型），cv=CV 优先
func_priority = cc
// CV 优先时的目标电压(V)，func_priority=cv 时生效（恒压吸收）。
// CC 优先下此项仅作为 VOLT 折算参考，不直接下发。
volt_set = 0
//======== 数据存储 ========
dbpath = pELoad.db
// 历史数据保留时长（小时，0=永久保留；对 eload_log/scpi_log/meas_log 统一生效）
log_keep_hours = 72
// 高采样测量落库周期 ms（默认=控制周期 100ms，实测 V/I/P 全量记录供分析；
// 0=关闭高频记录，仅保留 1Hz 状态快照）
meas_log_period_ms = 100
// 测量命令来源：fetch=FETCh（读设备表头缓存，不触发测量，响应快，推荐）；
// meas=MEAS（每次触发设备重新测量，响应慢）
meas_source = fetch
//======== 网页 ========
// （避开 pCCU 8080 / pPowerManger 8090 / pPowerMangerHost 18080 / pMotor 18081）
web_port = 18082
web_enable = true
logpath = pELoad.log
}
src/pELoad/store/DbStore.cpp
+436
View File
@@ -0,0 +1,436 @@
#include "DbStore.h"
#include "sqlite3.h"
#include <ctime>
#include <sys/time.h>
namespace eload {
namespace {
// 小数秒精度的 unix 时间（与 eload_log 的整秒对齐，供跨表分析）
double nowUnix() {
struct timeval tv;
gettimeofday(&tv, nullptr);
return static_cast<double>(tv.tv_sec) + static_cast<double>(tv.tv_usec) / 1e6;
}
} // namespace
DbStore::DbStore(const std::string& dbPath) : m_dbPath(dbPath) {}
DbStore::~DbStore() {
close();
}
bool DbStore::exec(const char* sql) {
char* err = nullptr;
int rc = sqlite3_exec(m_db, sql, nullptr, nullptr, &err);
if (rc != SQLITE_OK) {
m_lastError = err ? err : "sqlite error";
sqlite3_free(err);
return false;
}
return true;
}
bool DbStore::open() {
if (m_db) return true;
if (sqlite3_open(m_dbPath.c_str(), &m_db) != SQLITE_OK) {
m_lastError = m_db ? sqlite3_errmsg(m_db) : "cannot open db";
sqlite3_close(m_db);
m_db = nullptr;
return false;
}
sqlite3_busy_timeout(m_db, 2000);
exec("PRAGMA journal_mode=WAL;");
exec("PRAGMA synchronous=NORMAL;");
// eload_log：运行状态周期快照
if (!exec(
"CREATE TABLE IF NOT EXISTS eload_log ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" time INTEGER NOT NULL,"
" connected INTEGER NOT NULL,"
" outp INTEGER NOT NULL,"
" mode TEXT NOT NULL,"
" target_power REAL,"
" volt_set REAL,"
" cmd_current REAL,"
" cmd_volt REAL,"
" meas_voltage REAL,"
" meas_current REAL,"
" meas_power REAL,"
" func_mode TEXT,"
" tx_count INTEGER,"
" rx_count INTEGER,"
" tx_err INTEGER"
");")) return false;
exec("CREATE INDEX IF NOT EXISTS idx_eload_log_time ON eload_log(time);");
// scpi_log：非常规 SCPI 收发记录（例行 MEAS 轮询不落库）
if (!exec(
"CREATE TABLE IF NOT EXISTS scpi_log ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" time INTEGER NOT NULL,"
" direction INTEGER NOT NULL," // 0=收 1=发
" text TEXT NOT NULL"
");")) return false;
exec("CREATE INDEX IF NOT EXISTS idx_scpi_log_time ON scpi_log(time);");
// meas_log：高采样测量记录（默认每控制周期 100ms 一条，供波形分析）
if (!exec(
"CREATE TABLE IF NOT EXISTS meas_log ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" time REAL NOT NULL,"
" meas_voltage REAL,"
" meas_current REAL,"
" meas_power REAL,"
" cmd_current REAL,"
" cmd_volt REAL,"
" target_power REAL,"
" outp INTEGER"
");")) return false;
exec("CREATE INDEX IF NOT EXISTS idx_meas_log_time ON meas_log(time);");
// 旧库缺列自动迁移（协议/字段演进后旧数据库可自动补齐）
ensureColumn("eload_log", "volt_set", "REAL");
ensureColumn("eload_log", "cmd_volt", "REAL");
ensureColumn("meas_log", "cmd_volt", "REAL");
return prepareInsert() && prepareMeasInsert() && prepareScpiInsert();
}
// 检查列是否存在，缺失则 ALTER TABLE ADD COLUMN（旧库迁移）
bool DbStore::ensureColumn(const std::string& table, const std::string& col, const std::string& type) {
if (!m_db) return false;
std::string sql = "SELECT COUNT(*) FROM pragma_table_info('" + table + "') WHERE name='" + col + "';";
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK)
return false;
int n = 0;
if (sqlite3_step(stmt) == SQLITE_ROW) n = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
if (n > 0) return true; // 列已存在
std::string alt = "ALTER TABLE " + table + " ADD COLUMN " + col + " " + type + ";";
return exec(alt.c_str());
}
bool DbStore::prepareInsert() {
const char* sql =
"INSERT INTO eload_log (time, connected, outp, mode, target_power, volt_set, "
"cmd_current, cmd_volt, meas_voltage, meas_current, meas_power, func_mode, "
"tx_count, rx_count, tx_err) "
"VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15);";
if (sqlite3_prepare_v2(m_db, sql, -1, &m_stmtInsert, nullptr) != SQLITE_OK) {
m_lastError = sqlite3_errmsg(m_db);
return false;
}
return true;
}
bool DbStore::prepareMeasInsert() {
const char* sql =
"INSERT INTO meas_log (time, meas_voltage, meas_current, meas_power, "
"cmd_current, cmd_volt, target_power, outp) VALUES (?1,?2,?3,?4,?5,?6,?7,?8);";
if (sqlite3_prepare_v2(m_db, sql, -1, &m_stmtMeasInsert, nullptr) != SQLITE_OK) {
m_lastError = sqlite3_errmsg(m_db);
return false;
}
return true;
}
bool DbStore::prepareScpiInsert() {
const char* sql =
"INSERT INTO scpi_log (time, direction, text) VALUES (?1,?2,?3);";
if (sqlite3_prepare_v2(m_db, sql, -1, &m_stmtScpiInsert, nullptr) != SQLITE_OK) {
m_lastError = sqlite3_errmsg(m_db);
return false;
}
return true;
}
void DbStore::close() {
std::lock_guard<std::mutex> lock(m_mutex);
if (m_stmtInsert) {
sqlite3_finalize(m_stmtInsert);
m_stmtInsert = nullptr;
}
if (m_stmtMeasInsert) {
sqlite3_finalize(m_stmtMeasInsert);
m_stmtMeasInsert = nullptr;
}
if (m_stmtScpiInsert) {
sqlite3_finalize(m_stmtScpiInsert);
m_stmtScpiInsert = nullptr;
}
if (m_db) {
sqlite3_close(m_db);
m_db = nullptr;
}
}
void DbStore::insertStatus(bool connected, bool outp, const std::string& mode,
double targetPower, double voltSet,
double cmdCurrent, double cmdVolt,
double measV, double measI, double measP,
const std::string& funcMode,
unsigned long tx, unsigned long rx, unsigned long txErr) {
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_db || !m_stmtInsert) return;
sqlite3_reset(m_stmtInsert);
sqlite3_clear_bindings(m_stmtInsert);
int i = 1;
sqlite3_bind_int64(m_stmtInsert, i++, static_cast<sqlite3_int64>(::time(nullptr)));
sqlite3_bind_int(m_stmtInsert, i++, connected ? 1 : 0);
sqlite3_bind_int(m_stmtInsert, i++, outp ? 1 : 0);
sqlite3_bind_text(m_stmtInsert, i++, mode.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_double(m_stmtInsert, i++, targetPower);
sqlite3_bind_double(m_stmtInsert, i++, voltSet);
sqlite3_bind_double(m_stmtInsert, i++, cmdCurrent);
sqlite3_bind_double(m_stmtInsert, i++, cmdVolt);
sqlite3_bind_double(m_stmtInsert, i++, measV);
sqlite3_bind_double(m_stmtInsert, i++, measI);
sqlite3_bind_double(m_stmtInsert, i++, measP);
sqlite3_bind_text(m_stmtInsert, i++, funcMode.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_int64(m_stmtInsert, i++, static_cast<sqlite3_int64>(tx));
sqlite3_bind_int64(m_stmtInsert, i++, static_cast<sqlite3_int64>(rx));
sqlite3_bind_int64(m_stmtInsert, i++, static_cast<sqlite3_int64>(txErr));
int rc = sqlite3_step(m_stmtInsert);
if (rc != SQLITE_DONE) {
m_lastError = sqlite3_errmsg(m_db);
}
}
void DbStore::insertMeas(double measV, double measI, double measP,
double cmdCurrent, double cmdVolt, double targetPower, bool outp) {
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_db || !m_stmtMeasInsert) return;
sqlite3_reset(m_stmtMeasInsert);
sqlite3_clear_bindings(m_stmtMeasInsert);
sqlite3_bind_double(m_stmtMeasInsert, 1, nowUnix());
sqlite3_bind_double(m_stmtMeasInsert, 2, measV);
sqlite3_bind_double(m_stmtMeasInsert, 3, measI);
sqlite3_bind_double(m_stmtMeasInsert, 4, measP);
sqlite3_bind_double(m_stmtMeasInsert, 5, cmdCurrent);
sqlite3_bind_double(m_stmtMeasInsert, 6, cmdVolt);
sqlite3_bind_double(m_stmtMeasInsert, 7, targetPower);
sqlite3_bind_int(m_stmtMeasInsert, 8, outp ? 1 : 0);
int rc = sqlite3_step(m_stmtMeasInsert);
if (rc != SQLITE_DONE) {
m_lastError = sqlite3_errmsg(m_db);
}
}
void DbStore::insertScpi(int direction, const std::string& text) {
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_db || !m_stmtScpiInsert) return;
sqlite3_reset(m_stmtScpiInsert);
sqlite3_clear_bindings(m_stmtScpiInsert);
sqlite3_bind_int64(m_stmtScpiInsert, 1, static_cast<sqlite3_int64>(::time(nullptr)));
sqlite3_bind_int(m_stmtScpiInsert, 2, direction);
sqlite3_bind_text(m_stmtScpiInsert, 3, text.c_str(), -1, SQLITE_TRANSIENT);
int rc = sqlite3_step(m_stmtScpiInsert);
if (rc != SQLITE_DONE) {
m_lastError = sqlite3_errmsg(m_db);
}
}
std::vector<ELoadLogRow> DbStore::queryRecentStatus(int limit) {
std::lock_guard<std::mutex> lock(m_mutex);
std::vector<ELoadLogRow> rows;
if (!m_db) return rows;
if (limit <= 0) limit = 100;
if (limit > 1000) limit = 1000;
const char* sql =
"SELECT id, time, connected, outp, mode, target_power, volt_set, "
"cmd_current, cmd_volt, meas_voltage, meas_current, meas_power, func_mode, "
"tx_count, rx_count, tx_err "
"FROM eload_log ORDER BY id DESC LIMIT ";
std::string q = sql + std::to_string(limit) + ";";
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, q.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
m_lastError = sqlite3_errmsg(m_db);
return rows;
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
ELoadLogRow r;
r.id = sqlite3_column_int64(stmt, 0);
r.time = sqlite3_column_int64(stmt, 1);
r.connected = sqlite3_column_int(stmt, 2);
r.outp = sqlite3_column_int(stmt, 3);
r.mode = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 4));
r.targetPower = sqlite3_column_double(stmt, 5);
r.voltSet = sqlite3_column_double(stmt, 6);
r.cmdCurrent = sqlite3_column_double(stmt, 7);
r.cmdVolt = sqlite3_column_double(stmt, 8);
r.measVoltage = sqlite3_column_double(stmt, 9);
r.measCurrent = sqlite3_column_double(stmt, 10);
r.measPower = sqlite3_column_double(stmt, 11);
const char* fm = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 12));
r.funcMode = fm ? fm : "";
r.txCount = sqlite3_column_int64(stmt, 13);
r.rxCount = sqlite3_column_int64(stmt, 14);
r.txErr = sqlite3_column_int64(stmt, 15);
rows.push_back(std::move(r));
}
sqlite3_finalize(stmt);
return rows;
}
std::vector<DbStore::ScpiRow> DbStore::queryRecentScpi(int limit) {
std::lock_guard<std::mutex> lock(m_mutex);
std::vector<ScpiRow> rows;
if (!m_db) return rows;
if (limit <= 0) limit = 50;
if (limit > 500) limit = 500;
std::string q = "SELECT id, time, direction, text FROM scpi_log ORDER BY id DESC LIMIT "
+ std::to_string(limit) + ";";
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, q.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
m_lastError = sqlite3_errmsg(m_db);
return rows;
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
ScpiRow r;
r.id = sqlite3_column_int64(stmt, 0);
r.time = sqlite3_column_int64(stmt, 1);
r.direction = sqlite3_column_int(stmt, 2);
const char* t = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 3));
r.text = t ? t : "";
rows.push_back(std::move(r));
}
sqlite3_finalize(stmt);
return rows;
}
long long DbStore::countStatus() const {
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_db) return 0;
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, "SELECT COUNT(*) FROM eload_log;", -1, &stmt, nullptr) != SQLITE_OK)
return 0;
long long n = 0;
if (sqlite3_step(stmt) == SQLITE_ROW) n = sqlite3_column_int64(stmt, 0);
sqlite3_finalize(stmt);
return n;
}
long long DbStore::countScpi() const {
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_db) return 0;
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, "SELECT COUNT(*) FROM scpi_log;", -1, &stmt, nullptr) != SQLITE_OK)
return 0;
long long n = 0;
if (sqlite3_step(stmt) == SQLITE_ROW) n = sqlite3_column_int64(stmt, 0);
sqlite3_finalize(stmt);
return n;
}
long long DbStore::countMeas() const {
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_db) return 0;
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, "SELECT COUNT(*) FROM meas_log;", -1, &stmt, nullptr) != SQLITE_OK)
return 0;
long long n = 0;
if (sqlite3_step(stmt) == SQLITE_ROW) n = sqlite3_column_int64(stmt, 0);
sqlite3_finalize(stmt);
return n;
}
std::vector<MeasRow> DbStore::queryMeas(int limit) {
std::lock_guard<std::mutex> lock(m_mutex);
std::vector<MeasRow> rows;
if (!m_db) return rows;
if (limit <= 0) limit = 200;
if (limit > 5000) limit = 5000;
std::string q = "SELECT id, time, meas_voltage, meas_current, meas_power, "
"cmd_current, cmd_volt, target_power, outp FROM meas_log "
"ORDER BY id DESC LIMIT " + std::to_string(limit) + ";";
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, q.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
m_lastError = sqlite3_errmsg(m_db);
return rows;
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
MeasRow r;
r.id = sqlite3_column_int64(stmt, 0);
r.time = sqlite3_column_double(stmt, 1);
r.measVoltage = sqlite3_column_double(stmt, 2);
r.measCurrent = sqlite3_column_double(stmt, 3);
r.measPower = sqlite3_column_double(stmt, 4);
r.cmdCurrent = sqlite3_column_double(stmt, 5);
r.cmdVolt = sqlite3_column_double(stmt, 6);
r.targetPower = sqlite3_column_double(stmt, 7);
r.outp = sqlite3_column_int(stmt, 8);
rows.push_back(std::move(r));
}
sqlite3_finalize(stmt);
return rows;
}
std::vector<MeasRow> DbStore::queryMeasRange(double startSec, double endSec, int maxRows) {
std::lock_guard<std::mutex> lock(m_mutex);
std::vector<MeasRow> rows;
if (!m_db) return rows;
if (maxRows <= 0) maxRows = 5000;
if (maxRows > 20000) maxRows = 20000;
if (endSec <= startSec) return rows;
std::string q = "SELECT id, time, meas_voltage, meas_current, meas_power, "
"cmd_current, cmd_volt, target_power, outp FROM meas_log "
"WHERE time >= " + std::to_string(startSec) +
" AND time <= " + std::to_string(endSec) +
" ORDER BY id LIMIT " + std::to_string(maxRows) + ";";
sqlite3_stmt* stmt = nullptr;
if (sqlite3_prepare_v2(m_db, q.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
m_lastError = sqlite3_errmsg(m_db);
return rows;
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
MeasRow r;
r.id = sqlite3_column_int64(stmt, 0);
r.time = sqlite3_column_double(stmt, 1);
r.measVoltage = sqlite3_column_double(stmt, 2);
r.measCurrent = sqlite3_column_double(stmt, 3);
r.measPower = sqlite3_column_double(stmt, 4);
r.cmdCurrent = sqlite3_column_double(stmt, 5);
r.cmdVolt = sqlite3_column_double(stmt, 6);
r.targetPower = sqlite3_column_double(stmt, 7);
r.outp = sqlite3_column_int(stmt, 8);
rows.push_back(std::move(r));
}
sqlite3_finalize(stmt);
return rows;
}
long long DbStore::pruneOlderThan(long long cutoff) {
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_db) return -1;
std::string sql = "DELETE FROM eload_log WHERE time < " + std::to_string(cutoff) +
"; DELETE FROM scpi_log WHERE time < " + std::to_string(cutoff) +
"; DELETE FROM meas_log WHERE time < " + std::to_string(cutoff) + ";";
char* err = nullptr;
int rc = sqlite3_exec(m_db, sql.c_str(), nullptr, nullptr, &err);
if (rc != SQLITE_OK) {
m_lastError = err ? err : "sqlite error";
sqlite3_free(err);
return -1;
}
return sqlite3_changes(m_db);
}
} // namespace eload
src/pELoad/store/DbStore.h
+120
View File
@@ -0,0 +1,120 @@
#ifndef PELOAD_DB_STORE_H
#define PELOAD_DB_STORE_H
#include <string>
#include <mutex>
#include <vector>
struct sqlite3;
struct sqlite3_stmt;
namespace eload {
//============================================================================
// DbStore：pELoad SQLite 存储（复用仓库内 sqlite3.c）。
//
// eload_log：运行状态低频快照（1Hz），含连接/输出/模式/限值等状态；
// meas_log ：高采样测量记录（默认每控制周期 100ms 一条），
// 实测电压/电流/功率 + 指令电流/目标功率 —— 供功率波形分析；
// scpi_log ：非常规 SCPI 收发记录（设定/控制/识别/错误查询等，
// 例行的 MEAS 测量轮询不落库，防止表无限膨胀）。
// log_keep_hours 对三张表统一做历史清理。
//============================================================================
struct ELoadLogRow {
long long id;
long long time;
int connected;
int outp;
std::string mode; // follow / manual / current / volt
double targetPower; // 目标功率 W（volt 模式为 0）
double voltSet; // 目标电压 V（volt 模式）
double cmdCurrent; // 指令电流 A
double cmdVolt; // 指令电压 V（volt 模式）
double measVoltage; // 实测电压 V
double measCurrent; // 实测电流 A
double measPower; // 实测功率 W
std::string funcMode; // CURR / VOLT
long long txCount;
long long rxCount;
long long txErr;
};
// 高采样测量记录（meas_log）
struct MeasRow {
long long id;
double time; // unix 时间（秒，带小数）
double measVoltage;
double measCurrent;
double measPower;
double cmdCurrent;
double cmdVolt;
double targetPower;
int outp;
};
class DbStore {
public:
explicit DbStore(const std::string& dbPath);
~DbStore();
bool open();
void close();
bool isOpen() const { return m_db != nullptr; }
std::string lastError() const { return m_lastError; }
// 运行状态快照落库（控制线程周期调用）
void insertStatus(bool connected, bool outp, const std::string& mode,
double targetPower, double voltSet,
double cmdCurrent, double cmdVolt,
double measV, double measI, double measP,
const std::string& funcMode,
unsigned long tx, unsigned long rx, unsigned long txErr);
// 高采样测量落库（每个控制周期调用，meas_log）
void insertMeas(double measV, double measI, double measP,
double cmdCurrent, double cmdVolt, double targetPower, bool outp);
// SCPI 非常规收发落库：text 为 "CMD" 或 "CMD => RESP"（已配对）
// direction: 1=命令 0=查询应答
void insertScpi(int direction, const std::string& text);
// 历史查询（网页展示）
std::vector<ELoadLogRow> queryRecentStatus(int limit);
// 测量查询：limit 条最近记录（倒序）；或指定时间范围（unix 秒）
std::vector<MeasRow> queryMeas(int limit);
std::vector<MeasRow> queryMeasRange(double startSec, double endSec, int maxRows);
struct ScpiRow {
long long id;
long long time;
int direction;
std::string text;
};
std::vector<ScpiRow> queryRecentScpi(int limit);
long long countStatus() const;
long long countScpi() const;
long long countMeas() const;
// 历史清理：删除 time < cutoff 的记录，返回删除行数（<0 表示出错）
long long pruneOlderThan(long long cutoff);
private:
bool exec(const char* sql);
bool ensureColumn(const std::string& table, const std::string& col, const std::string& type);
bool prepareInsert();
bool prepareMeasInsert();
bool prepareScpiInsert();
std::string m_dbPath;
sqlite3* m_db = nullptr;
sqlite3_stmt* m_stmtInsert = nullptr;
sqlite3_stmt* m_stmtMeasInsert = nullptr;
sqlite3_stmt* m_stmtScpiInsert = nullptr;
mutable std::mutex m_mutex;
std::string m_lastError;
};
} // namespace eload
#endif // PELOAD_DB_STORE_H
src/pELoad/web/WebServer.cpp
+155
View File
@@ -0,0 +1,155 @@
#include "WebServer.h"
#include "pages/index.h"
#include "pages/trend.h"
#include <iostream>
namespace eload {
//---------------------------------------------------------
// 事件处理：HTTP 路由 + WebSocket 收发
void WebServer::handleEvent(struct mg_connection* c, int ev, void* ev_data) {
if (ev == MG_EV_HTTP_MSG) {
struct mg_http_message* hm = (struct mg_http_message*)ev_data;
// WebSocket 升级
if (mg_match(hm->uri, mg_str("/ws"), NULL)) {
mg_ws_upgrade(c, hm, NULL);
return;
}
// /api/* 接口：交给宿主程序处理，返回 (Content-Type, body)
std::string path(hm->uri.buf, hm->uri.len);
if (path.rfind("/api/", 0) == 0) {
std::string body, contentType = "application/json";
if (m_apiHandler) {
std::string query(hm->query.buf, hm->query.len);
std::pair<std::string, std::string> r = m_apiHandler(path, query);
body = r.second;
if (!r.first.empty()) contentType = r.first;
}
if (!body.empty()) {
std::string headers = "Content-Type: " + contentType + "\r\n";
mg_http_reply(c, 200, headers.c_str(),
"%.*s", (int)body.size(), body.c_str());
} else {
mg_http_reply(c, 404, "Content-Type: text/plain\r\n", "Not Found\n");
}
return;
}
// 电子负载控制页面
if (path == "/" || path == "/index.html") {
mg_http_reply(c, 200, "Content-Type: text/html; charset=utf-8\r\n",
"%.*s", (int)INDEX_HTML.size(), INDEX_HTML.c_str());
return;
}
// 实时曲线页（独立标签页）
if (path == "/trend" || path == "/trend.html") {
mg_http_reply(c, 200, "Content-Type: text/html; charset=utf-8\r\n",
"%.*s", (int)TREND_HTML.size(), TREND_HTML.c_str());
return;
}
mg_http_reply(c, 404, "Content-Type: text/plain\r\n", "Not Found\n");
} else if (ev == MG_EV_WS_OPEN) {
// Web 线程内：先构建欢迎快照，再登记连接
std::string welcome;
if (m_onOpen) welcome = m_onOpen();
m_wsConnections.push_back(c);
if (!welcome.empty()) {
mg_ws_send(c, welcome.c_str(), welcome.size(), WEBSOCKET_OP_TEXT);
}
} else if (ev == MG_EV_CLOSE || ev == MG_EV_ERROR) {
for (auto it = m_wsConnections.begin(); it != m_wsConnections.end(); ++it) {
if (*it == c) {
m_wsConnections.erase(it);
break;
}
}
} else if (ev == MG_EV_WS_MSG) {
// 忽略客户端消息（控制走 /api/*）
}
}
WebServer::WebServer() {
mg_mgr_init(&m_mgr);
}
WebServer::~WebServer() {
stop();
mg_mgr_free(&m_mgr);
}
void WebServer::setOnOpen(std::function<std::string()> handler) {
m_onOpen = std::move(handler);
}
void WebServer::setApiHandler(std::function<std::pair<std::string, std::string>(const std::string&, const std::string&)> handler) {
m_apiHandler = std::move(handler);
}
bool WebServer::start(int port) {
if (m_running) return true;
m_port = port;
std::string addr = "http://0.0.0.0:" + std::to_string(port);
mg_http_listen(&m_mgr, addr.c_str(), [](mg_connection* c, int ev, void* ev_data) {
WebServer* server = static_cast<WebServer*>(c->fn_data);
if (server) server->handleEvent(c, ev, ev_data);
}, this);
m_running = true;
m_thread = std::thread([this]() { serverThreadFunc(); });
std::cout << "pELoad web UI listening on " << addr << std::endl;
return true;
}
void WebServer::stop() {
if (!m_running) return;
m_running = false;
if (m_thread.joinable()) m_thread.join();
// Web 线程已退出，此处触碰连接列表安全
for (auto c : m_wsConnections) {
mg_ws_send(c, "", 0, WEBSOCKET_OP_CLOSE);
}
m_wsConnections.clear();
}
bool WebServer::serverThreadCB(void* pParam) {
WebServer* pThis = static_cast<WebServer*>(pParam);
return pThis->serverThreadFunc();
}
bool WebServer::serverThreadFunc() {
while (m_running) {
mg_mgr_poll(&m_mgr, 200);
// 仅在本线程（poll 间隙）发送，避免跨线程操作 mongoose 连接
flushPending();
}
return true;
}
void WebServer::flushPending() {
std::string text;
{
std::lock_guard<std::mutex> lock(m_pendingMutex);
text = std::move(m_pending);
m_pending.clear();
}
if (text.empty()) return;
for (auto c : m_wsConnections) {
mg_ws_send(c, text.c_str(), text.size(), WEBSOCKET_OP_TEXT);
}
}
void WebServer::broadcast(const std::string& text) {
// 只投递到队列，实际发送在 Web 线程 flushPending() 中完成
std::lock_guard<std::mutex> lock(m_pendingMutex);
m_pending = text;
}
} // namespace eload
src/pELoad/web/WebServer.h
+55
View File
@@ -0,0 +1,55 @@
#ifndef PELOAD_WEB_SERVER_H
#define PELOAD_WEB_SERVER_H
#define UNIX
#include "mongoose.h"
#include <string>
#include <functional>
#include <vector>
#include <mutex>
#include <atomic>
#include <thread>
namespace eload {
class WebServer {
public:
WebServer();
~WebServer();
bool start(int port);
void stop();
bool isRunning() const { return m_running; }
// 向所有 WebSocket 客户端广播文本
// 线程安全：mongoose 非线程安全，本接口只把文本放入待发队列，
// 由 Web 线程在 mg_mgr_poll 返回后统一发送（禁止跨线程直接 mg_ws_send）
void broadcast(const std::string& text);
// 新客户端连接时调用，返回初始快照
void setOnOpen(std::function<std::string()> handler);
// 处理 /api/* 请求：返回 (Content-Type, body)。
// 默认内容类型 application/json；文本/CSV 接口由处理器自行指定。
void setApiHandler(std::function<std::pair<std::string, std::string>(const std::string& uri, const std::string& query)> handler);
private:
static bool serverThreadCB(void* pParam);
bool serverThreadFunc();
void handleEvent(struct mg_connection* c, int ev, void* ev_data);
void flushPending();
struct mg_mgr m_mgr;
int m_port = 0;
std::atomic<bool> m_running{false};
std::thread m_thread;
std::mutex m_pendingMutex;
std::string m_pending; // latest snapshot to broadcast
std::vector<mg_connection*> m_wsConnections; // web thread only
std::function<std::string()> m_onOpen;
std::function<std::pair<std::string, std::string>(const std::string&, const std::string&)> m_apiHandler;
};
} // namespace eload
#endif // PELOAD_WEB_SERVER_H
src/pELoad/web/pages/index.h
+605
View File
@@ -0,0 +1,605 @@
#ifndef PELOAD_PAGE_INDEX_H
#define PELOAD_PAGE_INDEX_H
#include <string>
//============================================================================
// pELoad 电子负载控制页面（纯前端，内嵌 HTML）。
//
// 操作顺序（防误触 + 步骤引导）：
// ① 连接设备（链路绿 → 步骤2 可操作）
// ② 设置参数（选环路优先 CC/CV → 控制模式/目标量 → 限值）
// ③ 开启输出（确认后下发使能序列）
// 所有下发的指令均带确认对话框；按钮按当前状态禁用。
//
// 关键设计：页面为静态骨架（输入框/按钮是稳定 DOM，永不重建），
// render() 只按 id 更新动态数值/状态/按钮禁用 —— 输入框聚焦编辑时
// 不受 1Hz 快照刷新影响，光标稳定、输入流畅（setInput 聚焦时不覆盖）。
//
// 模式说明：
// CC 优先（电流型负载模拟）：控制量 = 电流，功率折算 I=P/U，可跟随 MOOS
// 功率 / 手动功率 / 手动电流；
// CV 优先（恒压吸收）：控制量 = 电压（VOLT），功率由外部源决定。
// FUNC:MODE 必须保持 FIX（实时功率控制前提），非 FIX 时页面红色告警。
//
// 设备说明：docs/电子负载说明手册（IT6000C 双向可编程直流电源）
//============================================================================
namespace eload {
const std::string INDEX_HTML = R"HTML(<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>pELoad 电子负载控制</title>
<style>
:root{--bg:#0f1420;--card:#1a2130;--line:#2a3447;--fg:#e6edf3;--dim:#8b98ab;--ok:#2ea043;--warn:#d29922;--bad:#f85149;--blue:#1f6feb;}
*{margin:0;padding:0;box-sizing:border-box;}
body{background:var(--bg);color:var(--fg);font-family:'Segoe UI',system-ui,sans-serif;font-size:13px;padding:16px;padding-bottom:60px;}
h1{font-size:18px;margin-bottom:12px;display:flex;align-items:center;gap:10px;flex-wrap:wrap;}
h2{font-size:13px;color:var(--dim);text-transform:uppercase;letter-spacing:.5px;margin-bottom:10px;border-bottom:1px solid var(--line);padding-bottom:6px;}
.badge{font-size:11px;padding:2px 8px;border-radius:10px;background:var(--card);border:1px solid var(--line);white-space:nowrap;}
.badge.ok{color:var(--ok);border-color:var(--ok);}
.badge.warn{color:var(--warn);border-color:var(--warn);}
.badge.err{color:var(--bad);border-color:var(--bad);}
.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(340px,1fr));gap:12px;}
.card{background:var(--card);border:1px solid var(--line);border-radius:8px;padding:12px;}
.row{display:flex;justify-content:space-between;padding:3px 0;border-bottom:1px dashed #222c3d;gap:12px;}
.row:last-child{border-bottom:none;}
.row .k{color:var(--dim);flex-shrink:0;}
.row .v{font-family:Consolas,monospace;color:var(--fg);text-align:right;}
.sub{font-size:11px;color:#79c0ff;margin:10px 0 2px;border-bottom:1px solid #22304a;padding-bottom:2px;}
.btn{padding:6px 14px;margin:0 8px 8px 0;border:1px solid var(--line);border-radius:6px;background:#222b3d;color:var(--fg);font-size:12px;cursor:pointer;}
.btn:hover:not(:disabled){border-color:#3b4a63;}
.btn:disabled{opacity:.35;cursor:not-allowed;}
.btn.on{background:#1f6feb;border-color:#1f6feb;color:#fff;font-weight:600;}
.btn.off{background:#3d2226;border-color:#f85149;color:#f85149;}
.btn.warn{background:#3a2e12;border-color:var(--warn);color:var(--warn);}
.btn.big{padding:10px 22px;font-size:14px;}
.btn.sel{background:var(--blue);border-color:var(--blue);color:#fff;font-weight:600;}
input[type=number],input[type=text]{width:120px;background:#0f1420;border:1px solid var(--line);border-radius:6px;color:var(--fg);font-family:Consolas,monospace;padding:5px 8px;font-size:13px;}
input:focus{outline:none;border-color:var(--blue);}
input:disabled{opacity:.4;}
.inline{display:flex;align-items:center;gap:8px;margin-bottom:8px;flex-wrap:wrap;}
.inline label{color:var(--dim);}
.dim{color:var(--dim);}
.errline{color:var(--bad);font-family:Consolas,monospace;font-size:12px;word-break:break-all;}
.okline{color:var(--ok);font-family:Consolas,monospace;font-size:12px;word-break:break-all;}
table{width:100%;border-collapse:collapse;font-size:11px;font-family:Consolas,monospace;}
th,td{padding:3px 6px;border-bottom:1px solid #222c3d;text-align:right;white-space:nowrap;}
th{color:var(--dim);font-weight:400;}
td.l,th.l{text-align:left;}
#status{color:var(--dim);font-size:12px;}
/* 顶部状态条 */
#topbar{display:flex;align-items:center;gap:8px;flex-wrap:wrap;background:var(--card);border:1px solid var(--line);border-radius:8px;padding:8px 12px;margin-bottom:12px;}
#topbar .sep{width:1px;height:20px;background:var(--line);margin:0 6px;}
/* 操作顺序步骤条 */
.steps{display:flex;align-items:center;gap:6px;background:var(--card);border:1px solid var(--line);border-radius:8px;padding:10px 12px;margin-bottom:12px;flex-wrap:wrap;}
.step{display:flex;align-items:center;gap:6px;padding:5px 12px;border-radius:16px;border:1px solid var(--line);color:var(--dim);font-size:12px;}
.step .n{width:18px;height:18px;border-radius:50%;background:#2a3447;color:var(--fg);display:flex;align-items:center;justify-content:center;font-size:11px;font-weight:700;}
.step.done{border-color:var(--ok);color:var(--ok);}
.step.done .n{background:var(--ok);color:#fff;}
.step.active{border-color:var(--blue);color:#fff;font-weight:600;}
.step.active .n{background:var(--blue);color:#fff;}
.step.err{border-color:var(--bad);color:var(--bad);}
.step.err .n{background:var(--bad);color:#fff;}
.sarrow{color:var(--dim);}
.tip{font-size:11px;color:var(--dim);line-height:1.5;}
.tip b{color:#79c0ff;}
.bigstat{font-size:24px;font-weight:700;font-family:Consolas,monospace;text-align:center;padding:10px 0;}
.bigstat.on{color:var(--ok);}
.bigstat.off{color:var(--dim);}
.bigstat.wait{color:var(--warn);}
.meas{display:grid;grid-template-columns:repeat(3,1fr);gap:8px;text-align:center;margin-bottom:8px;}
.meas .v{font-size:24px;font-family:Consolas,monospace;}
.meas .k{color:var(--dim);font-size:11px;}
.fixwarn{background:rgba(248,81,73,.15);border:1px solid var(--bad);color:var(--bad);border-radius:6px;padding:6px 10px;font-size:12px;margin-bottom:8px;}
</style>
</head>
<body>
<div id="topbar">
<h1 style="margin:0">pELoad 电子负载控制</h1>
<span id="status" class="badge">加载中...</span>
<span class="sep"></span>
<span id="badgeLink" class="badge err">未连接</span>
<span id="badgeOutp" class="badge err">输出关</span>
<span id="badgeMode" class="badge">模式 -</span>
<span style="flex:1"></span>
<a class="btn" href="/trend" target="_blank">📈 实时曲线</a>
</div>
<div class="steps" id="steps">
<div class="step" id="step1"><span class="n">1</span>连接设备</div>
<span class="sarrow">▸</span>
<div class="step" id="step2"><span class="n">2</span>设置参数</div>
<span class="sarrow">▸</span>
<div class="step" id="step3"><span class="n">3</span>开启输出</div>
<span style="flex:1"></span>
<span class="tip" id="stepTip"></span>
</div>
<div class="grid" id="pages">
<!--======== 卡1：以太网链路 ========-->
<div class="card">
<h2>① 连接设备 · 以太网链路</h2>
<div class="row"><span class="k">设备地址</span><span class="v" id="linkAddr">-</span></div>
<div class="row"><span class="k">连接状态</span><span class="v" id="linkConn">未连接</span></div>
<div class="row"><span class="k">自动重连</span><span class="v" id="linkAuto">-</span></div>
<div class="row"><span class="k">重连次数</span><span class="v" id="linkReconn">-</span></div>
<div class="row"><span class="k">收发统计</span><span class="v" id="linkStats">-</span></div>
<div class="row"><span class="k">最近收帧</span><span class="v" id="linkLastRx">-</span></div>
<div class="row"><span class="k">设备识别 *IDN?</span><span class="v" id="linkIdn">未识别</span></div>
<div class="errline" id="linkError" style="display:none"></div>
<div class="sub">操作（指令均需确认）</div>
<button id="btnConnect" class="btn on" onclick="sendCmd('connect',null,'确认连接电子负载？')">连接</button>
<button id="btnDisconnect" class="btn off" onclick="sendCmd('disconnect',null,'确认断开以太网链路？\n断开前会先关闭输出。')">断开</button>
<button id="btnIdentify" class="btn" onclick="sendCmd('identify')">识别 (*IDN?)</button>
<button id="btnClearProt" class="btn warn" onclick="sendCmd('clear_protect',null,'确认清除输出保护锁定？')">清保护</button>
<button id="btnReset" class="btn off" onclick="sendCmd('reset_dev',null,'确认复位设备 (*RST)？\n所有设定将恢复默认！')">复位设备</button>
</div>
<!--======== 卡2：当前状态 + 实时测量 ========-->
<div class="card">
<h2>当前状态 · 实时测量</h2>
<div class="bigstat off" id="bigOutp">输出关</div>
<div class="fixwarn" id="fixWarn" style="display:none"></div>
<div class="meas">
<div><div class="v" style="color:#79c0ff" id="measV">-</div><div class="k">电压 V</div></div>
<div><div class="v" style="color:#3fb950" id="measI">-</div><div class="k">电流 A</div></div>
<div><div class="v" style="color:#d29922" id="measP">-</div><div class="k">功率 W</div></div>
</div>
<div class="row"><span class="k">数据时效</span><span class="v" id="measAge">-</span></div>
<div class="row"><span class="k">测量查询</span><span class="v" id="measDiag">-</span></div>
<div class="errline" id="measDiagErr" style="display:none"></div>
<div class="row"><span class="k">环路优先(回读)</span><span class="v" id="devFunc">-</span></div>
<div class="row"><span class="k">功能模式(回读)</span><span class="v" id="devFuncMode">-</span></div>
<div class="row"><span class="k">设备配置同步</span><span class="v" id="cfgSync">-</span></div>
<div class="row"><span class="k">切换结果</span><span class="v" id="funcModeFeed">-</span></div>
<div class="sub">功能模式切换（FUNC:MODE）</div>
<div class="inline">
<select id="funcModeSel">
<option value="FIX">FIX 固定输出（实时控制）</option>
<option value="LIST">LIST 列表波形</option>
<option value="BATT">BATT 电池测试</option>
<option value="SOLAR">SOLAR 光伏曲线</option>
<option value="CAR">CAR 汽车波形</option>
</select>
<button id="btnFuncMode" class="btn" onclick="switchFuncMode()">切换功能模式</button>
</div>
<div class="tip" id="funcModeTip">实时功率控制必须保持 <b>FIX</b>。切换到 LIST/BATT/SOLAR/CAR 后，输出将按该模式自主运行，脱离本程序的实时功率控制（页面会红色告警），需切回 FIX 恢复。</div>
</div>
<!--======== 卡3：参数与输出控制 ========-->
<div class="card">
<h2>②③ 参数与输出控制</h2>
<div class="sub">环路优先模式（决定控制量类型）</div>
<button id="btnModeCC" class="btn sel" onclick="sendCmd('mode_cc',null,'确认切换为 CC 优先（电流型负载，功率折算 I=P/U）？')">CC 优先</button>
<button id="btnModeCV" class="btn sel" onclick="sendCmd('mode_cv',null,'确认切换为 CV 优先（恒压吸收，按电压控制）？')">CV 优先</button>
<div class="tip" id="ctrlTip"></div>
<div id="ccArea">
<div class="sub">控制模式（目标来源）</div>
<button id="btnModeFollow" class="btn" onclick="sendCmd('mode_follow',null,'确认切换为跟随 MOOS 功率消息（实时电机功率）？')">跟随MOOS</button>
<button id="btnModeManual" class="btn" onclick="sendCmd('mode_manual',null,'确认切换为手动功率？')">手动功率</button>
<button id="btnModeCurrent" class="btn" onclick="sendCmd('mode_current',null,'确认切换为手动电流？')">手动电流</button>
<div class="tip" id="curModeTip"></div>
<div class="inline"><label>功率 (W)</label>
<input type="number" id="powerInput" step="1" value="0">
<button id="btnSetPower" class="btn" onclick="sendFromInput('set_power','powerInput','手动目标功率','W')">设定功率</button></div>
<div class="inline"><label>电流 (A, 负=吸收)</label>
<input type="number" id="currInput" step="0.1" value="0">
<button id="btnSetCurr" class="btn" onclick="sendFromInput('set_current','currInput','手动电流','A')">设定电流</button></div>
<div class="row"><span class="k">MOOS 功率消息</span><span class="v" id="moosPower">-</span></div>
<div class="row"><span class="k">指令电流 CURR</span><span class="v" id="cmdCurrent">-</span></div>
<div class="row"><span class="k">符号约定</span><span class="v" id="signTip">-</span></div>
</div>
<div id="cvArea" style="display:none">
<div class="inline"><label>目标电压 (V)</label>
<input type="number" id="voltInput" step="1" value="0">
<button id="btnSetVolt" class="btn" onclick="sendFromInput('set_volt','voltInput','CV 目标电压','V')">设定电压</button></div>
<div class="row"><span class="k">指令电压 VOLT</span><span class="v" id="cmdVolt">-</span></div>
<div class="tip">恒压吸收：设备维持该电压，吸收电流由外部源决定；功率大小请以实测为准。</div>
</div>
<div class="sub">输出控制</div>
<button id="btnOutpOn" class="btn big on" onclick="sendCmd('outp_on',null,'确认开启输出？\n电子负载将按当前设定开始吸收电能！')">▶ 开启输出</button>
<button id="btnOutpOff" class="btn big off" onclick="sendCmd('outp_off',null,'确认关闭输出？\n电子负载停止吸收电能。')">■ 关闭输出</button>
<div class="tip" id="outpTip"></div>
</div>
<!--======== 卡4：设备参数与限值 ========-->
<div class="card">
<h2>设备参数（限值下发）</h2>
<div class="tip">限值在输出开启时统一下发，修改后需“关闭输出→重新开启”生效（或在运行中直接下发，设备实时响应）。</div>
<div class="inline"><label>电压限值 VOLT:LIM (V)</label>
<input type="number" id="voltlimInput" step="1" value="0">
<button id="btnSetVoltlim" class="btn" onclick="sendFromInput('set_voltlim','voltlimInput','电压限值','V')">下发</button></div>
<div class="inline"><label>电流限值 CURR:LIM (A)</label>
<input type="number" id="currlimInput" step="0.1" value="0">
<button id="btnSetCurrlim" class="btn" onclick="sendFromInput('set_currlimit','currlimInput','电流限值','A')">下发</button></div>
<div class="inline"><label>功率限值 POW:LIM (W)</label>
<input type="number" id="powlimInput" step="10" value="0">
<button id="btnSetPowlim" class="btn" onclick="sendFromInput('set_powlimit','powlimInput','功率限值','W')">下发</button></div>
<div class="sub">远控 / 本控</div>
<div class="row"><span class="k">当前控制端</span><span class="v" id="remoteState">-</span></div>
<div class="row"><span class="k">最近指令结果</span><span class="v" id="remoteFeed">-</span></div>
<div class="tip">IT6000C 无远控状态查询命令，此状态按最近一次远控/本控指令的发送结果推断；若面板被手动按回本控，需重新发送“远控”。</div>
<button id="btnRemote" class="btn" onclick="sendCmd('remote',null,'确认进入远控模式 (SYST:REM)？\n面板按键将被锁定。')">远控 SYST:REM</button>
<button id="btnLocal" class="btn warn" onclick="sendCmd('local',null,'确认切回面板本控 (SYST:LOC)？\n输出将关闭且远控失效。')">本控 SYST:LOC</button>
</div>
<!--======== 卡5：SCPI 调试 ========-->
<div class="card">
<h2>SCPI 调试（高级）</h2>
<div class="inline"><input type="text" id="rawCmd" style="flex:1;min-width:180px" placeholder="例如: *IDN? 或 VOLT:LIM? MAX" />
<button id="btnRawSend" class="btn" onclick="sendRaw()">发送</button></div>
<div class="sub">最近响应</div>
<div class="okline" id="rawResp">-</div>
<div class="sub">非常规 SCPI 收发记录 (sqlite scpi_log)</div>
<div id="scpiLog" style="max-height:200px;overflow:auto"><span class="dim">点击“刷新记录”加载</span></div>
<button class="btn" onclick="loadScpiLog()">刷新记录</button>
</div>
<!--======== 卡6：数据分析 ========-->
<div class="card">
<h2>数据分析 (高采样 meas_log)</h2>
<div class="row"><span class="k">测量记录条数</span><span class="v" id="measCount">-</span></div>
<div class="tip">实测电压/电流/功率按控制周期（默认 100ms）落库，用于功率波形分析。可预览最近数据或导出 CSV 离线分析（Excel/Python）。</div>
<div class="sub">最近数据预览</div>
<div id="measPreview" style="max-height:220px;overflow:auto"><span class="dim">点击“加载预览”</span></div>
<button class="btn" onclick="loadMeas()">加载预览 (最近50条)</button>
<button class="btn" onclick="downloadMeasCsv()">导出 CSV (最近2000条)</button>
<div class="sub">按时间范围导出（unix 秒）</div>
<div class="inline"><label>起始</label><input type="number" id="csvStart" step="1" placeholder="起始 unix 秒">
<label>结束</label><input type="number" id="csvEnd" step="1" placeholder="结束 unix 秒">
<button class="btn" onclick="downloadMeasRange()">按范围导出</button></div>
</div>
<!--======== 卡7：历史记录 ========-->
<div class="card">
<h2>历史记录 (sqlite eload_log, 1Hz)</h2>
<div class="row"><span class="k">记录总数</span><span class="v" id="statusCount">-</span></div>
<div id="history" style="max-height:240px;overflow:auto"><span class="dim">点击“查询”加载</span></div>
<button class="btn" onclick="loadHistory()">查询最近 60 条</button>
</div>
</div>
<script>
const $ = id => document.getElementById(id);
const statusEl = $('status');
function ageText(a){
if(typeof a !== 'number' || a < 0) return '从未';
if(a < 90) return a.toFixed(1)+' 秒前';
if(a < 3600) return Math.floor(a/60)+' 分 '+Math.floor(a%60)+' 秒前';
return Math.floor(a/3600)+' 时 '+Math.floor((a%3600)/60)+' 分前';
}
function ageCell(d, key){
if(!d || !d[key+'Valid']) return '<span class="dim">从未</span>';
const online = d[key+'Age'] < 3;
return (online ? '<span style="color:var(--ok)">' : '<span style="color:var(--bad)">')
+ ageText(d[key+'Age']) + (online ? ' (在线)' : ' (超时)') + '</span>';
}
function fmt(v, n){ return (typeof v === 'number') ? v.toFixed(n===undefined?2:n) : '-'; }
//------------------ 指令下发（全部带确认，防误触） ------------------
// 链路: 网页 fetch -> pELoad 入队 -> 控制线程(100ms) -> SCPI -> IT6000C
function sendCmd(action, value, confirmMsg){
if(confirmMsg && !confirm(confirmMsg)) return;
let url = '/api/eload_cmd?action='+action;
if(value !== undefined && value !== null) url += '&value='+value;
fetch(url)
.then(r => r.json())
.then(j => {
if(j.ok){ if(action!=='identify') statusEl.textContent = '已下发: '+action; }
else alert('下发失败: '+(j.error||'未知错误'));
})
.catch(() => alert('网络错误，指令未下发'));
}
function sendRaw(){
const cmd = $('rawCmd').value.trim();
if(!cmd){ alert('请输入 SCPI 命令'); return; }
if(!confirm('确认发送原始 SCPI 指令：\n'+cmd+'\n\n原始指令不做任何校验，请谨慎操作！')) return;
fetch('/api/eload_cmd?action=raw&cmd='+encodeURIComponent(cmd))
.then(r => r.json())
.then(j => {
$('rawResp').textContent = j.ok ? (j.response || '(无响应)') : ('错误: '+(j.error||''));
if(j.ok && j.response) loadScpiLog();
})
.catch(() => { $('rawResp').textContent = '网络错误'; });
}
// 从输入框取数并下发（带确认）
function sendFromInput(action, inputId, label, unit){
const v = parseFloat($(inputId).value);
if(isNaN(v)){ alert('请输入有效数值'); return; }
sendCmd(action, v, '确认设定'+label+' = '+v+' '+unit+' ？');
}
// 功能模式切换（带确认 + 脱离实时控制警告）
function switchFuncMode(){
const sel = $('funcModeSel');
const m = sel.value;
if(m === 'FIX'){
if(!confirm('确认切换为 FIX（固定输出）？\n将恢复本程序的实时功率控制。')) return;
} else {
if(!confirm('确认切换到 '+m+' 模式？\n\n⚠ 该模式会脱离本程序的实时功率控制，\n输出将按 '+m+' 的模式自主运行！\n请确保已理解风险后再确认。')) return;
}
fetch('/api/eload_cmd?action=func_mode&mode='+m)
.then(r => r.json())
.then(j => {
if(j.ok) statusEl.textContent = '已下发: func_mode '+m;
else alert('下发失败: '+(j.error||'未知错误'));
})
.catch(() => alert('网络错误，指令未下发'));
}
//------------------ 渲染（WebSocket 1Hz 快照，仅按 id 更新，不重建 DOM）------------------
let lastSnap = null;
// 设置输入框值：用户聚焦编辑中不覆盖（保证输入流畅、光标稳定）
function setInput(id, v){
const el = $(id);
if(!el) return;
if(document.activeElement === el) return;
const str = (v === undefined || v === null) ? '' : String(v);
if(el.value !== str) el.value = str;
}
function setDisabled(id, cond){ const el = $(id); if(el) el.disabled = !!cond; }
function render(s){
lastSnap = s;
const link = s.link || {}, ctrl = s.ctrl || {}, dev = s.dev || {}, db = s.db || {};
const connected = !!link.connected, cc = !!ctrl.ccPriority;
const loadOn = !!ctrl.loadOn, outpApplied = !!ctrl.outpApplied;
const modeName = {follow:'跟随 MOOS 功率', manual:'手动功率', current:'手动电流', volt:'恒压吸收'};
const powerStale = ctrl.moosPowerValid && ctrl.moosPowerAge > (ctrl.staleSec||0);
const now = Date.now() / 1000;
//---- 顶部状态条 ----
statusEl.textContent = connected ? '已连接 '+link.host+':'+link.port : '未连接';
statusEl.className = 'badge ' + (connected ? 'ok' : 'err');
$('badgeLink').textContent = '链路: ' + (connected ? '已连接' : '未连接');
$('badgeLink').className = 'badge ' + (connected ? 'ok' : 'err');
$('badgeOutp').textContent = '输出: ' + (outpApplied ? '开' : (loadOn ? '待开' : '关'));
$('badgeOutp').className = 'badge ' + (outpApplied ? 'ok' : (loadOn ? 'warn' : 'err'));
$('badgeMode').textContent = '模式: ' + (cc ? 'CC优先' : 'CV优先') + ' · ' + (modeName[ctrl.mode]||ctrl.mode);
$('badgeMode').className = 'badge' + (dev.funcModeFixWarn ? ' err' : '');
//---- 步骤条 ----
let curStep = 1, tipText = '';
if(!connected){ curStep = 1; tipText = '请先连接设备（步骤1）'; }
else if(!outpApplied){ curStep = 2; tipText = '设置环路优先/控制模式与限值（步骤2），然后开启输出（步骤3）'; }
else { curStep = 3; tipText = '输出已开启，正在进行实时功率控制'; }
if(dev.funcModeFixWarn) tipText = '!! FUNC:MODE 非 FIX，实时控制失效 !!';
$('step1').className = 'step ' + (connected ? 'done' : 'active');
$('step2').className = 'step ' + (outpApplied ? 'done' : (curStep===2 ? 'active' : ''));
$('step3').className = 'step ' + (outpApplied ? 'done active' : '');
$('stepTip').innerHTML = tipText;
//---- 卡1：链路 ----
$('linkAddr').textContent = link.host + ':' + link.port;
$('linkConn').innerHTML = connected
? '<span style="color:var(--ok)">已连接</span>'
: '<span style="color:var(--bad)">未连接</span>';
$('linkAuto').textContent = link.enabled ? '开启' : '关闭';
$('linkReconn').textContent = link.reconnects;
$('linkStats').textContent = 'tx='+link.tx+' rx='+link.rx+' txErr='+link.txErr;
$('linkLastRx').innerHTML = ageCell(link, 'lastRx');
$('linkIdn').innerHTML = link.idn || '<span class="dim">未识别</span>';
$('linkError').style.display = link.lastError ? '' : 'none';
$('linkError').textContent = link.lastError || '';
setDisabled('btnConnect', connected);
setDisabled('btnDisconnect', !connected);
setDisabled('btnIdentify', !connected);
setDisabled('btnClearProt', !connected);
setDisabled('btnReset', !connected);
//---- 卡2：状态 + 测量 ----
const bo = $('bigOutp');
bo.textContent = outpApplied ? '输出开' : (loadOn ? '待应用' : '输出关');
bo.className = 'bigstat ' + (outpApplied ? 'on' : (loadOn ? 'wait' : 'off'));
const fw = $('fixWarn');
if(dev.funcModeFixWarn){
fw.style.display = '';
fw.innerHTML = 'FUNC:MODE = '+(dev.funcMode||'?')+'（非 FIX）——实时功率控制已失效！请复位或手动恢复 FIX。';
} else fw.style.display = 'none';
$('measV').textContent = fmt(dev.measV, 2);
$('measI').textContent = fmt(dev.measI, 3);
$('measP').textContent = fmt(dev.measP, 1);
$('measAge').innerHTML = 'V '+ageCell(dev,'measV')+' · I '+ageCell(dev,'measI')+' · P '+ageCell(dev,'measP');
$('measDiag').innerHTML = '成功 <span style="color:var(--ok)">'+dev.measOk+'</span> · 失败 <span style="color:'+(dev.measFail>0?'var(--bad)':'var(--dim)')+'">'+dev.measFail+'</span>';
const mde = $('measDiagErr');
if(dev.lastMeasErr){
mde.style.display = '';
mde.textContent = dev.lastMeasErr;
} else mde.style.display = 'none';
$('devFunc').textContent = dev.func || '-';
const fmName = (dev.funcMode || '').trim();
$('devFuncMode').innerHTML = fmName
? '<b style="font-size:15px">' + fmName + '</b>'
+ (dev.funcModeFixWarn ? ' <span class="badge err">非FIX</span>' : ' <span class="badge ok">FIX</span>')
: '<span class="dim">回读中...</span>';
const cfs = $('cfgSync');
if(dev.cfgSynced){
cfs.innerHTML = '<span style="color:var(--ok)">已同步</span>（'+ageText(now - dev.cfgSyncTime)+'）';
} else {
cfs.innerHTML = '<span style="color:var(--warn)">同步中…</span>';
}
const fmf = $('funcModeFeed');
if(dev.funcModeFeedValid){
const ok = dev.funcModeFeedOk ? '已发送成功' : '发送失败（未连接或超时）';
fmf.textContent = dev.funcModeFeed + '：' + ok + '（'+ageText(now - dev.funcModeFeedTime)+'）';
fmf.style.color = dev.funcModeFeedOk ? 'var(--ok)' : 'var(--bad)';
} else { fmf.textContent = '-'; fmf.style.color = ''; }
setDisabled('btnFuncMode', !connected);
setDisabled('funcModeSel', !connected);
// 下拉框同步当前设备功能模式（仅当未聚焦时）
const fmsel = $('funcModeSel');
if(document.activeElement !== fmsel && dev.funcMode){
const opts = ['FIX','LIST','BATT','SOLAR','CAR'];
const idx = opts.indexOf(dev.funcMode);
if(idx >= 0 && fmsel.selectedIndex !== idx) fmsel.selectedIndex = idx;
}
//---- 卡3：控制 ----
setDisabled('btnModeCC', !connected || cc);
setDisabled('btnModeCV', !connected || !cc);
$('ctrlTip').innerHTML = cc
? '<b>CC 优先</b>：控制量 = 电流。目标功率/电流 → CURR 指令（负值=吸收电能）。'
: '<b>CV 优先</b>：控制量 = 电压。恒压吸收，功率由外部源决定。';
$('ccArea').style.display = cc ? '' : 'none';
$('cvArea').style.display = cc ? 'none' : '';
setDisabled('btnModeFollow', !connected || ctrl.mode==='follow');
setDisabled('btnModeManual', !connected || ctrl.mode==='manual');
setDisabled('btnModeCurrent', !connected || ctrl.mode==='current');
$('curModeTip').innerHTML = '当前：<b>'+(modeName[ctrl.mode]||ctrl.mode)+'</b>';
setInput('powerInput', ctrl.manualPower || 0);
setInput('currInput', ctrl.manualCurrent || 0);
setInput('voltInput', ctrl.voltSet || 0);
setDisabled('btnSetPower', !connected);
setDisabled('btnSetCurr', !connected);
setDisabled('btnSetVolt', !connected);
setDisabled('powerInput', !connected);
setDisabled('currInput', !connected);
setDisabled('voltInput', !connected);
$('moosPower').innerHTML = (ctrl.moosPowerValid
? fmt(ctrl.moosPower,1)+' W ('+ageText(ctrl.moosPowerAge)+')'
: '<span class="dim">未收到</span>')
+ (powerStale ? ' <span class="badge err">超时!</span>' : '');
$('cmdCurrent').textContent = fmt(ctrl.cmdCurrent,4) + ' A';
$('signTip').textContent = ctrl.sign==='negative' ? '负电流=吸收(负载模拟)' : '正电流=输出(电源模拟)';
$('cmdVolt').textContent = fmt(ctrl.cmdVolt,2) + ' V';
setDisabled('btnOutpOn', !connected || loadOn);
setDisabled('btnOutpOff', !connected || !loadOn);
$('outpTip').innerHTML = outpApplied
? '<b style="color:var(--ok)">输出已开启</b>，正在实时控制'
: (loadOn ? '<b style="color:var(--warn)">已请求开启，等待使能序列应用…</b>'
: '输出未开启，开启前请完成步骤②参数设置');
//---- 卡4：参数 ----
setInput('voltlimInput', dev.voltLimit || 0);
setInput('currlimInput', dev.currLimit || 0);
setInput('powlimInput', dev.powLimit || 0);
setDisabled('voltlimInput', !connected);
setDisabled('currlimInput', !connected);
setDisabled('powlimInput', !connected);
setDisabled('btnSetVoltlim', !connected);
setDisabled('btnSetCurrlim', !connected);
setDisabled('btnSetPowlim', !connected);
setDisabled('btnRemote', !connected);
setDisabled('btnLocal', !connected);
const rs = $('remoteState');
rs.textContent = dev.remoteState==='remote' ? '远控（SCPI 控制中）'
: dev.remoteState==='local' ? '本控（面板控制）' : '未知';
rs.style.color = dev.remoteState==='remote' ? 'var(--ok)'
: dev.remoteState==='local' ? 'var(--warn)' : 'var(--dim)';
const rf = $('remoteFeed');
rf.textContent = dev.remoteFeedValid
? dev.remoteFeed + '（'+ageText(now - dev.remoteFeedTime)+'）'
: '-';
const feedFail = (dev.remoteFeed||'').indexOf('失败') >= 0;
rf.style.color = feedFail ? 'var(--bad)' : '';
rf.style.fontFamily = feedFail ? 'Consolas,monospace' : '';
//---- 卡5：SCPI ----
setDisabled('btnRawSend', !connected);
setDisabled('rawCmd', !connected);
//---- 卡6/7：数据 ----
$('measCount').textContent = db.measCount;
$('statusCount').textContent = db.statusCount + ' / SCPI ' + db.scpiCount;
}
//------------------ 数据分析（高采样测量 meas_log） ------------------
function loadMeas(){
fetch('/api/meas?limit=50')
.then(r => r.json())
.then(j => {
const rows = j.rows || [];
let html = '<table><tr><th>时间</th><th class="l">V</th><th class="l">I(A)</th>'
+ '<th class="l">P(W)</th><th class="l">指令I</th><th class="l">指令V</th><th class="l">目标P</th><th>输出</th></tr>';
for(let i=0;i<rows.length;i++){
const r = rows[i];
const t = new Date(r.time*1000).toLocaleTimeString('zh-CN', {hour12:false}) + '.' + Math.floor((r.time%1)*1000);
html += '<tr><td class="l">'+t+'</td><td class="l">'+fmt(r.v,2)+'</td><td class="l">'+fmt(r.i,3)+'</td>'
+ '<td class="l">'+fmt(r.p,1)+'</td><td class="l">'+fmt(r.cmdI,3)+'</td><td class="l">'+fmt(r.cmdV,1)+'</td>'
+ '<td class="l">'+fmt(r.targetP,1)+'</td>'
+ '<td>'+(r.outp?1:0)+'</td></tr>';
}
$('measPreview').innerHTML = rows.length ? html : '<span class="dim">暂无数据</span>';
})
.catch(() => { $('measPreview').innerHTML = '<span class="errline">查询失败</span>'; });
}
function downloadMeasCsv(){
if(!confirm('导出最近 2000 条测量记录 (CSV) 用于离线分析？')) return;
window.location.href = '/api/meas_csv?limit=2000';
}
function downloadMeasRange(){
const st = parseFloat($('csvStart').value), et = parseFloat($('csvEnd').value);
if(isNaN(st) || isNaN(et)){ alert('请输入有效的起始/结束 unix 秒'); return; }
if(et <= st){ alert('结束时间必须大于起始时间'); return; }
if(!confirm('导出时间范围 ['+st+' ~ '+et+'] 的测量记录 (CSV)？')) return;
window.location.href = '/api/meas_csv?start='+st+'&end='+et;
}
function loadHistory(){
fetch('/api/history?limit=60')
.then(r => r.json())
.then(j => {
const rows = j.rows || [];
let html = '<table><tr><th>时间</th><th>连</th><th>输出</th><th class="l">模式</th>'
+ '<th>目标W</th><th>目标V</th><th>指令A</th><th>指令V</th><th>V</th><th>A</th><th>W</th></tr>';
for(let i=0;i<rows.length;i++){
const r = rows[i];
const t = new Date(r.time*1000).toLocaleTimeString();
html += '<tr><td class="l">'+t+'</td><td>'+(r.connected?1:0)+'</td><td>'+(r.outp?1:0)+'</td>'
+ '<td class="l">'+r.mode+'</td><td>'+fmt(r.targetPower,1)+'</td><td>'+fmt(r.voltSet,0)+'</td>'
+ '<td>'+fmt(r.cmdCurrent,3)+'</td><td>'+fmt(r.cmdVolt,1)+'</td>'
+ '<td>'+fmt(r.measVoltage,1)+'</td><td>'+fmt(r.measCurrent,3)+'</td><td>'+fmt(r.measPower,1)+'</td></tr>';
}
html += '</table>';
$('history').innerHTML = rows.length ? html : '<span class="dim">暂无记录</span>';
})
.catch(() => { $('history').innerHTML = '<span class="errline">查询失败</span>'; });
}
function loadScpiLog(){
fetch('/api/scpi_log?limit=50')
.then(r => r.json())
.then(j => {
const rows = j.rows || [];
let html = '<table><tr><th>时间</th><th class="l">收/发</th><th class="l">内容</th></tr>';
for(let i=0;i<rows.length;i++){
const r = rows[i];
const t = new Date(r.time*1000).toLocaleTimeString();
const dir = r.dir ? '<span style="color:#79c0ff">发</span>' : '<span style="color:#3fb950">收</span>';
html += '<tr><td class="l">'+t+'</td><td class="l">'+dir+'</td><td class="l">'+r.text+'</td></tr>';
}
html += '</table>';
$('scpiLog').innerHTML = rows.length ? html : '<span class="dim">暂无记录</span>';
})
.catch(() => { $('scpiLog').innerHTML = '<span class="errline">查询失败</span>'; });
}
//------------------ WebSocket 1Hz 快照 ------------------
let ws = null, wsTimer = null;
function connectWs(){
const proto = location.protocol === 'https:' ? 'wss://' : 'ws://';
ws = new WebSocket(proto + location.host + '/ws');
ws.onopen = () => { statusEl.textContent = '已连接'; statusEl.className = 'badge ok'; };
ws.onmessage = e => {
try { render(JSON.parse(e.data)); } catch(err) {}
};
ws.onclose = () => {
statusEl.textContent = '连接断开, 重连中...';
statusEl.className = 'badge err';
wsTimer = setTimeout(connectWs, 2000);
};
ws.onerror = () => ws.close();
}
connectWs();
</script>
</body>
</html>)HTML";
} // namespace eload
#endif // PELOAD_PAGE_INDEX_H
src/pELoad/web/pages/trend.h
+199
View File
@@ -0,0 +1,199 @@
#ifndef PELOAD_PAGE_TREND_H
#define PELOAD_PAGE_TREND_H
#include <string>
//============================================================================
// pELoad 实时曲线页（独立标签页）。
//
// - 通过 WebSocket /ws 接收 5Hz 快照，绘制电压/电流/功率三条实时曲线；
// - 可从 /api/meas（100ms 高采样 meas_log）加载历史数据回填；
// - 纯前端 canvas 绘制，无外部依赖。
//============================================================================
namespace eload {
const std::string TREND_HTML = R"HTML(<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>pELoad 实时曲线</title>
<style>
:root{--bg:#0f1420;--card:#1a2130;--line:#2a3447;--fg:#e6edf3;--dim:#8b98ab;--blue:#58a6ff;--green:#3fb950;--orange:#d29922;}
*{margin:0;padding:0;box-sizing:border-box;}
body{background:var(--bg);color:var(--fg);font-family:'Segoe UI',system-ui,sans-serif;font-size:13px;padding:14px;}
h1{font-size:17px;margin-bottom:10px;display:flex;align-items:center;gap:10px;flex-wrap:wrap;}
.badge{font-size:11px;padding:2px 8px;border-radius:10px;background:var(--card);border:1px solid var(--line);}
.badge.ok{color:var(--green);border-color:var(--green);}
.badge.err{color:#f85149;border-color:#f85149;}
.panel{background:var(--card);border:1px solid var(--line);border-radius:8px;padding:10px;margin-bottom:10px;}
.panel h2{font-size:12px;color:var(--dim);text-transform:uppercase;letter-spacing:.5px;margin-bottom:6px;}
.panel h2 .now{float:right;font-size:15px;font-family:Consolas,monospace;color:var(--fg);text-transform:none;}
canvas{width:100%;height:180px;display:block;background:#0b1018;border:1px solid #22304a;border-radius:4px;}
.controls{display:flex;align-items:center;gap:8px;margin-bottom:10px;flex-wrap:wrap;}
.controls select{background:#0f1420;border:1px solid var(--line);border-radius:6px;color:var(--fg);padding:4px 8px;}
.btn{padding:5px 14px;border:1px solid var(--line);border-radius:6px;background:#222b3d;color:var(--fg);font-size:12px;cursor:pointer;}
.btn:hover{border-color:#3b4a63;}
#status{color:var(--dim);font-size:12px;}
</style>
</head>
<body>
<h1>pELoad 实时曲线 <span id="status" class="badge">连接中...</span>
<span style="flex:1"></span>
<a class="btn" href="/" target="_blank">控制页面</a>
</h1>
<div class="controls">
<span style="color:var(--dim)">时间窗口</span>
<select id="winSel">
<option value="30">30 秒</option>
<option value="60" selected>60 秒</option>
<option value="120">120 秒</option>
<option value="300">300 秒 (5分钟)</option>
<option value="600">600 秒 (10分钟)</option>
</select>
<button class="btn" onclick="loadHistory()">加载历史数据 (最近窗口)</button>
<span style="color:var(--dim)" id="info">采样: 0 点</span>
</div>
<div class="panel"><h2>电压 V <span class="now" id="nowV" style="color:var(--blue)">-</span></h2><canvas id="cvV"></canvas></div>
<div class="panel"><h2>电流 A <span class="now" id="nowI" style="color:var(--green)">-</span></h2><canvas id="cvI"></canvas></div>
<div class="panel"><h2>功率 W <span class="now" id="nowP" style="color:var(--orange)">-</span></h2><canvas id="cvP"></canvas></div>
<script>
const $ = id => document.getElementById(id);
const statusEl = $('status');
const MAXPTS = 8000;
// 数据缓冲：{t: ms时间戳, v, i, p}
const data = [];
let winSec = 60;
// 裁剪到时间窗口
function trim(){
const cutoff = Date.now() - winSec*1000;
while(data.length && data[0].t < cutoff) data.shift();
if(data.length > MAXPTS) data.splice(0, data.length - MAXPTS);
$('info').textContent = '采样: ' + data.length + ' 点';
}
function draw(canvas, key, color){
const ctx = canvas.getContext('2d');
const W = canvas.width = canvas.clientWidth * (window.devicePixelRatio||1);
const H = canvas.height = 180 * (window.devicePixelRatio||1);
ctx.scale(window.devicePixelRatio||1, window.devicePixelRatio||1);
const w = canvas.clientWidth, h = 180;
ctx.fillStyle = '#0b1018'; ctx.fillRect(0,0,w,h);
// 纵向范围（动态，含 0）
let min = 0, max = 0, has = false;
for(const p of data){
const v = p[key];
if(!isFinite(v)) continue;
if(!has){ min = max = v; has = true; }
else { if(v<min)min=v; if(v>max)max=v; }
}
if(!has){ min = 0; max = 1; }
const pad = (max-min)*0.15 || 1;
min -= pad; max += pad;
if(max <= min){ max = min+1; }
// 网格（横向 5 条 + 纵向约 10 格）
ctx.strokeStyle = '#1c2740'; ctx.lineWidth = 1;
for(let i=0;i<=5;i++){
const y = (h-8) - (h-16) * (i/5) + 4;
ctx.beginPath(); ctx.moveTo(0,y); ctx.lineTo(w,y); ctx.stroke();
}
const tstep = winSec/10;
for(let i=0;i<=10;i++){
const x = (w-4) * (i/10) + 2;
ctx.beginPath(); ctx.moveTo(x,4); ctx.lineTo(x,h-4); ctx.stroke();
}
// 曲线
ctx.strokeStyle = color; ctx.lineWidth = 1.6;
ctx.beginPath();
let started = false;
const nowT = Date.now();
for(const p of data){
const x = 2 + (w-4) * (1 - (nowT - p.t)/ (winSec*1000));
const y = 4 + (h-16) * (1 - (p[key]-min)/(max-min));
if(x < -10) continue;
if(!started){ ctx.moveTo(x,y); started = true; }
else ctx.lineTo(x,y);
}
ctx.stroke();
// Y 轴刻度（最大值/最小值标注）
ctx.fillStyle = color;
ctx.font = '11px Consolas,monospace';
ctx.textAlign = 'left';
ctx.fillText(max.toFixed(max>100?0:1), 4, 14);
ctx.textAlign = 'right';
ctx.fillText(min.toFixed(min>100?0:1), w-4, h-6);
}
function redraw(){
trim();
draw($('cvV'), 'v', '#58a6ff');
draw($('cvI'), 'i', '#3fb950');
draw($('cvP'), 'p', '#d29922');
}
// 实时快照（WebSocket 5Hz）
function onSnapshot(s){
const d = s.dev || {};
if(!d.measVValid && !d.measIValid && !d.measPValid) return;
const t = Date.now();
data.push({t, v:d.measV, i:d.measI, p:d.measP});
$('nowV').textContent = d.measV.toFixed(2);
$('nowI').textContent = d.measI.toFixed(3);
$('nowP').textContent = d.measP.toFixed(1);
redraw();
}
// 历史数据加载（/api/meas 时间范围查询，覆盖整个窗口）
function loadHistory(){
const nowSec = Date.now()/1000;
const start = nowSec - winSec;
$('info').textContent = '加载历史...';
const url = '/api/meas?start=' + start.toFixed(3) + '&end=' + nowSec.toFixed(3) + '&limit=20000';
fetch(url).then(r=>r.json()).then(j => {
const arr = j.rows || []; // 时间升序
if(!arr.length){ $('info').textContent = '暂无历史数据'; return; }
const nowMs = Date.now();
data.length = 0;
for(let i=0;i<arr.length;i++){
const r = arr[i];
data.push({t: nowMs - (nowSec - r.time)*1000, v:r.v, i:r.i, p:r.p});
}
const last = arr[arr.length-1];
$('nowV').textContent = last.v.toFixed(2);
$('nowI').textContent = last.i.toFixed(3);
$('nowP').textContent = last.p.toFixed(1);
redraw();
$('info').textContent = '已加载 ' + arr.length + ' 条历史';
}).catch(()=>{ $('info').textContent = '历史加载失败'; });
}
$('winSel').addEventListener('change', function(){ winSec = parseInt(this.value,10); redraw(); });
// WebSocket 5Hz 快照
let ws=null, wsTimer=null;
function connectWs(){
const proto = location.protocol==='https:'?'wss://':'ws://';
ws = new WebSocket(proto + location.host + '/ws');
ws.onopen = () => { statusEl.textContent='已连接'; statusEl.className='badge ok'; };
ws.onmessage = e => { try{ onSnapshot(JSON.parse(e.data)); }catch(err){} };
ws.onclose = () => { statusEl.textContent='连接断开, 重连中...'; statusEl.className='badge err';
wsTimer = setTimeout(connectWs, 2000); };
ws.onerror = () => ws.close();
}
connectWs();
// 初始加载历史（有数据时立即有曲线）
loadHistory();
</script>
</body>
</html>)HTML";
} // namespace eload
#endif // PELOAD_PAGE_TREND_H
src/pELoad/需求.txt
+8
View File
@@ -0,0 +1,8 @@
本程序用于整个能源-动力系统中的电子负载控制，具备以下功能/需求
1.通过以太网与docs/电子负载说明手册中的电子负载连接，并可以进行基本的控制、操作、参数设定等
2.具备100ms周期的功率控制能力，后续有其他程序会通过MOOSDB发布功率消息，改功率消息为实施计算的电机功率，通过电子负载模拟电机功率的变化
3.使用web页面进行人机交互
4.具备sqlit3的数据存储功能
5.使用moos文件进行配置电子负载地址、端口等信息
电子负载的详细操作及指令见docs/电子负载说明手册中的文件
src/pMotor/web/pages/index.h
+148 -110
View File
@@ -12,6 +12,9 @@
// （fetch /api/motor_cmd -> pMotor 入队 -> MOOS CAN_TX -> pCanBridge -> CAN1）
// - 展示：反馈转速/母线电压、温度、支路一/支路二故障与报警（按位解析中文）
// - 协议定义：docs/推进电机通信协议20260321.docx
//
// 重要：页面 DOM 只在加载时构建一次，收到快照后仅就地更新各数值叶节点，
// 绝不再整块重建 pages（重建会销毁正被聚焦/输入的控件导致光标跳动）。
//============================================================================
namespace motor {
@@ -56,7 +59,7 @@ input[type=number]:focus{outline:none;border-color:#1f6feb;}
</head>
<body>
<h1>pMotor 推进电机控制 <span id="status" class="badge">连接中...</span></h1>
<div class="grid" id="pages">加载中...</div>
<div class="grid" id="pages"></div>
<script>
const $ = id => document.getElementById(id);
@@ -65,7 +68,6 @@ const statusEl = $('status');
function row(k, v){ return '<div class="row"><span class="k">'+k+'</span><span class="v">'+v+'</span></div>'; }
function sub(t){ return '<div class="sub">'+t+'</div>'; }
function hex(v){ return '0x' + (v & 0xFF).toString(16).toUpperCase().padStart(2,'0'); }
function hex16(v){ return '0x' + (v & 0xFFFF).toString(16).toUpperCase().padStart(4,'0'); }
function card(title, html){ return '<div class="card"><h2>'+title+'</h2>'+html+'</div>'; }
function ageText(a){
@@ -80,6 +82,8 @@ function ageCell(d){
return (online ? '<span class="fc-ok">' : '<span class="fc-bad">')
+ ageText(d.age) + (online ? ' (在线)' : ' (超时)') + '</span>';
}
// 就地更新：只替换叶节点内容，绝不重建含输入控件的父级 DOM
function setH(id, html){ const el = $(id); if(el) el.innerHTML = html; }
//------------------ 控制指令（/api/motor_cmd） ------------------
// 链路: 网页 fetch -> pMotor 入队 -> Iterate 周期编码 0x18EF2010
@@ -117,135 +121,172 @@ function motorSetSpeed(){
sendCmd('speed', v, '确认设定期望转速 '+v+' rpm？\n（对应指令帧 Byte2/3，使能状态保持不变）');
}
//------------------ 控制卡片 ------------------
function cmdCard(s){
const c = s || {};
const cmd = c.cmd || {};
const en = cmd.enable;
let h = '';
h += row('使能状态', en
? '<span class="fc-ok">已使能（运行）</span>'
: '<span style="color:var(--dim)">未使能（停机）</span>');
h += row('期望转速', (cmd.speed||0) + ' rpm');
h += row('复位命令', cmd.resetActive ? '<span class="fc-warn">生效中（保持数秒）</span>' : '无效');
if(cmd.lastCmdValid){
const names = {enable:'使能命令=1', disable:'使能命令=0(停机)', reset:'复位命令=1', speed:'期望转速'};
h += row('最近指令', (names[cmd.lastCmdAction]||cmd.lastCmdAction)
+ (cmd.lastCmdAction==='speed' ? ' ('+(cmd.lastCmdSpeed||0)+' rpm)' : '')
+ ' · ' + ageText(cmd.lastCmdAge));
} else {
h += row('最近指令', '<span style="color:var(--dim)">无</span>');
}
h += '<div class="sub">使能命令 (Byte0 bit0)</div>' +
//------------------ 页面骨架（只在加载时构建一次） ------------------
// 所有可被聚焦的控件（输入框/按钮）都在这份骨架里，之后绝不重建。
function buildUI(){
let html = '';
// 控制卡片（含输入框，永不重建）
let c = '';
c += row('使能状态', '<span id="cEnable">…</span>');
c += row('期望转速', '<span id="cSpeed">…</span> rpm');
c += row('复位命令', '<span id="cReset">…</span>');
c += row('最近指令', '<span id="cLast">…</span>');
c += sub('使能命令 (Byte0 bit0)') +
'<div>' +
'<button class="btn on" onclick="motorEnable()">使能 (1)</button>' +
'<button class="btn off" onclick="motorStop()">去使能 (0)</button></div>' +
'<div class="sub">复位命令 (Byte0 bit1，仅故障状态下有效)</div>' +
'<div>' +
'<button class="btn warn" onclick="motorReset()">复位</button></div>' +
'<div class="sub">期望转速 (Byte2/3，s16，单位 rpm)</div>' +
'<button class="btn off" onclick="motorStop()">去使能 (0)</button></div>';
c += sub('复位命令 (Byte0 bit1，仅故障状态下有效)') +
'<div><button class="btn warn" onclick="motorReset()">复位</button></div>';
c += sub('期望转速 (Byte2/3，s16，单位 rpm)') +
'<div>' +
'<input type="number" id="speedInput" value="1000" min="-32767" max="32767" step="100" title="期望转速 (rpm)">' +
'<span style="color:var(--dim);margin-left:6px;">rpm</span> ' +
'<button class="btn" onclick="motorSetSpeed()">设定</button></div>' +
'<div class="sub" style="margin-top:8px;">指令帧 0x18EF2010 周期 ' + ((c.link&&c.link.periodMs)||500) +
'ms 持续发送（协议要求）；停机=使能0且转速清0（协议示例 00 00 00 00 00 00 00 00）</div>';
return card('电机指令 (下行 0x18EF2010)', h);
'<div class="sub" style="margin-top:8px;">指令帧 0x18EF2010 周期 <span id="cPeriod">…</span>' +
' ms 持续发送（协议要求）；停机=使能0且转速清0（协议示例 00 00 00 00 00 00 00 00）</div>';
html += card('电机指令 (下行 0x18EF2010)', c);
// 运行状态（状态帧3：转速 / 母线电压）
let s3 = '';
s3 += row('反馈转速', '<span id="s3speed" class="state-big">…</span> rpm');
s3 += row('母线电压', '<span id="s3volt">…</span>');
s3 += row('最后更新', '<span id="s3age">…</span>');
s3 += sub('来源 0x18EF1220（100ms，冗余 0x18EF1221）');
html += card('运行状态', s3);
// 温度（状态帧4）
let s4 = '';
s4 += row('A相绕组温度', '<span id="tA">…</span>');
s4 += row('B相绕组温度', '<span id="tB">…</span>');
s4 += row('C相绕组温度', '<span id="tC">…</span>');
s4 += row('逆变组件底板温度', '<span id="tInv">…</span>');
s4 += row('输出滤波器温度', '<span id="tFilter">…</span>');
s4 += row('筒内空气温度', '<span id="tAir">…</span>');
s4 += row('最后更新', '<span id="tAge">…</span>');
s4 += sub('来源 0x18EF1320（100ms，冗余 0x18EF1321，Byte0~5 各 1 字节 s8）');
html += card('温度', s4);
// 支路一 / 支路二 故障报警卡片
function branchCard(title, pfx){
let b = '';
b += '<div class="row"><span class="k" id="'+pfx+'fK">故障</span>' +
'<span class="v"><span id="'+pfx+'faults">…</span></span></div>';
b += '<div class="row"><span class="k" id="'+pfx+'aK">报警</span>' +
'<span class="v"><span id="'+pfx+'alarms">…</span></span></div>';
b += row('故障字原始值', '<span id="'+pfx+'words">…</span>');
b += row('最后更新', '<span id="'+pfx+'age">…</span>');
return card(title, b);
}
html += branchCard('支路一故障/报警 (0x18EF1020)', 'f1');
html += branchCard('支路二故障/报警 (0x18EF1120)', 'f2');
// 通信链路卡片
let l = '';
l += row('下行通道 (CAN1)', '<span id="lch">…</span>');
l += row('冗余通道', '<span id="lred">…</span>');
l += row('指令帧周期', '<span id="lperiod">…</span> ms');
l += row('指令帧累计', '<span id="ltx">…</span>');
l += row('最近下发', '<span id="llast">…</span>');
l += row('电机报文接收', '<span id="lrx">…</span> 帧');
l += sub('链路: 电机 <-> CAN1 <-> CANET <-> pCanBridge <-> MOOS <-> pMotor');
html += card('通信链路 (pCanBridge)', l);
// 协议参考卡片（纯静态）
let p = '';
p += row('0x18EF2010', '主控指令帧（下行 500ms，冗余 0x18EF2011）');
p += row('0x18EF2110', '主控限制帧（下行，全预留，暂不使用）');
p += row('0x18EF1020', '支路一故障报警状态帧1（上行 200ms，冗余 0x18EF1021）');
p += row('0x18EF1120', '支路二故障报警状态帧2（上行 200ms，冗余 0x18EF1121）');
p += row('0x18EF1220', '状态帧3：反馈转速/母线电压（上行 100ms，冗余 0x18EF1221）');
p += row('0x18EF1320', '状态帧4：温度（上行 100ms，冗余 0x18EF1321）');
p += row('帧格式', 'CAN2.0B 扩展帧 29 位 ID，数据域 8 字节，Intel 字节序');
p += row('波特率', '250 kbps（默认，按客户可定制 125~1000）');
html += card('报文定义 (推进电机通信协议 20260321)', p);
pagesEl.innerHTML = html;
}
//------------------ 状态帧3：转速 / 母线电压 ------------------
function state3Card(d){
if(!d) return '';
let h = '';
h += row('反馈转速', '<span class="state-big">'+(d.valid?(d.speed||0):'—')+'</span> rpm');
h += row('母线电压', (d.valid?(d.voltage||0):'—') + (d.valid?' V':''));
h += row('最后更新', ageCell(d));
h += sub('来源 0x18EF1220（100ms，冗余 0x18EF1221）');
return card('运行状态', h);
//------------------ 快照就地更新（不触碰输入控件） ------------------
function updateCmd(c){
c = c || {};
setH('cEnable', c.enable
? '<span class="fc-ok">已使能（运行）</span>'
: '<span style="color:var(--dim)">未使能（停机）</span>');
setH('cSpeed', String(c.speed || 0));
setH('cReset', c.resetActive ? '<span class="fc-warn">生效中（保持数秒）</span>' : '无效');
if(c.lastCmdValid){
const names = {enable:'使能命令=1', disable:'使能命令=0(停机)', reset:'复位命令=1', speed:'期望转速'};
setH('cLast', (names[c.lastCmdAction] || c.lastCmdAction)
+ (c.lastCmdAction==='speed' ? ' ('+(c.lastCmdSpeed||0)+' rpm)' : '')
+ ' · ' + ageText(c.lastCmdAge));
} else {
setH('cLast', '<span style="color:var(--dim)">无</span>');
}
}
//------------------ 状态帧4：温度 ------------------
function state4Card(d){
if(!d) return '';
const v = d.valid;
let h = '';
function updateState3(d){
if(!d) return;
setH('s3speed', d.valid ? String(d.speed || 0) : '—');
setH('s3volt', d.valid ? ((d.voltage||0) + ' V') : '—');
setH('s3age', ageCell(d));
}
function updateState4(d){
if(!d) return;
const temps = [
['A相绕组温度', d.tA], ['B相绕组温度', d.tB], ['C相绕组温度', d.tC],
['逆变组件底板温度', d.tInv], ['输出滤波器温度', d.tFilter], ['筒内空气温度', d.tAir],
['tA', d.tA], ['tB', d.tB], ['tC', d.tC],
['tInv', d.tInv], ['tFilter', d.tFilter], ['tAir', d.tAir],
];
for(const t of temps){
h += row(t[0], v ? (t[1]|0) + ' ℃' : '—');
setH(t[0], d.valid ? ((t[1]|0) + ' ℃') : '—');
}
h += row('最后更新', ageCell(d));
h += sub('来源 0x18EF1320（100ms，冗余 0x18EF1321，Byte0~5 各 1 字节 s8）');
return card('温度', h);
setH('tAge', ageCell(d));
}
//------------------ 支路故障/报警卡片 ------------------
function branchCard(title, d){
if(!d) return '';
const words = d.words || [];
let h = '';
function updateBranch(pfx, d){
if(!d) return;
const faults = d.faults || [];
const alarms = d.alarms || [];
if(faults.length){
h += row('故障(' + faults.length + '条)', faults.map(function(f){ return '<span class="fc-bad">'+f+'</span>'; }).join(''));
} else {
h += row('故障', d.valid ? '<span class="fc-ok">无</span>' : '—');
}
if(alarms.length){
h += row('报警(' + alarms.length + '条)', alarms.map(function(a){ return '<span class="fc-warn">'+a+'</span>'; }).join(''));
} else {
h += row('报警', d.valid ? '<span class="fc-ok">无</span>' : '—');
}
h += row('故障字原始值', words.map(hex16).join(' '));
h += row('最后更新', ageCell(d));
return card(title, h);
setH(pfx+'fK', '故障' + (faults.length ? '(' + faults.length + '条)' : ''));
setH(pfx+'aK', '报警' + (alarms.length ? '(' + alarms.length + '条)' : ''));
setH(pfx+'faults', faults.length
? faults.map(function(f){ return '<span class="fc-bad">'+f+'</span>'; }).join('')
: (d.valid ? '<span class="fc-ok">无</span>' : '—'));
setH(pfx+'alarms', alarms.length
? alarms.map(function(a){ return '<span class="fc-warn">'+a+'</span>'; }).join('')
: (d.valid ? '<span class="fc-ok">无</span>' : '—'));
setH(pfx+'words', (d.words || []).map(hex16).join(' '));
setH(pfx+'age', ageCell(d));
}
//------------------ 通信链路卡片 ------------------
function linkCard(d){
const l = (d && d.link) || {};
let h = '';
h += row('下行通道 (CAN1)', l.channel || 'CAN1');
h += row('冗余通道', l.redChannel ? l.redChannel : '<span style="color:var(--dim)">未配置</span>');
h += row('指令帧周期', (l.periodMs||0) + ' ms');
h += row('指令帧累计', (l.txCount||0) + ' 成功 / ' + (l.txErr||0) + ' 失败');
h += row('最近下发', ageCell({valid:!!l.lastTxValid, age:l.lastTxAge}));
h += row('电机报文接收', (l.rxCount||0) + ' 帧');
h += sub('链路: 电机 <-> CAN1 <-> CANET <-> pCanBridge <-> MOOS <-> pMotor');
return card('通信链路 (pCanBridge)', h);
}
//------------------ 协议参考卡片 ------------------
function protoCard(){
let h = '';
h += row('0x18EF2010', '主控指令帧（下行 500ms，冗余 0x18EF2011）');
h += row('0x18EF2110', '主控限制帧（下行，全预留，暂不使用）');
h += row('0x18EF1020', '支路一故障报警状态帧1（上行 200ms，冗余 0x18EF1021）');
h += row('0x18EF1120', '支路二故障报警状态帧2（上行 200ms，冗余 0x18EF1121）');
h += row('0x18EF1220', '状态帧3：反馈转速/母线电压（上行 100ms，冗余 0x18EF1221）');
h += row('0x18EF1320', '状态帧4：温度（上行 100ms，冗余 0x18EF1321）');
h += row('帧格式', 'CAN2.0B 扩展帧 29 位 ID，数据域 8 字节，Intel 字节序');
h += row('波特率', '250 kbps（默认，按客户可定制 125~1000）');
return card('报文定义 (推进电机通信协议 20260321)', h);
function updateLink(l){
l = l || {};
setH('lch', l.channel || 'CAN1');
setH('lred', l.redChannel ? l.redChannel : '<span style="color:var(--dim)">未配置</span>');
setH('lperiod', String(l.periodMs || 0));
setH('ltx', (l.txCount||0) + ' 成功 / ' + (l.txErr||0) + ' 失败');
setH('llast', ageCell({valid:!!l.lastTxValid, age:l.lastTxAge}));
setH('lrx', String(l.rxCount || 0));
}
function render(snap){
let html = '';
html += cmdCard(snap);
html += state3Card(snap.state3);
html += state4Card(snap.state4);
html += branchCard('支路一故障/报警 (0x18EF1020)', snap.fault1);
html += branchCard('支路二故障/报警 (0x18EF1120)', snap.fault2);
html += linkCard(snap);
html += protoCard();
pagesEl.innerHTML = html;
// 保留转速输入值（render 会重建 DOM）
const prev = window.__lastSpeed;
if(prev !== undefined){ const el = $('speedInput'); if(el) el.value = prev; }
snap = snap || {};
const link = snap.link || {};
updateCmd(snap.cmd);
updateState3(snap.state3);
updateState4(snap.state4);
updateBranch('f1', snap.fault1);
updateBranch('f2', snap.fault2);
updateLink(link);
setH('cPeriod', String(link.periodMs || 500));
}
// 骨架构建一次后即保持稳定；render 只做叶节点就地更新，
// 输入框不再被销毁重建，光标与焦点因此不受快照刷新影响。
buildUI();
render({});
function connect(){
const proto = location.protocol==='https:'?'wss':'ws';
const ws = new WebSocket(proto+'://'+location.host+'/ws');
@@ -254,10 +295,7 @@ function connect(){
ws.onerror = ()=>{ ws.close(); };
ws.onmessage = (ev)=>{
try{
const snap = JSON.parse(ev.data);
const el = $('speedInput');
if(el && el === document.activeElement) window.__lastSpeed = el.value;
render(snap);
render(JSON.parse(ev.data));
}catch(e){}
};
}
src/pPowerManger/PowerManger.cpp
+3
View File
@@ -246,6 +246,9 @@ bool PowerManger::OnStartUp()
loguru::add_file(logPath.c_str(), loguru::Append, loguru::Verbosity_MAX);
LOG_F(INFO, "日志文件路径: %s", logPath.c_str());
// 网页日志监控使用同一文件（默认相对路径在 systemd WorkingDirectory 下打不开）
if (m_httpServer) m_httpServer->setLogFilePath(logPath);
// 初始化数据库：dbpath 未配置则默认当前目录
if (dbPath.empty()) dbPath = "power_data.db";
LOG_F(INFO, "数据库存储路径: %s", dbPath.c_str());
src/pPowerManger/httpserver/fuelcell.h
+308 -65
View File
@@ -278,34 +278,192 @@ body {
margin-bottom: 12px;
}
.slider-container {
/* 数值步进控件（替代滑块，防误拖） */
.stepper-container {
display: flex;
align-items: center;
gap: 8px;
}
.stepper-btn {
width: 40px;
height: 40px;
border: 1px solid #d1d5db;
border-radius: 4px;
background-color: #f9fafb;
color: #1a1a1a;
font-size: 1.25rem;
font-weight: 700;
line-height: 1;
cursor: pointer;
transition: all 0.15s;
user-select: none;
}
.stepper-btn:hover {
background-color: #e5e7eb;
}
.stepper-btn:active {
background-color: var(--primary-color);
color: white;
border-color: var(--primary-color);
}
.stepper-input {
width: 90px;
height: 40px;
padding: 0 8px;
border: 1px solid #d1d5db;
border-radius: 4px;
text-align: center;
font-family: 'SF Mono', 'Consolas', monospace;
font-size: 1rem;
font-weight: 600;
}
.stepper-input:focus {
outline: none;
border-color: var(--primary-color);
box-shadow: 0 0 0 2px rgba(37, 99, 235, 0.15);
}
.stepper-unit {
min-width: 84px;
color: #4b5563;
font-size: 0.9rem;
font-family: 'SF Mono', 'Consolas', monospace;
}
/* 下拉框危险选项标记 */
.select-control option.danger {
color: #dc2626;
font-weight: 700;
}
/* 指令确认弹窗 */
.modal-overlay {
display: none;
position: fixed;
inset: 0;
background: rgba(17, 24, 39, 0.55);
z-index: 100;
align-items: center;
justify-content: center;
padding: 16px;
}
.modal-overlay.visible {
display: flex;
}
.modal {
background: white;
border-radius: 8px;
width: 100%;
max-width: 560px;
max-height: 85vh;
display: flex;
flex-direction: column;
box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.3);
}
.modal-title {
padding: 16px 20px;
font-size: 1.1rem;
font-weight: 600;
border-bottom: 1px solid #e5e7eb;
}
.modal-body {
padding: 16px 20px;
overflow-y: auto;
}
.modal-hint {
font-size: 0.85rem;
color: #6b7280;
margin-bottom: 12px;
}
.modal-summary {
border: 1px solid #e5e7eb;
border-radius: 6px;
overflow: hidden;
}
.summary-row {
display: flex;
justify-content: space-between;
align-items: center;
padding: 8px 12px;
border-bottom: 1px solid #f3f4f6;
font-size: 0.9rem;
}
.summary-row:last-child {
border-bottom: none;
}
.summary-label {
color: #4b5563;
}
.summary-value {
font-weight: 600;
font-family: 'SF Mono', 'Consolas', monospace;
text-align: right;
}
.summary-row.danger {
background-color: #fef2f2;
}
.summary-row.danger .summary-label,
.summary-row.danger .summary-value {
color: #b91c1c;
}
.summary-danger-mark {
margin-right: 6px;
font-weight: 700;
}
.modal-note {
margin-top: 12px;
padding: 10px 12px;
border-radius: 4px;
background-color: #fef2f2;
color: #b91c1c;
font-size: 0.85rem;
font-weight: 600;
display: none;
}
.modal-note.visible {
display: block;
}
.modal-actions {
padding: 16px 20px;
border-top: 1px solid #e5e7eb;
display: flex;
gap: 12px;
}
.slider {
flex-grow: 1;
height: 6px;
-webkit-appearance: none;
background: #d1d5db;
border-radius: 3px;
outline: none;
.modal-actions .button {
flex: 1;
padding: 12px;
font-size: 1rem;
}
.slider::-webkit-slider-thumb {
-webkit-appearance: none;
width: 18px;
height: 18px;
background: var(--primary-color);
border-radius: 50%;
cursor: pointer;
.button-confirm {
background-color: var(--primary-color);
color: white;
}
.slider-value {
min-width: 60px;
text-align: right;
font-family: 'SF Mono', 'Consolas', monospace;
.button-confirm:hover {
background-color: var(--primary-hover);
}
.form-submit {
@@ -521,22 +679,24 @@ body {
<option value="00H">无效</option>
<option value="01H">自检</option>
<option value="02H">启动</option>
<option value="03H">停机</option>
<option value="04H">复位</option>
<option value="05H">紧急停机</option>
<option value="06H">补给</option>
<option value="07H">制氢预热</option>
<option value="08H">停机维护</option>
<option value="0AH">开机</option>
<option value="0BH">关机</option>
<option value="03H" class="danger">⚠ 停机（危险）</option>
<option value="05H" class="danger">⚠ 紧急停机（危险）</option>
<option value="08H" class="danger">⚠ 停机维护（危险）</option>
<option value="0BH" class="danger">⚠ 关机（危险）</option>
</select>
</div>
<div class="control-group">
<label class="control-label">输出功率指令 (0~250，分辨率0.1kW)</label>
<div class="slider-container">
<input type="range" class="slider" name="fcPower" min="0" max="250" value="0" step="1">
<span class="slider-value">0 (0.0 kW)</span>
<div class="stepper-container">
<button type="button" class="stepper-btn" data-target="fcPower" data-step="-1">−</button>
<input type="number" class="stepper-input" id="fcPower" name="fcPower" min="0" max="250" step="1" value="0">
<button type="button" class="stepper-btn" data-target="fcPower" data-step="1">+</button>
<span class="stepper-unit" id="fcPowerUnit">0 (0.0 kW)</span>
</div>
</div>
@@ -567,9 +727,11 @@ body {
<div class="control-group">
<label class="control-label">潜深深度 (m)</label>
<div class="slider-container">
<input type="range" class="slider" name="depth" min="0" max="1000" value="0" step="1">
<span class="slider-value">0 m</span>
<div class="stepper-container">
<button type="button" class="stepper-btn" data-target="depth" data-step="-1">−</button>
<input type="number" class="stepper-input" id="depth" name="depth" min="0" max="1000" step="1" value="0">
<button type="button" class="stepper-btn" data-target="depth" data-step="1">+</button>
<span class="stepper-unit" id="depthUnit">0 m</span>
</div>
</div>
@@ -612,9 +774,11 @@ body {
<div class="control-group">
<label class="control-label">动力锂电池功率配置值 (0~400 kW)</label>
<div class="slider-container">
<input type="range" class="slider" name="powerBatPower" min="0" max="400" value="0" step="10">
<span class="slider-value">0 kW</span>
<div class="stepper-container">
<button type="button" class="stepper-btn" data-target="powerBatPower" data-step="-10">−</button>
<input type="number" class="stepper-input" id="powerBatPower" name="powerBatPower" min="0" max="400" step="10" value="0">
<button type="button" class="stepper-btn" data-target="powerBatPower" data-step="10">+</button>
<span class="stepper-unit" id="powerBatPowerUnit">0 kW</span>
</div>
</div>
@@ -622,18 +786,34 @@ body {
<label class="control-label">主机状态</label>
<div class="radio-group">
<label class="radio-option"><input type="radio" name="hostStatus" value="AAH" checked><span>运行</span></label>
<label class="radio-option"><input type="radio" name="hostStatus" value="FFH"><span>关机</span></label>
<label class="radio-option"><input type="radio" name="hostStatus" value="55H"><span>故障</span></label>
<label class="radio-option"><input type="radio" name="hostStatus" value="FFH"><span>⚠ 关机（危险）</span></label>
<label class="radio-option"><input type="radio" name="hostStatus" value="55H"><span>⚠ 故障（危险）</span></label>
</div>
</div>
<button type="submit" class="button form-submit">提交操控指令</button>
<button type="submit" class="button form-submit">预览并提交操控指令</button>
<div id="statusMessage" class="status-message"></div>
</form>
</div>
</div>
</div>
<!-- 指令确认弹窗（防误操作，提交前拦截） -->
<div class="modal-overlay" id="confirmOverlay">
<div class="modal">
<div class="modal-title">⚠ 指令确认</div>
<div class="modal-body">
<div class="modal-hint">请逐项核对下方指令摘要，红色条目为高风险指令。点击“确认执行”后指令将立即下发。</div>
<div class="modal-summary" id="modalSummary"></div>
<div class="modal-note" id="modalDangerNote">本次包含高风险指令（停机/紧急停机/停机维护/关机等），请再次确认！</div>
</div>
<div class="modal-actions">
<button type="button" class="button button-secondary" id="modalCancelBtn">取消</button>
<button type="button" class="button button-confirm" id="modalConfirmBtn">确认执行</button>
</div>
</div>
</div>
<script>
let ws = null;
@@ -793,32 +973,42 @@ function initWebSocket() {
};
}
// 更新滑块值显示
document.querySelectorAll('.slider').forEach(slider => {
const valueDisplay = slider.nextElementSibling;
if (slider.name === 'fcPower') {
valueDisplay.textContent = slider.value + ' (0.0 kW)';
} else if (slider.name === 'depth') {
valueDisplay.textContent = slider.value + ' m';
} else if (slider.name === 'powerBatPower') {
valueDisplay.textContent = slider.value + ' kW';
} else {
valueDisplay.textContent = slider.value;
}
// 数值步进控件（替代滑块，防误拖）
const stepperUnitText = {
fcPower: v => v + ' (' + (v * 0.1).toFixed(1) + ' kW)',
depth: v => v + ' m',
powerBatPower: v => v + ' kW'
};
slider.addEventListener('input', () => {
if (slider.name === 'fcPower') {
valueDisplay.textContent = slider.value + ' (' + (slider.value * 0.1).toFixed(1) + ' kW)';
} else if (slider.name === 'depth') {
valueDisplay.textContent = slider.value + ' m';
} else if (slider.name === 'powerBatPower') {
valueDisplay.textContent = slider.value + ' kW';
} else {
valueDisplay.textContent = slider.value;
}
function clampStepper(input) {
const min = parseInt(input.min, 10);
const max = parseInt(input.max, 10);
let v = parseInt(input.value, 10);
if (isNaN(v)) v = isNaN(min) ? 0 : min;
if (!isNaN(min)) v = Math.max(v, min);
if (!isNaN(max)) v = Math.min(v, max);
input.value = v;
const unitFn = stepperUnitText[input.id];
if (unitFn) {
const unitEl = document.getElementById(input.id + 'Unit');
if (unitEl) unitEl.textContent = unitFn(v);
}
}
document.querySelectorAll('.stepper-btn').forEach(btn => {
btn.addEventListener('click', () => {
const input = document.getElementById(btn.dataset.target);
if (!input) return;
input.value = (parseInt(input.value, 10) || 0) + parseInt(btn.dataset.step, 10);
clampStepper(input);
});
});
document.querySelectorAll('.stepper-input').forEach(input => {
input.addEventListener('input', () => clampStepper(input));
input.addEventListener('blur', () => clampStepper(input));
});
// 处理按钮组选择
document.querySelectorAll('.button-group button').forEach(button => {
button.addEventListener('click', () => {
@@ -838,16 +1028,71 @@ document.querySelectorAll('.button-group button').forEach(button => {
});
});
// 处理表单提交
document.getElementById('fcsForm').addEventListener('submit', async (e) => {
// 指令文本映射（用于确认弹窗摘要）
const FC_MODE_TEXT = { '00H': '无效', '01H': '调试', '02H': '自动', '03H': '补给/排放' };
const FC_CMD_TEXT = { '00H': '无效', '01H': '自检', '02H': '启动', '03H': '停机', '04H': '复位', '05H': '紧急停机', '06H': '补给', '07H': '制氢预热', '08H': '停机维护', '0AH': '开机', '0BH': '关机' };
const EMERGENCY_TEXT = { '00H': '无', '01H': '允许降载', '02H': '允许排气', '03H': '降载+排气' };
const SUPPLY_TEXT = { '00H': '无效', '01H': '液氧加注', '02H': '甲醇加注', '03H': '液氧排空', '04H': '甲醇排空', '05H': 'CO2排空', '07H': '合金加注', '08H': '氮气加注', '09H': '纯水加注', '0AH': '备用', '0BH': '备用' };
const BAT_CMD_TEXT = { '00H': '无效', '10H': '启动', '20H': '关闭' };
const HOST_STATUS_TEXT = { 'AAH': '运行', 'FFH': '关机', '55H': '故障' };
const DANGER_FC_CMDS = ['03H', '05H', '08H', '0BH'];
const DANGER_HOST_STATUS = ['FFH', '55H'];
// 生成指令摘要并打开确认弹窗（提交前拦截，防误操作）
function openConfirmModal() {
const form = document.getElementById('fcsForm');
const fv = name => form.elements[name].value;
const rows = [
{ label: '模式设定', value: FC_MODE_TEXT[fv('fcMode')] || fv('fcMode') },
{ label: '操控指令', value: FC_CMD_TEXT[fv('fcCommand')] || fv('fcCommand'), danger: DANGER_FC_CMDS.includes(fv('fcCommand')) },
{ label: '输出功率指令', value: fv('fcPower') + ' (' + (fv('fcPower') * 0.1).toFixed(1) + ' kW)' },
{ label: '纵倾姿态数据1', value: fv('pitch') },
{ label: '横倾姿态数据1', value: fv('roll') },
{ label: '应急允许', value: EMERGENCY_TEXT[fv('emergencyAllow')] || fv('emergencyAllow') },
{ label: '潜深深度', value: fv('depth') + ' m' },
{ label: '补给/排放指令', value: SUPPLY_TEXT[fv('supplyExhaustCmd')] || fv('supplyExhaustCmd') },
{ label: '仪表锂电池启停指令', value: BAT_CMD_TEXT[fv('insBatCmd')] || fv('insBatCmd') },
{ label: '动力锂电池启停指令', value: BAT_CMD_TEXT[fv('powerBatCmd')] || fv('powerBatCmd') },
{ label: '动力锂电池功率配置值', value: fv('powerBatPower') + ' kW' },
{ label: '主机状态', value: HOST_STATUS_TEXT[fv('hostStatus')] || fv('hostStatus'), danger: DANGER_HOST_STATUS.includes(fv('hostStatus')) }
];
document.getElementById('modalSummary').innerHTML = rows.map(r =>
'<div class="summary-row' + (r.danger ? ' danger' : '') + '">' +
'<span class="summary-label">' + (r.danger ? '<span class="summary-danger-mark">⚠</span>' : '') + r.label + '</span>' +
'<span class="summary-value">' + r.value + '</span>' +
'</div>'
).join('');
const hasDanger = rows.some(r => r.danger);
document.getElementById('modalDangerNote').className = 'modal-note' + (hasDanger ? ' visible' : '');
document.getElementById('confirmOverlay').classList.add('visible');
}
function closeConfirmModal() {
document.getElementById('confirmOverlay').classList.remove('visible');
}
// 提交按钮：先弹出确认框，不直接发送
document.getElementById('fcsForm').addEventListener('submit', (e) => {
e.preventDefault();
const form = e.target;
const formData = new FormData(form);
openConfirmModal();
});
// 取消：关闭弹窗，不做任何提交
document.getElementById('modalCancelBtn').addEventListener('click', closeConfirmModal);
// 确认执行：真正下发指令
document.getElementById('modalConfirmBtn').addEventListener('click', async () => {
const form = document.getElementById('fcsForm');
const statusMessage = document.getElementById('statusMessage');
closeConfirmModal();
try {
const params = new URLSearchParams();
for (const [key, value] of formData.entries()) {
for (const [key, value] of new FormData(form).entries()) {
params.append(key, value);
}
@@ -864,18 +1109,16 @@ document.getElementById('fcsForm').addEventListener('submit', async (e) => {
if (result.success) {
statusMessage.textContent = '操控指令提交成功';
statusMessage.className = 'status-message';
statusMessage.style.display = 'block';
} else {
statusMessage.textContent = result.message || '操控指令提交失败';
statusMessage.className = 'status-message error';
statusMessage.style.display = 'block';
}
} catch (error) {
statusMessage.textContent = '网络错误: ' + error.message;
statusMessage.className = 'status-message error';
statusMessage.style.display = 'block';
}
statusMessage.style.display = 'block';
setTimeout(() => {
statusMessage.style.display = 'none';
}, 5000);
src/pPowerManger/httpserver/httpserver.h
+5
View File
@@ -86,6 +86,11 @@ private:
static const size_t MAX_CACHE_SIZE = 1000; // 最大缓存条数
static const size_t MAX_WS_BACKLOG = 256 * 1024; // WebSocket发送积压阈值，超过则跳过推送
public:
// 设置被监控的日志文件路径（须与 logpath 配置一致；
// 默认相对路径在 systemd WorkingDirectory 下会打开失败）
void setLogFilePath(const std::string& path) { m_logFilePath = path; }
};
#endif // HTTP_SERVER_H
src/pPowerManger/sqlit3/SQLite.cpp
+50 -1
View File
@@ -7,7 +7,7 @@
#include "../logc/loguru.hpp"
namespace {
const int SCHEMA_VERSION = 1;
const int SCHEMA_VERSION = 2;
}
//====================================================================
@@ -463,6 +463,10 @@ bool SQLite::migrate()
if (!createAllTablesUnlocked()) return false;
// 老库缺列自动补齐（协议演进新增字段后，旧表由 CREATE TABLE IF NOT EXISTS
// 创建、不会带新列，导致 INSERT prepare 失败、该表数据无法落库）
if (!migrateColumnsUnlocked()) return false;
if (version < SCHEMA_VERSION) {
std::string sql = "PRAGMA user_version = " + std::to_string(SCHEMA_VERSION) + ";";
sqlite3_exec(m_db, sql.c_str(), nullptr, nullptr, nullptr);
@@ -470,6 +474,51 @@ bool SQLite::migrate()
return true;
}
//====================================================================
// migrateColumnsUnlocked：按注册表逐一对比表现有列，缺哪列补哪列
// （ALTER TABLE ADD COLUMN，新增列对旧行取默认值 0/NULL）。
//====================================================================
bool SQLite::migrateColumnsUnlocked()
{
for (const TableDesc& t : allTables()) {
// 读取现有列（PRAGMA table_info 第 2 列为列名）
std::vector<std::string> existing;
sqlite3_stmt* stmt = nullptr;
std::string pragma = std::string("PRAGMA table_info(") + t.name + ");";
if (sqlite3_prepare_v2(m_db, pragma.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
while (sqlite3_step(stmt) == SQLITE_ROW) {
const unsigned char* name = sqlite3_column_text(stmt, 1);
if (name) existing.push_back(reinterpret_cast<const char*>(name));
}
sqlite3_finalize(stmt);
}
if (existing.empty()) continue; // 表不存在（新库），建表时已含全部列
for (const Column& c : t.columns) {
bool found = false;
for (const std::string& e : existing) {
if (e == c.name) { found = true; break; }
}
if (found) continue;
std::string sql = std::string("ALTER TABLE ") + t.name +
" ADD COLUMN " + c.name + " " + c.sqlType + ";";
char* errMsg = nullptr;
int rc = sqlite3_exec(m_db, sql.c_str(), nullptr, nullptr, &errMsg);
if (rc == SQLITE_OK) {
LOG_F(INFO, "SQLite 迁移: 表 %s 新增列 %s", t.name, c.name);
} else {
// 记录失败但不中断打开：其余列/表继续尝试，
// 未补齐列的 insert 仍会按原样报 prepare 错误
m_lastError = errMsg ? errMsg : "alter table failed";
LOG_F(ERROR, "SQLite 迁移失败: %s (%s)", sql.c_str(), m_lastError.c_str());
if (errMsg) sqlite3_free(errMsg);
}
}
}
return true;
}
bool SQLite::createTableInternal(const std::string& tableName, const std::string& columns)
{
std::string sql = "CREATE TABLE IF NOT EXISTS " + tableName + " (" + columns + ");";
src/pPowerManger/sqlit3/SQLite.h
+1
View File
@@ -65,6 +65,7 @@ private:
bool migrate();
bool createTableInternal(const std::string& tableName, const std::string& columns);
bool createAllTablesUnlocked();
bool migrateColumnsUnlocked();
// 列描述：名称 + SQL 类型 + 绑定器（无捕获函数指针）
struct Column {