feat(core): 移除状态监控任务并优化系统资源

移除原有的周期性状态监控任务，减少系统负载和内存占用。

perf(relay): 优化OTA中继挑战响应验证逻辑

重构挑战响应验证流程，统一响应长度定义，并改进验证算法。

fix(wifi): 修复OTA中继重复触发问题

确保中继状态正确重置，防止在非空闲状态下重复触发中继。

perf(transport): 优化SPI通信时序参数

调整CS片选信号的前后延时参数，提高SPI通信稳定性。

refactor(ui): 分离ESP32和GD32文件上传界面

重构前端界面，为ESP32和GD32分别提供独立的文件上传区域。

main/core/main.cpp

@@ -1,8 +1,6 @@
 /*
  * ESP32-C3FH4 OTA 中继 - 程序入口
- * 四个 FreeRTOS 任务：System Monitor / OTA Relay / WiFi Server / BLE GATT
- * 
- * 新增：周期性状态监控任务，每 10 秒打印系统状态
+ * 三个 FreeRTOS 任务：OTA Relay / WiFi Server / BLE GATT
  */
 #include <stdio.h>
 #include "freertos/FreeRTOS.h"
@@ -20,12 +18,6 @@
 #include "transport/protocol.h"
 #include "monitor/debug_log.h"
 
-/**
- * @brief 状态监控任务
- * @param pvParameters
- */
-static void status_monitor_task(void *pvParameters);
-
 /**
   * @brief 程序主入口，初始化系统组件并创建各 FreeRTOS 任务。
  */
@@ -130,22 +122,6 @@ extern "C" void app_main(void)
         DEBUG_INFO("MAIN", "BLE OTA 任务已创建");
     }
 
-    // 状态监控任务（低优先级，周期性打印系统状态）
-    xRet = xTaskCreatePinnedToCore(
-        status_monitor_task,
-        "status_mon",
-        4096,
-        NULL,
-        configMAX_PRIORITIES - 5,
-        NULL,
-        0
-    );
-    if (xRet != pdPASS) {
-        DEBUG_ERR("MAIN", "创建 status_monitor_task 失败");
-    } else {
-        DEBUG_INFO("MAIN", "状态监控任务已创建");
-    }
-
     DEBUG_INFO("MAIN", "========================================");
     DEBUG_INFO("MAIN", "所有任务创建完成，OTA Relay 运行中");
     DEBUG_INFO("MAIN", "调试日志输出: UDP(%s:%d) + UART0(GPIO21/TX, 115200)", 
@@ -153,83 +129,3 @@ extern "C" void app_main(void)
     DEBUG_INFO("MAIN", "========================================");
 }
 
-// ============================================================
-// 状态监控任务 - 每 10 秒打印系统状态
-/**
-  * @brief 周期性打印系统运行状态，包括内存、WiFi 和 OTA 中继信息。
- * @param pvParameters
- */
-static void status_monitor_task(void *pvParameters)
-{
-    (void)pvParameters;
-    DEBUG_INFO("STAT", "状态监控任务启动");
-
-    uint32_t loop_count = 0;
-
-    while (1) {
-        loop_count++;
-        
-        uint32_t free_heap = esp_get_free_heap_size();
-        uint32_t min_free_heap = esp_get_minimum_free_heap_size();
-        health_state_t health = health_get_current();
-        relay_state_t relay = ota_relay_get_state();
-        int8_t rssi = wifi_get_rssi();
-        bool wifi_conn = wifi_is_connected();
-
-        // 打印状态头
-        DEBUG_INFO("STAT", "========== 系统状态 #%lu ==========", (unsigned long)loop_count);
-        
-        // 内存状态
-        DEBUG_INFO("STAT", "内存: 空闲=%lu 字节, 最低=%lu 字节", 
-                   (unsigned long)free_heap, (unsigned long)min_free_heap);
-        
-        // 健康状态
-        const char *health_str;
-        switch (health) {
-            case SYS_NORMAL:       health_str = "正常"; break;
-            case SYS_WARNING:      health_str = "警告"; break;
-            case SYS_CRITICAL:     health_str = "危险"; break;
-            case SYS_SAFE_SHUTDOWN: health_str = "安全关机"; break;
-            default:               health_str = "未知"; break;
-        }
-        DEBUG_INFO("STAT", "健康状态: %s (%d)", health_str, health);
-
-        // WiFi 状态
-        if (wifi_conn) {
-            DEBUG_INFO("STAT", "WiFi: 已连接, RSSI=%d dBm", rssi);
-        } else {
-            DEBUG_INFO("STAT", "WiFi: 未连接");
-        }
-
-        // OTA 中继状态
-        const char *relay_str;
-        switch (relay) {
-            case RELAY_IDLE:              relay_str = "空闲"; break;
-            case RELAY_HANDSHAKE_IDLE:    relay_str = "等待握手"; break;
-            case RELAY_HANDSHAKE_SENT:    relay_str = "握手请求已发送"; break;
-            case RELAY_CHALLENGE_SENT:    relay_str = "挑战已发送"; break;
-            case RELAY_CHALLENGE_RESPOND: relay_str = "收到握手响应"; break;
-            case RELAY_SESSION_KEY_SENT:  relay_str = "会话密钥已发送"; break;
-            case RELAY_AUTH_COMPLETE:     relay_str = "认证完成"; break;
-            case RELAY_SIZE_SENT:         relay_str = "大小已发送"; break;
-            case RELAY_SIZE_ACK:          relay_str = "大小确认"; break;
-            case RELAY_RECEIVING:         relay_str = "接收中"; break;
-            case RELAY_RELAY_ACTIVE:      relay_str = "转发中"; break;
-            case RELAY_PACKET_SENT:       relay_str = "数据包已发送"; break;
-            case RELAY_PACKET_ACK_OK:     relay_str = "ACK 正常"; break;
-            case RELAY_PACKET_ACK_RETRY:  relay_str = "需要重试"; break;
-            case RELAY_RECEIVE_DONE:      relay_str = "接收完成"; break;
-            case RELAY_TRANSFER_DONE:     relay_str = "传输完成"; break;
-            case RELAY_FINISH_SENT:       relay_str = "结束已发送"; break;
-            case RELAY_DONE:              relay_str = "OTA 完成"; break;
-            case RELAY_ERROR:             relay_str = "错误"; break;
-            default:                      relay_str = "未知"; break;
-        }
-        DEBUG_INFO("STAT", "OTA 中继: %s (%d)", relay_str, relay);
-
-        DEBUG_INFO("STAT", "======================================");
-
-        // 每 10 秒打印一次
-        vTaskDelay(pdMS_TO_TICKS(10000));
-    }
-}

main/relay/ota_relay.cpp

@@ -30,8 +30,7 @@ static uint8_t g_k_session[16] = {0};
 static uint8_t g_gd32_uid_runtime[12] = {0};
 
 static constexpr size_t GD32_UID_LEN = 12;
-static constexpr size_t GD32_CHALLENGE_CIPHER_LEN = 32;
-static constexpr size_t GD32_CHALLENGE_PAYLOAD_WITH_SESSION = 36;
+static constexpr size_t GD32_CHALLENGE_RESPONSE_LEN = 36;
 
 /** @brief OTA 命令分发队列，从 WiFi/BLE 任务接收指令。 */
 QueueHandle_t g_ota_dispatch_queue = NULL;
@@ -149,54 +148,53 @@ static bool parse_and_verify_challenge_payload(const uint8_t *resp_payload, size
 {
     if (!resp_payload || !out_k_session || !out_uid) return false;
 
-    const uint8_t *cipher_blob = resp_payload;
-    size_t cipher_len = resp_len;
-    if (resp_len == GD32_CHALLENGE_PAYLOAD_WITH_SESSION) {
-        uint32_t session_num = read_u32_le(resp_payload);
-        DEBUG_INFO("OTA", "CHALLENGE session_num=0x%08" PRIX32, session_num);
-        cipher_blob = resp_payload + 4;
-        cipher_len = GD32_CHALLENGE_CIPHER_LEN;
-    }
-
-    if (cipher_len != GD32_CHALLENGE_CIPHER_LEN) {
+    if (resp_len != GD32_CHALLENGE_RESPONSE_LEN) {
         DEBUG_ERR("OTA", "CHALLENGE validate failed: invalid payload length=%u", (unsigned)resp_len);
         return false;
     }
-/*
-    if (cipher_len != GD32_CHALLENGE_CIPHER_LEN) {
-        DEBUG_ERR("OTA", "CHALLENGE payload长度异常: %u", (unsigned)resp_len);
+
+    /*
+     * GD32 响应格式 (36 bytes):
+     *   [0..11]  = UID (12 bytes)
+     *   [12..19] = nonce_server[8:16] (8 bytes, nonce 后半段)
+     *   [20..35] = encrypted_Ksession (16 bytes) = AES(K_master, K_session)
+     *
+     * 其中 K_session = AES(K_master, nonce_server)
+     */
+
+    const uint8_t *uid = resp_payload;
+    const uint8_t *nonce_frag = resp_payload + 12;
+    const uint8_t *encrypted_ksession = resp_payload + 20;
+
+    // 校验 nonce 片段: 应与 nonce_server[8:16] 一致
+    if (memcmp(nonce_frag, g_nonce_server + 8, 8) != 0) {
+        DEBUG_ERR("OTA", "CHALLENGE校验失败: nonce片段不匹配");
         return false;
     }
 
-*/
-    uint8_t expected_nonce_block[16] = {0};
-    if (aes128_ecb_encrypt_block_local(MASTER_KEY, g_nonce_server, expected_nonce_block) != 0) {
-        DEBUG_ERR("OTA", "CHALLENGE validate failed: nonce block encrypt failed");
-        return false;
-    }
-/*
-    if (aes128_ecb_encrypt_block_local(MASTER_KEY, g_nonce_server, expected_nonce_block) != 0) {
-        DEBUG_ERR("OTA", "CHALLENGE校验失败: 计算nonce加密块失败");
+    // 派生 K_session = AES(K_master, nonce_server)
+    uint8_t K_session[16] = {0};
+    if (aes128_ecb_encrypt_block_local(MASTER_KEY, g_nonce_server, K_session) != 0) {
+        DEBUG_ERR("OTA", "CHALLENGE校验失败: 派生K_session失败");
         return false;
     }
 
-*/
-    if (memcmp(cipher_blob, expected_nonce_block, sizeof(expected_nonce_block)) != 0) {
-        DEBUG_ERR("OTA", "CHALLENGE校验失败: nonce加密块不匹配");
+    // 验证 encrypted_Ksession: AES(K_master, K_session) 应匹配
+    uint8_t expected_encrypted[16] = {0};
+    if (aes128_ecb_encrypt_block_local(MASTER_KEY, K_session, expected_encrypted) != 0) {
+        DEBUG_ERR("OTA", "CHALLENGE校验失败: 加密K_session失败");
         return false;
     }
 
-    memcpy(out_k_session, expected_nonce_block, sizeof(expected_nonce_block));
-
-    uint8_t device_info[16] = {0};
-    if (aes128_ecb_decrypt_block_local(out_k_session, &cipher_blob[16], device_info) != 0) {
-        DEBUG_ERR("OTA", "CHALLENGE校验失败: device_info解密失败");
+    if (memcmp(encrypted_ksession, expected_encrypted, 16) != 0) {
+        DEBUG_ERR("OTA", "CHALLENGE校验失败: encrypted_Ksession不匹配");
         return false;
     }
 
-    // device_info[0..11] maps to contiguous GD32 UID bytes from
-    // DEVICE_SERIAL_ADDR_LSB (0x1FFFF7E8) to 0x1FFFF7F3.
-    memcpy(out_uid, device_info, GD32_UID_LEN);
+    // 校验通过，输出 K_session 和 UID
+    memcpy(out_k_session, K_session, 16);
+    memcpy(out_uid, uid, GD32_UID_LEN);
+
     if (bytes_all_value(out_uid, GD32_UID_LEN, 0x00U) ||
         bytes_all_value(out_uid, GD32_UID_LEN, 0xFFU)) {
         DEBUG_ERR("OTA", "CHALLENGE校验失败: UID无效(全00/全FF)");
@@ -372,8 +370,6 @@ esp_err_t meta_load(ota_meta_t *meta)
     if (nvs_get_u32(handle, "chunk_count", &val) == ESP_OK) meta->chunk_count = val;
 
     nvs_close(handle);
-    DEBUG_INFO("OTA", "元数据已加载: total=%u, stored=%u, seq=%u",
-               meta->total_size, meta->stored_size, meta->last_seq);
     return ESP_OK;
 }
 
@@ -402,8 +398,6 @@ esp_err_t meta_save(const ota_meta_t *meta)
 
     if (err != ESP_OK) {
         DEBUG_ERR("OTA", "NVS commit 失败: %s", esp_err_to_name(err));
-    } else {
-        DEBUG_INFO("OTA", "元数据已保存到 NVS");
     }
     return err;
 }
@@ -488,8 +482,12 @@ static void request_gd32_app_enter_bootloader(void)
     DEBUG_INFO("OTA", "尝试通知 GD32 APP 进入 Bootloader OTA 窗口");
     esp_err_t err = gd32_app_request_bootloader(500);
     if (err == ESP_OK) {
-        DEBUG_INFO("OTA", "GD32 APP 已确认进入 Bootloader，等待复位完成");
-        vTaskDelay(pdMS_TO_TICKS(3500));
+        /* 收到确认：可能来自 APP（即将跳转 BOOT）或 BOOT 本身（已在 BOOT）。
+         * 如果来自 APP，GD32 需要复位并重新初始化 SPI 外设，需等 ~1-2s；
+         * 如果已在 BOOT，SPI 已经就绪，200ms 足够。
+         * 等待 1000ms 给 GD32 足够时间完成系统复位和 Bootloader 初始化。 */
+        DEBUG_INFO("OTA", "GD32 已确认进入 Bootloader，等待就绪");
+        vTaskDelay(pdMS_TO_TICKS(1000));
     } else {
         DEBUG_WARN("OTA", "GD32 APP 未确认进入 Bootloader，继续尝试直接握手: %s", esp_err_to_name(err));
     }
@@ -513,7 +511,7 @@ static ota_result_t send_handshake_req(void)
                                      &resp_type, resp_payload, sizeof(resp_payload), &resp_len, 3000);
     log_resp_payload("HANDSHAKE_REQ", resp_type, resp_payload, resp_len);
     if (err == ESP_OK) {
-        err = wait_until_not_wait("HANDSHAKE_REQ", &resp_type, resp_payload, sizeof(resp_payload), &resp_len, 1000, 8);
+        err = wait_until_not_wait("HANDSHAKE_REQ", &resp_type, resp_payload, sizeof(resp_payload), &resp_len, 1000, 15);
     }
     if (err != ESP_OK || resp_type != SPI_OTA_RSP_ACK || resp_len < 2 ||
         resp_payload[0] != 0x00 || resp_payload[1] != 0xAC) {

main/server/wifi_ota.cpp

@@ -768,10 +768,13 @@ static esp_err_t ota_relay_trigger_handler(httpd_req_t *req)
         return ESP_FAIL;
     }
 
-    if (s_relay_triggered) {
+    if (s_relay_triggered && g_relay_state != RELAY_IDLE &&
+        g_relay_state != RELAY_DONE && g_relay_state != RELAY_ERROR) {
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "relay already triggered");
         return ESP_FAIL;
     }
+    /* 上一轮中继已结束/失败/空闲，重置标志允许重新触发 */
+    s_relay_triggered = false;
 
     if (!g_ota_dispatch_queue) {
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "relay queue not ready");
@@ -1404,10 +1407,13 @@ void wifi_ota_signal_relay(void)
         return;
     }
 
-    if (s_relay_triggered) {
-        DEBUG_WARN("WIFI", "转发已经触发过");
+    if (s_relay_triggered && g_relay_state != RELAY_IDLE &&
+        g_relay_state != RELAY_DONE && g_relay_state != RELAY_ERROR) {
+        DEBUG_WARN("WIFI", "转发正在执行中，状态: %d", g_relay_state);
         return;
     }
+    /* 上一轮中继已结束/失败/空闲，重置标志 */
+    s_relay_triggered = false;
 
     /** @brief OTA 中继是否已触发标志。 */
     s_relay_triggered = true;

main/transport/spi_master.cpp

@@ -246,8 +246,36 @@ esp_err_t spi_master_init(void)
     dev_cfg.command_bits = 0;
     dev_cfg.address_bits = 0;
     dev_cfg.dummy_bits = 0;
-    dev_cfg.cs_ena_posttrans = 0;
-    dev_cfg.cs_ena_pretrans = 0;
+    /* CS↑ 后保持 CS 高的时间（SPI 时钟周期数）。
+     *
+     * 0 = 最小 CS 高时间（仅满足 SPI 时序）。
+     * 设大一点让 GD32 EXTI ISR 有足够时间完成 onCsRelease() 处理：
+     * 切 internal NSS HIGH + 清 RBNE FIFO + 帧解析 + 准备响应帧。
+     *
+     * 10 × 250ns = 2.5µs，加上 SPI 驱动本身的 CS 间隮（~1µs），
+     * GD32 实际有 ~3.5µs 的 CS 高窗口。足够完成关键操作。
+     */
+    dev_cfg.cs_ena_posttrans = 10;
+    /* CS↓ 后等待 20 个 SPI 时钟周期再开始发 SCK。
+     *
+     * 4MHz SPI → 20×250ns = 5µs 延时。
+     *
+     * GD32 SPI 从机在 CS↓ 时需要 EXTI ISR 执行 onCsAssert():
+     *   设置 s_csActive=true → 清空接收缓冲 → 切 internal NSS LOW → 配置 DMA。
+     *
+     * 但 SPI0 RBNE 中断优先级 (1,0) 高于 EXTI (1,1)，
+     * 首字节 RBNE 会打断正在执行的 EXTI ISR →
+     *   s_csActive 还没设为 true → s_rxStreamLen 还没清零 →
+     *   首字节存到旧位置 → EXTI 返回后清零 → 首字节丢失。
+     *
+     * cs_ena_pretrans=20 让 ESP32 在 CS↓ 后多等 5µs，
+     * GD32 EXTI ISR 只需 ~1µs 就能完成关键初始化，
+     * 5µs 足够让 onCsAssert() 执行完 s_csActive=true + s_rxStreamLen=0U。
+     *
+     * 代价：每次 SPI 事务多 5µs 延时。
+     * 一次 OTA 事务 = 1次请求 + ~10次轮询 = ~55µs 额外开销，可接受。
+     */
+    dev_cfg.cs_ena_pretrans = 20;
 
     ret = spi_bus_add_device(SPI2_HOST, &dev_cfg, &g_spi_device);
     if (ret != ESP_OK) {
@@ -351,7 +379,7 @@ esp_err_t spi_ota_poll_response(uint8_t *resp_type, uint8_t *resp_payload,
         esp_err_t ret = spi_transfer_clocked(dummy, sizeof(dummy), rx_raw, sizeof(rx_raw));
         if (ret != ESP_OK) {
             DEBUG_WARN("SPI", "SPI OTA 响应读取失败[%u]: %s", attempt, esp_err_to_name(ret));
-            vTaskDelay(pdMS_TO_TICKS(1));
+            vTaskDelay(pdMS_TO_TICKS(2));
             continue;
         }
 
@@ -385,7 +413,7 @@ esp_err_t spi_ota_poll_response(uint8_t *resp_type, uint8_t *resp_payload,
                    rx_raw[0], rx_raw[1], rx_raw[2], rx_raw[3],
                    rx_raw[4], rx_raw[5], rx_raw[6], rx_raw[7],
                    rx_raw[8], rx_raw[9]);
-        vTaskDelay(pdMS_TO_TICKS(1));
+        vTaskDelay(pdMS_TO_TICKS(2));
     }
 
     DEBUG_ERR("SPI", "OTA响应超时: timeout=%ums", (unsigned)timeout_ms);
@@ -422,18 +450,43 @@ esp_err_t spi_ota_transfer(uint8_t type, const uint8_t *payload, size_t payload_
 
     DEBUG_INFO("SPI", "OTA事务: req_type=0x%02X req_len=%u", type, (unsigned)payload_len);
 
+    /* ============================================================
+     * 第1次 CS 周期：发送请求帧（只发不收）
+     *
+     * ESP32 发完请求帧后 CS↑，GD32 在 CS↑ 的 onCsRelease 中
+     * 或 RBNE 中断的 tryProcessCompleteFrame 中处理帧，
+     * 将 ACK 写入 s_txBuf 并启动 DMA。
+     *
+     * 注意：不能在同一个 CS 周期内发请求+读响应，因为：
+     * 1. SPI 全双工：ESP32 发请求时 MISO 同时在输出旧数据
+     * 2. GD32 收到请求帧后才能准备 ACK，需重启 DMA
+     * 3. DMA 重启期间 MISO 会输出 0x00/0xFF，导致帧断裂
+     * ============================================================ */
     esp_err_t ret = spi_transfer_clocked(tx_frame, tx_len, NULL, 0);
     if (ret != ESP_OK) {
-        DEBUG_ERR("SPI", "SPI OTA 请求事务失败: %s", esp_err_to_name(ret));
+        DEBUG_ERR("SPI", "SPI OTA 请求发送失败: %s", esp_err_to_name(ret));
         return ret;
     }
 
-    /* 给 GD32 从机一点时间在 ISR 中处理请求帧并准备响应帧。
-     * GD32 在 CS 释放的 EXTI ISR 中完成处理（微秒级），
-     * 但 EXTI ISR 到 TBE 中断启用之间有微小延迟。
-     * 500µs 足够覆盖所有中断响应延迟。 */
+    /* 等 GD32 处理帧 + 准备响应。
+     *
+     * GD32 在 CS↑ 的 onCsRelease() 中处理帧：
+     *   isrProcessFrame() → OTA handler 回调 → queueTxFrame() → DMA 启动
+     * 总耗时约 10-20µs（ISR 内执行，无调度延迟）。
+     *
+     * 但 EXTI ISR 可能被更高优先级的 RBNE 中断短暂抢占，
+     * 实际完成时间可能到 30-50µs。
+     *
+     * 500µs 提供了 10x 以上的安全余量，
+     * 同时对 OTA 事务延迟影响可忽略（一次 OTA 事务 ~1ms 级别）。 */
     esp_rom_delay_us(500);
 
+    /* ============================================================
+     * 第2次 CS 周期：发 0xFF dummy 产生时钟，读 MISO 上的响应帧
+     *
+     * GD32 的 onCsAssert 会重启 DMA，将 s_txBuf（ACK帧）
+     * 推到 MISO，ESP32 在 96 字节中扫描定位响应帧。
+     * ============================================================ */
     return spi_ota_poll_response(resp_type, resp_payload, resp_max, resp_len, timeout_ms);
 }