feat(ota): 添加WiFi OTA期间BLE堆管理机制

- WiFi OTA时自动暂停BLE以腾出堆空间给HTTP收流
- OTA完成后自动恢复BLE栈功能
- 避免WiFi OTA与BLE共存时的堆竞争问题

fix(debug_log): 优化堆紧张时日志处理策略

- 当堆空间小于8KB时，/logs接口仍返回最小JSON避免沉默失败
- 增加堆门控机制，OTA/SPI关键日志优先保留
- UDP发送在堆紧张时跳过，避免与HTTP回包争夺LWIP堆
- 调整日志缓冲区大小，减少栈压力

chore(version): 更新固件版本至0.3.43

- 版本号从0.3.42提升到0.3.43
- 更新编译时间和Git哈希信息

refactor(can_feedback): 优化CAN反馈任务配置

- 将反馈payload最大长度改为SPI_OTA_FRAME_MAX常量
- 使用takeEvent替代takeRingRx方法

main/monitor/can_feedback_task.cpp

@@ -28,7 +28,7 @@ namespace {
 constexpr uint32_t kWaitRingMs      = 500U;    ///< 单次等待 GD32 按铃超时
 constexpr uint32_t kPauseDelayMs    = 100U;    ///< 暂停时的轮询间隔
 constexpr uint8_t  kSpiCanFeedbackType = 0xC1U;
-constexpr size_t   kRingPayloadMax  = 128U;    ///< 反馈 payload 最大长度
+constexpr size_t   kRingPayloadMax  = SPI_OTA_FRAME_MAX;  ///< 与变长读一致，避免截断
 constexpr const char *kTag           = "CAN_FB";
 
 static can_feedback_result_t s_latest[CAN_CHANNEL_MAX];
@@ -72,8 +72,8 @@ static void taskLoop(void *)
         }
 
         /* 取出 checkGd32Request 存入的 type/payload */
-        if (!SpiMaster::instance().takeRingRx(&ring_type, ring_payload,
-                                              sizeof(ring_payload), &ring_len)) {
+        if (!SpiMaster::instance().takeEvent(&ring_type, ring_payload,
+                                             sizeof(ring_payload), &ring_len)) {
             continue;
         }
 

main/monitor/debug_log.cpp

@@ -24,6 +24,8 @@
 #include "freertos/semphr.h"
 #include "esp_log.h"
 #include "esp_err.h"
+#include "esp_system.h"
+#include "esp_heap_caps.h"
 #include "driver/uart.h"
 
 #include "debug_log.h"
@@ -117,13 +119,37 @@ char* DebugLog::ringDrainJson(int *out_len)
 {
     if (!out_len) return NULL;
     *out_len = 0;
+
+    /* 堆紧时不 malloc：返回堆上最小 "[]"，调用方仍 free。 */
+    const uint32_t free_now = esp_get_free_heap_size();
+    if (free_now < kDrainMinFree) {
+        char *empty = (char *)malloc(3);
+        if (!empty) return NULL;
+        empty[0] = '[';
+        empty[1] = ']';
+        empty[2] = '\0';
+        *out_len = 2;
+        return empty;
+    }
+
     int count = ringCount();
-    // ★ 限制单次导出条数，避免 count=64 时 malloc(32KB) 在堆紧张时失败
-    //   前端每秒轮询，16 条/次足够保持实时性；超出的旧条目下一轮再拉
-    static constexpr int kMaxDrain = 16;
+    /* OTA 沉默失败排查需要一次多拉；上限 24 条 */
+    static constexpr int kMaxDrain = 24;
     if (count > kMaxDrain) count = kMaxDrain;
     int capacity = count * (LOG_RING_SIZE * 2) + 16;
     if (capacity < 16) capacity = 16;
+
+    const size_t largest = heap_caps_get_largest_free_block(MALLOC_CAP_DEFAULT);
+    if (largest < (size_t)capacity) {
+        char *empty = (char *)malloc(3);
+        if (!empty) return NULL;
+        empty[0] = '[';
+        empty[1] = ']';
+        empty[2] = '\0';
+        *out_len = 2;
+        return empty;
+    }
+
     char *buf = (char*)malloc(capacity);
     if (!buf) return NULL;
 
@@ -333,14 +359,16 @@ esp_err_t DebugLog::send(const uint8_t *data, size_t len)
 {
     esp_err_t udp_ret = ESP_FAIL;
     esp_err_t uart_ret = ESP_FAIL;
+    const uint32_t free_now = esp_get_free_heap_size();
 
     // UART 通道（UART 不可用时跳过 uart_write_bytes 调用）
     if (m_uartAvailable) {
         uart_ret = uartSend(data, len);
     }
 
-    // UDP 通道（WiFi 未连接时 sendto 失败，静默跳过）
-    if (m_initialized) {
+    /* UDP 通道：堆紧时跳过 sendto，避免申请 LWIP TX pbuf 与 HTTP 回包抢堆。
+     * WiFi 未连接时 sendto 失败也静默跳过。 */
+    if (m_initialized && free_now >= kSkipUdpFree) {
         if (m_udpSock < 0) {
             ensureUdpSocket();
         }
@@ -355,12 +383,16 @@ esp_err_t DebugLog::send(const uint8_t *data, size_t len)
         }
     }
 
-    // 同时写入环形缓冲区（供 HTTP /logs 拉取）
+    // 同时写入环形缓冲区（供 HTTP /logs 拉取）——静态，不占堆
     ringPush((const char *)data, (int)len);
 
     if (udp_ret == ESP_OK || uart_ret == ESP_OK) {
         return ESP_OK;
     }
+    /* 仅 ring 成功也算可用（OTA 堆紧时常见） */
+    if (m_logRingMutex) {
+        return ESP_OK;
+    }
     return ESP_FAIL;
 }
 
@@ -381,7 +413,22 @@ void DebugLog::log(debug_log_level_t level, const char *tag, const char *fmt, ..
         return;
     }
 
-    char prefix[32];
+    /* 堆门控：OTA/SPI 的 INFO 必须进 ring，否则 WebUI 只能看到“沉默失败”。 */
+    const uint32_t free_now = esp_get_free_heap_size();
+    const bool keep_ota_spi = (tag != nullptr &&
+                               (strcmp(tag, "OTA") == 0 || strcmp(tag, "SPI") == 0));
+    if (!keep_ota_spi) {
+        if (free_now < kDropWarnFree && level > DEBUG_LOG_ERR) {
+            return;  // 无关模块：仅 ERR
+        }
+        if (free_now < kDropInfoFree && level > DEBUG_LOG_WARN) {
+            return;  // 无关模块：丢 INFO/DBG
+        }
+    } else if (free_now < kDropWarnFree && level >= DEBUG_LOG_DBG) {
+        return;  // OTA/SPI：极紧时仍丢 DBG，INFO/WARN/ERR 保留
+    }
+
+    char prefix[24];
     const char *level_str;
     switch (level) {
         case DEBUG_LOG_ERR:  level_str = "E"; break;
@@ -392,14 +439,14 @@ void DebugLog::log(debug_log_level_t level, const char *tag, const char *fmt, ..
     }
     snprintf(prefix, sizeof(prefix), "[%s][%s]", level_str, tag);
 
-    // 控制单条日志栈缓冲大小，避免调用任务（如 can_fb）因日志格式化爆栈。
+    /* 栈缓冲与 LOG_RING_SIZE 对齐，减轻 httpd 等任务栈压。 */
     va_list args;
     va_start(args, fmt);
-    char msg[256];
+    char msg[160];
     vsnprintf(msg, sizeof(msg), fmt, args);
     va_end(args);
 
-    char log_buf[320];
+    char log_buf[192];
     int total = snprintf(log_buf, sizeof(log_buf), "%s %s\n", prefix, msg);
 
     // ★ snprintf 截断时返回"本应写入的长度"(可能 > sizeof(log_buf))，

main/monitor/debug_log.h

@@ -99,14 +99,25 @@ private:
     //   m_uartInitialized 仅表示曾尝试初始化，m_uartAvailable 才是写日志的判据。
     bool m_uartAvailable = false;
 
+    /* 环形日志：OTA 中继期需保留关键 INFO，64×160≈10KB BSS。 */
     static constexpr int LOG_RING_SLOTS = 64;
-    static constexpr int LOG_RING_SIZE  = 256;
+    static constexpr int LOG_RING_SIZE  = 160;
     char  m_logRing[LOG_RING_SLOTS][LOG_RING_SIZE];
     int   m_logRingLens[LOG_RING_SLOTS];
     int   m_logRingHead  = 0;
     int   m_logRingCount = 0;
     SemaphoreHandle_t m_logRingMutex = NULL;
 
+    /* 堆门控（防 OTA 时 UDP/格式化抢 LWIP 堆）：
+     * free < kDropWarnFree → 非 OTA/SPI 只保留 ERR
+     * free < kDropInfoFree → 非 OTA/SPI 丢 INFO/DBG（OTA/SPI 的 INFO 仍进 ring）
+     * free < kSkipUdpFree  → 不 sendto（仍 UART+ring）
+     * free < kDrainMinFree → /logs 尽量仍返回 ring（降低门槛，避免“沉默失败”） */
+    static constexpr uint32_t kDropWarnFree = 6U * 1024U;
+    static constexpr uint32_t kDropInfoFree = 10U * 1024U;
+    static constexpr uint32_t kSkipUdpFree  = 10U * 1024U;
+    static constexpr uint32_t kDrainMinFree = 8U * 1024U;
+
     esp_err_t ensureUdpSocket();
     void ringPush(const char *data, int len);
 };

main/monitor/health_monitor.cpp

@@ -22,6 +22,7 @@
 #include "debug_log.h"
 #include "task_stack_check.h"
 #include "stack_overflow_hook.h"
+#include "ota/ota_coordinator.h"
 
 // ============================================================
 // 栈水位主动巡检
@@ -234,13 +235,19 @@ void HealthMonitor::taskEntry(void *pvParameters)
 
         uint32_t free_heap = esp_get_free_heap_size();
         if (free_heap < HEAP_WARNING_MIN) {
-            /* OTA 期间堆会短暂变紧，限流避免串口/UDP 二次吃堆、刷屏 */
+            /* WiFi OTA 收流时 TCP 窗口 + httpd 会把 free 压到 5~10KB，属预期，勿当故障刷屏。 */
             static TickType_t s_last_heap_warn = 0;
             TickType_t now = xTaskGetTickCount();
-            if ((now - s_last_heap_warn) >= pdMS_TO_TICKS(2000)) {
+            const bool ota_busy = !OtaCoordinator::instance().isIdle();
+            const uint32_t interval_ms = ota_busy ? 15000U : 3000U;
+            /* OTA 中只在 free 极低（<4KB）时告警；空闲时维持 10KB 阈值 */
+            const uint32_t warn_floor = ota_busy ? 4096U : (uint32_t)HEAP_WARNING_MIN;
+            if (free_heap < warn_floor &&
+                (now - s_last_heap_warn) >= pdMS_TO_TICKS(interval_ms)) {
                 s_last_heap_warn = now;
                 uint32_t largest_block = heap_caps_get_largest_free_block(MALLOC_CAP_DEFAULT);
-                DEBUG_WARN("MON", "堆内存不足: free=%lu min=%lu largest_blk=%lu",
+                DEBUG_WARN("MON", "堆内存偏紧%s: free=%lu min=%lu largest_blk=%lu",
+                           ota_busy ? "(OTA中)" : "",
                            (unsigned long)free_heap,
                            (unsigned long)esp_get_minimum_free_heap_size(),
                            (unsigned long)largest_block);