feat(ota_relay): 实现WiFi/AP双模式和CANFD 3通道SPI协议

- 新增AP/STA双工作模式，通过app_config.h配置切换
- 实现CANFD 3通道SPI协议，支持主通信通道和备用通道
- 添加GD32命令ID定义和HTTP API接口
- 集成上位机WebUI，支持固件上传和CAN帧发送

refactor(debug_log): 支持UDP+UART双通道调试输出

- 新增UART0串口调试功能，TX=GPIO21, RX=GPIO20, 115200波特率
- 实现UDP socket延迟创建机制，避免网络初始化冲突
- 调试日志同时输出到UDP和UART双通道

docs(README): 更新项目文档和目录结构说明

- 更新硬件平台和模块功能描述
- 添加WiFi工作模式配置说明
- 补充CANFD协议和GD32命令定义
- 增加HTTP API和上位机WebUI使用指南

fix(health_monitor): 优化健康监控和系统状态报告

- 增强温度和电压监控的警告提示信息
- 添加WiFi RSSI监控和健康状态更新
- 修复安全关机触发条件和状态变更日志

style(main): 优化程序入口和任务创建流程

- 修复网络接口初始化顺序问题
- 添加任务创建结果检查和错误处理
- 增加系统启动信息和CPU频率显示
- 新增周期性状态监控任务，每10秒打印系统状态

.vscode/settings.json

@@ -1,9 +1,9 @@
 {
   "C_Cpp.intelliSenseEngine": "default",
   "idf.openOcdConfigs": [
-    "board/esp32c3-bridge.cfg"
+	"board/esp32c3-bridge.cfg"
-  ],
+],
-  "idf.portWin": "detect",
+  "idf.portWin": "COM11",
   "idf.currentSetup": "F:\\software\\.espressif\\v6.0\\esp-idf",
   "idf.customExtraVars": {
     "IDF_TARGET": "esp32c3"

README.md

@@ -1,6 +1,6 @@
 # ESP32-C3 OTA Relay
 
-ESP32-C3FH4 OTA 中继固件，通过 WiFi / BLE 接收上位机 OTA 固件包，通过 SPI 转发给下位机（GD32）。
+ESP32-C3FH4 OTA 中继固件，通过 WiFi 接收上位机 OTA 固件包，通过 SPI 转发给下位机（GD32）。
 
 ## 硬件平台
 
@@ -14,27 +14,93 @@ ESP32-C3FH4 OTA 中继固件，通过 WiFi / BLE 接收上位机 OTA 固件包
 |------|------|
 | `health_monitor` | 温度 + 电压 + WiFi RSSI 监控 |
 | `ota_relay` | OTA 数据包接收与转发 |
-| `wifi_ota` | WiFi OTA 服务器 (HTTP) |
+| `wifi_ota` | WiFi OTA HTTP 服务器 + CAN 帧转发 |
-| `ble_ota` | BLE OTA 服务器 (GATT) |
+| `spi_master` | SPI 主站，与 GD32 通信 |
-| `spi_master` | SPI 主站，与下位机通信 |
+| `protocol` | CRC16 校验 + AES-128-CBC 解密（硬件加速） |
-| `protocol` | CRC 校验 + AES 解密 |
 
 ## 目录结构
 
 ```
-main/
+ESP32_COMM/
 ├── CMakeLists.txt
-├── core/main.cpp          # 任务创建入口
+├── main/
-├── relay/ota_relay.cpp   # OTA 中继逻辑
+│   ├── CMakeLists.txt
-├── transport/
+│   ├── include/
-│   ├── spi_master.cpp    # SPI 主站
+│   │   └── app_config.h      # WiFi / OTA 参数配置
-│   └── protocol.cpp       # 协议层 (CRC/AES)
+│   ├── core/main.cpp         # 任务创建入口
-├── server/
+│   ├── relay/ota_relay.cpp   # OTA 中继逻辑
-│   ├── wifi_ota.cpp      # WiFi OTA HTTP 服务器
+│   ├── transport/
-│   └── ble_ota.cpp       # BLE OTA GATT 服务器
+│   │   ├── spi_master.cpp    # SPI 主站 + CANFD 3通道发送
-└── monitor/
+│   │   └── protocol.cpp      # 协议层 (CRC16 / AES-128-CBC)
-    ├── health_monitor.cpp # 健康监控
+│   ├── server/
-    └── debug_log.cpp     # UDP 调试日志
+│   │   └── wifi_ota.cpp      # WiFi OTA HTTP 服务器
+│   └── monitor/
+│       ├── health_monitor.cpp  # 健康监控
+│       └── debug_log.cpp       # UDP 调试日志
+└── tools/
+    └── ota_host_web.html     # 上位机 WebUI（CAN 发送 + OTA 上传）
+```
+
+## WiFi 工作模式
+
+支持 AP / STA 两种模式，通过 `app_config.h` 配置：
+
+```c
+// AP 模式（ESP32 当热点）
+CONFIG_WIFI_MODE_IS_STA = 0
+WIFI_AP_SSID = "ESP32_OTA_RELAY"   // 默认热点名称
+WIFI_AP_PASSWORD = "12345678"      // 默认密码
+// 上位机连接热点后访问: http://192.168.4.1
+
+// STA 模式（连接路由器）
+CONFIG_WIFI_MODE_IS_STA = 1
+WIFI_STA_SSID = "004舰桥"          // 路由器名称
+WIFI_STA_PASSWORD = "q13362875622"  // 路由器密码
+// 上位机和 ESP32 在同一局域网，通过 DHCP 分配的 IP 访问
+```
+
+## CANFD 3通道 SPI 协议
+
+GD32 通信帧格式：`[通道编号: 1B] [扩展帧ID: 4B BE] [数据: 1~64B]`
+
+| 通道 | 用途 |
+|------|------|
+| CH0 | 主通信通道 |
+| CH1 | 备用通道 1 |
+| CH2 | 备用通道 2 |
+
+### 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
+
+`tools/ota_host_web.html` — 浏览器打开即可使用，无需安装。
+
+### HTTP API
+
+| 方法 | 路径 | 功能 |
+|------|------|------|
+| 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 连接状态 |
+
+### CAN 帧发送示例
+
+```bash
+curl -X POST http://192.168.4.1/can/send \
+  -H "Content-Type: application/json" \
+  -d '{"ch": 0, "id": 12345678, "dlc": 8, "data": "0102030405060708"}'
 ```
 
 ## 任务配置 (单核 ESP32-C3)
@@ -46,23 +112,23 @@ main/
 | health_mon | configMAX_PRIORITIES - 4 | 4096 | 健康监控 |
 | ota_relay | configMAX_PRIORITIES - 2 | 8192 | OTA 中继 |
 | wifi_ota | configMAX_PRIORITIES - 3 | 8192 | WiFi OTA |
-| ble_ota | configMAX_PRIORITIES - 3 | 8192 | BLE OTA |
+
+## 调试日志
+
+UDP 输出到上位机，端口 6666。上位机 WebUI 自动监听并显示。
+
+## 编译
+
+```bash
+idf.py set-target esp32c3
+idf.py fullclean
+idf.py build
+idf.py flash monitor
+```
 
 ## 待确认参数
 
 - AES-128 主密钥 (MASTER_KEY_HERE)
 - 搅伴算法种子 (SCRAMBLE_CONST_HERE)
 - 芯片唯一码 (CHIP_UID_HERE)
-- OTA Service UUID (需与 APP 侧协商)
+- OTA Service UUID (需与 APP 侧协商)
-
-## 编译
-
-```bash
-idf.py set-target esp32c3
-idf.py build
-idf.py flash monitor
-```
-
-## 调试日志
-
-UDP 输出到上位机，默认 IP: `DEBUG_LOG_IP`，端口: `DEBUG_LOG_PORT`。

main/core/main.cpp

@@ -1,11 +1,16 @@
 /*
  * ESP32-C3FH4 OTA 中继 - 程序入口
  * 四个 FreeRTOS 任务：System Monitor / OTA Relay / WiFi Server / BLE GATT
+ * 
+ * 新增：周期性状态监控任务，每 10 秒打印系统状态
  */
 #include <stdio.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_chip_info.h"
+#include "esp_system.h"
+#include "esp_clk_tree.h"
+#include "esp_netif.h"
 
 #include "monitor/health_monitor.h"
 #include "relay/ota_relay.h"
@@ -15,21 +20,33 @@
 #include "transport/protocol.h"
 #include "monitor/debug_log.h"
 
+// 状态监控任务
+static void status_monitor_task(void *pvParameters);
+
 extern "C" void app_main(void)
 {
+    // 【关键】在所有任务创建之前初始化网络接口
+    // esp_timer 内部依赖 tcpip 线程，health_monitor_task 的 esp_timer_create
+    // 会在 scheduler 启动后立即执行。如果 esp_netif_init() 没有提前调用，
+    // tcpip 线程的 mailbox 还未创建，此时 esp_timer 发消息给 tcpip 线程就会崩溃。
+    // esp_netif_init() 可以安全调用多次，后续 wifi_ota_task 中的调用是多余的但不报错。
+    ESP_ERROR_CHECK(esp_netif_init());
+
     esp_chip_info_t chip_info;
     esp_chip_info(&chip_info);
-
+	
-    // 初始化调试日志（UDP 输出到上位机）
+    // 初始化调试日志（UDP 输出到上位机 + UART0 串口）
     debug_log_init();
     DEBUG_INFO("MAIN", "========================================");
     DEBUG_INFO("MAIN", "ESP32-C3 OTA Relay v1.0 启动");
     DEBUG_INFO("MAIN", "Chip: %s, Rev %d", CONFIG_IDF_TARGET, chip_info.revision);
     DEBUG_INFO("MAIN", "Free heap: %lu bytes", esp_get_free_heap_size());
+    DEBUG_INFO("MAIN", "CPU Freq: %d MHz", CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ);
     DEBUG_INFO("MAIN", "========================================");
 
     // 健康监控任务（温度 + 电压 + WiFi RSSI）
-    xTaskCreatePinnedToCore(
+    BaseType_t xRet;
+    xRet = xTaskCreatePinnedToCore(
         health_monitor_task,
         "health_mon",
         4096,
@@ -38,6 +55,11 @@ extern "C" void app_main(void)
         NULL,
         0
     );
+    if (xRet != pdPASS) {
+        DEBUG_ERR("MAIN", "创建 health_monitor_task 失败");
+    } else {
+        DEBUG_INFO("MAIN", "健康监控任务已创建");
+    }
 
     // 初始化协议层（CRC、AES）
     protocol_init();
@@ -51,9 +73,6 @@ extern "C" void app_main(void)
         DEBUG_INFO("MAIN", "SPI 总线初始化完成");
     }
 
-    // 创建 FreeRTOS 任务
-    BaseType_t xRet;
-
     // OTA 中继任务（中高优先级）
     xRet = xTaskCreatePinnedToCore(
         ota_relay_task,
@@ -66,6 +85,8 @@ extern "C" void app_main(void)
     );
     if (xRet != pdPASS) {
         DEBUG_ERR("MAIN", "创建 ota_relay_task 失败");
+    } else {
+        DEBUG_INFO("MAIN", "OTA 中继任务已创建");
     }
 
     // WiFi OTA 服务器任务
@@ -80,6 +101,8 @@ extern "C" void app_main(void)
     );
     if (xRet != pdPASS) {
         DEBUG_ERR("MAIN", "创建 wifi_ota_task 失败");
+    } else {
+        DEBUG_INFO("MAIN", "WiFi OTA 任务已创建");
     }
 
     // BLE OTA 任务
@@ -94,8 +117,108 @@ extern "C" void app_main(void)
     );
     if (xRet != pdPASS) {
         DEBUG_ERR("MAIN", "创建 ble_ota_task 失败");
+    } else {
+        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", "调试日志输出到上位机: %s:%d", DEBUG_LOG_IP, DEBUG_LOG_PORT);
+    DEBUG_INFO("MAIN", "调试日志输出: UDP(%s:%d) + UART0(GPIO21/TX, 115200)", 
+               DEBUG_LOG_IP, DEBUG_LOG_PORT);
+    DEBUG_INFO("MAIN", "========================================");
+}
+
+// ============================================================
+// 状态监控任务 - 每 10 秒打印系统状态
+// ============================================================
+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/include/app_config.h

@@ -12,8 +12,7 @@
 // ============================================================
 // 0 = AP 模式（设备当热点）
 // 1 = STA 模式（连接路由器）
-#define CONFIG_WIFI_MODE_IS_STA  1
+inline constexpr uint8_t CONFIG_WIFI_MODE = 0;
-inline constexpr uint8_t CONFIG_WIFI_MODE = 1;
 
 // ============================================================
 // WiFi STA 模式配置（连接路由器）
@@ -23,10 +22,9 @@ inline constexpr const char* WIFI_STA_PASSWORD = "q13362875622";
 inline constexpr uint32_t WIFI_STA_CONNECT_TIMEOUT_MS = 30000;
 
 // STA 静态 IP
-inline constexpr uint8_t WIFI_STA_USE_STATIC_IP = 0;  // 设为 1 启用静态 IP
+inline constexpr uint8_t WIFI_STA_USE_STATIC_IP = 1;  // 设为 1 启用静态 IP
-#define WIFI_STA_STATIC_IP_IS_ENABLED  0
 
-#if WIFI_STA_STATIC_IP_IS_ENABLED
+#if WIFI_STA_USE_STATIC_IP
 inline constexpr const char* WIFI_STA_STATIC_IP      = "192.168.1.100";
 inline constexpr const char* WIFI_STA_STATIC_GW      = "192.168.1.1";
 inline constexpr const char* WIFI_STA_STATIC_NETMASK = "255.255.255.0";

main/monitor/debug_log.cpp

@@ -3,14 +3,19 @@
  *
  * 通过 UDP socket 发送调试日志到上位机
  * 上位机需监听 <DEBUG_LOG_IP>:<DEBUG_LOG_PORT>
+ * 
+ * 支持双通道输出：UDP + UART0 串口
+ * UART0: TX=GPIO21, RX=GPIO20, 115200 波特率
  */
 #include <string.h>
+#include <stdio.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <arpa/inet.h>
 #include "freertos/task.h"
 #include "esp_log.h"
 #include "esp_err.h"
+#include "driver/uart.h"
 
 #include "debug_log.h"
 
@@ -22,13 +27,104 @@ static int s_udp_sock = -1;
 static struct sockaddr_in s_debug_addr;
 static bool s_initialized = false;
 
-// 初始化 UDP socket
+// UART0 状态
+static bool s_uart_initialized = false;
+static uart_port_t s_uart_port = UART_NUM_0;
+
+// ============================================================
+// UART0 串口调试
+// ============================================================
+
+esp_err_t uart_debug_init(void)
+{
+    if (s_uart_initialized) {
+        return ESP_OK;
+    }
+
+    uart_config_t uart_config;
+    memset(&uart_config, 0, sizeof(uart_config));
+    uart_config.baud_rate = UART_DEBUG_BAUD_RATE;
+    uart_config.data_bits = UART_DATA_8_BITS;
+    uart_config.parity = UART_PARITY_DISABLE;
+    uart_config.stop_bits = UART_STOP_BITS_1;
+    uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
+    uart_config.source_clk = UART_SCLK_DEFAULT;
+    uart_config.rx_flow_ctrl_thresh = 0;
+
+    esp_err_t ret = uart_driver_install(s_uart_port, 1024, 0, 0, NULL, 0);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "UART0 驱动安装失败: %s", esp_err_to_name(ret));
+        return ret;
+    }
+
+    ret = uart_param_config(s_uart_port, &uart_config);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "UART0 参数配置失败: %s", esp_err_to_name(ret));
+        return ret;
+    }
+
+    ret = uart_set_pin(s_uart_port, UART_DEBUG_TX_GPIO, UART_DEBUG_RX_GPIO,
+                       UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "UART0 引脚配置失败: %s", esp_err_to_name(ret));
+        return ret;
+    }
+
+    s_uart_initialized = true;
+    ESP_LOGI(TAG, "UART0 调试输出已初始化 (TX=GPIO%d, RX=GPIO%d, %d baud)",
+             UART_DEBUG_TX_GPIO, UART_DEBUG_RX_GPIO, UART_DEBUG_BAUD_RATE);
+
+    return ESP_OK;
+}
+
+esp_err_t uart_debug_send(const uint8_t *data, size_t len)
+{
+    if (!s_uart_initialized) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    int ret = uart_write_bytes(s_uart_port, data, len);
+    if (ret < 0) {
+        return ESP_FAIL;
+    }
+
+    return ESP_OK;
+}
+
+// ============================================================
+// UDP 调试日志
+// ============================================================
+
+// 初始化 UDP socket（注意：socket 创建延迟到 debug_log_send 首次调用时）
+// 因为 esp_netif_init() 会在 wifi_ota_task 里调用，提前创建 socket 会导致 tcpip 线程未就绪而崩溃
 esp_err_t debug_log_init(void)
 {
     if (s_initialized) {
         return ESP_OK;
     }
 
+    // 初始化 UART0（不需要网络）
+    uart_debug_init();
+
+    // 延迟创建 socket：先只初始化目标地址，socket 在 debug_log_send 首次发 UDP 时创建
+    memset(&s_debug_addr, 0, sizeof(s_debug_addr));
+    s_debug_addr.sin_family = AF_INET;
+    s_debug_addr.sin_port = htons(DEBUG_LOG_PORT);
+    s_debug_addr.sin_addr.s_addr = inet_addr(DEBUG_LOG_IP);
+
+    s_initialized = true;
+    ESP_LOGI(TAG, "调试日志已初始化（UDP socket 延迟创建），上位机 IP=%s:%d", DEBUG_LOG_IP, DEBUG_LOG_PORT);
+
+    return ESP_OK;
+}
+
+// 延迟创建 UDP socket（仅在首次发送 UDP 时调用）
+static esp_err_t ensure_udp_socket(void)
+{
+    if (s_udp_sock >= 0) {
+        return ESP_OK;  // 已创建
+    }
+
     // 创建 UDP socket
     s_udp_sock = socket(AF_INET, SOCK_DGRAM, 0);
     if (s_udp_sock < 0) {
@@ -36,38 +132,54 @@ esp_err_t debug_log_init(void)
         return ESP_FAIL;
     }
 
-    // 设置目标地址
+    ESP_LOGI(TAG, "UDP socket 创建成功");
-    memset(&s_debug_addr, 0, sizeof(s_debug_addr));
-    s_debug_addr.sin_family = AF_INET;
-    s_debug_addr.sin_port = htons(DEBUG_LOG_PORT);
-    s_debug_addr.sin_addr.s_addr = inet_addr(DEBUG_LOG_IP);
-
-    s_initialized = true;
-    ESP_LOGI(TAG, "调试日志已初始化，上位机 IP=%s:%d", DEBUG_LOG_IP, DEBUG_LOG_PORT);
-
     return ESP_OK;
 }
 
-// 发送原始数据到上位机
+// 发送原始数据到上位机（UDP + UART 双通道）
 esp_err_t debug_log_send(const uint8_t *data, size_t len)
 {
-    if (!s_initialized || s_udp_sock < 0) {
+    esp_err_t udp_ret = ESP_FAIL;
-        return ESP_ERR_INVALID_STATE;
+    esp_err_t uart_ret = ESP_FAIL;
+
+    // UART 通道发送
+    if (s_uart_initialized) {
+        uart_ret = uart_debug_send(data, len);
     }
 
-    if (len > 1024) {
+    // UDP 通道发送（延迟创建 socket）
-        len = 1024;  // 限制单次发送大小
+    if (s_initialized) {
+        // 首次 UDP 发送前才创建 socket
+        if (s_udp_sock < 0) {
+            if (ensure_udp_socket() != ESP_OK) {
+                // socket 创建失败，走 UART 通道
+            } else {
+                udp_ret = ESP_OK;  // 标记为已就绪
+            }
+        }
+
+        if (s_udp_sock >= 0) {
+            if (len > 1024) {
+                len = 1024;  // 限制单次发送大小
+            }
+
+            int ret = sendto(s_udp_sock, data, len, 0,
+                             (struct sockaddr *)&s_debug_addr, sizeof(s_debug_addr));
+
+            if (ret < 0) {
+                udp_ret = ESP_FAIL;
+            } else {
+                udp_ret = ESP_OK;
+            }
+        }
     }
 
-    int ret = sendto(s_udp_sock, data, len, 0,
+    // 至少一个通道成功即返回成功
-                     (struct sockaddr *)&s_debug_addr, sizeof(s_debug_addr));
+    if (udp_ret == ESP_OK || uart_ret == ESP_OK) {
-
+        return ESP_OK;
-    if (ret < 0) {
-        // 静默失败，避免影响正常流程
-        return ESP_FAIL;
     }
 
-    return ESP_OK;
+    return ESP_FAIL;
 }
 
 // 格式化日志输出

main/monitor/debug_log.h

@@ -3,6 +3,9 @@
  *
  * 通过 UDP socket 将调试信息发送到上位机
  * 上位机监听 <udp_ip>/<udp_port> 接收日志
+ * 
+ * 支持双通道输出：UDP + UART0 串口
+ * UART0: TX=GPIO21, RX=GPIO20, 115200 波特率
  */
 #ifndef DEBUG_LOG_H
 #define DEBUG_LOG_H
@@ -14,6 +17,11 @@
 
 // 调试日志配置（DEBUG_LOG_IP/PORT/ENABLED 已在 app_config.h 中定义）
 
+// UART0 调试配置
+#define UART_DEBUG_TX_GPIO   21
+#define UART_DEBUG_RX_GPIO   20
+#define UART_DEBUG_BAUD_RATE 115200
+
 // 日志级别
 typedef enum {
     DEBUG_LOG_NONE  = 0,
@@ -27,9 +35,15 @@ typedef enum {
 // 当前日志级别（运行时可改）
 extern debug_log_level_t g_debug_log_level;
 
-// 初始化调试日志系统（启动 UDP 客户端）
+// 初始化调试日志系统（启动 UDP 客户端 + UART0）
 esp_err_t debug_log_init(void);
 
+// UART0 串口调试初始化
+esp_err_t uart_debug_init(void);
+
+// UART0 串口发送
+esp_err_t uart_debug_send(const uint8_t *data, size_t len);
+
 // 发送原始数据到上位机
 esp_err_t debug_log_send(const uint8_t *data, size_t len);
 

main/monitor/health_monitor.cpp

@@ -60,11 +60,13 @@ static void temp_monitor_callback(void *arg)
 
     if (temp >= TEMP_CRITICAL) {
         g_health_state = SYS_SAFE_SHUTDOWN;
-        DEBUG_ERR("TEMP", "危险: 温度 %.1f°C >= %d°C，触发安全关机", temp, TEMP_CRITICAL);
+        DEBUG_ERR("TEMP", "!!! 危险 !!! 温度 %.1f°C >= %d°C，触发安全关机", temp, TEMP_CRITICAL);
+        DEBUG_ERR("TEMP", "健康状态变更为: SYS_SAFE_SHUTDOWN");
     } else if (temp >= TEMP_WARNING) {
         if (g_health_state < SYS_WARNING) {
             g_health_state = SYS_WARNING;
             DEBUG_WARN("TEMP", "警告: 温度 %.1f°C >= %d°C", temp, TEMP_WARNING);
+            DEBUG_WARN("TEMP", "健康状态变更为: SYS_WARNING");
         }
     }
 }
@@ -79,12 +81,16 @@ static void voltage_monitor_callback(void *arg)
 
     if (voltage < 2.3f) {
         g_health_state = SYS_SAFE_SHUTDOWN;
-        DEBUG_ERR("VOLT", "危险: 电压 %.2fV < 2.3V，触发安全关机", voltage);
+        DEBUG_ERR("VOLT", "!!! 危险 !!! 电压 %.2fV < 2.3V，触发安全关机", voltage);
+        DEBUG_ERR("VOLT", "健康状态变更为: SYS_SAFE_SHUTDOWN");
     } else if (voltage < 2.5f) {
         if (g_health_state < SYS_WARNING) {
             g_health_state = SYS_WARNING;
             DEBUG_WARN("VOLT", "警告: 电压 %.2fV < 2.5V", voltage);
+            DEBUG_WARN("VOLT", "健康状态变更为: SYS_WARNING");
         }
+    } else {
+        DEBUG_INFO("VOLT", "电压正常: %.2fV", voltage);
     }
 }
 
@@ -93,7 +99,7 @@ static void voltage_monitor_callback(void *arg)
 // ----------------------------------------
 void health_monitor_task(void *pvParameters)
 {
-    DEBUG_INFO("MON", "健康监控任务启动");
+    DEBUG_INFO("MON", "=== 健康监控任务启动 ===");
 
     // 初始化内置温度传感器（测量范围 20°C ~ 80°C）
     temperature_sensor_config_t temp_config = TEMPERATURE_SENSOR_CONFIG_DEFAULT(20, 80);
@@ -116,13 +122,38 @@ void health_monitor_task(void *pvParameters)
     esp_timer_create(&timer_args, &temp_timer);
     esp_timer_start_periodic(temp_timer, 5 * 1000000);  // 5秒
 
+    DEBUG_INFO("MON", "温度监控定时器已启动 (间隔 5 秒)");
+
     // 启动时检查一次电压
     voltage_monitor_callback(NULL);
 
     // 每5秒打印一次健康状态
+    uint32_t loop_count = 0;
     while (1) {
-        DEBUG_INFO("MON", "健康状态: %d, 空闲堆: %lu",
+        loop_count++;
-                   g_health_state, esp_get_free_heap_size());
+        
+        uint32_t free_heap = esp_get_free_heap_size();
+        
+        const char *state_str;
+        switch (g_health_state) {
+            case SYS_NORMAL:       state_str = "正常"; break;
+            case SYS_WARNING:      state_str = "警告"; break;
+            case SYS_CRITICAL:     state_str = "危险"; break;
+            case SYS_SAFE_SHUTDOWN: state_str = "安全关机"; break;
+            default:               state_str = "未知"; break;
+        }
+        
+        DEBUG_INFO("MON", "--- 健康状态 #%lu ---", (unsigned long)loop_count);
+        DEBUG_INFO("MON", "健康状态: %s (%d)", state_str, g_health_state);
+        DEBUG_INFO("MON", "空闲堆: %lu 字节", (unsigned long)free_heap);
+        
+        // 堆内存警告
+        if (free_heap < HEAP_WARNING_MIN) {
+            DEBUG_WARN("MON", "空闲堆内存不足: %lu < %d", (unsigned long)free_heap, HEAP_WARNING_MIN);
+        }
+        
+        DEBUG_INFO("MON", "===================");
+        
         vTaskDelay(pdMS_TO_TICKS(5000));
     }
 }
@@ -132,7 +163,7 @@ void health_monitor_task(void *pvParameters)
 // ----------------------------------------
 void health_log_event(const char *event, int value)
 {
-    DEBUG_WARN("HEALTH", "[健康日志] %s: %d", event, value);
+    DEBUG_INFO("HEALTH", "[健康事件] %s: %d", event, value);
 }
 
 // ----------------------------------------
@@ -143,25 +174,36 @@ health_status_t health_check_before_ota(void)
     health_status_t status = HEALTH_MON_OK;
 
     if (g_health_state >= SYS_SAFE_SHUTDOWN) {
+        DEBUG_WARN("HEALTH", "OTA 前检查: SYS_SAFE_SHUTDOWN，禁止传输");
         return HEALTH_MON_SHUTDOWN;
     } else if (g_health_state >= SYS_CRITICAL) {
+        DEBUG_WARN("HEALTH", "OTA 前检查: SYS_CRITICAL，禁止传输");
         return HEALTH_MON_CRITICAL;
     } else if (g_health_state >= SYS_WARNING) {
         status = HEALTH_MON_WARNING;
+        DEBUG_WARN("HEALTH", "OTA 前检查: SYS_WARNING，继续传输但需注意");
     }
 
     wifi_ap_record_t ap_info;
     if (esp_wifi_sta_get_ap_info(&ap_info) == ESP_OK) {
         if (ap_info.rssi < WIFI_RSSI_CRITICAL) {
             g_health_state = SYS_CRITICAL;
+            DEBUG_WARN("HEALTH", "OTA 前检查: WiFi RSSI %d < %d (危险阈值)", 
+                       ap_info.rssi, WIFI_RSSI_CRITICAL);
             return HEALTH_MON_CRITICAL;
         } else if (ap_info.rssi < WIFI_RSSI_NORMAL) {
             if (status < HEALTH_MON_WARNING) {
                 status = HEALTH_MON_WARNING;
             }
+            DEBUG_WARN("HEALTH", "OTA 前检查: WiFi RSSI %d < %d (警告阈值)", 
+                       ap_info.rssi, WIFI_RSSI_NORMAL);
         }
     }
 
+    if (status == HEALTH_MON_OK) {
+        DEBUG_DBG("HEALTH", "OTA 前检查: 正常");
+    }
+
     return status;
 }
 
@@ -169,11 +211,13 @@ health_status_t health_update_from_wifi_rssi(int8_t rssi)
 {
     if (rssi < WIFI_RSSI_CRITICAL) {
         g_health_state = SYS_CRITICAL;
+        DEBUG_WARN("HEALTH", "WiFi RSSI 危险: %d dBm < %d dBm", rssi, WIFI_RSSI_CRITICAL);
         health_log_event("WIFI危险", rssi);
         return HEALTH_MON_CRITICAL;
     } else if (rssi < WIFI_RSSI_NORMAL) {
         if (g_health_state < SYS_WARNING) {
             g_health_state = SYS_WARNING;
+            DEBUG_WARN("HEALTH", "WiFi RSSI 警告: %d dBm < %d dBm", rssi, WIFI_RSSI_NORMAL);
             health_log_event("WIFI警告", rssi);
         }
         return HEALTH_MON_WARNING;
@@ -181,6 +225,7 @@ health_status_t health_update_from_wifi_rssi(int8_t rssi)
 
     if (g_health_state == SYS_WARNING && rssi >= WIFI_RSSI_NORMAL) {
         g_health_state = SYS_NORMAL;
+        DEBUG_INFO("HEALTH", "WiFi RSSI 恢复: %d dBm >= %d dBm", rssi, WIFI_RSSI_NORMAL);
         health_log_event("WIFI恢复", rssi);
     }
 

main/relay/ota_relay.cpp

@@ -152,6 +152,7 @@ esp_err_t flash_read_chunk(uint32_t offset, uint8_t *data, size_t len)
 static ota_result_t send_handshake_req(void)
 {
     DEBUG_INFO("OTA", "=== 阶段1: 握手开始 ===");
+    DEBUG_INFO("OTA", "发送 HANDSHAKE_REQ (0x00 0xAC)");
 
     uint8_t tx_frame[32];
     uint8_t rx_frame[32];
@@ -160,11 +161,12 @@ static ota_result_t send_handshake_req(void)
     frame_build(CMD_HANDSHAKE_REQ, payload, sizeof(payload), tx_frame);
 
     g_relay_state = RELAY_HANDSHAKE_SENT;
+    DEBUG_INFO("OTA", "状态: RELAY_HANDSHAKE_SENT");
 
     esp_err_t err = spi_sync_transfer(CMD_HANDSHAKE_REQ, payload, sizeof(payload),
                                       rx_frame, sizeof(rx_frame), 3000);
     if (err != ESP_OK) {
-        DEBUG_ERR("OTA", "HANDSHAKE_REQ 失败");
+        DEBUG_ERR("OTA", "HANDSHAKE_REQ 失败, err=%d", err);
         g_relay_state = RELAY_ERROR;
         return OTA_RESULT_ERR_TIMEOUT;
     }
@@ -188,38 +190,45 @@ static ota_result_t send_nonce_and_authenticate(void)
 
     scramble_generate(timestamp, mem_addr, rand_seed, nonce_server);
 
-    DEBUG_INFO("OTA", "发送 CHALLENGE，包含 nonce_server (16B)");
+    DEBUG_INFO("OTA", "--- 认证步骤 1: 发送 CHALLENGE ---");
+    DEBUG_INFO("OTA", "发送 nonce_server (16B), timestamp=0x%08X", timestamp);
     g_relay_state = RELAY_CHALLENGE_SENT;
+    DEBUG_INFO("OTA", "状态: RELAY_CHALLENGE_SENT");
 
     frame_build(CMD_CHALLENGE, nonce_server, 16, tx_frame);
 
     esp_err_t err = spi_sync_transfer(CMD_CHALLENGE, nonce_server, 16,
                                       rx_frame, sizeof(rx_frame), 5000);
     if (err != ESP_OK) {
-        DEBUG_ERR("OTA", "CHALLENGE 发送失败");
+        DEBUG_ERR("OTA", "CHALLENGE 发送失败, err=%d", err);
         g_relay_state = RELAY_ERROR;
         return OTA_RESULT_ERR_TIMEOUT;
     }
 
     g_relay_state = RELAY_CHALLENGE_RESPOND;
     DEBUG_INFO("OTA", "已收到 GD32 握手数据包");
+    DEBUG_INFO("OTA", "状态: RELAY_CHALLENGE_RESPOND");
 
     // 发送 SESSION_KEY（带变换后的随机数）
     uint8_t transformed_nonce[16];
     memcpy(transformed_nonce, nonce_server, 16);
 
-    DEBUG_INFO("OTA", "发送 SESSION_KEY（带变换后的随机数）");
+    DEBUG_INFO("OTA", "--- 认证步骤 2: 发送 SESSION_KEY ---");
+    DEBUG_INFO("OTA", "发送变换后的随机数 (16B)");
     g_relay_state = RELAY_SESSION_KEY_SENT;
+    DEBUG_INFO("OTA", "状态: RELAY_SESSION_KEY_SENT");
 
     frame_build(CMD_SESSION_KEY, transformed_nonce, 16, tx_frame);
     esp_err_t err2 = spi_sync_transfer(CMD_SESSION_KEY, transformed_nonce, 16,
                                        rx_frame, sizeof(rx_frame), 3000);
     if (err2 != ESP_OK) {
+        DEBUG_ERR("OTA", "SESSION_KEY 发送失败, err=%d", err2);
         g_relay_state = RELAY_ERROR;
         return OTA_RESULT_ERR_TIMEOUT;
     }
 
     g_relay_state = RELAY_AUTH_COMPLETE;
+    DEBUG_INFO("OTA", "状态: RELAY_AUTH_COMPLETE");
     DEBUG_INFO("OTA", "=== 阶段1 认证完成: 安全通道已建立 ===");
 
     uint8_t k_session[16] = {0};
@@ -234,7 +243,8 @@ static ota_result_t send_firmware_size(uint32_t size)
     uint8_t tx_frame[32];
     uint8_t rx_frame[32];
 
-    DEBUG_INFO("OTA", "=== 阶段2: 发送大小 ===");
+    DEBUG_INFO("OTA", "=== 阶段2: 发送固件大小 ===");
+    DEBUG_INFO("OTA", "固件大小: %u 字节", size);
 
     uint8_t size_payload[4];
     size_payload[0] = (uint8_t)(size & 0xFF);
@@ -243,18 +253,20 @@ static ota_result_t send_firmware_size(uint32_t size)
     size_payload[3] = (uint8_t)((size >> 24) & 0xFF);
 
     g_relay_state = RELAY_SIZE_SENT;
+    DEBUG_INFO("OTA", "状态: RELAY_SIZE_SENT");
 
     frame_build(CMD_SEND_SIZE, size_payload, 4, tx_frame);
     esp_err_t err = spi_sync_transfer(CMD_SEND_SIZE, size_payload, 4,
                                       rx_frame, sizeof(rx_frame), 3000);
     if (err != ESP_OK) {
-        DEBUG_ERR("OTA", "SEND_SIZE 失败");
+        DEBUG_ERR("OTA", "SEND_SIZE 失败, err=%d", err);
         g_relay_state = RELAY_ERROR;
         return OTA_RESULT_ERR_TIMEOUT;
     }
 
     DEBUG_INFO("OTA", "大小已发送: %u 字节，等待 GD32 确认...", size);
     g_relay_state = RELAY_SIZE_ACK;
+    DEBUG_INFO("OTA", "状态: RELAY_SIZE_ACK");
 
     return OTA_RESULT_OK;
 }
@@ -266,6 +278,7 @@ static ota_result_t relay_packets_from_flash(void)
 
     ota_meta_t meta;
     if (meta_load(&meta) != ESP_OK) {
+        DEBUG_ERR("OTA", "元数据加载失败");
         return OTA_RESULT_ERR_STORAGE;
     }
 
@@ -275,7 +288,9 @@ static ota_result_t relay_packets_from_flash(void)
     uint8_t rx_buf[32];
     ota_result_t result = OTA_RESULT_OK;
 
-    DEBUG_INFO("OTA", "准备转发 %u 包，每包 48 字节", total_packets);
+    DEBUG_INFO("OTA", "总包数: %u, 每包 48 字节", total_packets);
+    DEBUG_INFO("OTA", "状态: RELAY_RELAY_ACTIVE");
+    g_relay_state = RELAY_RELAY_ACTIVE;
 
     for (uint32_t seq = 0; seq < total_packets; seq++) {
         // 发送每个包前检查健康状态
@@ -292,7 +307,7 @@ static ota_result_t relay_packets_from_flash(void)
 
         esp_err_t err = flash_read_chunk(flash_offset, &tx_buf[2], chunk_size);
         if (err != ESP_OK) {
-            DEBUG_ERR("OTA", "Flash 读取失败，偏移=%u", flash_offset);
+            DEBUG_ERR("OTA", "Flash 读取失败, offset=%u, err=%d", flash_offset, err);
             return OTA_RESULT_ERR_STORAGE;
         }
 
@@ -310,7 +325,7 @@ static ota_result_t relay_packets_from_flash(void)
 
         err = spi_sync_transfer(cmd, tx_buf, tx_len, rx_buf, sizeof(rx_buf), 3000);
         if (err != ESP_OK) {
-            DEBUG_WARN("OTA", "数据包 %u 发送失败，重试中...", seq);
+            DEBUG_WARN("OTA", "数据包 %u 发送失败, err=%d, 重试中...", seq, err);
             result = OTA_RESULT_ERR_TIMEOUT;
             break;
         }
@@ -320,12 +335,14 @@ static ota_result_t relay_packets_from_flash(void)
 
         // 每 10% 记录一次进度
         if (seq % (total_packets / 10 + 1) == 0) {
+            uint32_t progress = (seq * 100) / total_packets;
             DEBUG_INFO("OTA", "转发进度: %u/%u 包 (%u%%)",
-                       seq, total_packets, (seq * 100) / total_packets);
+                       seq, total_packets, progress);
         }
     }
 
     g_relay_state = RELAY_RECEIVE_DONE;
+    DEBUG_INFO("OTA", "状态: RELAY_RECEIVE_DONE");
     return result;
 }
 
@@ -333,6 +350,7 @@ static ota_result_t relay_packets_from_flash(void)
 static ota_result_t finish_ota(void)
 {
     DEBUG_INFO("OTA", "=== 阶段4: 结束 OTA ===");
+    DEBUG_INFO("OTA", "发送 FINISH_OTA (0x0A 0xAC)");
 
     uint8_t tx_frame[16];
     uint8_t rx_frame[16];
@@ -341,11 +359,12 @@ static ota_result_t finish_ota(void)
     frame_build(CMD_FINISH_OTA, payload, sizeof(payload), tx_frame);
 
     g_relay_state = RELAY_FINISH_SENT;
+    DEBUG_INFO("OTA", "状态: RELAY_FINISH_SENT");
 
     esp_err_t err = spi_sync_transfer(CMD_FINISH_OTA, payload, sizeof(payload),
                                       rx_frame, sizeof(rx_frame), 5000);
     if (err != ESP_OK) {
-        DEBUG_ERR("OTA", "FINISH_OTA 失败");
+        DEBUG_ERR("OTA", "FINISH_OTA 失败, err=%d", err);
         g_relay_state = RELAY_ERROR;
         return OTA_RESULT_ERR_TIMEOUT;
     }
@@ -356,6 +375,7 @@ static ota_result_t finish_ota(void)
     memset(&g_session_ctx, 0, sizeof(session_ctx_t));
 
     g_relay_state = RELAY_DONE;
+    DEBUG_INFO("OTA", "状态: RELAY_DONE");
     DEBUG_INFO("OTA", "=== OTA 完成 ===");
 
     meta_clear();

main/server/wifi_ota.cpp

@@ -36,7 +36,7 @@ static httpd_handle_t s_http_server = NULL;
 // ----------------------------------------
 static esp_err_t wifi_init_ap(void)
 {
-    DEBUG_INFO("WIFI", "初始化 WiFi AP 模式...");
+    DEBUG_INFO("WIFI", "=== 初始化 WiFi AP 模式 ===");
 
     s_wifi_mode = OTA_WIFI_MODE_AP;
 
@@ -48,12 +48,15 @@ static esp_err_t wifi_init_ap(void)
     wifi_config.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
     wifi_config.ap.channel = WIFI_AP_CHANNEL;
 
+    DEBUG_INFO("WIFI", "AP SSID: %s, Channel: %d", WIFI_AP_SSID, WIFI_AP_CHANNEL);
+
     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
     ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
     ESP_ERROR_CHECK(esp_wifi_start());
 
     DEBUG_INFO("WIFI", "WiFi AP 已启动: %s", WIFI_AP_SSID);
     DEBUG_INFO("WIFI", "AP IP 地址: 192.168.4.1");
+    DEBUG_INFO("WIFI", "最大连接数: %d", WIFI_AP_MAX_CONNECT);
 
     return ESP_OK;
 }
@@ -63,7 +66,7 @@ static esp_err_t wifi_init_ap(void)
 // ----------------------------------------
 static esp_err_t wifi_init_sta(void)
 {
-    DEBUG_INFO("WIFI", "初始化 WiFi STA 模式...");
+    DEBUG_INFO("WIFI", "=== 初始化 WiFi STA 模式 ===");
 
     s_wifi_mode = OTA_WIFI_MODE_STA;
 
@@ -74,6 +77,8 @@ static esp_err_t wifi_init_sta(void)
     memcpy(wifi_config.sta.ssid, WIFI_STA_SSID, strlen(WIFI_STA_SSID) + 1);
     memcpy(wifi_config.sta.password, WIFI_STA_PASSWORD, strlen(WIFI_STA_PASSWORD) + 1);
 
+    DEBUG_INFO("WIFI", "STA SSID: %s", WIFI_STA_SSID);
+
     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
     ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
     ESP_ERROR_CHECK(esp_wifi_start());
@@ -133,10 +138,11 @@ static void wifi_set_static_ip(void)
 // ----------------------------------------
 static esp_err_t ota_upload_handler(httpd_req_t *req)
 {
-    DEBUG_INFO("WIFI", "收到固件上传请求, 内容长度: %d", req->content_len);
+    DEBUG_INFO("WIFI", "=== HTTP: POST /ota/upload ===");
+    DEBUG_INFO("WIFI", "收到固件上传请求, 内容长度: %d 字节", req->content_len);
 
     if (req->content_len > OTA_MAX_FIRMWARE_SIZE) {
-        DEBUG_ERR("WIFI", "固件太大: %d 字节", req->content_len);
+        DEBUG_ERR("WIFI", "固件太大: %d 字节 (最大 %d)", req->content_len, OTA_MAX_FIRMWARE_SIZE);
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "固件太大");
         return ESP_FAIL;
     }
@@ -151,7 +157,7 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
 
         int ret = httpd_req_recv(req, (char *)buf, to_read);
         if (ret <= 0) {
-            DEBUG_ERR("WIFI", "请求接收失败");
+            DEBUG_ERR("WIFI", "HTTP 请求接收失败");
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "接收失败");
             return ESP_FAIL;
         }
@@ -169,7 +175,8 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
                     .checksum = {0}
                 };
                 meta_save(&meta);
-                DEBUG_INFO("WIFI", "开始固件存储: %u 字节", total_size);
+                DEBUG_INFO("WIFI", "开始固件存储: %u 字节, %u 块", 
+                           total_size, meta.chunk_count);
             }
             first_chunk = 0;
         }
@@ -177,13 +184,18 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
         uint32_t flash_offset = (received / OTA_BLOCK_SIZE) * OTA_BLOCK_SIZE;
         esp_err_t err = flash_write_chunk(flash_offset, buf, ret);
         if (err != ESP_OK) {
-            DEBUG_ERR("WIFI", "Flash 写入失败 at offset %u", flash_offset);
+            DEBUG_ERR("WIFI", "Flash 写入失败, offset=%u, err=%d", flash_offset, err);
         }
 
         meta_update(flash_offset + ret, received / OTA_BLOCK_SIZE);
 
         received += ret;
-        DEBUG_DBG("WIFI", "已接收: %d / %d 字节", received, req->content_len);
+        
+        // 每 10% 打印进度
+        if (received % (req->content_len / 10 + 1) < OTA_BLOCK_SIZE) {
+            uint32_t progress = (received * 100) / req->content_len;
+            DEBUG_INFO("WIFI", "上传进度: %d / %d 字节 (%u%%)", received, req->content_len, progress);
+        }
     }
 
     DEBUG_INFO("WIFI", "固件存储完成: %d 字节", received);
@@ -207,6 +219,7 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
 static esp_err_t ota_relay_trigger_handler(httpd_req_t *req)
 {
     (void)req;
+    DEBUG_INFO("WIFI", "=== HTTP: POST /ota/relay ===");
     DEBUG_INFO("WIFI", "收到触发 OTA 中继请求");
     wifi_ota_signal_relay();
 
@@ -220,6 +233,8 @@ static esp_err_t ota_relay_trigger_handler(httpd_req_t *req)
 // HTTP GET /ota/status 处理器
 static esp_err_t ota_status_handler(httpd_req_t *req)
 {
+    DEBUG_INFO("WIFI", "=== HTTP: GET /ota/status ===");
+    
     ota_meta_t meta;
     meta_load(&meta);
 
@@ -232,6 +247,10 @@ static esp_err_t ota_status_handler(httpd_req_t *req)
         s_ota_storage_done ? "true" : "false",
         g_relay_state);
 
+    DEBUG_INFO("WIFI", "OTA 状态: total=%lu, stored=%lu, done=%s",
+               (unsigned long)meta.total_size, (unsigned long)meta.stored_size,
+               s_ota_storage_done ? "true" : "false");
+
     httpd_resp_set_type(req, "application/json");
     httpd_resp_send(req, resp, len);
 
@@ -241,12 +260,17 @@ static esp_err_t ota_status_handler(httpd_req_t *req)
 // HTTP GET /health 处理器
 static esp_err_t health_handler(httpd_req_t *req)
 {
+    DEBUG_INFO("WIFI", "=== HTTP: GET /health ===");
+    
     health_state_t state = health_get_current();
+    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)esp_get_free_heap_size());
+        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);
@@ -386,7 +410,8 @@ static esp_err_t http_ota_server_start(void)
     config.server_port = HTTP_SERVER_PORT;
     config.stack_size = HTTP_SERVER_STACK_SIZE;
 
-    DEBUG_INFO("WIFI", "启动 HTTP 服务器，端口 %d...", config.server_port);
+    DEBUG_INFO("WIFI", "=== 启动 HTTP OTA 服务器 ===");
+    DEBUG_INFO("WIFI", "HTTP 服务器端口: %d", config.server_port);
 
     esp_err_t err = httpd_start(&s_http_server, &config);
     if (err != ESP_OK) {
@@ -452,6 +477,7 @@ static esp_err_t http_ota_server_start(void)
     httpd_register_uri_handler(s_http_server, &can_status_uri);
 
     DEBUG_INFO("WIFI", "HTTP 服务器已启动");
+    DEBUG_INFO("WIFI", "注册端点: /ota/upload, /ota/relay, /ota/status, /health, /wifi/status, /can/send, /can/status");
 
     return ESP_OK;
 }
@@ -504,19 +530,23 @@ void wifi_ota_task(void *pvParameters)
 {
     (void)pvParameters;
 
-    DEBUG_INFO("WIFI", "WiFi OTA 任务启动");
+    DEBUG_INFO("WIFI", "=== WiFi OTA 任务启动 ===");
 
     // 初始化 NVS
     esp_err_t err = nvs_flash_init();
     if (err != ESP_OK) {
         DEBUG_ERR("WIFI", "NVS 初始化失败: %s", esp_err_to_name(err));
+    } else {
+        DEBUG_INFO("WIFI", "NVS 初始化成功");
     }
 
     // 初始化网络接口
     ESP_ERROR_CHECK(esp_netif_init());
+    DEBUG_INFO("WIFI", "网络接口初始化成功");
 
     // STA 优先，失败自动切 AP
 #if CONFIG_WIFI_MODE_IS_STA
+    DEBUG_INFO("WIFI", "工作模式: STA (优先)");
     err = wifi_init_sta();
     if (err == ESP_OK) {
         char ip_str[16] = {0};
@@ -536,6 +566,7 @@ void wifi_ota_task(void *pvParameters)
         }
     }
 #else
+    DEBUG_INFO("WIFI", "工作模式: AP");
     wifi_init_ap();
 #endif
 
@@ -545,7 +576,7 @@ void wifi_ota_task(void *pvParameters)
         DEBUG_ERR("WIFI", "HTTP 服务器启动失败");
     }
 
-    DEBUG_INFO("WIFI", "WiFi OTA 服务器就绪");
+    DEBUG_INFO("WIFI", "=== WiFi OTA 服务器就绪 ===");
 
     // 定期检查 WiFi 状态
     while (1) {
@@ -554,7 +585,9 @@ void wifi_ota_task(void *pvParameters)
             health_update_from_wifi_rssi(rssi);
 
             if (rssi < WIFI_RSSI_CRITICAL) {
-                DEBUG_WARN("WIFI", "WiFi RSSI 危险: %d dBm", rssi);
+                DEBUG_WARN("WIFI", "WiFi RSSI 危险: %d dBm (阈值: %d)", rssi, WIFI_RSSI_CRITICAL);
+            } else if (rssi < WIFI_RSSI_WARNING) {
+                DEBUG_WARN("WIFI", "WiFi RSSI 较弱: %d dBm", rssi);
             }
         }
 

main/transport/protocol.cpp

@@ -19,7 +19,8 @@ void protocol_init(void)
 {
     if (s_protocol_initialized) return;
 
-    DEBUG_INFO("PROT", "初始化协议层（CRC16、硬件AES-CBC）...");
+    DEBUG_INFO("PROT", "=== 初始化协议层 ===");
+    DEBUG_INFO("PROT", "协议层功能: CRC16 Modbus + 硬件 AES-128-CBC");
 
     s_protocol_initialized = true;
     DEBUG_INFO("PROT", "协议层就绪");
@@ -65,6 +66,8 @@ int frame_build(uint8_t cmd, const uint8_t *payload, size_t len, uint8_t *out_fr
     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;
 }
 
@@ -73,13 +76,14 @@ int frame_parse(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", frame[0]);
+        DEBUG_WARN("PROT", "无效 SOF: 0x%02X (期望 0x%02X)", frame[0], FRAME_SOF);
         return -1;
     }
 
@@ -89,13 +93,13 @@ int frame_parse(const uint8_t *frame, size_t frame_len,
     idx += 2;
 
     if (payload_len > FRAME_MAX_PAYLOAD) {
-        DEBUG_ERR("PROT", "Payload 长度太大: %zu", payload_len);
+        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);
+        DEBUG_WARN("PROT", "帧太短: %zu < %zu (期望)", frame_len, expected_len);
         return -1;
     }
 
@@ -103,10 +107,12 @@ int frame_parse(const uint8_t *frame, size_t frame_len,
     uint16_t calc_crc = crc16_modbus(frame, idx + payload_len);
 
     if (received_crc != calc_crc) {
-        DEBUG_WARN("PROT", "CRC 不匹配: 0x%04X vs 0x%04X", 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;
@@ -124,6 +130,7 @@ int protocol_aes_encrypt(const uint8_t *plaintext, size_t len,
                          uint8_t *ciphertext_out)
 {
     if (!plaintext || !key || !iv || !ciphertext_out) {
+        DEBUG_ERR("PROT", "AES 加密参数无效");
         return -1;
     }
 
@@ -136,6 +143,8 @@ int protocol_aes_encrypt(const uint8_t *plaintext, size_t len,
     if (pad == 0) pad = 16;
     memset(&padded[len], pad, pad);
 
+    DEBUG_DBG("PROT", "AES 加密: 明文=%zu 字节, 填充后=%zu 字节, 填充值=0x%02X", len, padded_len, pad);
+
     // 硬件 AES-CBC 加密（使用 ESP32-C3 硬件 AES 加速器）
     esp_aes_context aes_ctx;
     esp_aes_init(&aes_ctx);
@@ -155,6 +164,7 @@ int protocol_aes_encrypt(const uint8_t *plaintext, size_t len,
     esp_aes_free(&aes_ctx);
 
     if (ret == 0) {
+        DEBUG_DBG("PROT", "AES 加密成功: %zu -> %zu 字节", len, padded_len);
         return padded_len;
     } else {
         DEBUG_ERR("PROT", "esp_aes_crypt_cbc 加密失败: %d", ret);
@@ -168,14 +178,17 @@ int protocol_aes_decrypt(const uint8_t *ciphertext, size_t len,
                          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", len);
+        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);
@@ -206,7 +219,10 @@ int protocol_aes_decrypt(const uint8_t *ciphertext, size_t len,
         return -1;
     }
 
-    return len - pad;
+    size_t orig_len = len - pad;
+    DEBUG_DBG("PROT", "AES 解密成功: %zu -> %zu 字节 (填充=%d)", len, orig_len, pad);
+
+    return orig_len;
 }
 
 // 搅伴算法 - 生成随机数

main/transport/spi_master.cpp

@@ -20,7 +20,7 @@ spi_device_handle_t g_spi_device = NULL;
 // SPI2 总线初始化
 esp_err_t spi_master_init(void)
 {
-    DEBUG_INFO("SPI", "初始化 SPI2 (VSPI)...");
+    DEBUG_INFO("SPI", "=== 初始化 SPI2 (VSPI) ===");
 
     spi_bus_config_t bus_cfg = {};
     bus_cfg.mosi_io_num = 8;
@@ -30,6 +30,10 @@ esp_err_t spi_master_init(void)
     bus_cfg.quadhd_io_num = -1;
     bus_cfg.max_transfer_sz = 256;
 
+    DEBUG_INFO("SPI", "SPI2 引脚: MOSI=GPIO8, MISO=GPIO7, SCLK=GPIO6");
+    DEBUG_INFO("SPI", "SPI2 配置: CLK=%d MHz, CS=GPIO%d, 最大传输=%d 字节",
+               SPI_CLOCK_HZ / 1000000, SPI_MASTER_CS_GPIO, bus_cfg.max_transfer_sz);
+
     esp_err_t ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
     if (ret != ESP_OK) {
         DEBUG_ERR("SPI", "SPI 总线初始化失败: %s", esp_err_to_name(ret));
@@ -53,7 +57,9 @@ esp_err_t spi_master_init(void)
         return ret;
     }
 
-    DEBUG_INFO("SPI", "SPI2 已初始化: CLK=40MHz, CS=GPIO4");
+    DEBUG_INFO("SPI", "SPI2 已初始化: CLK=%dMHz, CS=GPIO%d, 模式=%d",
+               SPI_CLOCK_HZ / 1000000, SPI_MASTER_CS_GPIO, SPI_MODE);
+    DEBUG_INFO("SPI", "SPI 设备句柄: %p", g_spi_device);
     return ESP_OK;
 }
 
@@ -69,6 +75,9 @@ esp_err_t spi_sync_transfer(uint8_t cmd, const uint8_t *payload,
         return ESP_ERR_INVALID_STATE;
     }
 
+    DEBUG_DBG("SPI", "SPI 传输: cmd=0x%02X, 发送=%zu 字节, 接收=%zu 字节",
+              cmd, payload_len, recv_len);
+
     spi_transaction_t t = {};
     t.cmd = cmd;
     t.length = payload_len * 8;
@@ -83,6 +92,8 @@ esp_err_t spi_sync_transfer(uint8_t cmd, const uint8_t *payload,
     esp_err_t ret = spi_device_transmit(g_spi_device, &t);
     if (ret != ESP_OK) {
         DEBUG_WARN("SPI", "SPI 发送 cmd=0x%02X 失败: %s", cmd, esp_err_to_name(ret));
+    } else {
+        DEBUG_DBG("SPI", "SPI 传输完成: cmd=0x%02X", cmd);
     }
 
     return ret;
@@ -110,19 +121,22 @@ static int can_frame_send(can_channel_t channel, uint32_t ext_id,
                           uint32_t timeout_ms)
 {
     if (g_spi_device == NULL) {
+        DEBUG_ERR("SPI", "CAN 发送: SPI 设备未初始化");
         return -1;
     }
 
     if (dlc == 0 || dlc > CAN_MAX_DLC) {
-        DEBUG_ERR("SPI", "DLC 无效: %d", dlc);
+        DEBUG_ERR("SPI", "CAN[ch%d] DLC 无效: %d (范围 1~%d)", channel, dlc, CAN_MAX_DLC);
         return -2;
     }
 
     if (channel >= CAN_CHANNEL_MAX) {
-        DEBUG_ERR("SPI", "通道号无效: %d", channel);
+        DEBUG_ERR("SPI", "CAN 通道号无效: %d (范围 0~%d)", channel, CAN_CHANNEL_MAX - 1);
         return -3;
     }
 
+    DEBUG_DBG("SPI", "CAN[ch%d] ID=0x%08X 发送: DLC=%d", channel, ext_id, dlc);
+
     // 构建 CANFD 帧: [通道(1B)] [EXT_ID(4B)] [DATA(dlc B)]
     uint8_t tx_buf[1 + 4 + CAN_MAX_DLC] = {0};
     tx_buf[0] = (uint8_t)channel;
@@ -159,11 +173,12 @@ static int can_frame_send(can_channel_t channel, uint32_t ext_id,
         uint8_t copy_len = (resp_dlc < recv_max) ? resp_dlc : recv_max;
         memcpy(recv_buf, &rx_buf[5], copy_len);
 
-        DEBUG_INFO("SPI", "CAN[ch%d] ID=0x%08X 响应 DLC=%d",
+        DEBUG_INFO("SPI", "CAN[ch%d] ID=0x%08X 响应: DLC=%d, 接收=%d 字节",
-                   resp_channel, resp_id, copy_len);
+                   resp_channel, resp_id, copy_len, copy_len);
         return copy_len;
     }
 
+    DEBUG_DBG("SPI", "CAN[ch%d] ID=0x%08X 发送完成 (无响应)", channel, ext_id);
     return 0;
 }
 
@@ -192,18 +207,24 @@ esp_err_t spi_transfer_with_retry(uint8_t cmd, const uint8_t *payload,
     esp_err_t ret;
     int retry_count = 0;
 
+    DEBUG_INFO("SPI", "SPI 传输 (带重试): cmd=0x%02X, 最大重试=%d", cmd, max_retries);
+
     while (retry_count < max_retries) {
         ret = spi_sync_transfer(cmd, payload, payload_len,
                                 recv_buf, recv_len, 3000);
         if (ret == ESP_OK) {
+            if (retry_count > 0) {
+                DEBUG_INFO("SPI", "SPI 传输成功 (重试 %d 次后成功)", retry_count);
+            }
             return ESP_OK;
         }
 
         retry_count++;
-        DEBUG_WARN("SPI", "SPI 重试 %d/%d, cmd=0x%02X", retry_count, max_retries, cmd);
+        DEBUG_WARN("SPI", "SPI 重试 %d/%d, cmd=0x%02X, err=%s", 
+                   retry_count, max_retries, cmd, esp_err_to_name(ret));
         vTaskDelay(pdMS_TO_TICKS(100));
     }
 
-    DEBUG_ERR("SPI", "SPI 传输 %d 次重试后失败", max_retries);
+    DEBUG_ERR("SPI", "SPI 传输 %d 次重试后失败, cmd=0x%02X", max_retries, cmd);
     return ESP_ERR_TIMEOUT;
-}
+}