feat(ota): 实现GD32 OTA包间背压机制，优化传输节奏控制

移除固定的包间延迟配置 `OTA_PACKET_DELAY_MS`，采用基于SPI Link v2
CREDIT背压的动态节奏控制，在SpiMaster中通过remoteCredit==0时wait/拒发
实现流量控制，提高OTA传输稳定性。

refactor(stack): 统一任务栈大小配置并添加CPU统计功能

- 在app_config.h中集中定义所有任务栈大小常量，基于实测水位优化分配
- 新增monitor/cpu_stats.cpp组件，提供1Hz FreeRTOS CPU占用采样
- 更新main.cpp中的任务创建使用新的栈大小常量
- 调整health_monitor和ota_relay等任务的栈分配

perf(ota): 改进ESP32和GD32 OTA分区预擦策略

- ESP32 OTA从边写边擦改为整分区预擦模式，避免写入时的扇区擦除阻塞
- GD32 OTA在prepare阶段进行整分区预擦，提升后续写入吞吐量
- 优化OTA协调器状态管理，修复FINALIZING状态残留问题

fix(log): 改进UDP日志发送的堆内存管理

- 当堆内存不足时记录UDP发送跳过的告警信息到ring buffer
- 降低UDP发送跳过的内存阈值从10KB到6KB
- 降低日志排水最小内存阈值从8KB到4KB

docs(readme): 更新OTA配置参数文档说明

移除已废弃的OTA_PACKET_DELAY_MS参数，更新包间节奏控制说明为
基于CREDIT背压机制的描述。

tools/index.html

@@ -431,8 +431,8 @@
   <span id="toastMsg">操作成功</span>
 </div>
 
-<script type="module" src="js/app.js?v=20260715a"></script>
-<script type="module" src="js/ota/console-mode.js?v=20260715a"></script>
-<script type="module" src="js/ble_ota.js?v=20260715a"></script>
+<script type="module" src="js/app.js?v=20260716c"></script>
+<script type="module" src="js/ota/console-mode.js?v=20260716c"></script>
+<script type="module" src="js/ble_ota.js?v=20260716c"></script>
 </body>
 </html>

tools/js/app.js

@@ -12,11 +12,11 @@ import { showToast } from './common/toast.js';
 import { addLog, clearLogs, setLogFilter, toggleAutoScroll } from './common/log.js';
 import {
   updateConnectionUi, updateHealthUi, updateHeapAndTaskStatusUi,
-  testConnection, refreshSystemStatusNow
+  testConnection, refreshSystemStatusNow, diagnoseNetwork
 } from './common/connection.js';
 import {
   scheduleStatusPoll, startPolling, pausePollingForUpload,
-  resumePollingAfterUpload, pollStatus, pollLogs
+  resumePollingAfterUpload, pollStatus, pollLogs, setStatusPollIntervalMs
 } from './common/polling.js';
 
 import {
@@ -40,9 +40,12 @@ import {
 } from './ota/file-handle.js';
 import { sendSpiFrame, clearSpiFields, updateSpiHint } from './ota/spi.js';
 import { startUpload, verifyEsp32Firmware, restartEsp32 } from './ota/upload-esp32.js';
-import { triggerGd32Relay, markGd32OtaUiComplete, stopRelayProgressWatch, startRelayProgressWatch } from './ota/upload-gd32.js';
+import {
+  triggerGd32Relay, markGd32OtaUiComplete, stopRelayProgressWatch,
+  startRelayProgressWatch, emitRelayProgress, ensureRelayProgressComplete
+} from './ota/upload-gd32.js';
 
-// ==================== 工具函数（部分未拆分的辅助函数） ====================
+// ==================== 工具函数 ====================
 function formatPercent(value) {
   if (!Number.isFinite(value)) return '--';
   return value.toFixed(1).replace(/\.0$/, '') + '%';
@@ -178,6 +181,8 @@ window.triggerGd32Relay = triggerGd32Relay;
 window.markGd32OtaUiComplete = markGd32OtaUiComplete;
 window.stopRelayProgressWatch = stopRelayProgressWatch;
 window.startRelayProgressWatch = startRelayProgressWatch;
+window.emitRelayProgress = emitRelayProgress;
+window.ensureRelayProgressComplete = ensureRelayProgressComplete;
 
 // ==================== 挂载 common/* 函数到 window（供 polling.js 等通过 window.* 调用） ====================
 window.formatBytes = formatBytes;
@@ -196,11 +201,13 @@ window.updateHeapAndTaskStatusUi = updateHeapAndTaskStatusUi;
 window.testConnection = testConnection;
 window.refreshSystemStatusNow = refreshSystemStatusNow;
 window.scheduleStatusPoll = scheduleStatusPoll;
+window.setStatusPollIntervalMs = setStatusPollIntervalMs;
 window.startPolling = startPolling;
 window.pausePollingForUpload = pausePollingForUpload;
 window.resumePollingAfterUpload = resumePollingAfterUpload;
 window.pollStatus = pollStatus;
 window.pollLogs = pollLogs;
+window.diagnoseNetwork = diagnoseNetwork;
 
 // ==================== 挂载本入口的辅助函数到 window ====================
 window.getEspIp = getEspIp;

tools/js/ble/constants.js

@@ -10,7 +10,7 @@ export const UUIDS = {
   version: 0x0004,
 };
 
-export const UI_BUILD = '2026-07-12-ble-reorder-v6';
+export const UI_BUILD = '2026-07-16-ble-begin-ready';
 export const BLE_OTA_NOTIFY_ACK = 0xA1;
 export const BLE_OTA_NOTIFY_FINISH = 0xB1;
 export const BLE_OTA_NOTIFY_SHA256 = 0xC1;

tools/js/ble/transfer.js

@@ -189,6 +189,9 @@ export async function uploadFirmware() {
     bleLog('OTA', `开始写入 DATA_IN: build=${UI_BUILD}, target=${cfg.label}, file=${file.name}, total=${totalSize}, packets=${packetTotal}, payload=${payloadSize}, windowAck=${BLE_OTA_ACK_WINDOW}`);
 
     const MAX_WINDOW_RETRIES = 3;
+    // 整分区预擦可长达数十秒；首包 ACK 超时必须覆盖 begin/erase
+    const BEGIN_READY_TIMEOUT_MS = 120000;
+    const WINDOW_ACK_TIMEOUT_MS = 8000;
     for (let windowStart = 0; windowStart < packetTotal; windowStart += BLE_OTA_ACK_WINDOW) {
       if (state.abortRequested) throw new Error('用户中止');
 
@@ -197,37 +200,50 @@ export async function uploadFirmware() {
       // Windows Web Bluetooth 同一时刻只允许一个 GATT 操作。逐包等待仅保证
       // 提交顺序；实际吞吐由设备请求的高速 BLE 连接参数决定。
       // ★ 不再在循环内 setProgress：进度完全由设备 ACK 后的 state.lastAckBytes 驱动
+      //
+      // ★ 首窗特殊流控：seq=0 触发设备 begin+整分区预擦（worker 线程，可阻塞很久）。
+      //   旧逻辑 sleep(200) 后立刻 withoutResponse 连发 → 队列满丢包 → 整窗重传，体感极慢。
+      //   现改为：seq=0 送达后等设备「首包落盘 ACK」再发 1..endSeq。
       for (let seq = windowStart; seq <= endSeq; seq++) {
-        // ★ 中止检查放在循环内：abortTask 可能在本窗口发送过程中触发
-        //   （windowStart 处的检查无法覆盖窗口中途的 abort）
         if (state.abortRequested) throw new Error('用户中止');
         const start = seq * payloadSize;
         const end = Math.min(start + payloadSize, totalSize);
         const payload = fileBytes.slice(start, end);
         const packet = buildPacket(seq, totalSize, payload, cfg.packetCmd);
 
-        // ★ seq=0 必须用 writeValueWithResponse（带响应）：
-        // seq=0 触发设备端 esp_ota_begin()（flash 擦除 + OTA 会话创建），
-        // 若用 writeValueWithoutResponse 在 BLE 链路层丢失，
-        // 设备永远不会启动 OTA 会话，后续所有包都被丢弃。
         if (seq === 0) {
           try {
             await state.dataInChar.writeValueWithResponse(packet);
-            bleLog('OTA', 'seq=0 已用 writeValueWithResponse 确认送达', 'I');
+            bleLog('OTA', 'seq=0 已用 writeValueWithResponse 确认送达，等待设备 begin/预擦完成…', 'I');
+            setBleStageText('设备预擦 Flash 中，请等待…');
           } catch (e) {
             bleLog('OTA', `seq=0 写入失败: ${e.message}`, 'E');
             throw new Error('seq=0 写入失败，OTA 会话无法启动: ' + e.message);
           }
-          // seq=0 写入后等待设备完成 esp_ota_begin()（flash 擦除较耗时）
-          await sleep(200);
-        } else {
-          await state.dataInChar.writeValueWithoutResponse(packet);
+          state.ackGeneration++;
+          const firstBytes = Math.min(payloadSize, totalSize);
+          try {
+            await waitForAck(cfg.packetCmd, 0, BEGIN_READY_TIMEOUT_MS, {
+              expectedTotalSize: totalSize,
+              payloadSize: payloadSize
+            });
+          } catch (e) {
+            throw new Error('等待设备 begin/预擦完成超时: ' + e.message);
+          }
+          if (state.lastAckBytes < firstBytes) {
+            throw new Error('设备 begin 就绪 ACK 字节不足: got=' + state.lastAckBytes + ' need=' + firstBytes);
+          }
+          bleLog('OTA', '设备 begin 就绪 (ackBytes=' + state.lastAckBytes + ')，继续发送窗口数据', 'I');
+          setBleStageText('正在写入 ' + packetTotal + ' 包数据...');
+          continue;
         }
+
+        await state.dataInChar.writeValueWithoutResponse(packet);
       }
 
       state.ackGeneration++;
       try {
-        await waitForAck(cfg.packetCmd, endSeq, 5000, { expectedTotalSize: totalSize, payloadSize });
+        await waitForAck(cfg.packetCmd, endSeq, WINDOW_ACK_TIMEOUT_MS, { expectedTotalSize: totalSize, payloadSize });
       } catch (e) {
         bleLog('OTA', `ACK 等待失败: ${e.message}，进入重试`, 'W');
       }
@@ -270,15 +286,23 @@ export async function uploadFirmware() {
           const end = Math.min(start + payloadSize, totalSize);
           const payload = fileBytes.slice(start, end);
           const packet = buildPacket(seq, totalSize, payload, cfg.packetCmd);
-          // ★ 重试路径中 seq=0 也必须用 writeValueWithResponse
+          // ★ 重试路径中 seq=0 也必须用 writeValueWithResponse，并等 begin 就绪 ACK
           if (seq === 0) {
             try {
               await state.dataInChar.writeValueWithResponse(packet);
-              bleLog('OTA', '重试 seq=0 已用 writeValueWithResponse 确认', 'I');
+              bleLog('OTA', '重试 seq=0 已送达，等待 begin 就绪 ACK…', 'I');
+              state.ackGeneration++;
+              try {
+                await waitForAck(cfg.packetCmd, 0, BEGIN_READY_TIMEOUT_MS, {
+                  expectedTotalSize: totalSize,
+                  payloadSize: payloadSize
+                });
+              } catch (e2) {
+                bleLog('OTA', '重试 seq=0 等待 begin ACK 失败: ' + e2.message, 'W');
+              }
             } catch (e) {
               bleLog('OTA', `重试 seq=0 写入失败: ${e.message}`, 'E');
             }
-            await sleep(200);
           } else {
             await state.dataInChar.writeValueWithoutResponse(packet);
           }
@@ -286,7 +310,7 @@ export async function uploadFirmware() {
 
         state.ackGeneration++;
         try {
-          await waitForAck(cfg.packetCmd, endSeq, 3000, { expectedTotalSize: totalSize, payloadSize });
+          await waitForAck(cfg.packetCmd, endSeq, WINDOW_ACK_TIMEOUT_MS, { expectedTotalSize: totalSize, payloadSize });
         } catch (e) {
           bleLog('OTA', `重试 ACK 等待失败: ${e.message}`, 'W');
         }

tools/js/can.js

@@ -1,7 +1,7 @@
 /**
  * can.js - CAN 工具页面入口（ESM 组装层）
  *
- * 本文件对应原 tools/can.js 中未拆分到子模块的编排逻辑：
+ * CAN 页面的编排逻辑：
  *   - cacheElements：缓存 DOM 元素到 el（dbc.js 导出的共享 el 对象）
  *   - setConnectionState：CAN 页面专用连接状态更新（canConnPill 等元素）
  *   - testConnection：CAN 页面专用连接检测（GET /system/status，操作 el.connectionNote 等）

tools/js/can/dbc.js

@@ -1,8 +1,7 @@
 /**
  * dbc.js - DBC 解析器 + 共享状态/元素缓存/基础工具
  *
- * 从 tools/can.js 拆分。对应原 can.js 约 4~21 行（state/el）、78~104 行（基础工具）、
- * 178~335 行（DBC 解析）、830~833 行（cssEscape）、1335~1352 行（readDbcText）。
+ * 包含：共享 state/el、基础工具、DBC 解析、cssEscape、readDbcText。
  *
  * 本模块是 can 子系统的基础层，不依赖其他 can 子模块；state/el 在此导出，
  * 供 messages/signals/send/feedback 共享（ES Module 的 live binding 保证引用一致）。

tools/js/can/feedback.js

@@ -1,17 +1,8 @@
 /**
  * feedback.js - 1Hz 反馈轮询（预留模块）
  *
- * ⚠️ 说明：原 tools/can.js（1526 行）中不存在 1Hz 反馈轮询 / ID 快照表渲染相关代码。
- *    这些功能实际位于 tools/can_monitor.js（CAN 监控页面），操作的是 can_monitor.html
- *    的 DOM 元素（fb0State / fb0Rx / idsnapBody 等），与 can.html 页面的元素体系不同，
- *    因此无法直接迁移。
- *
- *    can.js 中与"连接状态反馈"相关的代码为 setConnectionState / testConnection
- *    （一次性 GET /system/status），属于入口文件（js/can.js）的 init/cacheElements/bindEvents
- *    编排范畴，不在本子模块内。
- *
- *    本模块按任务要求 import common/connection.js，供入口文件在需要时引入连接管理能力。
- *    若后续 can 页面需要增加 1Hz 轮询 /can/feedback 或 ID 快照功能，可在此模块实现。
+ * 重新导出 common/connection.js 的连接管理函数，供 can 入口文件按需使用。
+ * 1Hz 轮询 /can/feedback 或 ID 快照功能可在本模块按需实现。
  */
 import { updateConnectionUi, updateHealthUi, updateHeapAndTaskStatusUi, testConnection, refreshSystemStatusNow } from '../common/connection.js';
 

tools/js/can/messages.js

@@ -1,8 +1,7 @@
 /**
  * messages.js - 报文列表管理（渲染、过滤、节点过滤、批量 UI）
  *
- * 从 tools/can.js 拆分。对应原 can.js 约 337~686 行（DBC 文件信息、报文过滤、
- * 节点过滤面板、报文列表渲染、报文选择/展开、批量 UI）。
+ * 包含：DBC 文件信息、报文过滤、节点过滤面板、报文列表渲染、报文选择/展开、批量 UI。
  *
  * 依赖：dbc.js（state/el/padHex/normalizeWhitespace/cssEscape）、
  *       common/utils.js（escapeHtml/formatBytes）、

tools/js/can/send.js

@@ -1,17 +1,16 @@
 /**
  * send.js - CAN 帧构建与发送（DBC 报文 / 原始帧 / 批量发送 / 发送历史）
  *
- * 从 tools/can.js 拆分。对应原 can.js 约 1030~1333 行（sendCanRequest、响应框、
- * 历史、批量/选中/手动发送、手动帧校验/重置/载入预览）及 1491~1523 行
- * （CAN_SEND_ERR_DESC / GD32_ERR_DESC / buildSendResponseText）。
+ * 包含：sendCanRequest、响应框、历史、批量/选中/手动发送、
+ * 手动帧校验/重置/载入预览、CAN_SEND_ERR_DESC / GD32_ERR_DESC / buildSendResponseText。
  *
  * 依赖：dbc.js（state/el/getBaseUrl/padHex/bytesToHex/parseNumericId）、
  *       common/toast.js（showToast）、common/utils.js（escapeHtml）、
  *       messages.js（updateBatchUi）、signals.js（ensureMessageDefaults/getSignalValueMap/
  *       getSelectedMessage/updateEncodedPreview/encodeMessageData）。
  *
- * 注意：formatTime 保留 can.js 本地实现（HH:MM:SS，不含毫秒），与 common/utils.js
- * 的 formatTime（含毫秒）不同，以保证发送历史时间戳输出与原版完全一致。
+ * 注意：formatTime 保留本地实现（HH:MM:SS，不含毫秒），与 common/utils.js
+ * 的 formatTime（含毫秒）不同，以保证发送历史时间戳输出格式一致。
  */
 import { state, el, getBaseUrl, padHex, bytesToHex, parseNumericId } from './dbc.js';
 import { escapeHtml as sanitizeHtml } from '../common/utils.js';

tools/js/can/signals.js

@@ -1,8 +1,8 @@
 /**
  * signals.js - 信号编辑器渲染 + 信号编解码（raw ↔ physical）
  *
- * 从 tools/can.js 拆分。对应原 can.js 约 629~1028 行（信号行渲染、信号值存取、
- * 编码写入、浮点/整数/Motorola/Intel 位操作）及 761 行的 renderSelectedMessage shim。
+ * 包含：信号行渲染、信号值存取、编码写入、浮点/整数/Motorola/Intel 位操作、
+ * renderSelectedMessage shim。
  *
  * 依赖：dbc.js（state/el/padHex/bytesToHex/cssEscape/findSignal）、common/utils.js（escapeHtml）。
  */

tools/js/common/connection.js

@@ -1,17 +1,16 @@
 /**
  * connection.js - 连接管理 + 系统状态显示
  *
- * 从 app.js 的「连接管理」段 + testConnection / refreshSystemStatusNow 提取。
  * 操作 DOM 元素 #pillConn / #pillConnTxt / #connStatus / #connStatusTxt / #bConn 等。
  *
- * 共享状态（通过 window.* 引用，后续 app.js 拆分时会统一挂载）：
+ * 共享状态（通过 window.* 引用）：
  *   window.latestSystemStatus     — 最近一次 /system/status 响应
  *   window.lastSysStateCode       — 上次成功的 sys_state_code（polling.js 读取）
  *   window.lastRelayState         — 上次成功的 relay_state（polling.js 读取）
  *   window.consecutivePollFailures — 连续轮询失败计数（polling.js 读取）
  *
- * 未拆分的 app.js 函数（通过 window.* 引用）：
- *   window.getBaseUrl / window.updateSystemStatusUi / window.diagnoseNetwork / window.formatPercent
+ * 复用的函数（通过 window.* 引用）：
+ *   window.getBaseUrl / window.updateSystemStatusUi / window.formatPercent
  */
 import { formatBytes, formatTime, formatUptime, escapeHtml } from './utils.js';
 import { addLog } from './log.js';
@@ -51,15 +50,18 @@ export function updateHealthUi(healthCode, freeHeap) {
     mh.className = 'v ' + (healthCode === 0 ? 'ok' : healthCode === 1 ? 'warn' : 'err');
   }
 }
+/**
+ * 每次 pollStatus 成功后刷新堆/栈/CPU（固定周期约 1000ms，中继期 400ms；
+ * sample_ms 由设备两次采样墙钟差给出；WiFi 上传 ESP32 期间 pause 不刷）。
+ */
 export function updateHeapAndTaskStatusUi(data) {
   if (!data) return;
   var ota = data.ota || {};
-  var wifi = data.wifi || {};
-  var targetHost = window.getBaseUrl().replace(/^http:\/\//, '');
   var setText = function (id, value) {
     var el = document.getElementById(id);
     if (el) el.textContent = value;
   };
+
   // ---- 堆概况：已用 / 总计 + 占用条 ----
   function setFill(id, pct) {
     var el = document.getElementById(id);
@@ -85,10 +87,10 @@ export function updateHeapAndTaskStatusUi(data) {
     el.style.width = safePct + '%';
     el.className = 'heap-bar-fill cpu-fill' + (safePct >= 85 ? ' danger' : safePct >= 70 ? ' warn' : '');
   }
-  function updateCpuUsageUi(cpu) {
-    cpu = cpu || {};
+  function updateCpuUsageUi(cpuData) {
+    cpuData = cpuData || {};
     var taskList = document.getElementById('cpuTaskList');
-    if (!cpu.available) {
+    if (!cpuData.available) {
       setText('cpuUsageText', '未启用 FreeRTOS 统计');
       setText('cpuUsagePct', '--');
       setText('cpuIdlePct', '--');
@@ -98,7 +100,7 @@ export function updateHeapAndTaskStatusUi(data) {
       if (taskList) taskList.innerHTML = '<div class="status-empty">固件未启用 CPU runtime stats</div>';
       return;
     }
-    if (!cpu.valid) {
+    if (!cpuData.valid) {
       setText('cpuUsageText', '等待下一次采样...');
       setText('cpuUsagePct', '--');
       setText('cpuIdlePct', '--');
@@ -108,10 +110,10 @@ export function updateHeapAndTaskStatusUi(data) {
       if (taskList) taskList.innerHTML = '<div class="status-empty">首次刷新只建立基线，下一次刷新后显示 CPU 占用</div>';
       return;
     }
-    var usagePct = Number(cpu.usage_pct) || 0;
-    var idlePct = Number(cpu.idle_pct) || 0;
-    var sampleMs = Number(cpu.sample_ms) || 0;
-    var tasks = Array.isArray(cpu.tasks) ? cpu.tasks.slice() : [];
+    var usagePct = Number(cpuData.usage_pct) || 0;
+    var idlePct = Number(cpuData.idle_pct) || 0;
+    var sampleMs = Number(cpuData.sample_ms) || 0;
+    var tasks = Array.isArray(cpuData.tasks) ? cpuData.tasks.slice() : [];
     tasks.sort(function (a, b) {
       return (Number(b.usage_pct) || 0) - (Number(a.usage_pct) || 0);
     });
@@ -159,7 +161,6 @@ export function updateHeapAndTaskStatusUi(data) {
 
   setText('sOtaState', (ota.sys_state || '--') + (Number.isFinite(ota.sys_state_code) ? ' (' + ota.sys_state_code + ')' : ''));
   setText('sRelayState', Number.isFinite(ota.relay_state) ? String(ota.relay_state) : '--');
-  // 缓存最近一次成功的 sys_state_code / relay_state，供 pollStatus 失败时判断设备是否在忙
   if (Number.isFinite(ota.sys_state_code)) window.lastSysStateCode = ota.sys_state_code;
   if (Number.isFinite(ota.relay_state)) window.lastRelayState = ota.relay_state;
   var storedText = '--';
@@ -205,6 +206,45 @@ export function updateHeapAndTaskStatusUi(data) {
     statusJson.textContent = JSON.stringify(data, null, 2);
   }
 }
+/** 从设备 IP 推导网关 IP（取前三段 + .1） */
+function getGatewayIp() {
+  var parts = (window.getEspIp ? window.getEspIp() : '192.168.31.127').split('.');
+  if (parts.length === 4) return parts[0] + '.' + parts[1] + '.' + parts[2] + '.1';
+  return '192.168.31.1';
+}
+
+/**
+ * 网络诊断：区分浏览器离线 / 网关不通 / 仅设备不通。
+ * 放在 connection.js，避免与 polling.js 形成循环 import。
+ */
+export async function diagnoseNetwork() {
+  var result = [];
+  if (navigator.onLine === false) {
+    result.push('浏览器无网络连接');
+    return result.join('；');
+  }
+  var gwIp = getGatewayIp();
+  var gwOk = false;
+  try {
+    await fetch('http://' + gwIp + '/', { mode: 'no-cors', signal: AbortSignal.timeout(2000) });
+    gwOk = true;
+  } catch (_) {}
+  if (!gwOk) {
+    try {
+      await fetch('http://' + gwIp + '/favicon.ico', { mode: 'no-cors', signal: AbortSignal.timeout(1500) });
+      gwOk = true;
+    } catch (_) {}
+  }
+  if (!gwOk) {
+    result.push('网关 ' + gwIp + ' 不可达（本地网络不通）');
+  } else {
+    result.push('网关 ' + gwIp + ' 可达');
+    var espIp = window.getEspIp ? window.getEspIp() : '设备';
+    result.push('设备 ' + espIp + ' 不响应（可能断电、重启中或 WiFi 断开）');
+  }
+  return result.join('；');
+}
+
 /** @description 测试与 ESP32 的连接（GET /status）。 */
 export async function testConnection() {
   // 立即发一次请求检测
@@ -232,7 +272,7 @@ export async function testConnection() {
   } catch (e) {
     addLog('E', '连接', '连接失败: ' + e.message);
     // 连接失败时自动诊断
-    var diag = await window.diagnoseNetwork();
+    var diag = await diagnoseNetwork();
     addLog('W', '诊断', diag);
     showToast('无法连接: ' + diag, 'error');
   } finally {

tools/js/common/log.js

@@ -1,7 +1,7 @@
 /**
  * log.js - 日志系统（带去重 + 自动滚动）
  *
- * 从 app.js 提取的日志环形缓冲、去重、过滤、自动滚动逻辑。
+ * 日志环形缓冲、去重、过滤、自动滚动逻辑。
  * 操作 DOM 元素 #logScroll / #logCount / #autoScrollBtn / .log-filter。
  */
 import { formatTime } from './utils.js';

tools/js/common/polling.js

@@ -1,14 +1,13 @@
 /**
  * polling.js - 轮询状态 + Page Visibility 补偿 + ESP32 实时日志拉取
  *
- * 从 app.js 的「轮询状态」「Page Visibility 补偿」「ESP32 实时日志拉取 (增量)」段提取。
  * 递归 setTimeout 调度 /system/status + setInterval 调度 /logs，避免 setInterval 慢响应被 abort。
  *
  * 模块级状态（仅本模块使用，不导出）：
  *   statusTimerId / logsTimerId / statusAbortCtrl / statusPollInFlight / statusPollIntervalMs
- *   lastDiagTime / diagResult / uploadPollChip / lastLogTimestamp / pageVisible
+ *   uploadPollChip / lastLogTimestamp / pageVisible
  *
- * 共享状态（通过 window.* 引用，后续 app.js 拆分时会统一挂载）：
+ * 共享状态（通过 window.* 引用）：
  *   window.pollingPausedForUpload   — 上传期间暂停轮询标志
  *   window.consecutivePollFailures  — 连续轮询失败计数（connection.js 也写入）
  *   window.lastSysStateCode         — 上次成功的 sys_state_code（connection.js 写入）
@@ -21,7 +20,7 @@
  *   window.activeUploadChip         — 当前上传目标芯片
  *   window.currentOtaTarget         — 当前 OTA 目标
  *
- * 未拆分的 app.js 函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.getEspIp / window.getBaseUrl
  *   window.updateSystemStatusUi / window.updateEsp32StagesFromPhase
  *   window.applyRebootingRuntimeState / window.applyDisconnectedRuntimeState / window.applyUploadingRuntimeState
@@ -30,7 +29,7 @@
  */
 import { addLog } from './log.js';
 import { showToast } from './toast.js';
-import { updateConnectionUi } from './connection.js';
+import { updateConnectionUi, diagnoseNetwork } from './connection.js';
 
 // ==================== 轮询状态 ====================
 // 共享状态（初始化到 window，供 connection.js 等其他模块读写）
@@ -41,66 +40,32 @@ window.lastRelayState = 0;     // 上次成功的 relay_state
 // 模块级状态（仅本模块使用）
 var statusTimerId = null;
 var logsTimerId = null;
-var lastDiagTime = 0;       // 上次诊断时间
-var diagResult = '';        // 最近一次诊断结果
 var statusAbortCtrl = null;  // 当前 /system/status 请求的 AbortController（3s 超时用）
-var statusPollIntervalMs = 1000;  // 状态轮询目标间隔
+var statusPollIntervalMs = 1000;  // 状态轮询目标间隔（中继期可由 setStatusPollIntervalMs 降到 400ms）
 var statusPollInFlight = false;   // 是否正在请求 /system/status，防止重叠
 var pageVisible = !document.hidden;   // 页面可见性：切到后台/最小化/切标签会变 false
 var uploadPollChip = null; // 当前暂停轮询的上传目标，用于区分 WiFi/日志策略
 
-// 从设备 IP 推导网关 IP（取前三段 + .1）
-function getGatewayIp() {
-  var parts = window.getEspIp().split('.');
-  if (parts.length === 4) return parts[0] + '.' + parts[1] + '.' + parts[2] + '.1';
-  return '192.168.31.1';
-}
-// 网络诊断：区分浏览器离线 / 网关不通 / 仅设备不通
-async function diagnoseNetwork() {
-  lastDiagTime = Date.now();
-  var result = [];
-  // 1) 浏览器是否在线
-  if (navigator.onLine === false) {
-    result.push('浏览器无网络连接');
-    diagResult = result.join('；');
-    return diagResult;
-  }
-  // 2) 尝试触达网关（超时 2s）
-  var gwIp = getGatewayIp();
-  var gwOk = false;
-  try {
-    await fetch('http://' + gwIp + '/', { mode: 'no-cors', signal: AbortSignal.timeout(2000) });
-    gwOk = true; // no-cors 模式下不抛异常即视为可达
-  } catch (_) {}
-  if (!gwOk) {
-    // 再试一次 favicon（有些路由器不响应 /）
-    try {
-      await fetch('http://' + gwIp + '/favicon.ico', { mode: 'no-cors', signal: AbortSignal.timeout(1500) });
-      gwOk = true;
-    } catch (_) {}
-  }
-  if (!gwOk) {
-    result.push('网关 ' + gwIp + ' 不可达（本地网络不通）');
-  } else {
-    result.push('网关 ' + gwIp + ' 可达');
-    // 3) 网关通但设备不通 → 设备自身问题
-    result.push('设备 ' + window.getEspIp() + ' 不响应（可能断电、重启中或 WiFi 断开）');
-  }
-  diagResult = result.join('；');
-  return diagResult;
+/**
+ * 调整 /system/status 目标间隔。GD32 中继期用 400ms 缩小「转发 N/M」相对设备日志的滞后；
+ * 结束后恢复 1000ms，避免常态堆/栈卡片过刷。
+ */
+export function setStatusPollIntervalMs(ms) {
+  var n = Number(ms);
+  if (!Number.isFinite(n) || n < 200) n = 1000;
+  if (n > 5000) n = 5000;
+  statusPollIntervalMs = n;
 }
+
 /** @description 调度下一次 /system/status 轮询（递归 setTimeout）。
- *  上一次请求完成（或 3s 超时）后才调度下一次，避免 setInterval 把慢响应
- *  直接 abort 而导致堆/任务栈/CPU 等卡片刷新率不稳。
+ *  默认 delay = statusPollIntervalMs；pollStatus 完成后会按「固定周期」
+ *  传入 max(0, interval - 本轮耗时)，使 CPU 采样窗口 sample_ms ≈ interval，
+ *  而不是「完成后 + interval」（会稳定偏到 1100+ ms）。
+ *  仍保证 in-flight 不重叠，避免 setInterval 慢响应被 abort。
  */
 export function scheduleStatusPoll(delayMs) {
   if (statusTimerId) clearTimeout(statusTimerId);
-  // 中继期加快：进度条依赖 status.relay_seq，1s 间隔体感像卡死
   var interval = statusPollIntervalMs;
-  // 防御性守卫：window.OtaSessionState 可能尚未挂载（模块加载早期），此时不加速
-  if (window.OtaSessionState && window.otaSessionState === window.OtaSessionState.RELAYING) {
-    interval = Math.min(interval, 400);
-  }
   statusTimerId = setTimeout(function() {
     statusTimerId = null;
     pollStatus();
@@ -161,8 +126,9 @@ export async function pollStatus() {
   // 递归 setTimeout 调度，正常情况下不会重叠；做个保险避免并发请求
   if (statusPollInFlight) return;
   statusPollInFlight = true;
+  var pollStartedAt = Date.now();
   statusAbortCtrl = new AbortController();
-  var pollTimer = setTimeout(function() { try { statusAbortCtrl.abort(); } catch(_e) {} }, 3000);
+  var pollTimer = setTimeout(function() { try { statusAbortCtrl.abort(); } catch(_e) {} }, 5000);
   try {
     var resp = await fetch(window.getBaseUrl() + '/system/status', {
       signal: statusAbortCtrl.signal
@@ -287,7 +253,13 @@ export async function pollStatus() {
     }
   } finally {
     statusPollInFlight = false;
-    scheduleStatusPoll();
+    statusAbortCtrl = null;
+    /* 固定周期调度：interval 从本轮开始计时扣减请求耗时。
+     * 旧逻辑「完成后 + 1000ms」→ 窗口稳定 1100+；现 sample_ms 贴近 1000/400。
+     * 本轮超时/很慢时 delay=0，立即补下一轮，仍不重叠。 */
+    var elapsed = Date.now() - pollStartedAt;
+    var delay = Math.max(0, statusPollIntervalMs - elapsed);
+    scheduleStatusPoll(delay);
   }
 }
 // 注意：startPoll() 由入口模块（app.js / ble_ota.js）在所有模块加载完成后调用，
@@ -316,7 +288,7 @@ export async function pollLogs() {
   // ★ ESP32 上传期间也允许日志轮询
   try {
     var resp = await fetch(window.getBaseUrl() + '/logs', {
-      signal: AbortSignal.timeout(2000)
+      signal: AbortSignal.timeout(5000)
     });
     if (!resp.ok) return;
     var logs = await resp.json();
@@ -338,6 +310,18 @@ export async function pollLogs() {
           showToast('ESP32 已恢复在线', 'success');
           if (window.otaSessionState === window.OtaSessionState.REBOOTING) window.otaSessionTransition(window.OtaSessionState.DONE);
         }
+        /*
+         * 设备已报「全部数据包已转发」时，立刻补 UI 100% 进度。
+         * status 轮询可能仍停在旧 relay_seq，否则会出现 FINISH 日志之后还刷 94%。
+         */
+        if (m[2] === 'OTA' && /全部数据包已转发/.test(m[3]) &&
+            typeof window.emitRelayProgress === 'function') {
+          var otaSnap = (window.latestSystemStatus && window.latestSystemStatus.ota) || {};
+          var tot = Number(otaSnap.relay_total_packets) || 0;
+          if (tot > 0) {
+            window.emitRelayProgress(tot, tot, { force100: true });
+          }
+        }
       } else {
         addLog('I', 'ESP32', line.trimEnd());
       }

tools/js/common/toast.js

@@ -1,7 +1,7 @@
 /**
  * toast.js - Toast 提示组件
  *
- * 从 app.js 提取的 showToast 函数，操作 DOM 元素 #toast / #toastIco / #toastMsg。
+ * showToast 函数，操作 DOM 元素 #toast / #toastIco / #toastMsg。
  * 支持 info / success / warning / error 类型，内置 5s 去重防抖。
  */
 /** @description 显示 Toast 提示消息，支持 info/success/warning/error 类型。 */

tools/js/common/utils.js

@@ -1,7 +1,7 @@
 /**
  * utils.js - 通用工具函数
  *
- * 从 app.js 提取的格式化 / 转义工具函数，供各子模块和 can.js / can_monitor.js 共享。
+ * 格式化 / 转义工具函数，供各子模块和 can.js / can_monitor.js 共享。
  */
 // ==================== 工具函数 ====================
 /** @description 格式化字节大小为人类可读字符串（B/KB/MB）。 */

tools/js/ota/file-handle.js

@@ -1,14 +1,13 @@
 /**
  * file-handle.js - 文件处理 + Intel HEX → BIN 转换
  *
- * 从 app.js 的「文件处理」「Intel HEX → BIN 转换」「文件处理」段提取。
  * 包含：HEX 解析、文件选择、FSAPI、SHA-256 计算、文件信息 UI、清除。
  *
  * 共享状态（通过 window.* 引用）：
  *   window.esp32File / window.gd32File / window.esp32FileHandle / window.gd32FileHandle
  *   window._esp32FileSha256 / window._gd32FileSha256
  *
- * 未拆分的函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.updateUploadButtonLabel / window.showToast / window.addLog
  */
 import { formatBytes } from '../common/utils.js';
@@ -179,6 +178,73 @@ export async function convertHexFileToBin(file) {
   return { file: binFile, converted: true, baseAddr: result.baseAddr, endAddr: result.endAddr };
 }
 
+// ==================== SHA-256 缓存 ====================
+// 选文件时就把 SHA-256 算好并缓存（同时记录 file meta），上传前
+// 若 handle.getFile() 拿回的 fresh file meta 未变就直接复用，
+// 避免每次点上传都重算 30–80ms 的 crypto.subtle.digest。
+// 缓存 key：size + lastModified + name 三项均一致（lastModified 在
+// 文件 rebuild 后必变，是浏览器给的最可靠 rebuild 信号）。
+/**
+ * @description 计算 file 的 SHA-256 并写入缓存（sha + meta）。
+ *              GD32 UI 无 SHA 显示行；ESP32 同步更新 #fileSha256Esp32。
+ * @param {File} file 目标文件
+ * @param {'esp32'|'gd32'} chip 通道
+ * @param {ArrayBuffer=} optArrayBuffer 已读的 arrayBuffer（避免重复读取）
+ * @returns {Promise<string|null>} hex 大写 SHA，失败返回 null
+ */
+function _computeAndCacheFileSha(file, chip, optArrayBuffer) {
+  var suffix = chip === 'esp32' ? 'Esp32' : 'Gd32';
+  var shaElem = document.getElementById('fileSha256' + suffix); // GD32 可能为 null
+  if (shaElem) shaElem.textContent = '计算中...';
+  var bufPromise = optArrayBuffer ? Promise.resolve(optArrayBuffer) : file.arrayBuffer();
+  return bufPromise.then(function(buf) {
+    return crypto.subtle.digest('SHA-256', buf);
+  }).then(function(hashBuffer) {
+    var hashArray = Array.from(new Uint8Array(hashBuffer));
+    var hashHex = hashArray.map(function(b) { return b.toString(16).padStart(2, '0'); }).join('').toUpperCase();
+    if (shaElem) shaElem.textContent = hashHex;
+    var meta = { size: file.size, lastModified: file.lastModified, name: file.name };
+    if (chip === 'esp32') {
+      window._esp32FileSha256 = hashHex;
+      window._esp32FileShaMeta = meta;
+    } else {
+      window._gd32FileSha256 = hashHex;
+      window._gd32FileShaMeta = meta;
+    }
+    addLog('I', '文件', chip.toUpperCase() + ' 固件 SHA-256: ' + hashHex);
+    return hashHex;
+  }).catch(function(err) {
+    if (shaElem) shaElem.textContent = '计算失败: ' + err.message;
+    addLog('W', '文件', chip.toUpperCase() + ' SHA-256 计算失败: ' + err.message);
+    if (chip === 'esp32') { window._esp32FileSha256 = null; window._esp32FileShaMeta = null; }
+    else { window._gd32FileSha256 = null; window._gd32FileShaMeta = null; }
+    return null;
+  });
+}
+
+/**
+ * @description 确保 file 的 SHA-256 已在缓存中：命中直接返回，不命中则重算并缓存。
+ * @param {File} file 目标文件
+ * @param {'esp32'|'gd32'} chip 通道
+ * @param {ArrayBuffer=} optArrayBuffer 命中时不用，未命中时传入可避免重复读文件
+ * @returns {Promise<string|null>} hex 大写 SHA
+ */
+export function ensureFileShaCached(file, chip, optArrayBuffer) {
+  var cachedMeta = chip === 'esp32' ? window._esp32FileShaMeta : window._gd32FileShaMeta;
+  var cachedSha  = chip === 'esp32' ? window._esp32FileSha256  : window._gd32FileSha256;
+  if (cachedSha && cachedMeta &&
+      cachedMeta.size === file.size &&
+      cachedMeta.lastModified === file.lastModified &&
+      cachedMeta.name === file.name) {
+    // 命中：把 UI 上的 SHA 同步刷一下（幂等），避免其它代码误清
+    var shaElem = document.getElementById(chip === 'esp32' ? 'fileSha256Esp32' : 'fileSha256Gd32');
+    if (shaElem) shaElem.textContent = cachedSha;
+    addLog('I', '文件', chip.toUpperCase() + ' 复用已缓存 SHA-256（文件未变）');
+    return Promise.resolve(cachedSha);
+  }
+  return _computeAndCacheFileSha(file, chip, optArrayBuffer);
+}
+
 // ==================== 文件处理 ====================
 /** @description 处理用户选择的固件文件（HEX→BIN 转换、SHA-256 计算、文件校验）。 */
 export function processFile(file, chip) {
@@ -196,6 +262,7 @@ export function processFile(file, chip) {
         document.getElementById('fileType' + suffix).textContent = 'Binary(?)';
         document.getElementById('fileSize' + suffix).textContent = formatBytes(file.size);
         window.updateUploadButtonLabel();
+        ensureFileShaCached(file, 'gd32');
         return;
       }
       window.gd32File = result.file;
@@ -208,6 +275,7 @@ export function processFile(file, chip) {
       document.getElementById('fileType' + suffix).textContent = 'Binary (HEX转换)';
       document.getElementById('fileSize' + suffix).textContent = formatBytes(result.file.size);
       window.updateUploadButtonLabel();
+      ensureFileShaCached(result.file, 'gd32');
     }).catch(function(err) {
       addLog('E', '文件', 'HEX 解析失败: ' + err.message);
       showToast('HEX 文件解析失败: ' + err.message, 'error');
@@ -228,32 +296,21 @@ export function processFile(file, chip) {
   window.updateUploadButtonLabel();
   addLog('I', '文件', chip.toUpperCase() + ' 已选择: ' + file.name + ' (' + formatBytes(file.size) + ')');
   showToast(chip.toUpperCase() + ' 文件已选择', 'success');
-  // ESP32 文件: 计算并显示 SHA-256
-  if (chip === 'esp32') {
-    var shaElem = document.getElementById('fileSha256' + suffix);
-    if (shaElem) {
-      shaElem.textContent = '计算中...';
-      file.arrayBuffer().then(function(buf) {
-        return crypto.subtle.digest('SHA-256', buf);
-      }).then(function(hashBuffer) {
-        var hashArray = Array.from(new Uint8Array(hashBuffer));
-        var hashHex = hashArray.map(function(b) { return b.toString(16).padStart(2, '0'); }).join('');
-        shaElem.textContent = hashHex.toUpperCase();
-        // 存储到全局变量供上传时使用
-        window._esp32FileSha256 = hashHex.toUpperCase();
-        addLog('I', '文件', 'ESP32 固件 SHA-256: ' + hashHex.toUpperCase());
-      }).catch(function(err) {
-        shaElem.textContent = '计算失败: ' + err.message;
-      });
-    }
-  }
+  // 选文件时就把 SHA-256 算好并缓存（ESP32/GD32 都算），
+  // 上传时若文件未变 ensureFileShaCached 命中直接复用。
+  ensureFileShaCached(file, chip);
 }
 
 /** @description 清除已选固件文件并重置对应 UI 状态。 */
 export function clearFile(chip) {
   var suffix = chip === 'esp32' ? 'Esp32' : 'Gd32';
-  if (chip === 'esp32') { window.esp32File = null; window.esp32FileHandle = null; window._esp32FileSha256 = null; }
-  else { window.gd32File = null; window.gd32FileHandle = null; }
+  if (chip === 'esp32') {
+    window.esp32File = null; window.esp32FileHandle = null;
+    window._esp32FileSha256 = null; window._esp32FileShaMeta = null;
+  } else {
+    window.gd32File = null; window.gd32FileHandle = null;
+    window._gd32FileSha256 = null; window._gd32FileShaMeta = null;
+  }
   document.getElementById('fileInput' + suffix).value = '';
   document.getElementById('fileInfo' + suffix).classList.remove('show');
   var shaElem = document.getElementById('fileSha256' + suffix);

tools/js/ota/progress.js

@@ -1,13 +1,12 @@
 /**
  * progress.js - 折叠面板 + 刷写进度 + 阶段节点 UI
  *
- * 从 app.js 的「折叠面板」「刷写进度」段提取。
  * 操作 DOM: #esp32Stages / #gd32Stages / #stageStatusBar / #progressFill / #progressTxt / #progressPct
  *
  * 共享状态（通过 window.* 引用）：
  *   window.activePhase / window.currentOtaTarget / window.esp32OtaPhase
  *
- * 未拆分的函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.updateStagesFromRelayState / window.cleanupAfterOtaFailure
  *   window.resumePollingAfterUpload / window.addLog
  */

tools/js/ota/session.js

@@ -1,8 +1,7 @@
 /**
  * session.js - 前端 OTA 会话状态机
  *
- * 从 app.js 的「全局状态」+「前端 OTA 会话状态机」段提取。
- * 统一管理一次 OTA 会话的完整生命周期，消除散布的布尔标志
+ * 统一管理一次 OTA 会话的完整生命周期，避免散布的布尔标志
  * (isUploading / currentOtaTarget / activeUploadChip / isEsp32Rebooting)
  * 在网络错误后被轮询错误覆盖、状态混乱的问题。
  *
@@ -20,7 +19,7 @@
  *   window.gd32CompleteAnnounced / window.relayWatchLastSeq / window.gd32RelaySessionLive
  *   window.lastSysStateCode / window.lastRelayState
  *
- * 未拆分的函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.stopRelayProgressWatch / window.setProgress / window.addLog
  */
 import { addLog } from '../common/log.js';

tools/js/ota/spi.js

@@ -1,10 +1,9 @@
 /**
  * spi.js - SPI 帧构建与发送
  *
- * 从 app.js 的「SPI 发送」段提取。
  * 操作 DOM: #spiType / #spiData / #spiTimeout / #spiHint / #spiResp / #spiRespText
  *
- * 未拆分的函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.getBaseUrl / window.showToast / window.addLog
  */
 import { showToast } from '../common/toast.js';

tools/js/ota/stages.js

@@ -1,7 +1,6 @@
 /**
  * stages.js - OTA 阶段驱动 (真实状态)
  *
- * 从 app.js 的「OTA 阶段驱动 (真实状态)」段提取。
  * 将设备端 relay_state / sys_state 映射到 GD32 阶段节点 UI，
  * 并驱动 updateSystemStatusUi 综合 UI 更新。
  *
@@ -11,7 +10,7 @@
  *   window.gd32CompleteAnnounced / window.gd32RelaySessionLive
  *   window.lastSysStateCode / window.lastRelayState
  *
- * 未拆分的函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.updateHeapAndTaskStatusUi / window.updateConnectionUi / window.updateHealthUi
  *   window.updateStagesFromRelayState / window.setActivePhase / window.setProgress
  *   window.markGd32OtaUiComplete / window.cleanupAfterOtaFailure / window.otaSessionReset
@@ -234,6 +233,16 @@ export function updateSystemStatusUi(data) {
     if (isGd32Relaying || (rs >= 1 && rs <= 4)) {
       window.gd32RelaySessionLive = true;
     }
+    /* 包进度：进入 FINISHING/COMPLETE 时先补 100%，再走完成/收尾 UI */
+    if (window.gd32RelaySessionLive && relayTotal > 0 &&
+        (relaySeq >= relayTotal || rs >= 4 || isGd32Complete)) {
+      if (typeof window.emitRelayProgress === 'function') {
+        window.emitRelayProgress(relayTotal, relayTotal, { force100: true });
+      }
+    } else if (window.gd32RelaySessionLive && relayTotal > 0 && relaySeq > 0 &&
+               typeof window.emitRelayProgress === 'function') {
+      window.emitRelayProgress(relaySeq, relayTotal);
+    }
     if (window.gd32RelaySessionLive &&
         (isGd32Complete || rs === 5 ||
          (gd32AppAlive && relayTotal > 0 && relaySeq >= relayTotal && rs >= 3))) {
@@ -244,8 +253,14 @@ export function updateSystemStatusUi(data) {
       // HANDSHAKING
       setActivePhase('gd32Ota');
       setProgress(50, '握手与认证中...');
-    } else if (rs === 3 || (relayTotal > 0 && relaySeq > 0 && rs !== 5)) {
-      // TRANSFERRING
+    } else if (rs === 4) {
+      // FINISHING：转发已 100%，进度条进入收尾段（勿再落回中间百分比）
+      setActivePhase('gd32Ota');
+      if (!window.gd32CompleteAnnounced) {
+        setProgress(95, gd32AppAlive ? '收尾中…' : '收尾中，等待 APP 启动...');
+      }
+    } else if (rs === 3 || (relayTotal > 0 && relaySeq > 0 && rs !== 5 && rs !== 4)) {
+      // TRANSFERRING（不含 FINISHING）
       setActivePhase('gd32Ota');
       var relayOverall = 60 + Math.round(relayProgress * 0.30);
       var relayLabel = relayTotal > 0
@@ -258,11 +273,6 @@ export function updateSystemStatusUi(data) {
       setProgress(55, relayTotal > 0
         ? ('大小协商中（共 ' + relayTotal + ' 包）')
         : '固件大小协商中');
-    } else if (rs === 4) {
-      setActivePhase('gd32Ota');
-      if (!window.gd32CompleteAnnounced) {
-        setProgress(95, gd32AppAlive ? '收尾中…' : '收尾中，等待 APP 启动...');
-      }
     } else if (!window.gd32RelaySessionLive) {
       setActivePhase('gd32Ota');
       setProgress(48, '已触发中继，等待设备进入握手…');

tools/js/ota/upload-esp32.js

@@ -1,7 +1,6 @@
 /**
  * upload-esp32.js - ESP32 本机 OTA 上传流程 + 完成升级
  *
- * 从 app.js 的「上传固件」「ESP32 OTA 完成升级」段提取。
  * 包含：startUpload 入口（处理 esp32 + gd32 共用互斥/重读逻辑）、
  *       XHR 上传、SHA 校验、verifyEsp32Firmware、restartEsp32。
  *
@@ -10,7 +9,7 @@
  *   window._esp32FileSha256 / window._gd32FileSha256 / window.activeXhr
  *   window.isUploading / window.uploadBtnOrigText / window.activeUploadChip
  *
- * 未拆分的函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.otaSessionActive / window.otaSessionTerminated / window.otaSessionReset
  *   window.otaSessionTransition / window.OtaSessionState / window.otaSessionTarget
  *   window.cleanupAfterOtaFailure / window.pausePollingForUpload
@@ -31,6 +30,7 @@ import {
   startUploadWaitHeartbeat
 } from './session.js';
 import { updateEsp32StagesFromPhase, switchStageFlow, setActivePhase, setProgress, markPhaseDone, cleanupAfterOtaFailure } from './progress.js';
+import { ensureFileShaCached } from './file-handle.js';
 
 function isOtaBusyError(status, detail) {
   var text = (detail || '').toLowerCase();
@@ -104,9 +104,13 @@ export async function startUpload(chip) {
         var otaChannelName = ota.channel_name || (otaChannel === 1 ? 'BLE' : 'WIFI');
         // ESP32 RECEIVING(5) 可由同一 WiFi 通道的新上传接管；后台/休眠可能让 /ota/update 没发出，
         // 若这里提前拦截，后端 beginEsp32OtaWithRetry 的同通道清理分支永远没有机会执行。
-        // ERROR(8) 也放行给后端清理底层 OTA 句柄；FINALIZING(6)/REBOOTING(7) 是不可逆忙态。
-        if (ssc === 5 && otaChannel === 1 && _pi < 3) continue;
-        var esp32Busy = (ssc === 6 || ssc === 7 || (ssc === 5 && otaChannel !== 0));
+        // ERROR(8) 放行给后端清理；REBOOTING(7) 不可逆。
+        // FINALIZING(6)：真收尾时后端会 403；SHA 失败后可能假占用（core 已空），
+        // status 自愈 / begin 残留清理需要请求触达设备，前端同通道不硬拦。
+        if ((ssc === 5 || ssc === 6) && otaChannel === 1 && _pi < 3) continue;
+        var esp32Busy = (ssc === 7 ||
+          (ssc === 6 && otaChannel !== 0) ||
+          (ssc === 5 && otaChannel !== 0));
         // GD32 STORING(1) 可由同一 WiFi 通道的新上传接管；RELAYING(3) 不可中断。
         var gd32Busy = (ssc === 3 || (ssc === 1 && otaChannel !== 0));
         if ((esp32Busy || gd32Busy)) {
@@ -183,31 +187,10 @@ export async function startUpload(chip) {
   showToast('开始上传固件到 ' + chip.toUpperCase(), 'success');
   try {
     var arrayBuffer = await file.arrayBuffer();
-    // 刷写时重新计算 SHA-256（ESP32 和 GD32 都算）
-    if (chip === 'esp32') {
-      try {
-        var hashBuffer = await crypto.subtle.digest('SHA-256', arrayBuffer);
-        var hashArray = Array.from(new Uint8Array(hashBuffer));
-        var hashHex = hashArray.map(function(b) { return b.toString(16).padStart(2, '0'); }).join('');
-        window._esp32FileSha256 = hashHex.toUpperCase();
-        var shaElem = document.getElementById('fileSha256Esp32');
-        if (shaElem) shaElem.textContent = window._esp32FileSha256;
-        addLog('I', '文件', '刷写前重新计算 SHA-256: ' + window._esp32FileSha256);
-      } catch (e) {
-        addLog('W', '文件', 'SHA-256 重新计算失败: ' + e.message);
-      }
-    } else if (chip === 'gd32') {
-      try {
-        var hashBuffer = await crypto.subtle.digest('SHA-256', arrayBuffer);
-        var hashArray = Array.from(new Uint8Array(hashBuffer));
-        var hashHex = hashArray.map(function(b) { return b.toString(16).padStart(2, '0'); }).join('');
-        window._gd32FileSha256 = hashHex.toUpperCase();
-        addLog('I', '文件', 'GD32 SHA-256: ' + window._gd32FileSha256);
-      } catch (e) {
-        addLog('W', '文件', 'GD32 SHA-256 重新计算失败: ' + e.message);
-        window._gd32FileSha256 = null;
-      }
-    }
+    // SHA-256：processFile 阶段已算好并缓存；这里若 handle.getFile() 拿回的
+    // fresh file meta 未变就直接复用（命中 30–100ms/MB 的计算）；
+    // 用户 rebuild 使 lastModified 变化时 ensureFileShaCached 自动 fallback 到重算。
+    await ensureFileShaCached(file, chip, arrayBuffer);
     var fileSize = file.size;
     var body, url = window.getBaseUrl() + '/ota/upload';
     if (chip === 'esp32') {

tools/js/ota/upload-gd32.js

@@ -1,7 +1,6 @@
 /**
  * upload-gd32.js - GD32 中继 OTA 触发 + relay 态跟踪
  *
- * 从 app.js 的「GD32 OTA 触发（带 SHA-256 校验，对齐 BLE 0xF7）」段提取。
  * 包含：relay 进度观察定时器、markGd32OtaUiComplete、triggerGd32Relay。
  *
  * 共享状态（通过 window.* 引用）：
@@ -9,7 +8,7 @@
  *   window.pollingPausedForUpload / window.statusPollIntervalMs
  *   window.otaSessionState / window.lastSysStateCode / window.lastRelayState
  *
- * 未拆分的函数（通过 window.* 引用）：
+ * 复用的函数（通过 window.* 引用）：
  *   window.otaSessionTransition / window.OtaSessionState / window.otaSessionActive
  *   window.markPhaseDone / window.setProgress / window.updateSystemStatusUi
  *   window.cleanupAfterOtaFailure / window.scheduleStatusPoll / window.pollLogs
@@ -26,16 +25,61 @@ import { markPhaseDone, setProgress } from './progress.js';
  * GD32 中继进度观察：以 /system/status 为唯一真相源。
  * 日志环只有 64 条，中继/擦除期间 INFO 会被挤掉，时间戳还是浏览器本地时间——
  * 绝不能用「最后一条日志停在 SEND_SIZE」判断卡死。
+ *
+ * 时序约定（避免「设备已 FINISH / 完成，UI 还在 94%」）：
+ *   1) 包进度变化先刷进度条 + 日志；
+ *   2) 一旦 rseq>=rtot 或 rs>=4(FINISHING)，先强制打出 100% 再进收尾/完成；
+ *   3) markGd32OtaUiComplete 前再兜底一次 100%。
  */
 let relayWatchTimerId = null;
-let relayWatchInFlight = false;
 window.gd32CompleteAnnounced = false;
 window.relayWatchLastSeq = -1;
 /** 本会话是否已观察到真实中继态（1~4），避免旧 relay_state=5 残留导致一点击就“完成” */
 window.gd32RelaySessionLive = false;
 
+/**
+ * 包进度变更时更新进度条并写一条「转发」日志（同 seq 不重复）。
+ * @param {number} rseq
+ * @param {number} rtot
+ * @param {{force100?: boolean}} [opts]
+ * @returns {boolean} 是否实际输出了进度
+ */
+export function emitRelayProgress(rseq, rtot, opts) {
+  opts = opts || {};
+  rseq = Number(rseq) || 0;
+  rtot = Number(rtot) || 0;
+  if (rtot <= 0) return false;
+  if (opts.force100 || rseq >= rtot) {
+    rseq = rtot;
+  }
+  if (rseq <= 0) return false;
+  if (rseq === window.relayWatchLastSeq) return false;
+  window.relayWatchLastSeq = rseq;
+  var pct = Math.min(100, Math.round(rseq * 100 / rtot));
+  setProgress(60 + Math.round(pct * 0.30),
+    '已转发 ' + rseq + ' / ' + rtot + ' 包 (' + pct + '%)');
+  addLog('I', 'OTA', '转发 ' + rseq + '/' + rtot + ' (' + pct + '%)');
+  return true;
+}
+
+/** 完成/收尾前：若尚未打出 100%，用 status 里的包数补一条 */
+export function ensureRelayProgressComplete() {
+  var data = window.latestSystemStatus;
+  var o = (data && data.ota) || {};
+  var rtot = Number(o.relay_total_packets) || 0;
+  var rseq = Number(o.relay_seq) || 0;
+  if (rtot <= 0) return;
+  /* FINISHING/DONE 时后端 seq 已到 total；status 滞后时也强制 100% */
+  if (rseq < rtot && (Number(o.relay_state) >= 4 || Number(o.sys_state_code) === 4)) {
+    rseq = rtot;
+  }
+  if (rseq >= rtot) {
+    emitRelayProgress(rtot, rtot, { force100: true });
+  }
+}
+
 export function markGd32OtaUiComplete(msg) {
-  // 已公告过：禁止再改 className / setProgress / toast，否则每 400ms 重触发动效会「疯狂跳 ✓」
+  // 已公告过：禁止再改 className / setProgress / toast，否则定时器重触发动效会「疯狂跳 ✓」
   if (window.gd32CompleteAnnounced) {
     return;
   }
@@ -44,6 +88,8 @@ export function markGd32OtaUiComplete(msg) {
       window.otaSessionState !== OtaSessionState.FAILED) {
     return;
   }
+  /* 先 100% 转发进度，再宣布刷写完成 —— 避免日志里「完成」早于「1089/1089」 */
+  ensureRelayProgressComplete();
   window.gd32CompleteAnnounced = true;
   stopRelayProgressWatch();
 
@@ -67,18 +113,25 @@ export function stopRelayProgressWatch() {
     clearInterval(relayWatchTimerId);
     relayWatchTimerId = null;
   }
-  relayWatchInFlight = false;
-  if (window.statusPollIntervalMs < 1000) {
-    window.statusPollIntervalMs = 1000;
+  /* 中继结束：恢复常态 1s status 轮询 */
+  if (typeof window.setStatusPollIntervalMs === 'function') {
+    window.setStatusPollIntervalMs(1000);
   }
 }
 
+/**
+ * 中继进度观察：只读 pollStatus 写入的 latestSystemStatus，不再另起 /system/status。
+ * 中继期 status 加速到 400ms，使「转发 N/M」更贴近设备真实进度。
+ */
 export function startRelayProgressWatch() {
   stopRelayProgressWatch();
   if (window.pollingPausedForUpload) {
     window.resumePollingAfterUpload();
   }
-  window.statusPollIntervalMs = 400;
+  /* 中继期加速 status，缩小 UI 进度相对设备日志的滞后 */
+  if (typeof window.setStatusPollIntervalMs === 'function') {
+    window.setStatusPollIntervalMs(400);
+  }
   window.scheduleStatusPoll(0);
   window.pollLogs();
   addLog('I', 'OTA', '跟踪中继进度：看进度条与 relay_seq（/system/status），勿只看日志');
@@ -92,46 +145,38 @@ export function startRelayProgressWatch() {
       }
       return;
     }
-    if (relayWatchInFlight) return;
-    relayWatchInFlight = true;
-    fetch(window.getBaseUrl() + '/system/status', { signal: AbortSignal.timeout(3000) })
-      .then(function (resp) { return resp.ok ? resp.json() : null; })
-      .then(function (data) {
-        if (!data) return;
-        try { window.updateSystemStatusUi(data); } catch (e) { /* ignore */ }
-        var o = data.ota || {};
-        var code = Number(o.sys_state_code);
-        var rstate = Number(o.relay_state);
-        var alive = !!o.gd32_app_alive;
-        var rseq = Number(o.relay_seq) || 0;
-        var rtot = Number(o.relay_total_packets) || 0;
-        if (rstate >= 1 && rstate <= 4) {
-          window.gd32RelaySessionLive = true;
-        }
-        if (window.gd32RelaySessionLive &&
-            (code === 4 || rstate === 5 ||
-             (alive && rtot > 0 && rseq >= rtot && rstate >= 3))) {
-          markGd32OtaUiComplete('GD32 刷写完成');
-          window.pollLogs();
-          return;
-        }
-        if (code === 8 || rstate === 255) {
-          stopRelayProgressWatch();
-          window.pollLogs();
-          return;
-        }
-        // 前端进度同步：包数变化时更新进度条（updateSystemStatusUi 已做）并写一条前端日志
-        // 后端不再打「转发进度」文字，只靠这里 + 进度条
-        if (rtot > 0 && rseq > 0 && rseq !== window.relayWatchLastSeq) {
-          window.relayWatchLastSeq = rseq;
-          var pct = Math.round(rseq * 100 / rtot);
-          setProgress(60 + Math.round(pct * 0.30),
-            '已转发 ' + rseq + ' / ' + rtot + ' 包 (' + pct + '%)');
-          addLog('I', 'OTA', '转发 ' + rseq + '/' + rtot + ' (' + pct + '%)');
-        }
-      })
-      .catch(function () { /* 下轮继续 */ })
-      .then(function () { relayWatchInFlight = false; });
+    var data = window.latestSystemStatus;
+    if (!data || !data.ota) return;
+    var o = data.ota || {};
+    var code = Number(o.sys_state_code);
+    var rstate = Number(o.relay_state);
+    var alive = !!o.gd32_app_alive;
+    var rseq = Number(o.relay_seq) || 0;
+    var rtot = Number(o.relay_total_packets) || 0;
+    if (rstate >= 1 && rstate <= 4) {
+      window.gd32RelaySessionLive = true;
+    }
+    if (code === 8 || rstate === 255) {
+      stopRelayProgressWatch();
+      window.pollLogs();
+      return;
+    }
+    /*
+     * 顺序：先刷包进度（含强制 100%），再判定完成。
+     * FINISHING/DONE 时若 status 滞后未到 total，仍按 total 打 100%。
+     */
+    var transferDone = rtot > 0 && (rseq >= rtot || rstate >= 4 || code === 4);
+    if (transferDone) {
+      emitRelayProgress(rtot, rtot, { force100: true });
+    } else if (rtot > 0 && rseq > 0) {
+      emitRelayProgress(rseq, rtot);
+    }
+    if (window.gd32RelaySessionLive &&
+        (code === 4 || rstate === 5 ||
+         (alive && rtot > 0 && rseq >= rtot && rstate >= 3))) {
+      markGd32OtaUiComplete('GD32 刷写完成');
+      window.pollLogs();
+    }
   }, 400);
 }