refactor: 清理遗留死代码（−353 行）

仓库经多轮迭代积累了不少不再被引用的中间件代码。本次以当前前端依赖的
HTTP 端点为基准（/system/status、/logs、/can/send、/spi/send、/ota/upload、
/ota/update、/ota/relay、/restart），移除以下模块的未引用代码：

- main/transport/protocol.{h,cpp}（−257 行）
  * 移除 CMD_* / ACK_* 宏（CMD_HANDSHAKE_REQ 等 16 个）
  * 移除未引用方法：crc16Modbus、buildFrame、parseFrame、aesEncrypt、
    aesDecrypt、sessionEncrypt、sessionDecrypt、generateRandomNonce
  * 保留 init / scrambleGenerate / sessionKeyInit / sessionKeyClear
    （被 ota_relay 实际调用）

- main/relay/ota_relay.{h,cpp}（−84 行）
  * 移除未引用方法：startHandshake、probeBootHandshake、isStructuredAckWithPayload
  * 移除未使用枚举值：RELAY_HANDSHAKE_IDLE、RELAY_RECEIVING、RELAY_TRANSFER_DONE
  * 移除字段 ota_meta_t.chunk_count 与宏 OTA_META_NVS_KEY

- main/server/wifi_ota.cpp（−255 行）
  * 移除 6 个未被前端调用的 HTTP 端点：/health、/wifi/status、/can/status、
    /ota/status、/ota/esp32_status、/api/version
  * 移除其处理器与路由注册
  * 移除 mbedtls/private/sha256.h 直接引用（SHA-256 已委托 Esp32OtaCore）

- main/server/ble_ota.cpp、main/relay/ota_relay.cpp
  * 同步移除 chunk_count 引用

README.md

@@ -1,149 +1,565 @@
 # ESP32-C3 OTA Relay
 
-ESP32-C3FH4 OTA 中继固件，通过 WiFi 接收上位机 OTA 固件包，通过 SPI 转发给下位机（GD32）。
+**固件版本: v0.3.12** | 构建时间: 2026-06-14 | 基于 ESP-IDF v6.0
+
+## 项目概述
+
+ESP32-C3FH4 OTA 中继固件，作为 **GD32E508VET6** 的 OTA 升级桥梁。通过 **WiFi (HTTP)** 或 **BLE (GATT)** 从上位机（手机/PC）接收固件，存储在本地 SPI Flash 的 `gd32_ota` 分区，再通过 **SPI 总线** 经四阶段安全握手协议转发给 GD32。
+
+```
+[手机/PC 上位机] --WiFi/BLE--> [ESP32-C3FH4] --SPI--> [GD32E508VET6]
+                                  |
+                                  +-- gd32_ota 分区 (252KB)
+                                  +-- 健康自检 (温度 + WiFi RSSI)
+                                  +-- 本机 OTA (ESP32 自升级)
+```
 
 ## 硬件平台
 
-- **芯片:** ESP32-C3FH4 (RISC-V, 单核)
-- **Flash:** 4MB
-- **编译工具链:** ESP-IDF v6.0, riscv32-esp-elf
+| 项目 | 规格 |
+|------|------|
+| **芯片** | ESP32-C3FH4 (RISC-V, 单核, 160MHz) |
+| **Flash** | 4MB |
+| **SPI 引脚** | MOSI=GPIO5, MISO=GPIO7, SCLK=GPIO6, CS=GPIO4 |
+| **SPI 速率** | 4MHz, Mode 0 |
+| **UART 调试** | TX=GPIO21, RX=GPIO20, 115200 baud |
+| **编译工具链** | ESP-IDF v6.0, riscv32-esp-elf |
+
+### 分区表 (`config/partitions.csv`)
+
+| 分区 | 类型 | 偏移 | 大小 | 用途 |
+|------|------|------|------|------|
+| nvs | data/nvs | 0x9000 | 24KB | NVS 存储 |
+| otadata | data/ota | 0xF000 | 8KB | OTA 启动信息 |
+| gd32_ota | data/spiffs | 0x11000 | 252KB | GD32 固件缓存 |
+| app0 | app/ota_0 | 0x50000 | 1.25MB | ESP32 OTA 槽位 0 |
+| app1 | app/ota_1 | 0x190000 | 1.25MB | ESP32 OTA 槽位 1 |
+| spiffs | data/spiffs | 0x2D0000 | 1.06MB | 文件系统 |
 
 ## 功能模块
 
-| 模块 | 描述 |
-|------|------|
-| `health_monitor` | 温度 + WiFi RSSI 监控 |
-| `ota_relay` | OTA 数据包接收与转发 |
-| `wifi_ota` | WiFi OTA HTTP 服务器 + CAN 帧转发 |
-| `spi_master` | SPI 主站，与 GD32 通信 |
-| `protocol` | CRC16 校验 + AES-128-CBC 解密（硬件加速） |
+| 模块 | 文件 | 描述 |
+|------|------|------|
+| **core** | `core/main.cpp` | 程序入口，初始化各模块并创建 4 个 FreeRTOS 任务 |
+| **health_monitor** | `monitor/health_monitor.{h,cpp}` | 温度 + WiFi RSSI 监控，OTA 前健康检查 |
+| **debug_log** | `monitor/debug_log.{h,cpp}` | 三路日志输出：UART0 + UDP + 环形缓冲区 |
+| **ota_relay** | `relay/ota_relay.{h,cpp}` | GD32 OTA 中继核心状态机（四阶段 15 状态） |
+| **esp32_ota_core** | `ota/esp32_ota_core.{h,cpp}` | ESP32 本机 OTA 核心（begin/write/finalize/abort，WiFi/BLE 共用） |
+| **wifi_ota** | `server/wifi_ota.{h,cpp}` | WiFi AP/STA + HTTP OTA 服务器 + CAN 帧转发 |
+| **ble_ota** | `server/ble_ota.{h,cpp}` | BLE GATT 服务器（NimBLE 协议栈） |
+| **spi_master** | `transport/spi_master.{h,cpp}` | SPI 主站驱动 + CANFD 3 通道 + OTA 帧协议 |
+| **protocol** | `transport/protocol.{h,cpp}` | 协议层（nonce 搅伴生成、AES 会话密钥管理） |
 
 ## 目录结构
 
 ```
 ESP32_COMM/
-├── CMakeLists.txt
+├── CMakeLists.txt                    # 顶层 CMake 项目定义
+├── sdkconfig.defaults                # SDK 配置默认值 (WiFi RX/TX BA=6)
+├── config/
+│   └── partitions.csv                # 4MB Flash 分区表
+├── cmake/
+│   └── gen_version_script.cmake      # 构建时自动生成 version.h
 ├── main/
-│   ├── CMakeLists.txt
+│   ├── CMakeLists.txt                # 注册 11 个源文件 + 依赖
 │   ├── include/
-│   │   └── app_config.h      # WiFi / OTA 参数配置
-│   ├── core/main.cpp         # 任务创建入口
-│   ├── relay/ota_relay.cpp   # OTA 中继逻辑
+│   │   ├── app_config.h              # 统一配置 (constexpr: WiFi/BLE/OTA/阈值/密钥)
+│   │   ├── version.h                 # 自动生成版本信息 (v0.3.12)
+│   │   └── ota_mutex.h               # BLE/WiFi OTA 全局互斥
+│   ├── core/main.cpp                 # app_main 入口，4 个 FreeRTOS 任务
+│   ├── relay/ota_relay.{h,cpp}       # GD32 OTA 中继状态机
+│   ├── ota/esp32_ota_core.{h,cpp}    # ESP32 本机 OTA 核心
 │   ├── transport/
-│   │   ├── spi_master.cpp    # SPI 主站 + CANFD 3通道发送
-│   │   └── protocol.cpp      # 协议层 (CRC16 / AES-128-CBC)
+│   │   ├── spi_master.{h,cpp}        # SPI 主站 + CANFD 3 通道
+│   │   └── protocol.{h,cpp}          # 协议层 (CRC16 / AES / nonce)
 │   ├── server/
-│   │   └── wifi_ota.cpp      # WiFi OTA HTTP 服务器
+│   │   ├── wifi_ota.{h,cpp}          # WiFi OTA HTTP 服务器
+│   │   └── ble_ota.{h,cpp}           # BLE GATT OTA 服务器
 │   └── monitor/
-│       ├── health_monitor.cpp  # 健康监控
-│       └── debug_log.cpp       # UDP 调试日志
-└── tools/
-    └── ota_host_web.html     # 上位机 WebUI（CAN 发送 + OTA 上传）
+│       ├── health_monitor.{h,cpp}    # 温度 + RSSI 健康监控
+│       └── debug_log.{h,cpp}         # UART0 + UDP + 环形缓冲区日志
+├── components/
+│   └── cjson/                        # cJSON 组件
+├── managed_components/
+│   └── espressif__mdns/              # mDNS 组件
+├── tools/
+│   ├── index.html                    # WiFi OTA WebUI 控制台
+│   ├── ble_ota.html                  # BLE OTA WebUI 控制台 (Web Bluetooth)
+│   ├── app.js                        # WebUI JavaScript
+│   ├── style.css                     # WebUI 样式
+│   ├── serve.bat                     # Python HTTP 服务器启动脚本 (端口 8080)
+│   ├── serial_monitor.py             # 串口日志采集工具 (COM15)
+│   └── ota_upload_test.py            # OTA 上传测试脚本
+├── docs/
+│   ├── esp32_ota_relay_design.md     # 架构设计文档
+│   ├── DEVELOPMENT_GUIDE.md          # 开发者指南 (T0-T8)
+│   └── COMMUNICATION_AUDIT_2026-05-05.md  # 通信审计
+├── .vscode/                          # VS Code 调试/编译配置 (COM15, clangd)
+└── .devcontainer/                    # Docker 开发容器 (ESP-IDF 6.0)
 ```
 
-## WiFi 工作模式
+## FreeRTOS 任务
 
-支持 AP / STA 两种模式，通过 `app_config.h` 配置：
+4 个主任务全部固定运行在 ESP32-C3 单核（核 0），通过 FreeRTOS 队列通信：
 
-```c
-// AP 模式（ESP32 当热点）
-CONFIG_WIFI_MODE_IS_STA = 0
-WIFI_AP_SSID = "ESP32_OTA_RELAY"   // 默认热点名称
-WIFI_AP_PASSWORD = "12345678"      // 默认密码
-// 上位机连接热点后访问: http://192.168.31.1
+| 任务名 | 函数 | 优先级 | 栈大小 | 职责 |
+|--------|------|--------|--------|------|
+| `health_mon` | `HealthMonitor::taskEntry` | configMAX_PRIORITIES - 4 | 4096 | 温度监控 (1s 定时器) + 堆巡检 (5s) + 健康状态管理 |
+| `wifi_ota` | `WifiOta::taskEntry` | configMAX_PRIORITIES - 3 | 8192 | WiFi (AP/STA) + HTTP 服务器 (端口 80) + 状态轮询 |
+| `ble_ota` | `BleOta::taskEntry` | configMAX_PRIORITIES - 3 | 8192 | BLE GATT 服务器初始化 + NimBLE Host 任务 + 心跳保活 |
+| `ota_relay` | `OtaRelay::taskEntry` | configMAX_PRIORITIES - 2 | 12288 | 等待调度信号 → 四阶段状态机 → SPI 转发 |
 
-// STA 模式（连接路由器）
-CONFIG_WIFI_MODE_IS_STA = 1
-WIFI_STA_SSID = "004舰桥"          // 路由器名称
-WIFI_STA_PASSWORD = "q13362875622"  // 路由器密码
-// 上位机和 ESP32 在同一局域网，通过 DHCP 分配的 IP 访问
+额外后台任务：
+
+| 任务名 | 优先级 | 栈大小 | 职责 |
+|--------|--------|--------|------|
+| `wifi_reconnect` | 5 | 4096 | STA 断线重连（退避算法，独立任务避免死锁）|
+| `ble_ota_finish` | 5 | 4096 | BLE ESP32 OTA 异步收尾（SHA 校验 + end + reboot）|
+| `nimble_host` | NimBLE 内部 | NimBLE 内部 | BLE 协议栈事件循环 |
+
+### 跨任务通信
+
+- **OTA 调度**: WiFi/BLE 任务通过 `OtaRelay::dispatchQueue` (FreeRTOS 队列, 深度 4) 发送调度信号给 `ota_relay` 任务；结果通过 `resultQueue` 回传
+- **OTA 互斥**: `g_esp32OtaMutex` (全局 Mutex) + `g_esp32OtaOccupied` 标志，防止 BLE 和 WiFi 同时操作 ESP32 OTA 分区
+- **中继状态**: `OtaRelay::s_stateMutex` 保护 relayState/relaySeq/relayTotalPackets 等跨任务状态（`StateLockGuard` RAII 封装）
+- **WiFi 状态**: `WifiOta::m_stateMutex` + `std::atomic` 保护 WiFi 连接状态和重连计数器
+- **健康状态**: `HealthMonitor::m_mutex` 保护 healthState/temperature/RSSI
+- **UDP 日志**: `DebugLog::m_logRingMutex` 保护 HTTP `/logs` 环形缓冲区
+
+## OTA 核心流程
+
+### 一、GD32 OTA 中继（四阶段 + APP 验证）
+
+上位机上传 GD32 固件到 ESP32 本地 `gd32_ota` 分区 → 收到触发命令后启动状态机：
+
+```
+阶段1 ─ 安全握手 (5 状态)
+  RELAY_HANDSHAKE_SENT → RELAY_CHALLENGE_SENT → RELAY_CHALLENGE_RESPOND
+  → RELAY_SESSION_KEY_SENT → RELAY_AUTH_COMPLETE
+
+阶段2 ─ 固件大小协商 (2 状态)
+  RELAY_SIZE_SENT → RELAY_SIZE_ACK
+
+阶段3 ─ 数据包转发 (4 状态)
+  RELAY_RELAY_ACTIVE → RELAY_PACKET_SENT → RELAY_PACKET_ACK_OK
+  [重试] RELAY_PACKET_ACK_RETRY
+
+阶段4 ─ 完成与跳转 (3 状态)
+  RELAY_RECEIVE_DONE → RELAY_FINISH_SENT → RELAY_DONE
+
+阶段5 ─ APP 存活验证
+  RELAY_APP_VERIFY (PING GD32 APP, 最多 30 次 × 500ms)
 ```
 
-## CANFD 3通道 SPI 协议
+#### 安全握手协议
 
-GD32 通信帧格式：`[通道编号: 1B] [扩展帧ID: 4B BE] [数据: 1~64B]`
+1. **握手请求**: ESP32 发送 `0x00 0xAC`（最多重试 10 次，200ms 超时）
+2. **Challenge**: GD32 回复 36B 数据包（12B UID + 8B nonce 片段 + 16B 加密会话密钥）
+3. **验证**: ESP32 验证 nonce 匹配，用 MasterKey 派生 `K_session = AES(MasterKey, nonce_server)` 并比对
+4. **确认**: ESP32 发送 `nonce_server ^ 0x55` 经 `K_session` AES-ECB 加密
+5. **完成**: GD32 回复 `0xBA 0xC0`，建立 AES 加密通道
+
+#### 数据包转发
+
+- 每包 48 字节固件载荷，使用 `K_session` AES-ECB 加密
+- 包结构: `session(4B) + seq(4B) + encrypted48(48B) + if_end(4B) + crc32(4B)` = 64B
+- 每 32 包执行一次 OTA 健康检查（温度/堆）
+- 支持重试（单包最多 10 次），结构化 ACK 含 seq 校验，残留 ACK 自动过滤
+- 全局超时: 动态计算 5~10 分钟
+
+### 二、ESP32 本机 OTA（WiFi + BLE 共用）
+
+核心逻辑封装在 `Esp32OtaCore` 单例中，WiFi 和 BLE 通道共用：
+
+| 步骤 | 方法 | 说明 |
+|------|------|------|
+| 1 | `begin(total_size)` | 选择非当前 OTA 分区，获取全局互斥，`esp_ota_begin` |
+| 2 | `write(data, len)` | 循环调用 `esp_ota_write`（WiFi 通过 HTTP 流，BLE 通过 GATT 块） |
+| 3 | `finalize(sha_hex, reboot)` | `esp_ota_end` → 从分区读回计算 SHA-256 → 比对前端 SHA → `esp_ota_set_boot_partition` → 可选重启 |
+| - | `abort()` | 中止并清理（释放 mutex + 复位状态） |
+
+**SHA-256 校验**: 固件写入完成后从 OTA 分区读回计算，不做增量 SHA。前端与设备端比对一致才 set_boot，否则返回 `ESP_ERR_INVALID_VERSION`。
+
+**回滚保护**: `esp_ota_mark_app_valid_cancel_rollback()` 在启动时标记当前固件有效。启用 `CONFIG_APP_ROLLBACK_ENABLE` 后，新固件崩溃自动回退。
+
+## 通信协议
+
+### SPI OTA 帧格式（底层传输）
+
+`esp32_ota_core.cpp` 中的 `otaBuildFrame` / `otaParseFrame`：
+
+```
+| SOF(0xA5, 1B) | TYPE(1B) | LEN(2B LE) | PAYLOAD(LEN) | CRC8(1B) |
+```
+
+| TYPE | 名称 | 用途 |
+|------|------|------|
+| 0x01 | OTA_CMD_REQ | OTA 请求帧 |
+| 0x02 | OTA_CMD_DATA | OTA 数据帧 |
+| 0x03 | OTA_CMD_CANCEL | 取消 OTA |
+| 0xB0 | APP_ENTER_BOOT_CMD | 通知 GD32 APP 进入 Bootloader |
+| 0x80 | RSP_ACK | 响应：数据就绪 |
+| 0x81 | RSP_WAIT | 响应：GD32 忙，请等待 |
+| 0x82 | RSP_ERROR | 响应：错误 |
+
+### CANFD 3 通道 SPI 协议
+
+ESP32 通过 SPI 转发 CAN 帧到 GD32（GD32 端驱动外部 CAN 收发器）：
+
+```
+| 通道编号(1B) | 扩展帧ID(4B BE) | 数据(1~64B) |
+```
 
 | 通道 | 用途 |
 |------|------|
 | CH0 | 主通信通道 |
-| CH1 | 备用通道 1 |
-| CH2 | 备用通道 2 |
+| CH1 | 备用通道 |
+| CH2 | 备用通道 |
 
 ### GD32 命令 ID 定义
 
 | 域 | 命令 | ID |
-|---|---|---|
+|------|------|------|
 | 系统 | PING / RESET / GET_VERSION / GET_STATUS / SET_STATUS | 0x0001~0x0005 |
 | Flash | ERASE / WRITE / READ / VERIFY | 0x1001~0x1004 |
 | OTA | START / DATA / END / ABORT | 0x2001~0x2004 |
 | 传感器 | READ / CONFIG | 0x3001~0x3002 |
 | Bootloader | ENTER / JUMP_APP | 0xF001~0xF002 |
 
-## 上位机 WebUI
+## WiFi 工作模式
 
-`tools/ota_host_web.html` — 浏览器打开即可使用，无需安装。
+支持 AP/STA 双模式，启动时优先 STA，超时自动回退 AP。
 
-### HTTP API
+### AP 模式（设备当热点）
 
-| 方法 | 路径 | 功能 |
-|------|------|------|
-| POST | `/ota/upload` | 上传固件 (.bin) |
-| POST | `/ota/relay` | 触发 OTA 中继 |
-| GET | `/ota/status` | 查询 OTA 状态 |
-| POST | `/can/send` | 发送 CAN 帧到 GD32 |
-| GET | `/can/status` | CAN 通道状态 |
-| GET | `/health` | ESP32 健康状态 |
-| GET | `/wifi/status` | WiFi 连接状态 |
+| 参数 | 值 |
+|------|------|
+| SSID | `ESP32_OTA_RELAY` |
+| 密码 | `12345678` |
+| IP | 192.168.31.1 |
+| 信道 | 6 |
+| 最大客户端 | 4 |
 
-### CAN 帧发送示例
+### STA 模式（连接路由器）
+
+| 参数 | 值 |
+|------|------|
+| SSID | `004舰桥` |
+| 连接超时 | 30 秒 |
+| 最大重试 | 5 次（超限后自动切换 AP 模式） |
+| IP 分配 | DHCP（可切换静态 IP 192.168.31.32）|
+| 国家码 | CN（允许信道 1-13）|
+
+**冷启动优化**: 复位原因为 POWERON/BROWNOUT 时，清除 WiFi NVS 缓存 + PHY 校准数据，增加 500ms 启动延迟，防止长时间断电后校准残留导致连接失败。
+
+### mDNS 发现
+
+设备在局域网内通过 `esp32-ota-relay.local` 可发现（需 `managed_components/espressif__mdns` 组件）。
+
+## BLE GATT 服务
+
+基于 **NimBLE** 协议栈，设备名 `ESP32-OTA-RELAY`，ATT MTU 512 字节，支持 GD32 和 ESP32 两种 OTA 目标。
+
+| UUID | 特征 | 属性 | 用途 |
+|------|------|------|------|
+| 0xFFFF | Service | - | OTA GATT 服务 |
+| 0x0001 | CTRL | Write | 控制命令：`0xF7`=触发GD32中继, `0xF8+32B SHA`=ESP32 OTA, `0xFA`=重启ESP32 |
+| 0x0002 | DATA_IN | Write | 固件数据块：`cmd(1)+seq(2)+total_size(4)+payload` |
+| 0x0003 | DATA_OUT | Notify | 推送：ACK(窗口确认, 0xA1+8B) / FINISH(阶段事件, 0xB1+6B) / SHA256(0xC1+33B) |
+| 0x0004 | VERSION | Read | 固件版本字符串 |
+
+### BLE 数据传输
+
+- **ACK 窗口**: 每 32 包等待一次 DATA_OUT ACK（带累计字节数验证）
+- **窗口重传**: ACK 超时或字节数不足时重发整个窗口（最多 3 次）
+- **ESP32 收尾**: BLE 传输完成后由前端发 `0xF8 + 32B 文件 SHA-256`，设备端创建异步任务执行 finalize（含 SHA 比对），结果通过 FINISH 事件通知前端
+- **GD32 触发**: 传输完成后自动发 `0xF7` 触发 SPI 中继
+- **合并包**: NimBLE 可能将多个 writeWithoutResponse 合并到同一 mbuf，接收端支持一次解析多个数据包
+
+## HTTP API (WiFi WebUI)
+
+| 方法 | 端点 | 功能 | 请求体 | 响应 |
+|------|------|------|--------|------|
+| POST | `/ota/upload` | 上传固件 | JSON 头 + binary 数据 | `{"status":"ok", "target":"esp32"}` |
+| POST | `/ota/update` | 完成 ESP32 OTA | `{"sha256":"...","verify_only":true/false}` | `{"status":"ok","sha256":"..."}` |
+| POST | `/ota/relay` | 触发 GD32 中继 | - | `{"status":"ok"}` |
+| GET | `/system/status` | 系统状态 JSON | - | 含版本/WiFi/OTA/温度/堆/GD32 版本等 |
+| GET | `/logs` | 拉取调试日志 | - | JSON 数组字符串 |
+| POST | `/can/send` | 发送 CAN 帧 | `{"ch":0,"id":123,"dlc":8,"data":"0102..."}` | `{"status":"ok","recv":"..."}` |
+| POST | `/spi/send` | SPI 直接发送 | `{"type":"01","data":"00AC","timeout_ms":1000}` | `{"status":"ok","resp_type":".."}` |
+| POST | `/restart` | 重启 ESP32 | - | 500ms 后 `esp_restart()` |
+
+### POST /ota/upload 协议
+
+通过 JSON 头中的 `type` 字段自动区分目标：
+
+```json
+// ESP32 OTA
+{"type": "esp32", "total_size": 524288}
+<binary firmware data...>
+
+// GD32 OTA
+{"type": "gd32", "total_size": 131072}
+<binary firmware data...>
+```
+
+- **ESP32 模式**: 直接写入 OTA 分区，进度上报，完成后调用 `/ota/update` 收尾
+- **GD32 模式**: 写入 `gd32_ota` 分区 → 擦除 → 计算 SHA-256 → 自动触发 SPI 中继
+
+### curl 示例
 
 ```bash
+# 查询系统状态
+curl http://192.168.31.1/system/status | jq
+
+# 发送 CAN 帧
 curl -X POST http://192.168.31.1/can/send \
   -H "Content-Type: application/json" \
-  -d '{"ch": 0, "id": 12345678, "dlc": 8, "data": "0102030405060708"}'
+  -d '{"ch":0,"id":0x18DA00F1,"dlc":8,"data":"0102030405060708"}'
+
+# SPI 直接发送
+curl -X POST http://192.168.31.1/spi/send \
+  -H "Content-Type: application/json" \
+  -d '{"type":"01","data":"00AC","timeout_ms":1000}'
+
+# 获取日志
+curl http://192.168.31.1/logs
 ```
 
-## 任务配置 (单核 ESP32-C3)
+## WebUI 工具
 
-所有任务固定运行在 CPU 核 0：
+### WiFi OTA 控制台 (`tools/index.html`)
 
-| 任务 | 优先级 | 栈大小 | 说明 |
-|------|--------|--------|------|
-| health_mon | configMAX_PRIORITIES - 4 | 4096 | 健康监控 |
-| ota_relay | configMAX_PRIORITIES - 2 | 8192 | OTA 中继 |
-| wifi_ota | configMAX_PRIORITIES - 3 | 8192 | WiFi OTA |
+- ESP32 固件上传与 OTA 升级（含 SHA-256 前端校验）
+- GD32 固件上传（支持 .bin/.hex）与 SPI 中继触发
+- 实时 OTA 流程阶段显示（6 阶段进度追踪）
+- CAN 帧手动发送面板
+- SPI 直接发送面板
+- 系统状态监控（温度、RSSI、空闲堆、最小堆、GD32 APP/BOOT 版本、OTA 缓存）
+- 调试日志面板（HTTP `/logs` 轮询，按级别过滤）
+- 一键重启 ESP32
 
-## 调试日志与上位机通信
+### BLE OTA 控制台 (`tools/ble_ota.html`)
 
-当前与上位机相关的通信分成两类：
+- **Web Bluetooth API** 连接（需 Chrome/Edge/Android Chromium）
+- GD32 与 ESP32 双目标切换
+- 一键刷写（自动重连）
+- 窗口 ACK 重传机制（最多 3 次重试）
+- SHA-256 前端+设备端比对校验（校验面板显示）
+- FINISH 阶段事件通知
+- 设备重启 + 自动重连（退避 1.6x 指数，最多 12 次）
 
-1. **业务通信：HTTP**
-   - WebUI 通过 HTTP 接口与 ESP32 通信
-   - 典型接口：`/system/status`、`/logs`、`/can/send`、`/ota/*`
-   - 其中日志面板实际通过 **轮询 `GET /logs`** 获取日志
+## 健康监控
 
-2. **调试镜像：UART0 + UDP**
-   - 所有 `DEBUG_*` 日志会同时写到 UART0、UDP、以及内部环形缓冲区
-   - UDP 目标端口为 `6666`，适合独立调试接收器使用
-   - 但 **当前 tools WebUI 不直接监听 UDP 6666**
+### 健康状态等级
 
-因此，当前 WebUI 场景下：
-- `/system/status` 用于在线状态/健康状态展示
-- `/logs` 用于日志展示
-- 不再需要额外的 `{"t":"hb"}` 假日志心跳包
+| 等级 | 名称 | 触发条件 | OTA 影响 |
+|------|------|----------|----------|
+| 0 | SYS_NORMAL | 正常 | 允许 |
+| 1 | SYS_WARNING | 温度 ≥ 80°C 或 RSSI < -75 dBm | 允许（带警告）|
+| 2 | SYS_CRITICAL | RSSI < -85 dBm | ESP32 OTA 禁止，SPI 中继允许 |
+| 3 | SYS_SAFE_SHUTDOWN | 温度 ≥ 100°C | 所有 OTA 禁止 |
 
-## 编译
+### 监控指标
 
-```bash
-idf.py set-target esp32c3
-idf.py fullclean
-idf.py build
-idf.py flash monitor
+- **温度**: 1 秒定时器读取内部温度传感器（20°C~80°C 量程）
+- **WiFi RSSI**: WiFi 任务每 10 秒检查一次
+- **空闲堆**: 每 5 秒巡检，低于 10KB 触发警告
+
+### OTA 前健康检查
+
+- `checkBeforeOta()`: 完整检查（温度 + RSSI + WiFi 连接状态）
+- `checkBeforeOtaRelay()`: 仅检查温度（中继阶段不依赖 WiFi）
+
+## 诊断日志
+
+三条并行输出路径：
+
+1. **UART0**: GPIO21(TX), GPIO20(RX), 115200 baud — 本地串口调试
+2. **UDP 单播**: `192.168.31.3:6666` — 独立调试接收端
+3. **环形缓冲区**: 64 槽 × 256 字节，互斥保护 — 供 HTTP `GET /logs` 轮询拉取
+
+日志级别: `E`(错误) / `W`(警告) / `I`(信息) / `D`(调试)，运行时可调。
+
+UDP socket 延迟创建（首次 `send()` 时才分配），WiFi 未连接时 `sendto()` 静默跳过。
+
+**当前 WebUI 日志面板通过 HTTP `/logs` 轮询获取日志，不直接监听 UDP 6666。**
+
+## 配置参数 (`main/include/app_config.h`)
+
+| 分类 | 参数 | 默认值 | 说明 |
+|------|------|--------|------|
+| WiFi | `CONFIG_WIFI_MODE` | 1 (STA) | 0=AP, 1=STA |
+| WiFi | `WIFI_STA_SSID` | "004舰桥" | 路由器名称 |
+| WiFi | `WIFI_AP_SSID` | "ESP32_OTA_RELAY" | 热点名称 |
+| OTA | `OTA_BLOCK_SIZE` | 8192 | 读写块大小 |
+| OTA | `OTA_MAX_FIRMWARE_SIZE` | 216KB | GD32 固件上限 |
+| OTA | `GD32_OTA_PACKET_SIZE` | 48 | 每包载荷字节 |
+| OTA | `OTA_RESEND_RETRIES` | 10 | 单包最大重发次数 |
+| OTA | `OTA_PACKET_HEALTH_CHECK_INTERVAL` | 32 | 每 N 包健康检查 |
+| 阈值 | `TEMP_WARNING` | 80°C | 温度警告阈值 |
+| 阈值 | `TEMP_CRITICAL` | 100°C | 温度危险阈值 |
+| 阈值 | `WIFI_RSSI_CRITICAL` | -85 dBm | RSSI 危险阈值 |
+| 调试 | `DEBUG_LOG_IP` | "192.168.31.3" | UDP 日志目标 IP |
+| 调试 | `DEBUG_LOG_PORT` | 6666 | UDP 日志端口 |
+| BLE | `BLE_DEVICE_NAME` | "ESP32-OTA-RELAY" | BLE 广播名称 |
+| BLE | `BLE_MTU_SIZE` | 512 | ATT MTU |
+| BLE | `BLE_OTA_ACK_WINDOW` | 32 | ACK 窗口大小 |
+| BLE | `BLE_OTA_CHUNK_PAYLOAD` | 480 | BLE 单包载荷 |
+
+## 安全配置
+
+| 参数 | 位置 | 说明 | 状态 |
+|------|------|------|------|
+| `MASTER_KEY[16]` | app_config.h:110 | AES-128 主密钥 | ⚠️ 占位值，生产环境需更换 |
+| `SCRAMBLE_CONST[16]` | app_config.h:115 | Nonce 搅伴常量 | ⚠️ 占位值，生产环境需更换 |
+| `GD32_CHIP_UID[12]` | app_config.h:125 | 运行时从握手包获取 | 仅保留默认占位 |
+| `K_session` | 运行时派生 | `AES(MasterKey, nonce_server)` | 每次 OTA 重新生成 |
+| SHA-256 | 最终校验 | 从分区读回计算，前端比对 | WiFi/BLE 均已实现 |
+
+## 构建与部署
+
+### 一、本地编译（Windows PowerShell + ESP-IDF v6.0）
+
+首次编译前需设置工具链环境变量（PowerShell）：
+
+```powershell
+# ── 设置 ESP-IDF v6.0 工具链环境 ──
+$env:IDF_VERSION = "6.0"
+$env:IDF_PYTHON_ENV_PATH = "C:\Espressif\tools\python\v6.0\venv"
+$env:IDF_TOOLS_PATH = "C:\Espressif\tools"
+$env:IDF_PATH = "F:\.espressif\v6.0\esp-idf"
+$env:ESP_ROM_ELF_DIR = "C:\Espressif\tools\esp-rom-elfs\20241011"
+
+# ── 添加工具链到 PATH ──
+$env:PATH = "C:\Espressif\tools\ccache\4.12.1\ccache-4.12.1-windows-x86_64;" +
+            "C:\Espressif\tools\cmake\4.0.3\bin;" +
+            "C:\Espressif\tools\esp-clang\esp-20.1.1_20250829\esp-clang\bin;" +
+            "C:\Espressif\tools\idf-exe\1.0.3\;" +
+            "C:\Espressif\tools\ninja\1.12.1\;" +
+            "C:\Espressif\tools\riscv32-esp-elf\esp-15.2.0_20251204\riscv32-esp-elf\bin;" +
+            "C:\Espressif\tools\riscv32-esp-elf\esp-15.2.0_20251204\riscv32-esp-elf\riscv32-esp-elf\bin;" +
+            "C:\Espressif\tools\python\v6.0\venv\Scripts;" + $env:PATH
 ```
 
-## 待确认参数
+编译命令：
 
-- AES-128 主密钥 (MASTER_KEY_HERE)
-- 搅伴算法种子 (SCRAMBLE_CONST_HERE)
-- 芯片唯一码 (CHIP_UID_HERE)
-- OTA Service UUID (需与 APP 侧协商)
+```powershell
+# ── 进入项目目录 ──
+Set-Location "G:\Robot_v2\DCU\ESP32_COMM"
+
+# ── 全量编译（自动生成 version.h，确认零 error/warning）──
+& "C:\Espressif\tools\python\v6.0\venv\Scripts\python.exe" `
+  "F:\.espressif\v6.0\esp-idf\tools\idf.py" build
+
+# ── 目标文件 ──
+# build/ESP32_COMM.bin       ← OTA 烧录用
+# build/bootloader/bootloader.bin
+# build/partition_table/partition-table.bin
+```
+
+### 二、烧录方式
+
+#### 方式 A：串口烧录（首次 / 恢复）
+
+连接 ESP32-C3 到串口（默认 COM15），直接在 PowerShell 中烧录：
+
+```powershell
+# 全量烧录（固件 + bootloader + 分区表）
+& "F:\.espressif\v6.0\esp-idf\tools\idf.py" -p COM15 flash
+
+# 仅烧录应用程序（分区不变时快速更新）
+& "F:\.espressif\v6.0\esp-idf\tools\idf.py" -p COM15 app-flash
+
+# 烧录 + 监控
+& "F:\.espressif\v6.0\esp-idf\tools\idf.py" -p COM15 flash monitor
+```
+
+#### 方式 B：WiFi OTA 烧录（ESP32 自升级，无需串口线）
+
+前提：ESP32 已通过 WiFi 联网（或 AP 模式），上位机与 ESP32 在同一网络。
+
+**步骤 1 — 启动 WebUI 服务**：
+
+```powershell
+# 在项目目录下运行
+tools\serve.bat
+# 浏览器打开 http://localhost:8080/tools/index.html
+```
+
+**步骤 2 — 连接设备**：
+
+- 在页面顶部输入 ESP32 IP 地址（AP 模式为 `192.168.31.1`，STA 模式查路由器分配 IP）
+- 点击 **"测试"** 确认连通，状态指示应变为绿色
+
+**步骤 3 — 上传固件**：
+
+- 在 **"ESP32 自身升级"** 卡片中，拖拽或点击选择 `build/ESP32_COMM.bin`
+- 页面自动读取文件大小并计算 SHA-256
+- 点击 **"上传并升级 ESP32"**
+- WebUI 自动执行：上传 → OTA 写入 → SHA-256 校验 → 设置启动分区 → 重启
+- 重启后页面连接断开，ESP32 以新固件启动（约 10~15 秒）
+
+> ⚠️ 如果上传后 ESP32 无法正常启动（反复重启），说明固件有严重 bug，此时需用 **串口烧录** 恢复。
+
+#### 方式 C：BLE OTA 烧录（无需 WiFi）
+
+前提：上位机（手机/PC）支持 Web Bluetooth（Chrome / Edge / Android Chromium）。
+
+- 浏览器打开 `tools/ble_ota.html`
+- 点击 **"连接设备"**，在设备选择器中选择 `ESP32-OTA-RELAY`
+- 选择固件文件，点击 **"一键刷写"**
+- 通过 GATT Notify 实时查看进度和 SHA-256 校验结果
+
+### 三、GD32 SPI OTA 中继烧录
+
+GD32 固件通过 ESP32 中转烧录，不需要串口连接 GD32：
+
+**步骤 1** — 在 ESP32 WebUI 的 **"GD32 SPI 中继"** 卡片中上传 GD32 固件（.bin 或 .hex）
+
+**步骤 2** — 上传完成后，系统自动计算 SHA-256 并触发 SPI 中继转发
+
+**步骤 3** — ESP32 通过四阶段安全握手协议将固件逐包转发给 GD32 Bootloader
+
+**步骤 4** — 转发完成后 GD32 APP 启动，ESP32 轮询 PING 确认 APP 存活（最多 15 秒）
+
+> 也可手动点击 **"触发 GD32 OTA 中继"** 按钮重新触发转发。
+
+### 四、Python 辅助工具
+
+```powershell
+# 串口日志采集（COM15, 5 分钟）
+python serial_monitor.py
+
+# OTA 上传测试（HTTP）
+python ota_upload_test.py <esp32_ip> <firmware.bin>
+```
+
+### 五、开发容器
+
+`.devcontainer/` 提供 Docker 容器，含 ESP-IDF v6.0 工具链和 riscv32-esp-elf 编译器，支持 VS Code Remote-Containers 开箱即用。
+
+## SDK 配置 (`sdkconfig.defaults`)
+
+```ini
+CONFIG_ESP_WIFI_RX_BA_WIN=6
+CONFIG_ESP_WIFI_TX_BA_WIN=6
+CONFIG_LWIP_MAX_SOCKETS=10
+CONFIG_LWIP_TCP_WND_DEFAULT=11480
+CONFIG_LWIP_TCP_SND_BUF_DEFAULT=11520
+```
+
+## OTA 回滚保护
+
+启用 `CONFIG_APP_ROLLBACK_ENABLE` 后：
+1. 新固件首次启动必须在主循环前调用 `esp_ota_mark_app_valid_cancel_rollback()`
+2. 若新固件在标记前崩溃/重启，bootloader 自动回退到上一个有效分区
+3. `main.cpp:140` 在任务创建完成后执行此标记
+
+## 固件版本管理
+
+位于 `cmake/gen_version_script.cmake`，在每次 `idf.py build` 时自动执行：
+- **版本号**: `0.3.12`（手动修改 CMake 文件中的 MAJOR/MINOR/PATCH）
+- **构建时间**: 自动写入 `%Y-%m-%d %H:%M:%S`
+- **Git Hash**: 自动从 `git rev-parse --short HEAD` 获取
+- 输出到 `main/include/version.h`，仅在内容变化时写入以避免不必要的重编译

main/include/version.h

@@ -8,7 +8,7 @@
 #define FW_VERSION_STRING "0.3.12"
 
 // 编译时间
-#define BUILD_TIME "2026-06-14 22:46:58"
+#define BUILD_TIME "2026-06-14 23:55:14"
 
 // Git 信息
-#define GIT_HASH "2caf10b"
+#define GIT_HASH "unknown"

main/relay/ota_relay.cpp

@@ -201,9 +201,6 @@ bool OtaRelay::isFinishPlainAck(const uint8_t *payload, size_t len)
     return false;
 }
 
-bool OtaRelay::isStructuredAckWithPayload(const uint8_t *payload, size_t len)
-{ return payload && len >= 6U && payload[0] == 0xBAU && payload[1] == 0xC0U; }
-
 esp_err_t OtaRelay::pollUntilExpectedAckShape(const char *stage,
                                                uint8_t *resp_type, uint8_t *resp_payload,
                                                size_t resp_max, size_t *resp_len,
@@ -306,7 +303,6 @@ esp_err_t OtaRelay::metaLoad(ota_meta_t *meta)
     if (nvs_get_u32(handle, "total_size", &val) == ESP_OK) meta->total_size = val;
     if (nvs_get_u32(handle, "stored_size", &val) == ESP_OK) meta->stored_size = val;
     if (nvs_get_u32(handle, "last_seq", &val) == ESP_OK) meta->last_seq = val;
-    if (nvs_get_u32(handle, "chunk_count", &val) == ESP_OK) meta->chunk_count = val;
 
     size_t sha_len = sizeof(meta->checksum);
     if (nvs_get_blob(handle, "checksum", meta->checksum, &sha_len) == ESP_OK && sha_len == sizeof(meta->checksum)) {
@@ -338,7 +334,6 @@ esp_err_t OtaRelay::metaSave(const ota_meta_t *meta)
     nvs_set_u32(handle, "total_size", meta->total_size);
     nvs_set_u32(handle, "stored_size", meta->stored_size);
     nvs_set_u32(handle, "last_seq", meta->last_seq);
-    nvs_set_u32(handle, "chunk_count", meta->chunk_count);
     nvs_set_blob(handle, "checksum", meta->checksum, sizeof(meta->checksum));
     err = nvs_commit(handle);
     nvs_close(handle);
@@ -618,27 +613,6 @@ esp_err_t OtaRelay::requestGd32AppEnterBootloader()
 }
 
 
-ota_result_t OtaRelay::probeBootHandshake()
-{
-    /* 0xB0 timeout: probe if GD32 is already in BOOT.
-     * Send one lightweight HANDSHAKE_REQ, accept only echo ACK 0x00 0xAC
-     * as "already in BOOT" signal; otherwise fail immediately. */
-    DEBUG_INFO("OTA", "0xB0 timeout, probing if GD32 already in BOOT...");
-    uint8_t payload[] = {0x00, 0xAC};
-    uint8_t resp_type = 0U;
-    uint8_t resp_payload[64] = {0};
-    size_t resp_len = 0U;
-
-    esp_err_t err = SpiMaster::instance().otaTransfer(SPI_OTA_CMD_REQ, payload, sizeof(payload),
-                                     &resp_type, resp_payload, sizeof(resp_payload), &resp_len, 500);
-    if (err == ESP_OK && resp_type == SPI_OTA_RSP_ACK && isHandshakeEchoAck(resp_payload, resp_len)) {
-        DEBUG_INFO("OTA", "BOOT probe success: GD32 already in BOOT, continue OTA");
-        return OTA_RESULT_OK;
-    }
-    DEBUG_ERR("OTA", "BOOT probe failed: GD32 not in BOOT, abort (err=%d resp_type=0x%02X)", err, resp_type);
-    return OTA_RESULT_ERR_TIMEOUT;
-}
-
 ota_result_t OtaRelay::sendHandshakeReq()
 {
     DEBUG_INFO("OTA", "=== 阶段1: 握手开始 ===");
@@ -1157,51 +1131,6 @@ ota_result_t OtaRelay::finishOta()
     return OTA_RESULT_OK;
 }
 
-/**
- * @brief 启动完整 OTA 流程的主入口
- * @return 操作结果码。
- */
-ota_result_t OtaRelay::startHandshake()
-{
-    ota_result_t res;
-
-    esp_err_t boot_err = requestGd32AppEnterBootloader();
-    if (boot_err != ESP_OK) {
-        res = probeBootHandshake();
-        if (res != OTA_RESULT_OK) {
-            reset();
-            return res;
-        }
-    }
-
-    res = sendHandshakeReq();
-    if (res != OTA_RESULT_OK) { reset(); return res; }
-
-    res = sendNonceAndAuthenticate();
-    if (res != OTA_RESULT_OK) { reset(); return res; }
-
-    ota_meta_t meta;
-    OtaRelay::metaLoad(&meta);
-
-    // 固件完整性校验
-    esp_err_t verify_err = metaVerifyChecksum();
-    if (verify_err != ESP_OK) {
-        DEBUG_ERR("OTA", "固件完整性校验失败，中止转发");
-        reset();
-        return OTA_RESULT_ERR_CRC;
-    }
-
-    res = sendFirmwareSize(meta.total_size);
-    if (res != OTA_RESULT_OK) { reset(); return res; }
-
-    res = relayPacketsFromFlash(0);
-    if (res != OTA_RESULT_OK) { reset(); return res; }
-
-    res = finishOta();
-
-    return res;
-}
-
 /**
  * @brief 从 Flash 向 GD32 转发固件
  * @return 操作结果码。
@@ -1213,8 +1142,8 @@ ota_result_t OtaRelay::forwardFirmware()
         return OTA_RESULT_ERR_STORAGE;
     }
 
-    DEBUG_INFO("OTA", "开始固件转发: %u 字节, %u 块",
-               meta.total_size, meta.chunk_count);
+    DEBUG_INFO("OTA", "开始固件转发: %u 字节",
+               meta.total_size);
 
     // 固件完整性校验
     {

main/relay/ota_relay.h

@@ -16,19 +16,16 @@
 #include "esp_partition.h"
 
 #define OTA_META_NVS_NAMESPACE "ota_meta"
-#define OTA_META_NVS_KEY "meta"
 
 typedef struct {
     uint32_t total_size;
     uint32_t stored_size;
     uint32_t last_seq;
-    uint32_t chunk_count;
     uint8_t  checksum[32];
 } ota_meta_t;
 
 typedef enum {
     RELAY_IDLE = 0,
-    RELAY_HANDSHAKE_IDLE,
     RELAY_HANDSHAKE_SENT,
     RELAY_CHALLENGE_SENT,
     RELAY_CHALLENGE_RESPOND,
@@ -36,13 +33,11 @@ typedef enum {
     RELAY_AUTH_COMPLETE,
     RELAY_SIZE_SENT,
     RELAY_SIZE_ACK,
-    RELAY_RECEIVING,
     RELAY_RELAY_ACTIVE,
     RELAY_PACKET_SENT,
     RELAY_PACKET_ACK_OK,
     RELAY_PACKET_ACK_RETRY,
     RELAY_RECEIVE_DONE,
-    RELAY_TRANSFER_DONE,
     RELAY_FINISH_SENT,
     RELAY_DONE,
     RELAY_APP_VERIFY,
@@ -65,7 +60,6 @@ public:
     static OtaRelay& instance();
 
     static void taskEntry(void *pvParameters);
-    ota_result_t startHandshake();
     ota_result_t forwardFirmware();
 
     /* ---- 线程安全的状态访问接口 ----
@@ -136,7 +130,6 @@ public:
     static constexpr size_t GD32_CHALLENGE_RESPONSE_LEN = 36;
 
     esp_err_t requestGd32AppEnterBootloader();
-    ota_result_t probeBootHandshake();
     ota_result_t sendHandshakeReq();
     ota_result_t sendNonceAndAuthenticate();
     ota_result_t sendFirmwareSize(uint32_t size);
@@ -157,8 +150,6 @@ public:
     static bool isConfirmPlainAck(const uint8_t *payload, size_t len);
     static bool isSizeSeq0Ack(const uint8_t *payload, size_t len);
     static bool isFinishPlainAck(const uint8_t *payload, size_t len);
-    static bool isTransferDoneAck(const uint8_t *payload, size_t len);
-    static bool isStructuredAckWithPayload(const uint8_t *payload, size_t len);
 
     static esp_err_t pollUntilExpectedAckShape(const char *stage,
                                                uint8_t *resp_type,

main/server/ble_ota.cpp

@@ -133,14 +133,18 @@ static void ble_esp32_finish_and_reboot_task(void *pvParameters)
     // 通知前端：开始 finalize
     sendFinishEvent(BLE_OTA_FINISH_BEGIN_OTA_END, 0);
 
+    // 关键：reboot=false，让 finalize 真正返回、拿到 device_sha_hex，
+    // 再依次推送 SHA 通知 + FINISH_DONE_OTA_END + FINISH_REBOOT_NOW，
+    // 最后延迟重启。若 reboot=true，core 内部直接 esp_restart()，
+    // 下面所有 notifyResponse / sendFinishEvent 都不会执行，
+    // 前端也就拿不到设备端 SHA 与"收尾完成/即将重启"事件。
     char device_sha_hex[65] = {0};
     esp_err_t err = core.finalize(frontend_sha_hex,
-                                  /*reboot=*/true,
+                                  /*reboot=*/false,
                                   device_sha_hex);
-    // reboot=true 时 finalize 正常不会返回（core 内部 esp_restart）
 
     if (err == ESP_OK) {
-        // 极端情况：reboot 未执行（理论上不会发生），仍上报并标记
+        // 1) 把设备端 SHA 通过 SHA256 通知推给前端
         if (device_sha_hex[0] != '\0') {
             uint8_t sha_pkt[33] = {0};
             sha_pkt[0] = BLE_OTA_NOTIFY_SHA256;
@@ -151,8 +155,18 @@ static void ble_esp32_finish_and_reboot_task(void *pvParameters)
             }
             BleOta::instance().notifyResponse(sha_pkt, sizeof(sha_pkt));
         }
+        // 2) 等待 SHA 通知从 NimBLE host 队列送出
+        vTaskDelay(pdMS_TO_TICKS(150));
+
+        // 3) 推送"OTA 收尾完成"与"即将重启"事件
         sendFinishEvent(BLE_OTA_FINISH_DONE_OTA_END, 0);
         sendFinishEvent(BLE_OTA_FINISH_REBOOT_NOW, 0);
+
+        // 4) 通知全部发出后延迟 500ms 重启
+        DEBUG_INFO(TAG, "[FINISH] 通知已发送，500ms 后重启...");
+        vTaskDelay(pdMS_TO_TICKS(500));
+        esp_restart();
+        // 不会返回
     } else if (err == ESP_ERR_INVALID_VERSION) {
         DEBUG_ERR(TAG, "[FINISH] SHA-256 不匹配，OTA 已中止");
         sendFinishEvent(BLE_OTA_FINISH_ERR_SHA_MISMATCH, 0);
@@ -536,7 +550,6 @@ static int ble_ota_data_in_access(uint16_t conn_handle, uint16_t attr_handle,
                 meta.total_size  = total_size;
                 meta.stored_size = 0;
                 meta.last_seq    = 0;
-                meta.chunk_count = (total_size + expected_payload - 1U) / expected_payload;
 
                 esp_err_t err = OtaRelay::metaSave(&meta);
                 if (err != ESP_OK) {
@@ -544,8 +557,8 @@ static int ble_ota_data_in_access(uint16_t conn_handle, uint16_t attr_handle,
                     return BLE_ATT_ERR_UNLIKELY;
                 }
 
-                DEBUG_INFO(TAG, "GD32 固件存储开始: total=%" PRIu32 " chunk_count=%" PRIu32 ", payload=%zu",
-                           meta.total_size, meta.chunk_count, data_len);
+                DEBUG_INFO(TAG, "GD32 固件存储开始: total=%" PRIu32 ", payload=%zu",
+                           meta.total_size, data_len);
             }
 
             ota_meta_t meta = {};

main/server/wifi_ota.cpp

@@ -21,10 +21,6 @@
 #include "esp_event.h"
 #include "esp_mac.h"
 
-// SHA-256 哈希计算
-#define MBEDTLS_DECLARE_PRIVATE_IDENTIFIERS
-#include "mbedtls/private/sha256.h"
-
 #include "app_config.h"
 #include "ota_mutex.h"
 #include "wifi_ota.h"
@@ -501,19 +497,31 @@ static esp_err_t esp32_ota_update_handler(httpd_req_t *req)
         return ESP_OK;
     }
 
-    // ── 完整模式：finalize（end → 校验 → set_boot）后由 core 内部重启 ──
+    // ── 完整模式：finalize 不重启，先把含设备端 SHA 的结果返回给前端 ──
+    //   关键：reboot=false，让 core.finalize 真正返回，才能拿到 device_sha_hex
+    //   并把响应发回前端；待响应发完后再延迟重启。
+    //   若 reboot=true，core 内部直接 esp_restart()，HTTP 响应永远发不出去，
+    //   前端会得到 "Failed to fetch" 而错过核对结果。
     DEBUG_INFO("OTA", "ESP32 OTA finalize, %u bytes...", (unsigned)core.getReceived());
     esp_err_t err = core.finalize(has_frontend_sha ? frontend_sha_hex : nullptr,
-                                  /*reboot=*/true,
+                                  /*reboot=*/false,
                                   device_sha_hex);
 
     if (err == ESP_OK) {
-        // 正常不会走到这里（reboot=true 时 core 会 esp_restart）
-        char resp[256] = {0};
+        // 1) 把包含设备端 SHA 的响应发回前端
+        char resp[320] = {0};
         snprintf(resp, sizeof(resp),
-                 "{\"status\": \"ok\", \"message\": \"OTA finished\"}");
+                 "{\"status\": \"ok\", \"message\": \"OTA finished, rebooting\", "
+                 "\"sha256\": \"%s\"}",
+                 device_sha_hex);
         httpd_resp_set_type(req, "application/json");
         httpd_resp_send(req, resp, strlen(resp));
+
+        // 2) 响应发完后延迟 500ms 重启，给 TCP 缓冲区时间 flush 到客户端
+        DEBUG_INFO("OTA", "响应已发送，500ms 后重启...");
+        vTaskDelay(pdMS_TO_TICKS(500));
+        esp_restart();
+        // 不会返回
         return ESP_OK;
     }
 
@@ -552,27 +560,7 @@ static esp_err_t restart_handler(httpd_req_t *req)
     return ESP_OK;
 }
 
-/**
- * @brief HTTP GET /ota/update - 查询 ESP32 OTA 状态
- * @param req
- * @return
- */
-static esp_err_t esp32_ota_status_handler(httpd_req_t *req)
-{
-    http_set_cors_headers(req);
-    char resp[128];
-    if (Esp32OtaCore::instance().isActive()) {
-        snprintf(resp, sizeof(resp),
-            "{\"active\": true, \"received\": %u}",
-            (unsigned int)Esp32OtaCore::instance().getReceived());
-    } else {
-        snprintf(resp, sizeof(resp), "{\"active\": false}");
-    }
-    httpd_resp_set_type(req, "application/json");
-    httpd_resp_send(req, resp, strlen(resp));
-    return ESP_OK;
-}
-
+// ----------------------------------------
 // 从 HTTP 流中读取完整的 JSON 头（以 } 结尾）
 /**
  * @brief 返回 JSON 字符串长度，失败返回 0
@@ -795,7 +783,6 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
         .total_size = expected_fw_size_raw,
         .stored_size = 0,
         .last_seq = 0,
-        .chunk_count = (expected_fw_size_raw + OTA_BLOCK_SIZE - 1U) / OTA_BLOCK_SIZE,
         .checksum = {0}
     };
     OtaRelay::metaSave(&meta_raw);
@@ -935,72 +922,6 @@ static esp_err_t ota_relay_trigger_handler(httpd_req_t *req)
     return ESP_OK;
 }
 
-/**
- * @brief HTTP GET /ota/status 处理器
- * @param req
- * @return
- */
-static esp_err_t ota_status_handler(httpd_req_t *req)
-{
-    http_set_cors_headers(req);
-    DEBUG_INFO("WIFI", "=== HTTP: GET /ota/status ===");
-    
-    ota_meta_t meta;
-    OtaRelay::metaLoad(&meta);
-
-    char resp[256];
-    int len = snprintf(resp, sizeof(resp),
-        "{\"total_size\": %lu, \"stored_size\": %lu, \"last_seq\": %lu, "
-        "\"storage_done\": %s, \"relay_state\": %d, \"gd32_app_alive\": %s}",
-        (unsigned long)meta.total_size, (unsigned long)meta.stored_size,
-        (unsigned long)meta.last_seq,
-        WifiOta::instance().getGd32StorageDone() ? "true" : "false",
-        OtaRelay::getState(),
-        OtaRelay::getGd32AppAlive() ? "true" : "false");
-
-    gd32_version_t snapVer = {};
-    OtaRelay::getGd32Version(&snapVer);
-    DEBUG_INFO("WIFI", "OTA 状态: total=%lu, stored=%lu, done=%s, app_alive=%s",
-               (unsigned long)meta.total_size, (unsigned long)meta.stored_size,
-               WifiOta::instance().getGd32StorageDone() ? "true" : "false",
-               OtaRelay::getGd32AppAlive() ? "true" : "false",
-        snapVer.app_major, snapVer.app_minor,
-        snapVer.app_patch, snapVer.app_build,
-        snapVer.boot_major, snapVer.boot_minor,
-        snapVer.boot_patch, snapVer.boot_build);
-
-    httpd_resp_set_type(req, "application/json");
-    httpd_resp_send(req, resp, len);
-
-    return ESP_OK;
-}
-
-/**
- * @brief HTTP GET /health 处理器
- * @param req
- * @return
- */
-static esp_err_t health_handler(httpd_req_t *req)
-{
-    http_set_cors_headers(req);
-    DEBUG_INFO("WIFI", "=== HTTP: GET /health ===");
-    
-    health_state_t state = HealthMonitor::instance().getCurrent();
-    uint32_t free_heap = esp_get_free_heap_size();
-
-    char resp[128];
-    int len = snprintf(resp, sizeof(resp),
-        "{\"health\": %d, \"free_heap\": %lu}",
-        state, (unsigned long)free_heap);
-
-    DEBUG_INFO("WIFI", "健康状态: %d, 空闲堆: %lu", state, (unsigned long)free_heap);
-
-    httpd_resp_set_type(req, "application/json");
-    httpd_resp_send(req, resp, len);
-
-    return ESP_OK;
-}
-
 /**
  * @brief HTTP GET /logs - 拉取并清空日志缓冲区
  * @param req
@@ -1198,79 +1119,6 @@ static esp_err_t spi_send_handler(httpd_req_t *req)
     return ESP_OK;
 }
 
-/**
- * @brief HTTP GET /can/status 处理器
- * @param req
- * @return
- */
-static esp_err_t can_status_handler(httpd_req_t *req)
-{
-    http_set_cors_headers(req);
-    char resp[128];
-    snprintf(resp, sizeof(resp),
-        "{\"channels\": 3, \"max_dlc\": %d, \"spi_init\": %s}",
-        CAN_MAX_DLC,
-        SpiMaster::instance().deviceHandle() != NULL ? "true" : "false");
-    httpd_resp_set_type(req, "application/json");
-    httpd_resp_send(req, resp, strlen(resp));
-    return ESP_OK;
-}
-
-/**
- * @brief HTTP GET /wifi/status 处理器
- * @param req
- * @return
- */
-static esp_err_t wifi_status_handler(httpd_req_t *req)
-{
-    http_set_cors_headers(req);
-    char resp[256];
-    char ip_str[16] = "0.0.0.0";
-    int8_t rssi = -127;
-
-    if (WifiOta::instance().m_wifiMode == OTA_WIFI_MODE_STA && WifiOta::instance().getStaConnected()) {
-        esp_netif_ip_info_t ip_info;
-        esp_netif_t *sta_netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
-        if (sta_netif && esp_netif_get_ip_info(sta_netif, &ip_info) == ESP_OK) {
-            snprintf(ip_str, sizeof(ip_str), IPSTR, IP2STR(&ip_info.ip));
-        }
-        wifi_ap_record_t ap_info;
-        if (esp_wifi_sta_get_ap_info(&ap_info) == ESP_OK) {
-            rssi = ap_info.rssi;
-        }
-    }
-
-    int len = snprintf(resp, sizeof(resp),
-        "{\"mode\": \"%s\", \"ip\": \"%s\", \"rssi\": %d, \"connected\": %s}",
-        WifiOta::instance().m_wifiMode == OTA_WIFI_MODE_AP ? "AP" : "STA",
-        ip_str, rssi,
-        (WifiOta::instance().m_wifiMode == OTA_WIFI_MODE_STA) ? (WifiOta::instance().getStaConnected() ? "true" : "false") : "N/A");
-
-    httpd_resp_set_type(req, "application/json");
-    httpd_resp_send(req, resp, len);
-
-    return ESP_OK;
-}
-
-/**
- * @brief HTTP GET /api/version 处理器 - 返回固件版本、编译时间、Git hash
- */
-static esp_err_t version_handler(httpd_req_t *req)
-{
-    http_set_cors_headers(req);
-    gd32_version_t gv = {}; OtaRelay::getGd32Version(&gv);
-    char resp[512];
-    int len = snprintf(resp, sizeof(resp),
-        "{\"version\": \"%s\", \"build_time\": \"%s\", \"git_hash\": \"%s\", "
-        "\"gd32_app\": \"v%d.%d.%d.%d\", \"gd32_boot\": \"v%d.%d.%d.%d\", \"gd32_alive\": %s}",
-        FW_VERSION, FW_BUILD_TIME, FW_GIT_HASH,
-        gv.app_major, gv.app_minor, gv.app_patch, gv.app_build,
-        gv.boot_major, gv.boot_minor, gv.boot_patch, gv.boot_build,
-        OtaRelay::getGd32AppAlive() ? "true" : "false");
-    httpd_resp_set_type(req, "application/json");
-    httpd_resp_send(req, resp, len);
-    return ESP_OK;
-}
 /**
  * @brief HTTP GET /system/status 处理器
  * @param req
@@ -1419,21 +1267,6 @@ esp_err_t WifiOta::httpServerStart()
     };
     httpd_register_uri_handler(WifiOta::instance().m_httpServer, &relay_options_uri);
 
-    httpd_uri_t status_uri = {
-        .uri = "/ota/status",
-        .method = HTTP_GET,
-        .handler = ota_status_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &status_uri);
-    httpd_uri_t status_options_uri = {
-        .uri = "/ota/status",
-        .method = HTTP_OPTIONS,
-        .handler = http_options_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &status_options_uri);
-
     httpd_uri_t esp32_update_uri = {
         .uri = "/ota/update",
         .method = HTTP_POST,
@@ -1464,36 +1297,6 @@ esp_err_t WifiOta::httpServerStart()
     };
     httpd_register_uri_handler(WifiOta::instance().m_httpServer, &restart_options_uri);
 
-    httpd_uri_t esp32_status_uri = {
-        .uri = "/ota/esp32_status",
-        .method = HTTP_GET,
-        .handler = esp32_ota_status_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &esp32_status_uri);
-    httpd_uri_t esp32_status_options_uri = {
-        .uri = "/ota/esp32_status",
-        .method = HTTP_OPTIONS,
-        .handler = http_options_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &esp32_status_options_uri);
-
-    httpd_uri_t health_uri = {
-        .uri = "/health",
-        .method = HTTP_GET,
-        .handler = health_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &health_uri);
-    httpd_uri_t health_options_uri = {
-        .uri = "/health",
-        .method = HTTP_OPTIONS,
-        .handler = http_options_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &health_options_uri);
-
     httpd_uri_t logs_uri = {
         .uri = "/logs",
         .method = HTTP_GET,
@@ -1509,21 +1312,6 @@ esp_err_t WifiOta::httpServerStart()
     };
     httpd_register_uri_handler(WifiOta::instance().m_httpServer, &logs_options_uri);
 
-    httpd_uri_t wifi_status_uri = {
-        .uri = "/wifi/status",
-        .method = HTTP_GET,
-        .handler = wifi_status_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &wifi_status_uri);
-    httpd_uri_t wifi_status_options_uri = {
-        .uri = "/wifi/status",
-        .method = HTTP_OPTIONS,
-        .handler = http_options_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &wifi_status_options_uri);
-
     httpd_uri_t system_status_uri = {
         .uri = "/system/status",
         .method = HTTP_GET,
@@ -1555,22 +1343,6 @@ esp_err_t WifiOta::httpServerStart()
     };
     httpd_register_uri_handler(WifiOta::instance().m_httpServer, &can_send_options_uri);
 
-    httpd_uri_t can_status_uri = {
-        .uri = "/can/status",
-        .method = HTTP_GET,
-        .handler = can_status_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &can_status_uri);
-    httpd_uri_t can_status_options_uri = {
-        .uri = "/can/status",
-        .method = HTTP_OPTIONS,
-        .handler = http_options_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &can_status_options_uri);
-
-    DEBUG_INFO("WIFI", "HTTP 服务器已启动");
     // SPI 直接发送
     httpd_uri_t spi_send_uri = {
         .uri = "/spi/send",
@@ -1586,23 +1358,8 @@ esp_err_t WifiOta::httpServerStart()
         .user_ctx = NULL
     };
     httpd_register_uri_handler(WifiOta::instance().m_httpServer, &spi_send_options_uri);
-    // 版本信息端点
-    httpd_uri_t version_uri = {
-        .uri = "/api/version",
-        .method = HTTP_GET,
-        .handler = version_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &version_uri);
-    httpd_uri_t version_options_uri = {
-        .uri = "/api/version",
-        .method = HTTP_OPTIONS,
-        .handler = http_options_handler,
-        .user_ctx = NULL
-    };
-    httpd_register_uri_handler(WifiOta::instance().m_httpServer, &version_options_uri);
 
-    DEBUG_INFO("WIFI", "注册端点: /ota/upload, /ota/relay, /ota/update, /ota/status, /ota/esp32_status, /health, /wifi/status, /system/status, /can/send, /can/status, /spi/send, /api/version");
+    DEBUG_INFO("WIFI", "注册端点: /ota/upload, /ota/relay, /ota/update, /restart, /logs, /system/status, /can/send, /spi/send");
 
     return ESP_OK;
 }

main/transport/protocol.cpp

@@ -5,7 +5,9 @@
  *
  * 加密实现使用 ESP32-C3 硬件 AES 加速器（通过 mbedtls port）
  *
- * 所有功能封装为 Protocol 类的静态方法。
+ * 当前保留的接口：init、scrambleGenerate（nonce 生成）、
+ * sessionKeyInit / sessionKeyClear（会话密钥生命周期管理）。
+ * 帧构建、AES-CBC 加解密、CRC16 等中间件代码已移除。
  */
 #include <string.h>
 #include <stdio.h>
@@ -29,225 +31,12 @@ void Protocol::init()
     if (m_initialized) return;
 
     DEBUG_INFO("PROT", "=== 初始化协议层 ===");
-    DEBUG_INFO("PROT", "协议层功能: CRC16 Modbus + 硬件 AES-128-CBC");
+    DEBUG_INFO("PROT", "协议层功能: nonce 扰码 + 会话密钥管理");
 
     m_initialized = true;
     DEBUG_INFO("PROT", "协议层就绪");
 }
 
-/**
- * @brief CRC16 Modbus（LE，低字节在前）
- */
-uint16_t Protocol::crc16Modbus(const uint8_t *data, size_t len)
-{
-    uint16_t crc = 0xFFFF;
-    for (size_t i = 0; i < len; i++) {
-        crc ^= data[i];
-        for (int j = 0; j < 8; j++) {
-            if (crc & 0x0001) {
-                crc = (crc >> 1) ^ 0xA001;
-            } else {
-                crc >>= 1;
-            }
-        }
-    }
-    return (crc >> 8) | (crc << 8);
-}
-
-/**
- * @brief 构建 SPI 帧: SOF + CMD + LEN(2LE) + PAYLOAD + CRC16(2LE)
- */
-int Protocol::buildFrame(uint8_t cmd, const uint8_t *payload, size_t len, uint8_t *out_frame)
-{
-    if (len > FRAME_MAX_PAYLOAD) {
-        DEBUG_ERR("PROT", "Payload 太大: %zu > %d", len, FRAME_MAX_PAYLOAD);
-        return -1;
-    }
-
-    size_t idx = 0;
-    out_frame[idx++] = FRAME_SOF;
-    out_frame[idx++] = cmd;
-    out_frame[idx++] = (uint8_t)(len & 0xFF);
-    out_frame[idx++] = (uint8_t)((len >> 8) & 0xFF);
-
-    if (payload && len > 0) {
-        memcpy(&out_frame[idx], payload, len);
-        idx += len;
-    }
-
-    uint16_t crc = crc16Modbus(out_frame, idx);
-    out_frame[idx++] = (uint8_t)(crc & 0xFF);
-    out_frame[idx++] = (uint8_t)((crc >> 8) & 0xFF);
-
-    DEBUG_DBG("PROT", "帧构建: cmd=0x%02X, len=%zu, crc=0x%04X", cmd, len, crc);
-
-    return idx;
-}
-
-/**
- * @brief 解析并校验一帧 SPI 协议数据。
- */
-int Protocol::parseFrame(const uint8_t *frame, size_t frame_len,
-                         uint8_t *out_cmd, uint8_t *out_payload, size_t *out_len)
-{
-    if (frame_len < 6) {
-        DEBUG_WARN("PROT", "帧太短: %zu < 6", frame_len);
-        return -1;
-    }
-
-    size_t idx = 0;
-
-    if (frame[idx++] != FRAME_SOF) {
-        DEBUG_WARN("PROT", "无效 SOF: 0x%02X (期望 0x%02X)", frame[0], FRAME_SOF);
-        return -1;
-    }
-
-    uint8_t cmd = frame[idx++];
-
-    size_t payload_len = frame[idx] | (frame[idx + 1] << 8);
-    idx += 2;
-
-    if (payload_len > FRAME_MAX_PAYLOAD) {
-        DEBUG_ERR("PROT", "Payload 长度太大: %zu > %d", payload_len, FRAME_MAX_PAYLOAD);
-        return -1;
-    }
-
-    size_t expected_len = 1 + 1 + 2 + payload_len + 2;
-    if (frame_len < expected_len) {
-        DEBUG_WARN("PROT", "帧太短: %zu < %zu (期望)", frame_len, expected_len);
-        return -1;
-    }
-
-    uint16_t received_crc = frame[idx + payload_len] | (frame[idx + payload_len + 1] << 8);
-    uint16_t calc_crc = crc16Modbus(frame, idx + payload_len);
-
-    if (received_crc != calc_crc) {
-        DEBUG_WARN("PROT", "CRC 不匹配: 收到=0x%04X, 计算=0x%04X", received_crc, calc_crc);
-        return -1;
-    }
-
-    DEBUG_DBG("PROT", "帧解析: cmd=0x%02X, len=%zu, crc=0x%04X OK", cmd, payload_len, calc_crc);
-
-    if (out_payload && out_len) {
-        memcpy(out_payload, &frame[idx], payload_len);
-        *out_len = payload_len;
-    }
-    if (out_cmd) {
-        *out_cmd = cmd;
-    }
-
-    return 0;
-}
-
-/**
- * @brief 使用 AES-128 CBC 对明文进行加密（PKCS#7 填充）。
- */
-int Protocol::aesEncrypt(const uint8_t *plaintext, size_t len,
-                         const uint8_t *key, const uint8_t *iv,
-                         uint8_t *ciphertext_out)
-{
-    if (!plaintext || !key || !iv || !ciphertext_out) {
-        DEBUG_ERR("PROT", "AES 加密参数无效");
-        return -1;
-    }
-
-    // PKCS#7 填充
-    size_t padded_len = ((len / 16) + 1) * 16;
-    uint8_t padded[FRAME_MAX_PAYLOAD + 16];
-    if (padded_len > sizeof(padded)) {
-        DEBUG_ERR("PROT", "填充后长度超出缓冲区: %zu", padded_len);
-        return -1;
-    }
-
-    memcpy(padded, plaintext, len);
-    uint8_t pad_val = (uint8_t)(padded_len - len);
-    memset(&padded[len], pad_val, pad_val);
-
-    DEBUG_DBG("PROT", "AES 加密: 明文=%zu 字节, 填充后=%zu 字节", len, padded_len);
-
-    // 硬件 AES-CBC 加密（使用 ESP32-C3 硬件 AES 加速器）
-    esp_aes_context aes_ctx;
-    esp_aes_init(&aes_ctx);
-
-    int ret = esp_aes_setkey(&aes_ctx, key, 128);
-    if (ret != 0) {
-        DEBUG_ERR("PROT", "esp_aes_setkey 失败: %d", ret);
-        esp_aes_free(&aes_ctx);
-        return -1;
-    }
-
-    uint8_t iv_copy[16];
-    memcpy(iv_copy, iv, 16);
-
-    ret = esp_aes_crypt_cbc(&aes_ctx, ESP_AES_ENCRYPT, padded_len, iv_copy, padded, ciphertext_out);
-
-    esp_aes_free(&aes_ctx);
-
-    if (ret != 0) {
-        DEBUG_ERR("PROT", "esp_aes_crypt_cbc 加密失败: %d", ret);
-        return -1;
-    }
-
-    DEBUG_DBG("PROT", "AES 加密成功: %zu -> %zu 字节", len, padded_len);
-
-    return padded_len;
-}
-
-/**
- * @brief 使用 AES-128 CBC 对密文进行解密（去除 PKCS#7 填充）。
- */
-int Protocol::aesDecrypt(const uint8_t *ciphertext, size_t len,
-                         const uint8_t *key, const uint8_t *iv,
-                         uint8_t *plaintext_out)
-{
-    if (!ciphertext || !key || !iv || !plaintext_out) {
-        DEBUG_ERR("PROT", "AES 解密参数无效");
-        return -1;
-    }
-
-    if (len % 16 != 0 || len == 0) {
-        DEBUG_ERR("PROT", "Ciphertext 长度无效: %zu (必须为 16 的倍数)", len);
-        return -1;
-    }
-
-    DEBUG_DBG("PROT", "AES 解密: 密文=%zu 字节", len);
-
-    // 硬件 AES-CBC 解密（使用 ESP32-C3 硬件 AES 加速器）
-    esp_aes_context aes_ctx;
-    esp_aes_init(&aes_ctx);
-
-    int ret = esp_aes_setkey(&aes_ctx, key, 128);
-    if (ret != 0) {
-        DEBUG_ERR("PROT", "esp_aes_setkey 失败: %d", ret);
-        esp_aes_free(&aes_ctx);
-        return -1;
-    }
-
-    uint8_t iv_copy[16];
-    memcpy(iv_copy, iv, 16);
-
-    ret = esp_aes_crypt_cbc(&aes_ctx, ESP_AES_DECRYPT, len, iv_copy, ciphertext, plaintext_out);
-
-    esp_aes_free(&aes_ctx);
-
-    if (ret != 0) {
-        DEBUG_ERR("PROT", "esp_aes_crypt_cbc 解密失败: %d", ret);
-        return -1;
-    }
-
-    // 移除 PKCS#7 填充
-    uint8_t pad = plaintext_out[len - 1];
-    if (pad > 16) {
-        DEBUG_ERR("PROT", "无效填充: %d", pad);
-        return -1;
-    }
-
-    size_t orig_len = len - pad;
-    DEBUG_DBG("PROT", "AES 解密成功: %zu -> %zu 字节 (填充=%d)", len, orig_len, pad);
-
-    return orig_len;
-}
-
 /**
  * @brief 根据时间戳、地址和随机种子生成 16 字节 nonce。
  */
@@ -303,50 +92,4 @@ void Protocol::sessionKeyClear(session_ctx_t *sess)
         memset(sess->iv, 0, 16);
         sess->used = 0;
     }
-}
-
-/**
- * @brief 使用会话上下文加密数据。
- */
-int Protocol::sessionEncrypt(session_ctx_t *sess, const uint8_t *in, size_t len, uint8_t *out)
-{
-    if (!sess || !in || !out) return -1;
-
-    uint8_t iv_copy[16];
-    memcpy(iv_copy, sess->iv, 16);
-
-    int ret = aesEncrypt(in, len, sess->key, iv_copy, out);
-
-    if (ret > 0) {
-        memcpy(sess->iv, &out[ret - 16], 16);
-    }
-
-    return ret;
-}
-
-/**
- * @brief 使用会话上下文解密数据。
- */
-int Protocol::sessionDecrypt(session_ctx_t *sess, const uint8_t *in, size_t len, uint8_t *out)
-{
-    if (!sess || !in || !out) return -1;
-
-    uint8_t iv_copy[16];
-    memcpy(iv_copy, sess->iv, 16);
-
-    int ret = aesDecrypt(in, len, sess->key, iv_copy, out);
-
-    if (ret > 0) {
-        memcpy(sess->iv, &in[len - 16], 16);
-    }
-
-    return ret;
-}
-
-/**
- * @brief 使用 ESP-IDF 硬件 RNG 生成随机数
- */
-void Protocol::generateRandomNonce(uint8_t *nonce, size_t len)
-{
-    esp_fill_random(nonce, len);
 }

main/transport/protocol.h

@@ -17,28 +17,6 @@
 #define FRAME_MAX_PAYLOAD  (64)      // 安全最大 payload
 #define FRAME_OVERHEAD     (6)       // SOF + CMD + LEN(2) + CRC16(2)
 
-// 命令码（对应 GD32 OTA 协议）
-#define CMD_HANDSHAKE_REQ   (0xF0)   // 握手请求
-#define CMD_CHALLENGE       (0xF1)   // 挑战/随机数
-#define CMD_SESSION_KEY     (0xF2)   // 会话密钥
-#define CMD_SEND_SIZE       (0xF3)   // 发送固件大小
-#define CMD_DATA_PACKET     (0xF4)   // 数据包
-#define CMD_DATA_END        (0xF5)   // 数据结束
-#define CMD_TRANSFER_DONE   (0xF6)   // 传输完成
-#define CMD_FINISH_OTA      (0xF7)   // 结束 OTA
-#define CMD_ACK             (0x80)   // 通用 ACK
-#define CMD_ERROR           (0x81)   // 通用错误
-
-// ACK 状态码
-#define ACK_OK              (0x00)   // 成功
-#define ACK_UNSUPPORTED    (0x01)   // 命令不支持
-#define ACK_AUTH_FAILED    (0x02)   // 认证失败
-#define ACK_SIZE_OOR       (0x03)   // 大小超出范围
-#define ACK_CRC_FAILED     (0x04)   // CRC 校验失败
-#define ACK_RETRY_EXCEED   (0x05)   // 重试次数超限
-#define ACK_SESSION_INVALID (0x06)   // 会话密钥无效
-#define ACK_FLASH_FAILED    (0x07)   // Flash 写入失败
-
 // 安全常量（定义在 app_config.h 中）
 inline constexpr size_t MASTER_KEY_HERE_LEN = 16;
 inline constexpr size_t SCRAMBLE_CONST_HERE_LEN = 16;
@@ -63,23 +41,10 @@ public:
 
     void init();
 
-    static uint16_t crc16Modbus(const uint8_t *data, size_t len);
-    static int buildFrame(uint8_t cmd, const uint8_t *payload, size_t len, uint8_t *out_frame);
-    static int parseFrame(const uint8_t *frame, size_t frame_len,
-                          uint8_t *out_cmd, uint8_t *out_payload, size_t *out_len);
-    static int aesEncrypt(const uint8_t *plaintext, size_t len,
-                          const uint8_t *key, const uint8_t *iv,
-                          uint8_t *ciphertext_out);
-    static int aesDecrypt(const uint8_t *ciphertext, size_t len,
-                          const uint8_t *key, const uint8_t *iv,
-                          uint8_t *plaintext_out);
     static void scrambleGenerate(uint32_t timestamp, uint32_t mem_addr,
                                  uint32_t rand_seed, uint8_t *nonce_out);
     static int sessionKeyInit(session_ctx_t *sess, const uint8_t *k_session);
     static void sessionKeyClear(session_ctx_t *sess);
-    static int sessionEncrypt(session_ctx_t *sess, const uint8_t *in, size_t len, uint8_t *out);
-    static int sessionDecrypt(session_ctx_t *sess, const uint8_t *in, size_t len, uint8_t *out);
-    static void generateRandomNonce(uint8_t *nonce, size_t len);
 
 private:
     Protocol() = default;

tools/ble_ota.html

@@ -1114,22 +1114,19 @@
         log('OTA', `⚠️ file.size(${file.size}) ≠ arrayBuffer(${totalSize})，以 arrayBuffer 为准，请确认页面已 Ctrl+F5 刷新`, 'W');
       }
 
-      // 计算文件的 SHA-256 哈希值用于完整性验证
-      setBleStage(4, '计算SHA-256...', null);
-      setBleStageText('正在计算文件哈希...');
+      // SHA-256 已在文件选择时（updateFileInfo）计算并存入 state.fileSha256。
+      // 此处不再重复打日志（避免与 [FILE] SHA-256 重复），仅保证 fileSha256 变量有值。
       var fileSha256;
       if (state.fileSha256) {
-        // 复用已计算的 SHA-256
         fileSha256 = state.fileSha256.toLowerCase();
-        log('OTA', `复用已计算的 SHA-256: ${fileSha256.toUpperCase()}`);
       } else {
+        // 极端兜底：state.fileSha256 未初始化（理论上 updateFileInfo 总会先设置）
         log('OTA', '正在计算文件 SHA-256 哈希...');
         const hashBuffer = await crypto.subtle.digest('SHA-256', fileBytes.buffer);
         const hashArray = Array.from(new Uint8Array(hashBuffer));
         fileSha256 = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
         state.fileSha256 = fileSha256.toUpperCase();
       }
-      log('OTA', `文件 SHA-256: ${fileSha256.toUpperCase()}`);
       // Update SHA display in file info
       var shaElem = document.getElementById('fileSha256');
       if (shaElem) shaElem.textContent = fileSha256.toUpperCase();
@@ -1296,12 +1293,22 @@
   }
 
   async function autoFlash() {
-    // 每次刷写前尝试重新从本地读取文件
+    // 每次刷写前尝试重新从本地读取文件（支持热重载：用户重新编译后无需重新选择）
     if (state.selectedFileHandle) {
       try {
         const freshFile = await state.selectedFileHandle.getFile();
-        updateFileInfo(freshFile);
-        log('FILE', '已重新读取本地文件: ' + freshFile.name + ' (' + formatBytes(freshFile.size) + ')');
+        // 仅在文件变化时才刷新元数据并重算 SHA-256
+        // （name/size/lastModified 任一不同即视为变化）
+        // 避免对同一文件重复触发 updateFileInfo → 产生重复的 [FILE] SHA-256 日志
+        const cached = state.selectedFile;
+        const changed = !cached ||
+                        cached.name !== freshFile.name ||
+                        cached.size !== freshFile.size ||
+                        cached.lastModified !== freshFile.lastModified;
+        if (changed) {
+          updateFileInfo(freshFile);
+          log('FILE', '已重新读取本地文件（已变更）: ' + freshFile.name + ' (' + formatBytes(freshFile.size) + ')');
+        }
       } catch (e) {
         log('FILE', '重新读取文件失败: ' + e.message + '，将使用缓存版本', 'W');
       }