cbb/DCU_APP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(spi): 更新SPI命令v2，处理逻辑和项目配置

Browse Source 
- 在cproject.yml中添加spi_link模块组和相关头文件路径
- 修改boot_request.cpp中的ACK响应机制，改用标准帧格式并优化CAN反馈处理
- 重构ping.cpp响应payload结构，包含版本信息、运行时间等16字节数据
- 添加systick.h依赖用于获取系统运行时间
- 优化启动bootloader流程，避免SPI中断阻塞问题
This commit is contained in:
cbb
2026-07-13 03:10:37 +08:00
parent 10989939e9
commit 7c05496b89
9 changed files with 422 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files
GD32E508_DCU_APP/GD32E508_DCU_APP.cproject.yml
+4
View File
@@ -46,6 +46,9 @@ project:
- file: ./device/spi/app_spi_cmd_can_bridge.cpp
- file: ./device/spi/app_spi_cmd_can_feedback.cpp
- file: ./device/spi/app_spi_cmd_id_snapshot.cpp
- group: spi_link
files:
- file: ../../spi_link/spi_link_v2.cpp
- group: comm
files:
- file: ./comm/esc_exmc_bus.h
@@ -97,6 +100,7 @@ project:
- -fshort-enums
- -fshort-wchar
- -Wno-register
- -IG:/Robot_v2/DCU/spi_link
C:
- -std=gnu11
CPP:
GD32E508_DCU_APP/device/spi/app_spi_cmd_boot_request.cpp
+9 -17
View File
@@ -18,24 +18,16 @@ public:
{
bus.postLog("BOOT_REQ → 进BOOT(异步)");
/* 立即装 0xB5 ACK，让 ESP32 尽快收到确认。
* Flash 操作延迟到主循环执行，避免阻塞 SPI ISR。
*
* ESP32 appRequestBootloader() 发送单字节 0xB0 后，逐字节轮询读回 0xB5。
* 必须返回裸字节 ACK，不能用 buildResponse() 构建帧式 ACK
* （帧式 ACK 以 0xA5 开头，ESP32 永远匹配不到 0xB5）。
* tx_buf[0] 必须是 ack 字节本身，因为 ESP32 只读首个 MISO 字节。 */
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;
}
/* 先取消 CAN feedback 按铃，避免 0xC1 残留帧盖住本 ACK / 干扰复位。 */
bus.cancelRing();
/* 设置 pending 标志，主循环执行 Flash 操作 + 复位。
* 原来在 ISR 内直接调 requestEnterBoot() 会执行 Flash 页擦除（20-30ms），
* 导致 CPU 总线停顿、SPI RBNE 中断无法响应、ESP32 ACK 轮询丢字节。 */
/* 立即装标准帧 ACK：type=0xB0 payload=[0xB5]，勿用通用 0x80。
* Flash 擦写放到主循环，避免阻塞 SPI ISR。 */
uint8_t status = CONFIG_SPI_APP_OTA_BOOT_ACK_OK;
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kTypeBootReq, &status, 1U);
/* pending + 立即冻结 SPI 业务；并拉高优先级心跳，尽快 process() 擦页复位。 */
OtaBootRequest::requestEnterBootAsync();
TaskManager::set(1UL << TASK_HEARTBEAT);
}
GD32E508_DCU_APP/device/spi/app_spi_cmd_ping.cpp
+26 -18
View File
@@ -2,6 +2,7 @@
#include "device/spi/app_spi_command.h"
#include "device/spi/app_spi_command_defs.h"
#include "sys/config.h"
#include "sys/systick.h"
#include "main.h"
#include <cstring>
@@ -16,32 +17,39 @@ public:
void handle(AppSpiCommand &bus, const SpiCommandContext &ctx) override
{
uint8_t alive_payload[19];
std::memset(alive_payload, 0, sizeof(alive_payload));
alive_payload[0] = 0xA1U; /* magic */
alive_payload[1] = 0x55U; /* APP version tag */
alive_payload[2] = (uint8_t)APP_FW_VERSION_MAJOR;
alive_payload[3] = (uint8_t)APP_FW_VERSION_MINOR;
alive_payload[4] = (uint8_t)APP_FW_VERSION_PATCH;
alive_payload[5] = (uint8_t)APP_FW_VERSION_BUILD;
alive_payload[6] = 0xAAU; /* BOOT version tag */
/* v2 PING 响应 payload（16B）：
* [0..3] APP version (major/minor/patch/build)
* [4..7] BOOT version (major/minor/patch/build)
* [8..11] uptime_ms (4B LE)
* [12..15] build_hash (4B, 暂用 0 占位) */
uint8_t ping_payload[16];
std::memset(ping_payload, 0, sizeof(ping_payload));
ping_payload[0] = (uint8_t)APP_FW_VERSION_MAJOR;
ping_payload[1] = (uint8_t)APP_FW_VERSION_MINOR;
ping_payload[2] = (uint8_t)APP_FW_VERSION_PATCH;
ping_payload[3] = (uint8_t)APP_FW_VERSION_BUILD;
/* BOOT 版本号从 OTA 配置页 Flash 读取 */
const volatile uint32_t *bv0 = (const volatile uint32_t *)CONFIG_BOOT_VERSION_ADDR0;
const volatile uint32_t *bv1 = (const volatile uint32_t *)CONFIG_BOOT_VERSION_ADDR1;
uint32_t bw0 = *bv0;
uint32_t bw1 = *bv1;
alive_payload[7] = (uint8_t)(bw0 & 0xFFU);
alive_payload[8] = (uint8_t)((bw0 >> 16) & 0xFFU);
alive_payload[9] = (uint8_t)(bw1 & 0xFFU);
alive_payload[10] = (uint8_t)((bw1 >> 16) & 0xFFU);
ping_payload[4] = (uint8_t)(bw0 & 0xFFU);
ping_payload[5] = (uint8_t)((bw0 >> 16) & 0xFFU);
ping_payload[6] = (uint8_t)(bw1 & 0xFFU);
ping_payload[7] = (uint8_t)((bw1 >> 16) & 0xFFU);
alive_payload[11] = (uint8_t)(g_app_uptime_sec & 0xFFU);
alive_payload[12] = (uint8_t)((g_app_uptime_sec >> 8) & 0xFFU);
alive_payload[13] = (uint8_t)((g_app_uptime_sec >> 16) & 0xFFU);
alive_payload[14] = (uint8_t)((g_app_uptime_sec >> 24) & 0xFFU);
const uint32_t uptime_ms = SysTickTimer::getMs();
ping_payload[8] = (uint8_t)(uptime_ms & 0xFFU);
ping_payload[9] = (uint8_t)((uptime_ms >> 8) & 0xFFU);
ping_payload[10] = (uint8_t)((uptime_ms >> 16) & 0xFFU);
ping_payload[11] = (uint8_t)((uptime_ms >> 24) & 0xFFU);
/* build_hash 占位 0（ping_payload[12..15] 已由 memset 清零） */
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspAck, alive_payload, sizeof(alive_payload));
SpiDefs::kRspAck, ping_payload, sizeof(ping_payload));
}
};
GD32E508_DCU_APP/device/spi/app_spi_command.cpp
+307 -273
View File
@@ -12,15 +12,19 @@
* 通过 registerHandler() 注册进来，后续新增 SPI 业务时
* 只需要新增命令处理器，不再继续膨胀本文件。
*
* 握手架构（线与 SPIready，PB6<->ESP32 GPIO10 开漏单线）：
* 握手架构（v2 DATA_READY，PB6<->ESP32 GPIO10 开漏单线）：
* - PB6 低 = 有待发数据（m_txLen>0 或 m_ringPending），高 = 队列空。
* - 命令处理在 onCsRelease() EXTI ISR 内同步完成（对齐 BOOT 的 isrProcessFrame），
* 不再推迟到主循环，消除 PB6 拉高延迟。
* - GD32 可通过 requestEsp32Read() 下拉 SPIready 主动按铃请求 ESP32 来读。
* 完成后由 updateDataReady() 依据待发数据驱动 PB6，不再延迟拉高。
* - GD32 可通过 requestEsp32Read() 设 m_ringPending 并由 updateDataReady()
* 拉低 PB6 主动按铃，请求 ESP32 来读。
*/
#include "device/spi/app_spi_command.h"
#include "device/spi/spi_command_handler.h"
#include "device/spi/app_spi_command_defs.h"
#include "spi_link_v2.h"
#include "sys/ota_boot_request.h"
extern "C" {
#include "gd32e50x_exti.h"
@@ -33,7 +37,6 @@ extern "C" {
#include "sys/config.h"
#include "sys/critical.h"
#include "sys/task_manager.h"
#include "sys/ota_boot_request.h"
#include "sys/systick.h"
#include "main.h"
#include <cstdio>
@@ -42,7 +45,6 @@ extern "C" {
/* ============================================================
* 本地别名：保持当前实现文件内部风格不变
* ============================================================ */
static constexpr uint8_t kSof = SpiDefs::kSof;
static constexpr uint8_t kTypeBootReq = SpiDefs::kTypeBootReq;
static constexpr uint8_t kTypeCanSend = SpiDefs::kTypeCanSend;
static constexpr uint8_t kTypeOtaReq = SpiDefs::kTypeOtaReq;
@@ -52,7 +54,6 @@ static constexpr uint8_t kTypeOtaCancel = SpiDefs::kTypeOtaCancel;
static constexpr uint8_t kRspAck = SpiDefs::kRspAck;
static constexpr uint8_t kRspWait = SpiDefs::kRspWait;
static constexpr uint8_t kRspError = SpiDefs::kRspError;
static constexpr uint16_t kFrameOverhead = SpiDefs::kFrameOverhead;
/* DMA 配置（与 BOOT SpiOta 一致：DMA0_CH2 用于 SPI0 TX） */
#define SPI_TX_DMA_PERIPH DMA0
@@ -90,12 +91,10 @@ static bool shouldIgnoreTransaction(const uint8_t *data, uint16_t len)
return true;
}
/* APP 侧只接受两类事务：
* 1) 旧式单字节 0xB0
* 2) 完整协议帧（至少 5 字节）
* 短于 5 字节且不是 0xB0 的事务只能是启动切换期的残包，直接忽略。 */
return (len < kFrameOverhead) &&
!(len == 1U && data[0] == CONFIG_SPI_APP_OTA_BOOT_CMD);
/* v2 协议帧最小长度为 V2_OVERHEAD(20B)。
* 短于该长度的事务只能是启动切换期的残包，直接忽略。
* （0xB0 进 BOOT 现已走标准 v2 帧 handler，不再有裸字节通道。） */
return (len < V2_OVERHEAD);
}
static bool isFlashRelatedFrame(uint8_t frame_type)
@@ -111,155 +110,67 @@ static bool isFlashRelatedFrame(uint8_t frame_type)
}
}
/* ============================================================
* CRC8 / 帧构建 / 帧解析（与 BOOT SpiOta 一致）
* ============================================================ */
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);
/* 扫描前 16 字节查找同步帧头 SOF0 SOF1，容忍 RXORERR 导致的首字节偏移。
* 与 spi_try_parse_frame 的偏移扫描逻辑对齐。 */
static bool containsSyncSof(const uint8_t *data, uint16_t len)
{
if (!data || len < 2U) { return false; }
uint16_t last = (len < 16U) ? (uint16_t)(len - 1U) : 16U;
for (uint16_t i = 0U; i < last; ++i) {
if (data[i] == kSyncSof0 && data[i + 1U] == kSyncSof1) { return true; }
}
return false;
}
/* 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)
{
pp[0] = (uint8_t)(v & 0xFFU);
pp[1] = (uint8_t)((v >> 8) & 0xFFU);
}
/* SPI Link v2 会话/序号状态机（ISR 写、主循环读写，均原子，无需临界区）。 */
static volatile uint32_t g_sessionId = 0; /* v2 会话 ID（0=未建立） */
static volatile uint8_t g_txSeq = 0; /* GD32 发送序号（事件/响应帧） */
static volatile uint8_t g_expectedRxSeq = 0; /* 期望收到的 ESP32 请求序号 */
static volatile bool g_v2Active = false; /* v2 session 是否激活 */
/* 当前请求的 TX_SEQ，写入响应 ACK_SEQ，供 ESP32 做响应归属匹配（延迟一拍）。 */
static volatile uint8_t g_pendingAckSeq = 0;
static uint16_t getU16Le(const uint8_t *pp)
{
return (uint16_t)(pp[0] | ((uint16_t)pp[1] << 8));
}
/* 响应缓存：用于重复请求重发同一响应（避免业务 handler 重复执行）。 */
static uint8_t s_lastReqSeq = 0xFF;
static uint8_t s_lastRespBuf[256];
static uint16_t s_lastRespLen = 0;
static bool s_hasCachedResp = false;
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);
}
/* ============================================================
* v2 帧构建 / 帧解析（委托 spi_link_v2.h，三工程共用）
* ============================================================ */
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 ^= (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 旧常量仍保留供旧路径使用。 */
/* 构建响应帧；上层接口（type/payload）保持不变，handler 无需改动。
* 内部调用 v2_build_frame，FLAGS 默认 V2_FLAG_RESPONSE，session/seq/credit
* 从 v2 状态全局变量取。session 未建立时 session_id 填 0。
* ACK_SEQ = g_pendingAckSeq（对端请求的 TX_SEQ），不能写死 0，否则 ESP32
* otaFindFrame 在 m_v2Active 时会把合法延迟响应当成 stale 丢弃。 */
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)(kSyncOverhead + payload_len);
if (total > AppSpiCommand::kTxBufSize) { return false; }
if ((uint32_t)V2_OVERHEAD + payload_len > AppSpiCommand::kTxBufSize) { return false; }
out[0] = kSyncSof0;
out[1] = kSyncSof1;
out[2] = g_localCredit;
out[3] = type;
putU16Le(&out[4], payload_len);
if (payload && payload_len > 0U) {
memcpy(&out[kSyncHeaderLen], payload, payload_len);
}
uint32_t crc = spi_crc32(out, (uint16_t)(kSyncHeaderLen + payload_len));
putU32Le(&out[kSyncHeaderLen + payload_len], crc);
*out_len = total;
const uint32_t sess = g_v2Active ? g_sessionId : 0U;
size_t built = 0U;
const bool ok = v2_build_frame(type, V2_FLAG_RESPONSE, sess,
g_txSeq, g_pendingAckSeq, (uint8_t)g_localCredit,
payload, payload_len, out, &built);
if (!ok) { return false; }
*out_len = (uint16_t)built;
return true;
}
/* 解析：新同步帧优先；失败回退旧 0xA5 帧（含首字节偏移容错）。 */
/* 解析 v2 帧；委托 v2_parse_frame，扫描 SOF 并校验 VERSION/CRC32。
* 旧的 0xA5 CRC8 帧兼容路径已移除（v2 不再向后兼容 v1）。 */
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)
uint8_t *type, const uint8_t **payload, uint16_t *payload_len,
v2_header_t *out_hdr = nullptr)
{
if (!frame || !type || !payload || !payload_len) { return false; }
for (uint16_t s = 0U; s + kSyncOverhead <= frame_len; ++s) {
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; }
v2_header_t hdr;
const uint8_t *pload = nullptr;
const bool ok = v2_parse_frame(frame, frame_len, &hdr, &pload);
if (!ok) { return false; }
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) {
const uint16_t shifted_len = (uint16_t)(frame_len - s);
if (shifted_len >= kFrameOverhead) {
const uint16_t len_field = (uint16_t)frame[s + 2U] | ((uint16_t)frame[s + 3U] << 8);
const uint16_t expected = (uint16_t)(kFrameOverhead + len_field);
if (shifted_len >= expected &&
spi_crc8(&frame[s], (uint16_t)(4U + len_field)) == frame[s + 4U + len_field]) {
*type = frame[s + 1U];
*payload = &frame[s + 4U];
*payload_len = len_field;
return true;
}
}
}
if (frame_len < kFrameOverhead) { return false; }
if (frame[0] != kSof) { return false; }
uint16_t len = (uint16_t)frame[2] | ((uint16_t)frame[3] << 8);
uint16_t expected = (uint16_t)(kFrameOverhead + len);
if (frame_len < expected) { return false; }
if (spi_crc8(frame, (uint16_t)(4U + len)) != frame[4U + len]) { return false; }
*type = frame[1];
*payload = &frame[4];
*payload_len = len;
g_remoteCredit = hdr.credit;
*type = hdr.type;
*payload = pload;
*payload_len = hdr.payload_len;
if (out_hdr) { *out_hdr = hdr; }
return true;
}
@@ -322,9 +233,9 @@ 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 握手线（开漏输出，线与）。
/* PB6 复用为 DATA_READY 握手线（开漏输出，线与）。
* 开漏模式：写 BRR = 下拉驱动低；写 BSRR = 高阻释放，靠外部/对端上拉拉高。
* 默认释放（HIGH），允许主机立刻发起首帧。 */
* 语义：低 = 有待发数据，高 = 队列空；默认释放（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);
}
@@ -340,6 +251,14 @@ void AppSpiCommand::setSpiReady(bool ready)
}
}
/* v2 DATA_READY: PB6 低 = 有待发数据，高 = 队列空。
* 替代旧 BUSY/READY 语义中所有 setSpiReady 调用。 */
void AppSpiCommand::updateDataReady()
{
const bool has_data = (m_txLen > 0U) || m_ringPending;
setSpiReady(!has_data);
}
void AppSpiCommand::configureSpi0()
{
rcu_periph_clock_enable(RCU_SPI0);
@@ -362,7 +281,7 @@ void AppSpiCommand::configureSpi0()
spi_i2s_interrupt_enable(SPI0, SPI_I2S_INT_RBNE);
spi_i2s_interrupt_enable(SPI0, SPI_I2S_INT_ERR);
spi_i2s_interrupt_disable(SPI0, SPI_I2S_INT_TBE);
nvic_irq_enable(SPI0_IRQn, CONFIG_IRQ_PREEMPT_SPI_USART, 0U);
nvic_irq_enable(SPI0_IRQn, 2U, 0U);
spi_enable(SPI0);
}
@@ -393,15 +312,14 @@ void AppSpiCommand::configureExti()
exti_init(EXTI_15, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
exti_interrupt_enable(EXTI_15);
exti_interrupt_flag_clear(EXTI_15);
nvic_irq_enable(EXTI10_15_IRQn, CONFIG_IRQ_PREEMPT_SPI_USART, 1U);
nvic_irq_enable(EXTI10_15_IRQn, 1U, 1U);
}
void AppSpiCommand::configureSpiReadyExti()
{
/* PB6 已在 configureGpio() 配置为开漏输出，此处启用 EXTI6 上升沿检测。
* EXTI 检测引脚实际电平（IDR），与 GPIO 输出模式兼容。
* 用于检测 ESP32 releaseReady 产生的上升沿（线从忙碌→空闲），
* 作为 ESP32 完成上一帧处理的可靠信号。 */
/* PB6 已在 configureGpio() 配置为开漏输出，此处保留 EXTI6 中断使能。
* v2 DATA_READY: ESP32 不再操作 PB6，EXTI6 上升沿无业务含义，
* onSpiReadyExti() 仅清标志避免反复触发。 */
gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB, GPIO_PIN_SOURCE_6);
exti_init(EXTI_6, EXTI_INTERRUPT, EXTI_TRIG_RISING);
exti_interrupt_enable(EXTI_6);
@@ -411,10 +329,10 @@ void AppSpiCommand::configureSpiReadyExti()
void AppSpiCommand::onSpiReadyExti()
{
/* v2 DATA_READY: ESP32 不再操作 PB6，EXTI6 上升沿不再有意义。
* 清除中断标志避免反复触发。 */
if (exti_interrupt_flag_get(EXTI_6) != RESET) {
exti_interrupt_flag_clear(EXTI_6);
/* 线升高（空闲）：ESP32 已 releaseReady，上一帧处理完 */
m_linkState.onEsp32Complete();
}
}
@@ -478,100 +396,202 @@ void AppSpiCommand::processCommand()
return;
}
/* 尝试按协议帧解析 */
/* 0xB0 已受理、正在写 OTA 配置页 / 即将复位：不再处理业务帧，避免打断 Flash。 */
if (OtaBootRequest::isSpiFrozenForBoot() || OtaBootRequest::isRebootPending()) {
m_txLen = 0U;
m_txPos = 0U;
updateDataReady();
return;
}
/* 尝试按 v2 协议帧解析；同时取回完整帧头用于 session/seq 校验 */
uint8_t frame_type = 0U;
const uint8_t *payload = nullptr;
uint16_t payload_len = 0U;
v2_header_t hdr;
if (spi_try_parse_frame(m_rxBuf, m_rxLen, &frame_type, &payload, &payload_len)) {
if (CONFIG_SPI_APP_LOG_ENABLE != 0 && !isFlashRelatedFrame(frame_type)) {
postLogFmt("[SPI-APP] 收到非刷写 SPI type=0x%02X", frame_type);
}
/* 合法帧：按 TYPE 分发给已注册命令处理器 */
if (!spi_try_parse_frame(m_rxBuf, m_rxLen, &frame_type, &payload, &payload_len, &hdr)) {
/* 无法解析为合法 v2 帧：构建 ERROR 响应 */
postLogFmt("[SPI-APP] 非v2帧 0x%02X -> ERROR", m_rxBuf[0]);
uint16_t tx_len = 0U;
bool handled = false;
SpiCommandContext ctx{};
ctx.frame_type = frame_type;
ctx.payload = payload;
ctx.payload_len = payload_len;
ctx.tx_buf = m_txBuf;
ctx.tx_buf_size = kTxBufSize;
ctx.tx_len = &tx_len;
for (uint8_t i = 0U; i < m_commandCount; ++i) {
ISpiCommandHandler *handler = m_commands[i];
if (handler && handler->canHandle(frame_type)) {
handler->handle(AppSpiCommandBus, ctx);
handled = true;
break;
}
}
if (!handled) {
postLogFmt("[SPI-APP] 未知 type=0x%02X -> ERROR", frame_type);
uint8_t err = 0xEEU;
spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
}
if (tx_len == 0U) {
/* 兜底：避免残留上一次应答帧 */
uint8_t err = 0xEEU;
spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
}
uint8_t err = 0xEEU;
spi_build_frame(kRspError, &err, 1U, m_txBuf, &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");
uint16_t tx_len_legacy = 0U;
SpiCommandContext ctx{};
ctx.frame_type = first_valid;
ctx.payload = nullptr;
ctx.payload_len = 0U;
ctx.tx_buf = m_txBuf;
ctx.tx_buf_size = kTxBufSize;
ctx.tx_len = &tx_len_legacy;
bool handled = false;
for (uint8_t i = 0U; i < m_commandCount; ++i) {
ISpiCommandHandler *handler = m_commands[i];
if (handler && handler->canHandle(first_valid)) {
handler->handle(AppSpiCommandBus, ctx);
handled = true;
break;
}
}
if (!handled) {
/* 兜底路径（handler 未注册时的死代码保护）：
* 同样使用异步路径，避免在 ISR 内执行 Flash 操作。
* 先装 0xB5 ACK，再设 pending 标志。 */
m_txBuf[0] = CONFIG_SPI_APP_OTA_BOOT_ACK_OK;
m_txBuf[1] = CONFIG_SPI_APP_OTA_BOOT_CMD;
m_txBuf[2] = 0x4FU;
m_txBuf[3] = 0x54U;
tx_len_legacy = 4U;
OtaBootRequest::requestEnterBootAsync();
TaskManager::set(1UL << TASK_HEARTBEAT);
}
m_txLen = tx_len_legacy;
m_txPos = 0U;
} else {
/* 无法识别 */
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 = tx_len;
m_txPos = 0U;
if (m_logPending) {
TaskManager::set(1UL << TASK_SPI_LOG);
}
if (m_txLen > 0U) {
m_ringPending = true;
m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
}
updateDataReady();
return;
}
if (CONFIG_SPI_APP_LOG_ENABLE != 0 && !isFlashRelatedFrame(frame_type)) {
postLogFmt("[SPI-APP] 收到非刷写 SPI type=0x%02X", frame_type);
}
/* 响应归属：ACK_SEQ 必须回显请求 TX_SEQ（延迟一拍 + ESP32 otaFindFrame 匹配）。 */
g_pendingAckSeq = hdr.tx_seq;
/* ---------- HELLO 建链路处理（在 session 校验之前） ---------- */
if (frame_type == V2_TYPE_LINK_HELLO) {
/* 接受 ESP32 提供的 session_id，重置本端序号状态机 */
g_sessionId = hdr.session_id;
g_txSeq = 0;
g_expectedRxSeq = 0;
g_v2Active = true;
s_hasCachedResp = false;
/* 构建 HELLO_ACK 响应帧（回显 session_id + 角色 + credit_max） */
size_t built_len = 0U;
v2_build_hello_ack_frame(g_sessionId, V2_ROLE_APP, (uint8_t)g_localCredit,
0, hdr.tx_seq, m_txBuf, &built_len);
m_txLen = (uint16_t)built_len;
m_txPos = 0U;
/* 缓存 HELLO_ACK 便于重复 HELLO 重发 */
s_lastReqSeq = hdr.tx_seq;
memcpy(s_lastRespBuf, m_txBuf, m_txLen);
s_lastRespLen = m_txLen;
s_hasCachedResp = true;
if (m_logPending) {
TaskManager::set(1UL << TASK_SPI_LOG);
}
if (m_txLen > 0U) {
m_ringPending = true;
m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
}
updateDataReady();
return;
}
/* ---------- SESSION / SEQ 校验（仅在 v2 session 激活后生效） ---------- */
if (g_v2Active) {
/* session_id 不匹配：构建 LINK_ERROR(V2_ERR_SESSION)，跳过 handler */
if (hdr.session_id != g_sessionId) {
postLogFmt("[SPI-APP] session 不匹配 0x%02X -> LINK_ERROR",
(uint8_t)(hdr.session_id & 0xFFU));
size_t built_len = 0U;
v2_build_error_frame(g_sessionId, g_txSeq, hdr.tx_seq,
(uint8_t)g_localCredit, V2_ERR_SESSION,
(uint8_t)g_expectedRxSeq, m_txBuf, &built_len);
m_txLen = (uint16_t)built_len;
m_txPos = 0U;
if (m_logPending) {
TaskManager::set(1UL << TASK_SPI_LOG);
}
if (m_txLen > 0U) {
m_ringPending = true;
m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
}
updateDataReady();
return;
}
/* 序号回绕距离判定 */
const uint8_t dist = v2_seq_distance(hdr.tx_seq, g_expectedRxSeq);
if (dist == 0U) {
/* 正常：序号匹配，推进期望序号 */
g_expectedRxSeq = (uint8_t)(g_expectedRxSeq + 1U);
} else if (dist >= 128U) {
/* 重复请求：重发缓存的响应帧，跳过 handler */
if (s_hasCachedResp && hdr.tx_seq == s_lastReqSeq) {
postLogFmt("[SPI-APP] 重复请求 seq=0x%02X -> 重发缓存", hdr.tx_seq);
memcpy(m_txBuf, s_lastRespBuf, s_lastRespLen);
m_txLen = s_lastRespLen;
m_txPos = 0U;
if (m_logPending) {
TaskManager::set(1UL << TASK_SPI_LOG);
}
if (m_txLen > 0U) {
m_ringPending = true;
m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
}
updateDataReady();
return;
}
/* 无缓存可用：按正常请求处理 */
} else {
/* dist 1-127：序号跳变。对齐期望序号后：
* - 普通业务：回 LINK_ERROR 并丢弃（避免副作用）
* - 0xB0 ENTER_BOOT：控制面命令，仍必须执行，否则永远进不了 BOOT */
postLogFmt("[SPI-APP] SEQ jump rx=0x%02X", hdr.tx_seq);
g_expectedRxSeq = (uint8_t)(hdr.tx_seq + 1U);
if (frame_type != kTypeBootReq) {
size_t built_len = 0U;
v2_build_error_frame(g_sessionId, g_txSeq, hdr.tx_seq,
(uint8_t)g_localCredit, V2_ERR_SEQ_JUMP,
(uint8_t)g_expectedRxSeq, m_txBuf, &built_len);
m_txLen = (uint16_t)built_len;
m_txPos = 0U;
if (m_logPending) {
TaskManager::set(1UL << TASK_SPI_LOG);
}
if (m_txLen > 0U) {
m_ringPending = true;
m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
}
updateDataReady();
return;
}
postLog("SEQ jump but BOOT_REQ still handled");
/* fall through → 业务分发 */
}
}
/* ---------- 业务命令分发 ---------- */
uint16_t tx_len = 0U;
bool handled = false;
SpiCommandContext ctx{};
ctx.frame_type = frame_type;
ctx.payload = payload;
ctx.payload_len = payload_len;
ctx.tx_buf = m_txBuf;
ctx.tx_buf_size = kTxBufSize;
ctx.tx_len = &tx_len;
for (uint8_t i = 0U; i < m_commandCount; ++i) {
ISpiCommandHandler *handler = m_commands[i];
if (handler && handler->canHandle(frame_type)) {
handler->handle(AppSpiCommandBus, ctx);
handled = true;
break;
}
}
if (!handled) {
postLogFmt("[SPI-APP] 未知 type=0x%02X -> ERROR", frame_type);
uint8_t err = 0xEEU;
spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
}
if (tx_len == 0U) {
/* 兜底：避免残留上一次应答帧 */
uint8_t err = 0xEEU;
spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
}
m_txLen = tx_len;
m_txPos = 0U;
/* 缓存本次响应，便于重复请求时重发（避免 handler 重复执行副作用） */
if (g_v2Active) {
s_lastReqSeq = hdr.tx_seq;
memcpy(s_lastRespBuf, m_txBuf, m_txLen);
s_lastRespLen = m_txLen;
s_hasCachedResp = true;
/* 推进本端发送序号（响应帧占用一个 tx_seq 槽位） */
g_txSeq = (uint8_t)(g_txSeq + 1U);
}
if (m_logPending) {
@@ -579,7 +599,7 @@ void AppSpiCommand::processCommand()
TaskManager::set(1UL << TASK_SPI_LOG);
}
/* 应答帧已就绪：拉高 PB6（释放 SPIready）通知主机可发起下一笔事务。
/* 应答帧已就绪：由 updateDataReady() 依据 m_txLen 驱动 PB6（有待发=低）。
* 命令处理已在 ISR 内同步完成，无需 m_cmdPending 推迟机制。 */
/* 有响应待发时，设置按铃标志阻止主循环 canFeedbackPushStep() 覆盖 m_txBuf。
@@ -589,11 +609,11 @@ void AppSpiCommand::processCommand()
m_ringPending = true;
m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
}
setSpiReady(true);
updateDataReady();
}
/* ============================================================
* GD32 主动按铃：下拉 SPIready 请求 ESP32 来读
* GD32 主动按铃：设 m_ringPending + updateDataReady() 拉低 PB6 请求 ESP32 来读
* ============================================================ */
void AppSpiCommand::cancelRing()
@@ -605,8 +625,9 @@ void AppSpiCommand::cancelRing()
m_txPos = 0U;
/* 超时后允许重试，不依赖 ESP32 releaseReady 上升沿 */
m_linkState.onRingTimeout();
/* 释放 SPIready（高阻），避免永久占用线 */
setSpiReady(true);
/* 释放 SPIready（高阻），避免永久占用线。
* cancelRing 已清 m_txLen 和 m_ringPending，updateDataReady() 会释放为高。 */
updateDataReady();
}
bool AppSpiCommand::requestEsp32Read(uint8_t frame_type, const uint8_t *payload, uint16_t payload_len)
@@ -616,22 +637,32 @@ bool AppSpiCommand::requestEsp32Read(uint8_t frame_type, const uint8_t *payload,
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)) {
/* 构建 v2 EVENT 帧到 m_txBuf（ESP32 下次读事务时通过 DMA 输出到 MISO）。
* 主动按铃帧使用 V2_FLAG_EVENT，session/seq 从 v2 状态全局变量取；
* session 未建立时 session_id 填 0。 */
const uint32_t sess = g_v2Active ? g_sessionId : 0U;
size_t built_len = 0U;
if (!v2_build_frame(frame_type, V2_FLAG_EVENT, sess,
g_txSeq, 0U, (uint8_t)g_localCredit,
payload, payload_len, m_txBuf, &built_len)) {
return false;
}
/* EVENT 帧占用一个发送序号槽位 */
if (g_v2Active) {
g_txSeq = (uint8_t)(g_txSeq + 1U);
}
m_ringTxLen = built_len;
m_txLen = built_len;
m_ringTxLen = (uint16_t)built_len;
m_txLen = (uint16_t)built_len;
m_txPos = 0U;
m_ringDeadline = SysTickTimer::getMs() + kRingTimeoutMs;
m_ringPending = true;
/* 消费完成 flag，等 ESP32 releaseReady 触发 EXTI6 上升沿 */
m_linkState.onRingStart();
/* 下拉 SPIready，通知 ESP32「我有请求帧要给你读」 */
setSpiReady(false);
/* v2 DATA_READY: 已设 m_ringPending=true 且 m_txLen>0，
* updateDataReady() 据此拉低 PB6，通知 ESP32「有待发数据」。 */
updateDataReady();
return true;
}
@@ -681,10 +712,8 @@ void AppSpiCommand::onCsAssert()
return;
}
m_csActive = true;
/* CS 下降沿立即拉低 PB6:表示从机即将忙碌，
* 防止主机在 onCsRelease 准备好响应前抢跑发起下一笔 CS。
* (若此帧被 shouldIgnoreTransaction 忽略,onCsRelease 会恢复 HIGH) */
setSpiReady(false);
/* v2 DATA_READY: CS 本身即互斥，PB6 不再表示「忙碌」，不在 CS 下降沿拉低。
* PB6 仅由 updateDataReady() 依据待发数据驱动，避免与队列语义冲突。 */
m_rxLen = 0U;
m_txPos = 0U;
m_txActiveThisCs = false;
@@ -740,24 +769,27 @@ void AppSpiCommand::onCsRelease()
/* 若本次 CS 事务是 ESP32 响应 GD32 按铃来读请求帧，
* 则 GD32 的请求帧已通过 DMA 输出到 MISO，取消按铃状态。
*
* 但需区分：ESP32 发的是 dummy 读（按铃响应）还是 0xB0 命令（OTA 请求）。
* 若 GD32 正在按铃时 ESP32 发 0xB0，会因 m_ringPending=true 被误吞，
* 导致 OTA 无法启动。检测到 0xB0 时取消按铃并走正常命令处理。 */
* 但需区分：ESP32 发的是 dummy 读（按铃响应）还是 v2 协议帧（如 PING/OTA/0xB0）。
* 若 GD32 正在按铃时 ESP32 发协议帧，会因 m_ringPending=true 被误吞，
* 导致命令无法处理。检测到 v2 SOF 时取消按铃并走正常命令处理。 */
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 (containsSyncSof(m_rxBuf, m_rxLen)) {
/* ESP32 发的是协议帧（如 PING/OTA 等），不是按铃响应。
/* 判断本次收到的数据是否为 v2 协议帧（扫描 SOF0 SOF1）。
* 取代旧 containsSyncSof，直接用 V2_SOF0/V2_SOF1。
* 0xB0 进 BOOT 现已走标准 v2 帧 handler，不再单独检测裸字节。 */
bool is_v2_frame = false;
if (m_rxLen >= 2U) {
const uint16_t last = (m_rxLen < 16U) ? (uint16_t)(m_rxLen - 1U) : 16U;
for (uint16_t i = 0U; i < last; ++i) {
if (m_rxBuf[i] == V2_SOF0 && m_rxBuf[i + 1U] == V2_SOF1) {
is_v2_frame = true;
break;
}
}
}
if (is_v2_frame) {
/* ESP32 发的是 v2 协议帧（如 PING/OTA/0xB0 等），不是按铃响应。
* 取消按铃，清空 TX 让 processCommand() 重新装载对应应答。
* 不释放 SPIready，processCommand() 末尾会释放。 */
* processCommand() 末尾由 updateDataReady() 依据新 m_txLen 驱动 PB6。 */
m_ringPending = false;
m_ringTxLen = 0U;
m_txLen = 0U;
@@ -772,8 +804,10 @@ void AppSpiCommand::onCsRelease()
m_txLen = 0U;
m_txPos = 0U;
memset(m_txBuf, 0xFF, sizeof(m_txBuf));
/* 释放 SPIready，通知 ESP32 本帧完成 */
setSpiReady(true);
/* v2 DATA_READY: 已清 m_txLen=0 与 m_ringPending=false，
* updateDataReady() 释放为高；ESP32 完成 CS 即视为已读走确认。 */
m_linkState.onEsp32Complete();
updateDataReady();
/* 上层若需要 ESP32 处理该请求帧，由 ESP32 侧读到的帧 TYPE 决定后续动作 */
return;
}
@@ -787,9 +821,9 @@ void AppSpiCommand::onCsRelease()
memset(m_txBuf, 0xFF, sizeof(m_txBuf));
}
m_txActiveThisCs = false;
/* 忽略事务(空轮询/残包)后恢复 PB6=HIGH，
* 避免 PB6 卡 LOW 导致 ESP32 等待上升沿超时 */
setSpiReady(true);
/* v2 DATA_READY: shouldIgnoreTransaction 路径已清 m_txLen=0，
* updateDataReady() 释放为高，避免 PB6 卡 LOW。 */
updateDataReady();
return;
}
GD32E508_DCU_APP/device/spi/app_spi_command.h
+29 -22
View File
@@ -6,26 +6,26 @@
class ISpiCommandHandler;
/**
* @brief GD32 侧 SPI 链路状态机：封装按铃状态 + ESP32 完成信号。
* @brief GD32 侧 SPI 链路状态机：封装按铃状态。
*
* 线状态语义（对齐 OTA）：
* - 线 HIGH = 空闲（双方释放），GD32 可发起新按铃
* - 线 LOW = 忙碌（GD32 按铃下拉 或 ESP32 checkGd32Request 期间下拉）
* v2 DATA_READY 语义：PB6 低 = 有待发数据，高 = 队列空。
* ESP32 不再操作 PB6，无独立「完成」信号；按铃完成由 ESP32
* 的 CS 读事务本身确认（onCsRelease 按铃响应路径调 onEsp32Complete）。
*
* 状态流转：
* - canRingNow()=true（初始/ESP32 完成后）→ requestEsp32Read() → canRingNow()=false
* - ESP32 releaseReady 上升沿 → onEsp32Complete() → canRingNow()=true
* - 按铃超时 → onRingTimeout() → canRingNow()=true（允许重试）
* canRingNow() 总是返回 true，由 requestEsp32Read() 的 m_ringPending
* 检查控制重复按铃。
*/
class SpiLinkState {
public:
/** 是否允许发起新按铃（ESP32 已完成上一帧 或 初始态）。 */
bool canRingNow() const { return m_esp32Ready; }
/** 是否允许发起新按铃。
* v2 DATA_READY: ESP32 不再操作 PB6，无独立完成信号；
* 总是允许，由 requestEsp32Read() 的 m_ringPending 检查控制重复。 */
bool canRingNow() const { return true; }
/** 发起按铃时调用（消费完成 flag）。 */
/** 发起按铃时调用（v2 下仅保留兼容写法，无实际门禁作用）。 */
void onRingStart() { m_esp32Ready = false; }
/** ESP32 releaseReady 上升沿触发（EXTI6 ISR 调用）。 */
/** ESP32 CS 读事务完成确认（onCsRelease 按铃响应路径调用）。 */
void onEsp32Complete() { m_esp32Ready = true; }
/** 按铃超时取消时调用（允许重试，不依赖 EXTI）。 */
@@ -48,14 +48,14 @@ private:
* 具体命令处理逻辑不再放在这里，而是拆到 device/spi/app_spi_cmd_*.cpp，
* 通过 registerHandler() 注册进来，保持本模块可扩展。
*
* 握手架构（线与 SPIready，PB6<->ESP32 GPIO10 开漏单线）：
* - 空闲态线 HIGH（双方释放，靠上拉）。
* - ESP32 主动发起：下拉 SPIready -> 立刻 CS 发请求 -> CS 释放后保持下拉，
* GD32 在 onCsRelease() ISR 内完成帧处理+响应装载后释放 SPIready（高），
* ESP32 检测到上升沿后发起 CS#2 读响应。
* - GD32 主动按铃：下拉 SPIready -> ESP32 下降沿中断唤醒后发起读事务，
* GD32 在 onCsRelease() 中装入请求帧并释放 SPIready。
* 握手架构（v2 DATA_READY，PB6<->ESP32 GPIO10 开漏单线）：
* - PB6 低 = 有待发数据（m_txLen>0 或 m_ringPending），高 = 队列空。
* - ESP32 主动发起：CS 发请求，CS 释放后 GD32 在 onCsRelease() ISR 内
* 完成帧处理+响应装载，由 updateDataReady() 据 m_txLen 驱动 PB6。
* - GD32 主动按铃：requestEsp32Read() 设 m_ringPending=true 且 m_txLen>0，
* updateDataReady() 拉低 PB6，ESP32 检测下降沿后发起读事务读走请求帧。
* - PB6 配置为开漏输出，setSpiReady(true)=高阻释放，setSpiReady(false)=下拉。
* - ESP32 不再操作 PB6，EXTI6 上升沿仅清标志，无业务含义。
*/
class AppSpiCommand {
public:
@@ -71,7 +71,8 @@ public:
/** @brief CS 边沿中断处理入口。 */
void onCsExtiInterrupt();
/** @brief SPI Ready(PB6) EXTI 上升沿中断处理入口（ESP32 完成信号）。 */
/** @brief SPI Ready(PB6) EXTI6 中断入口。
* v2 DATA_READY: ESP32 不再操作 PB6，EXTI6 仅清标志。 */
void onSpiReadyExti();
/**
@@ -120,6 +121,10 @@ public:
/** @brief 查询当前是否有未读按铃（ESP32 尚未来读）。 */
bool isRingPending() const { return m_ringPending; }
/** @brief 取消未完成的按铃（释放 SPIready、清 m_ringPending）。
* 0xB0 进 BOOT 等路径需公开调用，避免 0xC1 残留盖住 ACK。 */
void cancelRing();
/** @brief 查询 ESP32 是否已完成上一帧处理（SPIready 上升沿触发）。
* 初始为 true 允许第一次按铃；每次 requestEsp32Read 后置 false，
* ESP32 releaseReady 产生上升沿后由 EXTI 置 true。 */
@@ -172,8 +177,10 @@ private:
*/
void setSpiReady(bool ready);
/** @brief 取消未完成的按铃（释放 SPIready、清 m_ringPending）。 */
void cancelRing();
/** @brief v2 DATA_READY 语义：依据待发数据驱动 PB6。
* PB6 低 = 有待发数据（m_txLen>0 或 m_ringPending），高 = 队列空。
* 替代旧 BUSY/READY 语义中所有 setSpiReady 调用。 */
void updateDataReady();
};
/**
GD32E508_DCU_APP/device/spi/app_spi_command_defs.h
+3 -3
View File
@@ -14,7 +14,9 @@
namespace SpiDefs {
static constexpr uint8_t kSof = 0xA5U;
/* 链路层帧类型（v2） */
static constexpr uint8_t kTypeLinkHello = 0x00U;
static constexpr uint8_t kTypeLinkError = 0x7FU;
/* 帧类型 */
static constexpr uint8_t kTypeOtaReq = 0x01U;
@@ -32,8 +34,6 @@ static constexpr uint8_t kRspAck = 0x80U;
static constexpr uint8_t kRspWait = 0x81U;
static constexpr uint8_t kRspError = 0x82U;
static constexpr uint16_t kFrameOverhead = 5U;
} // namespace SpiDefs
#endif /* DEVICE_APP_SPI_COMMAND_DEFS_H */
GD32E508_DCU_APP/sys/ota_boot_request.cpp
+30 -9
View File
@@ -90,6 +90,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;
volatile bool OtaBootRequest::s_spiFrozenForBoot = false;
/**
* @brief 初始化进入 Bootloader 请求模块的运行态。
@@ -98,6 +99,7 @@ void OtaBootRequest::init()
{
s_rebootPending = false;
s_bootRequestPending = false;
s_spiFrozenForBoot = false;
}
/**
@@ -115,6 +117,9 @@ bool OtaBootRequest::requestEnterBoot()
if(ok) {
s_rebootPending = true;
} else {
/* 写配置页失败则永远停在 APP，ESP32 会看到持续 role=1 */
/* 无 printf 依赖：由调用方 process() 恢复 SPI 后继续运行 */
}
return ok;
}
@@ -127,6 +132,9 @@ bool OtaBootRequest::requestEnterBoot()
void OtaBootRequest::requestEnterBootAsync()
{
s_bootRequestPending = true;
/* 立即冻结 SPI 业务：不必等 process()（原依赖 1Hz 心跳，最坏拖 ~1s）。
* 否则 ESP32 紧跟着 HELLO/0xC1 会继续进 processCommand，干扰擦页/复位。 */
s_spiFrozenForBoot = true;
}
/**
@@ -157,13 +165,25 @@ bool OtaBootRequest::handleCanFrame(uint8_t channel, uint32_t id, const uint8_t
*/
void OtaBootRequest::process()
{
/* 异步处理 0xB0 请求：在主循环执行 Flash 操作（20-30ms），不阻塞 SPI ISR */
/* 异步处理 0xB0：主循环写 Flash（可能擦页 20–30ms）。
* 期间冻结 SPI 业务处理，避免 ESP32 紧跟着 HELLO/按铃读 打断擦写。 */
if(s_bootRequestPending) {
s_bootRequestPending = false;
s_spiFrozenForBoot = true;
nvic_irq_disable(SPI0_IRQn);
nvic_irq_disable(EXTI10_15_IRQn);
nvic_irq_disable(EXTI5_9_IRQn);
const bool ok = requestEnterBoot();
if(ok) {
s_rebootPending = true;
if(!ok) {
s_spiFrozenForBoot = false;
nvic_irq_enable(SPI0_IRQn, 2U, 0U);
nvic_irq_enable(EXTI10_15_IRQn, 1U, 1U);
nvic_irq_enable(EXTI5_9_IRQn, CONFIG_IRQ_PREEMPT_SPI_USART, 1U);
/* requestEnterBoot 失败时 s_rebootPending 仍为 false */
return;
}
s_rebootPending = true;
}
if(!s_rebootPending) {
@@ -171,13 +191,14 @@ void OtaBootRequest::process()
}
s_rebootPending = false;
s_spiFrozenForBoot = true;
nvic_irq_disable(SPI0_IRQn);
nvic_irq_disable(EXTI10_15_IRQn);
nvic_irq_disable(EXTI5_9_IRQn);
/* 方案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);
/* v2 DATA_READY: Boot 切换不再用 PB6 通知对端，
* BOOT 起机后再由 HELLO role=boot 确认。 */
/* SysTick 中断仍开，delayMs 可用；SPI 相关 IRQ 已关。 */
SysTickTimer::delayMs(kRebootDelayMs);
__disable_irq();
NVIC_SystemReset();
GD32E508_DCU_APP/sys/ota_boot_request.h
+8 -3
View File
@@ -42,13 +42,18 @@ public:
/** @brief 若已确认进入 BOOT 请求，则延迟片刻后复位。 */
static void process();
/** @brief 查询是否已收到进入 Bootloader 请求（等待复位中）。
* 供主循环在复位前停止主动按铃等可能干扰 OTA 的操作。 */
static bool isRebootPending() { return s_rebootPending; }
/** @brief 查询是否已进入“即将进 BOOT”路径（异步 pending 或已写标志待复位）。
* 供 CAN 按铃等模块在复位前停止干扰 SPI 的操作。 */
static bool isRebootPending() { return s_rebootPending || s_bootRequestPending; }
/** @brief SPI 命令路径查询：true 时忽略业务帧，仅释放 ready。 */
static bool isSpiFrozenForBoot() { return s_spiFrozenForBoot; }
private:
static volatile bool s_rebootPending;
static volatile bool s_bootRequestPending; ///< 0xB0 异步请求标志，process() 中执行 Flash 操作
/** 写 OTA 配置页期间冻结 SPI 业务，避免 Flash 擦写与 SPI ISR 互踩。 */
static volatile bool s_spiFrozenForBoot;
};
#endif /* SYS_OTA_BOOT_REQUEST_H */
GD32E508_DCU_APP/sys/task_runner.cpp
+6
View File
@@ -367,6 +367,12 @@ void TaskRunner::runPending()
* 放在 canFeedbackPushStep() 前确保卡死的按铃先被清掉再推送下一帧。 */
AppSpiCommandBus.poll();
/* 0xB0 进 BOOT：必须每圈检查，不能只靠 1Hz TASK_HEARTBEAT。
* 否则 Flash 写/复位被拖到下一秒，ESP32 HELLO 一直 role=app 超时。 */
if (OtaBootRequest::isRebootPending()) {
OtaBootRequest::process();
}
/* CAN 反馈主动推送：GD32 APP 循环推送 3 通道 × 2 页反馈帧到 ESP32，
* 替代 ESP32 主动轮询。非阻塞：上一帧未读走时立即返回。
* 每次主循环迭代调用一次，ESP32 读走一帧后 CS 释放中断唤醒主循环继续推送。 */