feat(spi): 实现SPI同步通信协议和主动推送机制

- 实现新的SPI同步帧格式，采用0xA5 0x5A起始符和CRC32校验，提升通信可靠性
- 添加GD32与ESP32间的握手机制，通过PB6开漏输出实现SPIready线与控制
- 实现异步OTA启动机制，将Flash操作延迟到主循环执行，避免SPI ISR阻塞
- 改进CAN反馈命令处理，提取通用payload构建函数支持主动推送模式
- 实现GD32主动按铃机制，循环推送CAN反馈数据到ESP32，减少轮询开销
- 添加SPI通信超时保护和死锁防护机制，确保系统稳定性

GD32E508_DCU_APP/device/spi/app_spi_cmd_boot_request.cpp

@@ -16,17 +16,28 @@ public:
 
     void handle(AppSpiCommand &bus, const SpiCommandContext &ctx) override
     {
-        bus.postLog("BOOT_REQ → 进BOOT");
+        bus.postLog("BOOT_REQ → 进BOOT(异步)");
 
-        const bool ok = OtaBootRequest::requestEnterBoot();
+        /* 立即装 0xB5 ACK，让 ESP32 尽快收到确认。
-        uint8_t ack = ok ? CONFIG_SPI_APP_OTA_BOOT_ACK_OK
+         * Flash 操作延迟到主循环执行，避免阻塞 SPI ISR。
-                         : CONFIG_SPI_APP_OTA_BOOT_ACK_ERROR;
+         *
-        bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
+         * ESP32 appRequestBootloader() 发送单字节 0xB0 后，逐字节轮询读回 0xB5。
-                              SpiDefs::kRspAck, &ack, 1U);
+         * 必须返回裸字节 ACK，不能用 buildResponse() 构建帧式 ACK
-
+         * （帧式 ACK 以 0xA5 开头，ESP32 永远匹配不到 0xB5）。
-        if (ok) {
+         * tx_buf[0] 必须是 ack 字节本身，因为 ESP32 只读首个 MISO 字节。 */
-            TaskManager::set(1UL << TASK_HEARTBEAT);
+        if (ctx.tx_buf && ctx.tx_len && ctx.tx_buf_size >= 4U) {
+            ctx.tx_buf[0] = CONFIG_SPI_APP_OTA_BOOT_ACK_OK;
+            ctx.tx_buf[1] = CONFIG_SPI_APP_OTA_BOOT_CMD;
+            ctx.tx_buf[2] = 0x4FU;
+            ctx.tx_buf[3] = 0x54U;
+            *ctx.tx_len = 4U;
         }
+
+        /* 设置 pending 标志，主循环执行 Flash 操作 + 复位。
+         * 原来在 ISR 内直接调 requestEnterBoot() 会执行 Flash 页擦除（20-30ms），
+         * 导致 CPU 总线停顿、SPI RBNE 中断无法响应、ESP32 ACK 轮询丢字节。 */
+        OtaBootRequest::requestEnterBootAsync();
+        TaskManager::set(1UL << TASK_HEARTBEAT);
     }
 };
 

GD32E508_DCU_APP/device/spi/app_spi_cmd_can_feedback.cpp

@@ -38,17 +38,19 @@
 #include "device/spi/app_spi_command_defs.h"
 #include "device/canfd.h"
 #include "sys/config.h"
+#include "sys/ota_boot_request.h"
 #include <cstdio>
 #include <cstring>
 
-namespace {
+/* ---- 文件内共享常量与辅助函数（供匿名命名空间内的 handler 与
+ *      全局作用域的 canFeedbackPushStep() 共同复用） ---- */
 
-constexpr uint8_t  kFeedbackChannelCount = 3U;
+static constexpr uint8_t  kFeedbackChannelCount = 3U;
-constexpr uint16_t kFeedbackPayloadLen   = 123U; /* kTxBufSize=128 - overhead=5 */
+static constexpr uint16_t kFeedbackPayloadLen   = 123U; /* kTxBufSize=128 - overhead=5 */
-constexpr uint8_t  kPageEntries          = 8U;
+static constexpr uint8_t  kPageEntries          = 8U;
-constexpr uint16_t kFixedHeaderLen       = 28U;   /* ch(1)+page(1)+total(1)+cnt(1)+mode(1)+seq(4)+rx(4)+tx(4)+drop(4)+err(4)+tec(1)+rec(1)+bus_state(1) */
+static constexpr uint16_t kFixedHeaderLen       = 28U;   /* ch(1)+page(1)+total(1)+cnt(1)+mode(1)+seq(4)+rx(4)+tx(4)+drop(4)+err(4)+tec(1)+rec(1)+bus_state(1) */
 
-void writeU32Le(uint8_t *dst, uint32_t value)
+static void writeU32Le(uint8_t *dst, uint32_t value)
 {
     dst[0] = static_cast<uint8_t>(value & 0xFFU);
     dst[1] = static_cast<uint8_t>((value >> 8) & 0xFFU);
@@ -56,41 +58,24 @@ void writeU32Le(uint8_t *dst, uint32_t value)
     dst[3] = static_cast<uint8_t>((value >> 24) & 0xFFU);
 }
 
-class SpiCanFeedbackHandler final : public ISpiCommandHandler {
+/**
-public:
+ * @brief 构建一页 CAN 反馈 payload（与 ESP32 canFdPollFeedback 解析格式一致）。
-    bool canHandle(uint8_t frame_type) const override
+ * @param[in]  channel  目标通道 0/1/2。
+ * @param[in]  page     页号 0/1。
+ * @param[out] payload  输出缓冲（至少 kFeedbackPayloadLen 字节）。
+ * @param[in]  max_len  缓冲最大长度。
+ * @return 构建完成的 payload 长度；0 表示参数错误。
+ *
+ * 提取自 handleFeedback()，供被动响应与主动推送复用。
+ */
+static uint16_t buildFeedbackPayload(uint8_t channel, uint8_t page,
+                              uint8_t *payload, uint16_t max_len)
 {
-        return (frame_type == SpiDefs::kTypeCanFeedback)
+    if (channel >= kFeedbackChannelCount || page >= 2U) {
-            || (frame_type == SpiDefs::kTypeCanSetMode);
+        return 0U;
     }
-
+    if (max_len < kFeedbackPayloadLen) {
-    void handle(AppSpiCommand &bus, const SpiCommandContext &ctx) override
+        return 0U;
-    {
-        if (ctx.frame_type == SpiDefs::kTypeCanFeedback) {
-            handleFeedback(bus, ctx);
-        } else {
-            handleSetMode(bus, ctx);
-        }
-    }
-
-private:
-    void handleFeedback(AppSpiCommand &bus, const SpiCommandContext &ctx)
-    {
-        if (ctx.payload_len < 2U) {
-            uint8_t err = 0xE0U;
-            bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
-                              SpiDefs::kRspError, &err, 1U);
-            return;
-        }
-
-        const uint8_t channel = ctx.payload[0];
-        const uint8_t page    = ctx.payload[1];
-
-        if (channel >= kFeedbackChannelCount) {
-            uint8_t err = 0xE1U;
-            bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
-                              SpiDefs::kRspError, &err, 1U);
-            return;
     }
 
     /* 拷贝统计快照 */
@@ -103,14 +88,9 @@ private:
 
     const uint8_t start = static_cast<uint8_t>(page * kPageEntries);
     if (start >= CANFD_ID_SNAPSHOT_MAX) {
-            uint8_t err = 0xE3U;
+        return 0U;
-            bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
-                              SpiDefs::kRspError, &err, 1U);
-            return;
     }
 
-        uint8_t payload[kFeedbackPayloadLen] = {};
-
     /* 固定头 */
     payload[0] = channel;
     payload[1] = page;
@@ -157,9 +137,52 @@ private:
     }
 
     payload[3] = packed;
+    return offset;
+}
+
+namespace {
+
+class SpiCanFeedbackHandler final : public ISpiCommandHandler {
+public:
+    bool canHandle(uint8_t frame_type) const override
+    {
+        return (frame_type == SpiDefs::kTypeCanFeedback)
+            || (frame_type == SpiDefs::kTypeCanSetMode);
+    }
+
+    void handle(AppSpiCommand &bus, const SpiCommandContext &ctx) override
+    {
+        if (ctx.frame_type == SpiDefs::kTypeCanFeedback) {
+            handleFeedback(bus, ctx);
+        } else {
+            handleSetMode(bus, ctx);
+        }
+    }
+
+private:
+    void handleFeedback(AppSpiCommand &bus, const SpiCommandContext &ctx)
+    {
+        if (ctx.payload_len < 2U) {
+            uint8_t err = 0xE0U;
+            bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
+                              SpiDefs::kRspError, &err, 1U);
+            return;
+        }
+
+        const uint8_t channel = ctx.payload[0];
+        const uint8_t page    = ctx.payload[1];
+
+        uint8_t payload[kFeedbackPayloadLen] = {};
+        uint16_t payload_len = buildFeedbackPayload(channel, page, payload, sizeof(payload));
+        if (payload_len == 0U) {
+            uint8_t err = 0xE3U;
+            bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
+                              SpiDefs::kRspError, &err, 1U);
+            return;
+        }
 
         bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
-                          SpiDefs::kRspAck, payload, offset);
+                          SpiDefs::kRspAck, payload, payload_len);
     }
 
     void handleSetMode(AppSpiCommand &bus, const SpiCommandContext &ctx)
@@ -207,6 +230,49 @@ static SpiCanFeedbackHandler s_handler;
 
 } // namespace
 
+/**
+ * @brief CAN 反馈主动推送一步（非阻塞）。
+ *
+ * 由主循环每次迭代调用。维护内部 (channel, page) 游标，循环遍历 3 通道 × 2 页。
+ * 若上一帧按铃尚未被 ESP32 读走（m_ringPending）则立即返回等待；
+ * 否则构建当前页反馈 payload 并通过 requestEsp32Read(0xC1) 主动推送到 ESP32，
+ * 然后推进游标。ESP32 检测到 SPIready 下降沿后发起读事务取走该帧，
+ * CS 释放后 GD32 中断唤醒主循环继续推送下一帧。
+ */
+void canFeedbackPushStep()
+{
+    static uint8_t s_channel = 0U;
+    static uint8_t s_page    = 0U;
+
+    /* 已收到 0xB0 进入 Bootloader 请求，停止主动按铃避免干扰 OTA 流程。
+     * 复位前主循环仍在运行，但不再下拉 SPIready，让 ESP32 的
+     * waitForBootloaderReady 信号检测不受干扰。 */
+    if (OtaBootRequest::isRebootPending()) {
+        return;
+    }
+
+    /* 上一帧尚未被 ESP32 读走，等待（不占用主线带宽） */
+    if (AppSpiCommandBus.isRingPending()) {
+        return;
+    }
+
+    uint8_t payload[kFeedbackPayloadLen] = {};
+    uint16_t payload_len = buildFeedbackPayload(s_channel, s_page,
+                                                payload, sizeof(payload));
+    if (payload_len > 0U) {
+        (void)AppSpiCommandBus.requestEsp32Read(SpiDefs::kTypeCanFeedback,
+                                                payload, payload_len);
+    }
+
+    /* 推进到下一页/下一通道，无限循环 3 通道 × 2 页 */
+    if (++s_page >= 2U) {
+        s_page = 0U;
+        if (++s_channel >= kFeedbackChannelCount) {
+            s_channel = 0U;
+        }
+    }
+}
+
 void registerSpiCanFeedbackCommand(AppSpiCommand &bus)
 {
     bus.registerHandler(&s_handler);

GD32E508_DCU_APP/device/spi/app_spi_command.cpp

@@ -8,9 +8,14 @@
  * - 公共帧格式解析与应答构建
  * - 业务命令的注册与分发
  *
- * 具体命令处理逻辑已经拆到独立的 `app_spi_cmd_*.cpp`，
+ * 具体命令处理逻辑已经拆到独立的 app_spi_cmd_*.cpp，
- * 通过 `registerHandler()` 注册进来，后续新增 SPI 业务时
+ * 通过 registerHandler() 注册进来，后续新增 SPI 业务时
  * 只需要新增命令处理器，不再继续膨胀本文件。
+ *
+ * 握手架构（线与 SPIready，PB6<->ESP32 GPIO10 开漏单线）：
+ * - 命令处理在 onCsRelease() EXTI ISR 内同步完成（对齐 BOOT 的 isrProcessFrame），
+ *   不再推迟到主循环，消除 PB6 拉高延迟。
+ * - GD32 可通过 requestEsp32Read() 下拉 SPIready 主动按铃请求 ESP32 来读。
  */
 
 #include "device/spi/app_spi_command.h"
@@ -62,12 +67,12 @@ static void startSpiTxDma(const uint8_t *buf, uint16_t len)
     DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) |= DMA_CHXCTL_CHEN;
 }
 
-static bool isAllBytesValue(const uint8_t *data, uint8_t len, uint8_t value)
+static bool isAllBytesValue(const uint8_t *data, uint16_t len, uint8_t value)
 {
     if (!data || len == 0U) {
         return false;
     }
-    for (uint8_t i = 0U; i < len; ++i) {
+    for (uint16_t i = 0U; i < len; ++i) {
         if (data[i] != value) {
             return false;
         }
@@ -75,7 +80,7 @@ static bool isAllBytesValue(const uint8_t *data, uint8_t len, uint8_t value)
     return true;
 }
 
-static bool shouldIgnoreTransaction(const uint8_t *data, uint8_t len)
+static bool shouldIgnoreTransaction(const uint8_t *data, uint16_t len)
 {
     if (!data || len == 0U) {
         return true;
@@ -110,40 +115,111 @@ static bool isFlashRelatedFrame(uint8_t frame_type)
  * CRC8 / 帧构建 / 帧解析（与 BOOT SpiOta 一致）
  * ============================================================ */
 
-static uint8_t spi_crc8(const uint8_t *data, uint16_t len)
+static constexpr uint8_t  kSyncSof0     = 0xA5U;
+static constexpr uint8_t  kSyncSof1     = 0x5AU;
+static constexpr uint16_t kSyncHeaderLen = 6U;
+static constexpr uint16_t kSyncCrcLen    = 4U;
+static constexpr uint16_t kSyncOverhead  = (uint16_t)(kSyncHeaderLen + kSyncCrcLen);
+
+/* GD32 APP 侧同步状态机（ISR 与主循环只读/原子写，避免临界区开销）。 */
+static volatile uint8_t  g_localCredit = 8U;
+static volatile uint8_t  g_remoteCredit = 8U;
+
+static void putU16Le(uint8_t *pp, uint16_t v)
 {
-    uint8_t crc = 0x00U;
+    pp[0] = (uint8_t)(v & 0xFFU);
+    pp[1] = (uint8_t)((v >> 8) & 0xFFU);
+}
+
+static uint16_t getU16Le(const uint8_t *pp)
+{
+    return (uint16_t)(pp[0] | ((uint16_t)pp[1] << 8));
+}
+
+static void putU32Le(uint8_t *pp, uint32_t v)
+{
+    pp[0] = (uint8_t)(v & 0xFFU);
+    pp[1] = (uint8_t)((v >> 8) & 0xFFU);
+    pp[2] = (uint8_t)((v >> 16) & 0xFFU);
+    pp[3] = (uint8_t)((v >> 24) & 0xFFU);
+}
+
+static uint32_t getU32Le(const uint8_t *pp)
+{
+    return (uint32_t)pp[0] | ((uint32_t)pp[1] << 8) |
+           ((uint32_t)pp[2] << 16) | ((uint32_t)pp[3] << 24);
+}
+
+static uint32_t spi_crc32(const uint8_t *data, uint16_t len)
+{
+    uint32_t crc = 0xFFFFFFFFU;
     for (uint16_t i = 0U; i < len; ++i) {
-        crc ^= data[i];
+        crc ^= (uint32_t)data[i] << 24;
+        for (int b = 0; b < 8; ++b) {
+            if (crc & 0x80000000U) {
+                crc = (crc << 1) ^ 0x04C11DB7U;
+            } else {
+                crc <<= 1;
+            }
+        }
     }
     return crc;
 }
 
+static uint8_t spi_crc8(const uint8_t *data, uint16_t len)
+{
+    uint8_t crc = 0x00U;
+    for (uint16_t i = 0U; i < len; ++i) { crc ^= data[i]; }
+    return crc;
+}
+
+/* 构建新同步帧；上层接口（type/payload）保持不变，handler 无需改动。
+ * kFrameOverhead 旧常量仍保留供旧路径使用。 */
 static bool spi_build_frame(uint8_t type, const uint8_t *payload, uint16_t payload_len,
                             uint8_t *out, uint16_t *out_len)
 {
     if (!out || !out_len) { return false; }
-    uint16_t total = (uint16_t)(kFrameOverhead + payload_len);
+    uint16_t total = (uint16_t)(kSyncOverhead + payload_len);
     if (total > AppSpiCommand::kTxBufSize) { return false; }
-    out[0] = kSof;
+
-    out[1] = type;
+    out[0] = kSyncSof0;
-    out[2] = (uint8_t)(payload_len & 0xFFU);
+    out[1] = kSyncSof1;
-    out[3] = (uint8_t)((payload_len >> 8) & 0xFFU);
+    out[2] = g_localCredit;
+    out[3] = type;
+    putU16Le(&out[4], payload_len);
     if (payload && payload_len > 0U) {
-        memcpy(&out[4], payload, payload_len);
+        memcpy(&out[kSyncHeaderLen], payload, payload_len);
     }
-    out[4 + payload_len] = spi_crc8(out, (uint16_t)(4U + payload_len));
+    uint32_t crc = spi_crc32(out, (uint16_t)(kSyncHeaderLen + payload_len));
+    putU32Le(&out[kSyncHeaderLen + payload_len], crc);
     *out_len = total;
     return true;
 }
 
+/* 解析：新同步帧优先；失败回退旧 0xA5 帧（含首字节偏移容错）。 */
 static bool spi_try_parse_frame(const uint8_t *frame, uint16_t frame_len,
                                 uint8_t *type, const uint8_t **payload, uint16_t *payload_len)
 {
     if (!frame || !type || !payload || !payload_len) { return false; }
 
-    /* 兼容首字节延迟：在帧头前面可能出现若干 0xFF / 0x00 残留字节，
+    for (uint16_t s = 0U; s + kSyncOverhead <= frame_len; ++s) {
-     * 搜索到第一个 kSof 后尝试按合法帧长度校验 CRC。 */
+        if (frame[s] != kSyncSof0 || frame[s + 1U] != kSyncSof1) { continue; }
+        uint16_t plen = getU16Le(&frame[s + 4U]);
+        uint16_t total = (uint16_t)(kSyncOverhead + plen);
+        if ((uint16_t)(frame_len - s) < total) { continue; }
+        uint32_t expect = getU32Le(&frame[s + kSyncHeaderLen + plen]);
+        uint32_t calc = spi_crc32(&frame[s], (uint16_t)(kSyncHeaderLen + plen));
+        if (expect != calc) { continue; }
+
+        uint8_t  credit = frame[s + 2U];
+        *type = frame[s + 3U];
+        *payload = (plen > 0U) ? &frame[s + kSyncHeaderLen] : nullptr;
+        *payload_len = plen;
+        g_remoteCredit = credit;
+        return true;
+    }
+
+    /* 旧 0xA5 帧兼容：首字节可能偏移，扫描 SOF。 */
     uint16_t s = 0U;
     while (s < frame_len && frame[s] != kSof) { ++s; }
     if (s > 0U && s < frame_len) {
@@ -214,15 +290,11 @@ void AppSpiCommand::buildResponse(uint8_t *tx_buf, uint16_t tx_buf_size,
     const bool ok = spi_build_frame(rsp_type, payload, payload_len, tx_buf, &built_len);
     if (ok) {
         *tx_len = built_len;
-    } else {
-        uint8_t err = 0xEEU;
-        (void)spi_build_frame(kRspError, &err, 1U, tx_buf, &built_len);
-        *tx_len = built_len;
     }
 }
 
 /* ============================================================
- * 硬件配置（与 BOOT 完全一致）
+ * 硬件配置
  * ============================================================ */
 
 void AppSpiCommand::configureGpio()
@@ -238,13 +310,17 @@ void AppSpiCommand::configureGpio()
     gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
     gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
 
-    /* PB6 复用为 SPI Ready 握手输出,默认 HIGH(就绪),允许主机立刻发起首帧 */
+    /* PB6 复用为 SPI Ready 握手线（开漏输出，线与）。
-    gpio_init(CONFIG_SPI_READY_PORT, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, CONFIG_SPI_READY_PIN);
+     * 开漏模式：写 BRR = 下拉驱动低；写 BSRR = 高阻释放，靠外部/对端上拉拉高。
+     * 默认释放（HIGH），允许主机立刻发起首帧。 */
+    gpio_init(CONFIG_SPI_READY_PORT, GPIO_MODE_OUT_OD, GPIO_OSPEED_50MHZ, CONFIG_SPI_READY_PIN);
     gpio_bit_set(CONFIG_SPI_READY_PORT, CONFIG_SPI_READY_PIN);
 }
 
 void AppSpiCommand::setSpiReady(bool ready)
 {
+    /* 开漏线与：ready=true 释放（BSRR，高阻，靠上拉拉高）；
+     *          ready=false 下拉（BRR，驱动低）。 */
     if (ready) {
         gpio_bit_set(CONFIG_SPI_READY_PORT, CONFIG_SPI_READY_PIN);
     } else {
@@ -328,6 +404,9 @@ void AppSpiCommand::init()
     m_logPending = false;
     m_txActiveThisCs = false;
     m_commandCount = 0U;
+    m_ringPending = false;
+    m_ringDeadline = 0U;
+    m_ringTxLen = 0U;
     memset(m_txBuf, 0xFF, sizeof(m_txBuf));
     memset(m_logBuf, 0, sizeof(m_logBuf));
     memset(m_commands, 0, sizeof(m_commands));
@@ -395,7 +474,7 @@ void AppSpiCommand::processCommand()
         }
 
         if (!handled) {
-            postLogFmt("[SPI-APP] 未知 type=0x%02X → ERROR", frame_type);
+            postLogFmt("[SPI-APP] 未知 type=0x%02X -> ERROR", frame_type);
             uint8_t err = 0xEEU;
             spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
         }
@@ -406,13 +485,13 @@ void AppSpiCommand::processCommand()
             spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
         }
 
-        m_txLen = (uint8_t)tx_len;
+        m_txLen = tx_len;
         m_txPos = 0U;
     } else {
         /* 非标准帧：保留旧式单字节 0xB0 通道，后续新命令建议走注册式帧协议 */
         const uint8_t first_valid = m_rxBuf[0U];
         if (first_valid == CONFIG_SPI_APP_OTA_BOOT_CMD) {
-            postLog("旧式0xB0 → 进BOOT");
+            postLog("旧式0xB0 -> 进BOOT");
 
             uint16_t tx_len_legacy = 0U;
             SpiCommandContext ctx{};
@@ -434,28 +513,27 @@ void AppSpiCommand::processCommand()
             }
 
             if (!handled) {
-                const bool ok = OtaBootRequest::requestEnterBoot();
+                /* 兜底路径（handler 未注册时的死代码保护）：
-                uint8_t ack = ok ? CONFIG_SPI_APP_OTA_BOOT_ACK_OK
+                 * 同样使用异步路径，避免在 ISR 内执行 Flash 操作。
-                                 : CONFIG_SPI_APP_OTA_BOOT_ACK_ERROR;
+                 * 先装 0xB5 ACK，再设 pending 标志。 */
-                m_txBuf[0] = CONFIG_SPI_APP_OTA_BOOT_CMD;
+                m_txBuf[0] = CONFIG_SPI_APP_OTA_BOOT_ACK_OK;
-                m_txBuf[1] = ack;
+                m_txBuf[1] = CONFIG_SPI_APP_OTA_BOOT_CMD;
                 m_txBuf[2] = 0x4FU;
                 m_txBuf[3] = 0x54U;
                 tx_len_legacy = 4U;
-                if (ok) {
+                OtaBootRequest::requestEnterBootAsync();
                 TaskManager::set(1UL << TASK_HEARTBEAT);
             }
-            }
 
-            m_txLen = (uint8_t)tx_len_legacy;
+            m_txLen = tx_len_legacy;
             m_txPos = 0U;
         } else {
             /* 无法识别 */
-            postLogFmt("[SPI-APP] 非协议 0x%02X → ERROR", first_valid);
+            postLogFmt("[SPI-APP] 非协议 0x%02X -> ERROR", first_valid);
             uint16_t tx_len = 0U;
             uint8_t err = 0xEEU;
             spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
-            m_txLen = (uint8_t)tx_len;
+            m_txLen = tx_len;
             m_txPos = 0U;
         }
     }
@@ -465,20 +543,65 @@ void AppSpiCommand::processCommand()
         TaskManager::set(1UL << TASK_SPI_LOG);
     }
 
-    /* 应答帧已就绪:若解析期间未再收到新帧(m_cmdPending 仍为 false),
+    /* 应答帧已就绪：拉高 PB6（释放 SPIready）通知主机可发起下一笔事务。
-     * 拉高 PB6 通知主机可发起下一笔事务;否则保持 LOW,等待下一轮
+     * 命令处理已在 ISR 内同步完成，无需 m_cmdPending 推迟机制。 */
-     * processCommand 完成后再翻高,避免主机在从机未就绪时抢跑。 */
+
-    if (!m_cmdPending) {
+    /* 有响应待发时，设置按铃标志阻止主循环 canFeedbackPushStep() 覆盖 m_txBuf。
-        setSpiReady(true);
+     * ESP32 下次 CS assert 时 DMA 输出响应，onCsRelease 清除 m_ringPending。
+     * 50ms 超时后 cancelRing() 清除，恢复 CAN 反馈推送。 */
+    if (m_txLen > 0U) {
+        m_ringPending = true;
+        m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
     }
+    setSpiReady(true);
 }
 
 /* ============================================================
- * 主循环轮询：打印延迟日志
+ * GD32 主动按铃：下拉 SPIready 请求 ESP32 来读
+ * ============================================================ */
+
+void AppSpiCommand::cancelRing()
+{
+    m_ringPending = false;
+    m_ringTxLen = 0U;
+    /* 清除待发响应，防止超时后残留帧在下一次 CS assert 时被错误输出 */
+    m_txLen = 0U;
+    m_txPos = 0U;
+    /* 释放 SPIready（高阻），避免永久占用线 */
+    setSpiReady(true);
+}
+
+bool AppSpiCommand::requestEsp32Read(uint8_t frame_type, const uint8_t *payload, uint16_t payload_len)
+{
+    /* 若上一次按铃尚未被 ESP32 读走，拒绝重复按铃 */
+    if (m_ringPending) {
+        return false;
+    }
+
+    /* 构建请求帧到 m_txBuf（ESP32 下次读事务时通过 DMA 输出到 MISO） */
+    uint16_t built_len = 0U;
+    if (!spi_build_frame(frame_type, payload, payload_len, m_txBuf, &built_len)) {
+        return false;
+    }
+
+    m_ringTxLen = built_len;
+    m_txLen = built_len;
+    m_txPos = 0U;
+    m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
+    m_ringPending = true;
+
+    /* 下拉 SPIready，通知 ESP32「我有请求帧要给你读」 */
+    setSpiReady(false);
+    return true;
+}
+
+/* ============================================================
+ * 主循环轮询：打印延迟日志 + 按铃超时看护
  * ============================================================ */
 
 void AppSpiCommand::poll()
 {
+    /* 打印 ISR 推迟的日志 */
     char log_copy[kLogBufSize] = {};
     bool has_log = false;
 
@@ -493,15 +616,18 @@ void AppSpiCommand::poll()
     if (has_log) {
         printf("%s\r\n", log_copy);
     }
-}
 
-void AppSpiCommand::processPendingCommand()
+    /* 按铃超时看护：ESP32 未在 kRingTimeoutMs 内来读则放弃本次按铃。
-{
+     * 防止 ESP32 不响应时永久占用 SPIready 线导致双方死锁。 */
-    if (!m_cmdPending) {
+    if (m_ringPending) {
-        return;
+        uint32_t save2 = RT_CRITICAL_SAVE();
+        if (m_ringPending) {
+            if ((int32_t)(SysTickTimer::getMs() - m_ringDeadline) >= 0) {
+                cancelRing();
+            }
+        }
+        RT_CRITICAL_RESTORE(save2);
     }
-    m_cmdPending = false;
-    processCommand();
 }
 
 /* ============================================================
@@ -514,8 +640,8 @@ void AppSpiCommand::onCsAssert()
         return;
     }
     m_csActive = true;
-    /* CS 下降沿立即拉低 PB6:表示从机即将忙碌,
+    /* CS 下降沿立即拉低 PB6:表示从机即将忙碌，
-     * 防止主机在 onCsRelease 拉低 PB6 前抢跑发起下一笔 CS。
+     * 防止主机在 onCsRelease 准备好响应前抢跑发起下一笔 CS。
      * (若此帧被 shouldIgnoreTransaction 忽略,onCsRelease 会恢复 HIGH) */
     setSpiReady(false);
     m_rxLen = 0U;
@@ -570,6 +696,48 @@ void AppSpiCommand::onCsRelease()
         }
     }
 
+    /* 若本次 CS 事务是 ESP32 响应 GD32 按铃来读请求帧，
+     * 则 GD32 的请求帧已通过 DMA 输出到 MISO，取消按铃状态。
+     *
+     * 但需区分：ESP32 发的是 dummy 读（按铃响应）还是 0xB0 命令（OTA 请求）。
+     * 若 GD32 正在按铃时 ESP32 发 0xB0，会因 m_ringPending=true 被误吞，
+     * 导致 OTA 无法启动。检测到 0xB0 时取消按铃并走正常命令处理。 */
+    if (m_ringPending) {
+        if (m_rxLen >= 1U && m_rxBuf[0] == CONFIG_SPI_APP_OTA_BOOT_CMD) {
+            /* ESP32 发的是 0xB0 Bootloader 请求，不是按铃响应。
+             * 取消按铃，清空 TX 让 processCommand() 重新装载 0xB5 应答。
+             * 不释放 SPIready，processCommand() 末尾会释放。 */
+            m_ringPending = false;
+            m_ringTxLen = 0U;
+            m_txLen = 0U;
+            m_txPos = 0U;
+            memset(m_txBuf, 0xFF, sizeof(m_txBuf));
+            /* 继续走 shouldIgnoreTransaction + processCommand()，不 return */
+        } else if (m_rxLen >= 2U && m_rxBuf[0] == kSyncSof0 && m_rxBuf[1] == kSyncSof1) {
+            /* ESP32 发的是协议帧（如 PING/OTA 等），不是按铃响应。
+             * 取消按铃，清空 TX 让 processCommand() 重新装载对应应答。
+             * 不释放 SPIready，processCommand() 末尾会释放。 */
+            m_ringPending = false;
+            m_ringTxLen = 0U;
+            m_txLen = 0U;
+            m_txPos = 0U;
+            memset(m_txBuf, 0xFF, sizeof(m_txBuf));
+            /* 继续走 shouldIgnoreTransaction + processCommand()，不 return */
+        } else {
+            /* 正常按铃响应：请求帧已被读走，取消按铃状态 */
+            m_ringPending = false;
+            m_ringTxLen = 0U;
+            /* 请求帧已被读走，清空 TX 防止下次事务重复输出 */
+            m_txLen = 0U;
+            m_txPos = 0U;
+            memset(m_txBuf, 0xFF, sizeof(m_txBuf));
+            /* 释放 SPIready，通知 ESP32 本帧完成 */
+            setSpiReady(true);
+            /* 上层若需要 ESP32 处理该请求帧，由 ESP32 侧读到的帧 TYPE 决定后续动作 */
+            return;
+        }
+    }
+
     if (shouldIgnoreTransaction(m_rxBuf, m_rxLen)) {
         m_rxLen = 0U;
         if (m_txActiveThisCs) {
@@ -578,8 +746,8 @@ void AppSpiCommand::onCsRelease()
             memset(m_txBuf, 0xFF, sizeof(m_txBuf));
         }
         m_txActiveThisCs = false;
-        /* 忽略事务(空轮询/残包)后恢复 PB6=HIGH,
+        /* 忽略事务(空轮询/残包)后恢复 PB6=HIGH，
-         * 避免 PB6 卡 LOW 导致 ESP32 waitSpiReady 超时 */
+         * 避免 PB6 卡 LOW 导致 ESP32 等待上升沿超时 */
         setSpiReady(true);
         return;
     }
@@ -588,10 +756,10 @@ void AppSpiCommand::onCsRelease()
     m_txPos = 0U;
     m_txActiveThisCs = false;
     memset(m_txBuf, 0xFF, sizeof(m_txBuf));
-    m_cmdPending = true;
+
-    /* 拉低 PB6 通知主机:从机正忙,在主循环解析完前不要再发起 CS */
+    /* 命令处理在 EXTI ISR 内同步完成（对齐 BOOT 的 isrProcessFrame 模式），
-    setSpiReady(false);
+     * 消除主循环延迟。处理完成后 processCommand() 末尾释放 SPIready。 */
-    TaskManager::set(1UL << TASK_SPI_CMD_PROCESS);
+    processCommand();
 }
 
 /* ============================================================

GD32E508_DCU_APP/device/spi/app_spi_command.h

@@ -12,20 +12,26 @@ class ISpiCommandHandler;
  * - 维护 SPI0 从机的硬件链路（GPIO/SPI/DMA/EXTI）
  * - 将接收到的合法帧按 TYPE 注册式分发给 ISpiCommandHandler
  *
- * 具体命令处理逻辑不再放在这里，而是拆到 `device/spi/app_spi_cmd_*.cpp`，
+ * 具体命令处理逻辑不再放在这里，而是拆到 device/spi/app_spi_cmd_*.cpp，
- * 通过 `registerHandler()` 注册进来，保持本模块可扩展。
+ * 通过 registerHandler() 注册进来，保持本模块可扩展。
+ *
+ * 握手架构（线与 SPIready，PB6<->ESP32 GPIO10 开漏单线）：
+ * - 空闲态线 HIGH（双方释放，靠上拉）。
+ * - ESP32 主动发起：下拉 SPIready -> 立刻 CS 发请求 -> CS 释放后保持下拉，
+ *   GD32 在 onCsRelease() ISR 内完成帧处理+响应装载后释放 SPIready（高），
+ *   ESP32 检测到上升沿后发起 CS#2 读响应。
+ * - GD32 主动按铃：下拉 SPIready -> ESP32 下降沿中断唤醒后发起读事务，
+ *   GD32 在 onCsRelease() 中装入请求帧并释放 SPIready。
+ * - PB6 配置为开漏输出，setSpiReady(true)=高阻释放，setSpiReady(false)=下拉。
  */
 class AppSpiCommand {
 public:
     /** @brief 初始化 SPI0 从机命令通道并注册默认命令处理器。 */
     void init();
 
-    /** @brief 主循环轮询：打印延迟日志。 */
+    /** @brief 主循环轮询：打印延迟日志 + GD32 主动按铃超时看护。 */
     void poll();
 
-    /** @brief 主循环调用:执行 ISR 中推迟的 SPI 命令解析(从 onCsRelease 移出)。 */
-    void processPendingCommand();
-
     /** @brief SPI0 中断处理入口。 */
     void onInterrupt();
 
@@ -57,19 +63,41 @@ public:
                        uint16_t *tx_len, uint8_t rsp_type,
                        const uint8_t *payload, uint16_t payload_len);
 
-    static constexpr uint16_t kRxBufSize = 128U;
+    /**
-    static constexpr uint16_t kTxBufSize = 128U;
+     * @brief GD32 主动按铃：下拉 SPIready，通知 ESP32「我有请求帧要给你读」。
+     *
+     * 将提供的请求帧装入内部 TX 缓冲区（供下次 ESP32 读事务通过 DMA 输出到 MISO），
+     * 然后下拉 SPIready 线。ESP32 检测到下降沿后会发起一次 SPI 读事务把该帧读走。
+     * 调用方负责确保 frame_type 与 payload 符合协议帧格式。
+     *
+     * @param[in] frame_type 请求帧类型（复用 SPI 协议帧 TYPE）。
+     * @param[in] payload    请求帧载荷，可为 nullptr。
+     * @param[in] payload_len 载荷长度。
+     * @return true 成功下拉并装入 TX；false 当前已有未读按铃或帧构建失败。
+     *
+     * @note 可在主循环或 ISR 中调用。若上一次按铃尚未被 ESP32 读走（m_ringPending），
+     *       则返回 false，调用方应稍后重试。按铃后启动 m_ringDeadline 超时看护，
+     *       超时则放弃本次按铃（防止 ESP32 不响应时永久占用 SPIready 线）。
+     */
+    bool requestEsp32Read(uint8_t frame_type, const uint8_t *payload, uint16_t payload_len);
+
+    /** @brief 查询当前是否有未读按铃（ESP32 尚未来读）。 */
+    bool isRingPending() const { return m_ringPending; }
+
+    static constexpr uint16_t kRxBufSize = 256U;
+    static constexpr uint16_t kTxBufSize = 256U;
     static constexpr uint16_t kLogBufSize = 256U;
 
 private:
     static constexpr uint8_t kMaxCommands = 8U;
+    /** GD32 主动按铃超时（ms）：ESP32 未在该时间内来读则放弃。 */
+    static constexpr uint32_t kRingTimeoutMs = 50U;
 
     volatile bool m_csActive = false;
-    volatile uint8_t m_rxLen = 0U;
+    volatile uint16_t m_rxLen = 0U;
-    uint8_t m_txLen = 0U;
+    uint16_t m_txLen = 0U;
     volatile uint8_t m_txPos = 0U;
     volatile bool m_logPending = false;
-    volatile bool m_cmdPending = false; /**< ISR 置位,标记有待主循环解析的 SPI 命令。 */
     bool m_txActiveThisCs = false;
     uint8_t m_rxBuf[kRxBufSize] = {};
     uint8_t m_txBuf[kTxBufSize] = {};
@@ -77,6 +105,13 @@ private:
     uint8_t m_commandCount = 0U;
     ISpiCommandHandler *m_commands[kMaxCommands] = {};
 
+    /** GD32 主动按铃状态：true 表示已下拉 SPIready 等待 ESP32 来读。 */
+    volatile bool m_ringPending = false;
+    /** 按铃超时截止时刻（ms，基于 SysTickTimer::getMs）。 */
+    volatile uint32_t m_ringDeadline = 0U;
+    /** 按铃期间暂存的请求帧长度（供 onCsAssert 装入 DMA）。 */
+    volatile uint16_t m_ringTxLen = 0U;
+
     void configureGpio();
     void configureSpi0();
     void configureDma();
@@ -85,13 +120,27 @@ private:
     void onCsRelease();
     void processCommand();
 
-    /** @brief 翻转 SPI Ready 握手引脚(PB6)电平。
+    /** @brief 翻转 SPI Ready 握手引脚(PB6)电平（开漏线与）。
-     *  @param[in] ready true=就绪(HIGH), false=忙(LOW)。
+     *  @param[in] ready true=释放(高阻,靠上拉拉高), false=下拉(驱动低)。
-     *  @note  GPIO BSRR/BRR 写入原子,无需临界区;可由 ISR 与主循环共同调用。
+     *  @note  GPIO BRR 写入原子,无需临界区;可由 ISR 与主循环共同调用。
+     *         开漏模式下 setSpiReady(true) 仅写 BRR 不驱动高,由外部上拉拉高。
      */
     void setSpiReady(bool ready);
+
+    /** @brief 取消未完成的按铃（释放 SPIready、清 m_ringPending）。 */
+    void cancelRing();
 };
 
+/**
+ * @brief CAN 反馈主动推送一步（非阻塞，由主循环每次迭代调用）。
+ *
+ * GD32 APP 主动循环推送 3 通道 × 2 页 CAN 反馈帧到 ESP32，替代 ESP32
+ * 主动轮询。每次调用推进一帧：若上一帧尚未被 ESP32 读走则立即返回，
+ * 否则构建当前 (channel, page) 的反馈 payload 并 requestEsp32Read() 推送，
+ * 然后推进到下一页/下一通道。
+ */
+void canFeedbackPushStep();
+
 /** @brief 全局 SPI 命令总线实例。 */
 extern AppSpiCommand AppSpiCommandBus;
 

GD32E508_DCU_APP/sys/config.h

@@ -18,7 +18,7 @@ constexpr const char *APP_BANNER_TEXT = "GD32E508 DCU task scheduler start";
 constexpr uint32_t APP_FW_VERSION_MAJOR = 1U;
 constexpr uint32_t APP_FW_VERSION_MINOR = 2U;
 constexpr uint32_t APP_FW_VERSION_PATCH = 3U;
-constexpr uint32_t APP_FW_VERSION_BUILD = 1U;
+constexpr uint32_t APP_FW_VERSION_BUILD = 2U;
 
 
 /** @brief USART0 默认波特率。 */
@@ -109,7 +109,7 @@ constexpr uint32_t CONFIG_CAN_DATA_BS2 = CAN_BT_BS2_1TQ;
 #define CONFIG_CAN_FD_BRS_ENABLE       1U
 
 /** @brief CAN0 通道使能开关：true=启用初始化/收发/自测，false=完全禁用。 */
-constexpr bool CONFIG_CAN_CH0_ENABLE = true;
+constexpr bool CONFIG_CAN_CH0_ENABLE = false;
 /** @brief CAN1 通道使能开关。 */
 constexpr bool CONFIG_CAN_CH1_ENABLE = false;
 /** @brief CAN2 通道使能开关。 */

GD32E508_DCU_APP/sys/ota_boot_request.cpp

@@ -89,6 +89,7 @@ static bool requestMagicValid(const uint8_t *data, uint8_t length)
 
 /** @brief 已写入 OTA 标志并等待软复位的挂起标志。 */
 volatile bool OtaBootRequest::s_rebootPending = false;
+volatile bool OtaBootRequest::s_bootRequestPending = false;
 
 /**
  * @brief 初始化进入 Bootloader 请求模块的运行态。
@@ -96,6 +97,7 @@ volatile bool OtaBootRequest::s_rebootPending = false;
 void OtaBootRequest::init()
 {
     s_rebootPending = false;
+    s_bootRequestPending = false;
 }
 
 /**
@@ -117,6 +119,16 @@ bool OtaBootRequest::requestEnterBoot()
     return ok;
 }
 
+/**
+ * @brief 异步请求进入 Bootloader（ISR 安全）。
+ * @note 仅设置 pending 标志，Flash 操作和复位由 process() 在主循环执行。
+ *       用于 SPI EXTI ISR 内的 0xB0 命令处理，避免 Flash 擦除阻塞 SPI 中断。
+ */
+void OtaBootRequest::requestEnterBootAsync()
+{
+    s_bootRequestPending = true;
+}
+
 /**
  * @brief 处理备用 CAN 入口的进入 Bootloader 请求。
  * @note 当前主路径是 SPI 命令；CAN 入口只负责识别魔术字并触发同一套标志写入逻辑。
@@ -138,19 +150,34 @@ bool OtaBootRequest::handleCanFrame(uint8_t channel, uint32_t id, const uint8_t
 }
 
 /**
- * @brief 在主循环任务中执行短延迟软复位。
+ * @brief 在主循环任务中执行异步 Flash 操作和短延迟软复位。
- * @note 不在 SPI/CAN 中断里直接复位，避免应答还没发出就重启。
+ * @note 不在 SPI/CAN 中断里直接复位，避免应答还没有发出就重启。
- *       这里使用毫秒级短延时，而不是 1s 心跳计数；否则一次 SPI 请求
+ *       异步路径：SPI ISR 收到 0xB0 后只设标志，Flash 操作（可能擦页 20-30ms）
- *       实际会拖到 2~3 秒后才复位，ESP32 第二次 OTA 时很容易在 APP 还没
+ *       在此主循环执行，避免阻塞 SPI 中断导致 ESP32 ACK 轮询丢字节。
- *       真正重启进入 BOOT 之前就发出 HANDSHAKE_REQ。
  */
 void OtaBootRequest::process()
 {
+    /* 异步处理 0xB0 请求：在主循环执行 Flash 操作（20-30ms），不阻塞 SPI ISR */
+    if(s_bootRequestPending) {
+        s_bootRequestPending = false;
+        const bool ok = requestEnterBoot();
+        if(ok) {
+            s_rebootPending = true;
+        }
+    }
+
     if(!s_rebootPending) {
         return;
     }
 
     s_rebootPending = false;
+
+    /* 方案A: 拉低 PB6 通知 ESP32 "即将复位"。
+     * ESP32 通过 LOW→HIGH 序列识别 Bootloader 就绪:
+     *   APP 拉低 → 复位(μs级HIGH) → Bootloader极早拉低 → init完成释放HIGH
+     * 20ms 延时确保 ESP32 5ms 轮询能捕获到 LOW 信号后再复位。 */
+    gpio_bit_reset(CONFIG_SPI_READY_PORT, CONFIG_SPI_READY_PIN);
+
     SysTickTimer::delayMs(kRebootDelayMs);
     __disable_irq();
     NVIC_SystemReset();

GD32E508_DCU_APP/sys/ota_boot_request.h

@@ -28,14 +28,27 @@ public:
      * @brief 设置 Bootloader OTA 等待标志并安排软复位。
      * @retval true 标志写入成功，稍后会复位进入 Bootloader。
      * @retval false Flash 标志写入失败。
+     * @note 此函数会执行 Flash 操作（可能擦页 20-30ms），不可在 ISR 内调用。
      */
     static bool requestEnterBoot();
 
+    /**
+     * @brief 异步请求进入 Bootloader（ISR 安全）。
+     * @note 仅设置 pending 标志，Flash 操作和复位由 process() 在主循环执行。
+     *       用于 SPI EXTI ISR 内的 0xB0 命令处理，避免 Flash 擦除阻塞 SPI 中断。
+     */
+    static void requestEnterBootAsync();
+
     /** @brief 若已确认进入 BOOT 请求，则延迟片刻后复位。 */
     static void process();
 
+    /** @brief 查询是否已收到进入 Bootloader 请求（等待复位中）。
+     *         供主循环在复位前停止主动按铃等可能干扰 OTA 的操作。 */
+    static bool isRebootPending() { return s_rebootPending; }
+
 private:
     static volatile bool s_rebootPending;
+    static volatile bool s_bootRequestPending; ///< 0xB0 异步请求标志，process() 中执行 Flash 操作
 };
 
 #endif /* SYS_OTA_BOOT_REQUEST_H */

GD32E508_DCU_APP/sys/systick.h

@@ -35,6 +35,13 @@ public:
      */
     static void onInterrupt();
 
+    /**
+     * @brief 获取当前系统毫秒节拍数。
+     * @return 自启动以来的毫秒数（32 位回绕）。
+     * @note   用于超时判定（如 SPI 按铃看护）。读取 volatile 原子。
+     */
+    static uint32_t getMs() { return s_ms; }
+
 private:
     static volatile uint32_t s_ms;
 };

GD32E508_DCU_APP/sys/task_runner.cpp

@@ -331,7 +331,7 @@ void TaskRunner::taskDiagnosticPrint()
  */
 void TaskRunner::taskSpiCmdProcess()
 {
-    AppSpiCommandBus.processPendingCommand();
+    AppSpiCommandBus.poll();  // 命令处理已移入 ISR，此处仅日志打印+按铃看护
 }
 
 /**
@@ -378,6 +378,11 @@ void TaskRunner::runPending()
 {
     Watchdog::feed();
 
+    /* CAN 反馈主动推送：GD32 APP 循环推送 3 通道 × 2 页反馈帧到 ESP32，
+     * 替代 ESP32 主动轮询。非阻塞：上一帧未读走时立即返回。
+     * 每次主循环迭代调用一次，ESP32 读走一帧后 CS 释放中断唤醒主循环继续推送。 */
+    canFeedbackPushStep();
+
     /* 周期路径( SYNC0 ISR preempt=0 )用 s_periodicSeq 序列号通知主循环,
      * 不再走 task_flags,避免 BASEPRI 临界区与 preempt=0 的 RMW 竞态。
      * 优先于 takePending() 处理,确保周期数据及时消费。