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

fix(spi-ota): SPI刷写初版已可完整进行刷写流程

Browse Source 
- 在SPI OTA ISR处理函数入口立即设置已响应标志，防止帧被重复处理，避免状态机错误推进
- 修正DMA启动前预填SPI发送缓冲区，覆盖旧字节，解决MISO线输出旧ACK字节导致序号错位问题
- 改为SPI从机内部NSS固定低电平，防止因EXTI延迟丢失首字节，提升帧接收稳定性
- 优化CS下降沿处理流程，确保DMA停止后重新配置并启动，避免数据丢失和标志位误触发
- CS上升沿停止DMA但保持内部NSS低电平，提高下一次事务的接收连续性
- SPI中断处理加入对上次事务提前检测和补充分支，增强系统鲁棒性
- 降低调试打印频率，减少ISR日志开销
- 修复看门狗复位检测代码，阻止BOOT跳转至卡死的APP，进入等待OTA修复模式
- 在工程配置文件中添加bin格式输出支持
This commit is contained in:
cbb
2026-05-30 00:35:56 +08:00
parent 8590d327e6
commit ea7a885de4
8 changed files with 1406 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files
GD32E50X_BOOT/GD32E50X_BOOT.cproject.yml
+1
View File
@@ -28,6 +28,7 @@ project:
type:
- elf
- hex
- bin
- map
components:
GD32E50X_BOOT/device/SpiOta.cpp
+60 -11
View File
@@ -179,17 +179,30 @@ void SpiOta::isrProcessFrame() {
u16 rx_len = s_rxStreamLen;
if (rx_len == 0U) { return; }
/* 关键修复：一旦开始处理本次 CS 周期中的完整帧，立刻标记“已响应/已处理”。
*
* 否则会出现这样的竞态：
* 1) SPI0 RBNE IRQ 在收到最后一个字节后调用 isrProcessFrame()
* 2) 还没执行到函数尾部的 s_isrResponded = true
* 3) CS 已经上升，优先级更高的 EXTI IRQ 抢占进来执行 onCsRelease()
* 4) onCsRelease() 看到 s_isrResponded 仍为 false，于是再次调用 isrProcessFrame()
* 5) 同一帧被重复处理一次，状态机被错误推进（如 challenge 又被当 confirm）
*
* 所以必须在函数入口就先置位，防止 REQ/DATA 被双重分发。 */
s_isrResponded = true;
if (rx_len >= 1U && s_rxStream[0] == SPI_OTA_CMD_BOOT) {
u8 ack[4] = {0xB0U, 0xA5U, 0x4FU, 0x54U};
queueTxFrame(ack, sizeof(ack));
if (s_otaHandler != nullptr) { s_otaHandler->resetToIdle(); }
s_otaSessionActive = false;
s_rxStreamLen = 0U;
isrLogFrameEx("[BOOT-CMD]", s_txBuf, s_txLen);
s_isrResponded = true;
return;
}
if (s_rxStream[0] != kSof) {
isrLogFrameEx("[NO-SOF]", s_rxStream, (rx_len < 8U) ? rx_len : 8U);
return;
}
if (rx_len < kFrameOverhead) { return; }
@@ -225,7 +238,8 @@ void SpiOta::isrProcessFrame() {
queueTxFrame(ack_frame, ack_len);
}
if (s_otaHandler != nullptr) { s_otaHandler->resetToIdle(); }
isrLogFrameEx("[BOOT-FRAME]", s_txBuf, s_txLen);
s_otaSessionActive = false;
s_rxStreamLen = 0U;
s_isrResponded = true;
return;
}
@@ -234,11 +248,22 @@ void SpiOta::isrProcessFrame() {
s_otaSessionActive = true;
s_otaHandler->setTransportSender(sender);
ota_link_msg_type_t msg_type = mapMsgType(frame_type);
isrLogFrameEx("[OTA-MSG]", (const u8*)&frame_type, 1);
/* 精简诊断: 只记录帧类型+状态, 减少ISR日志开销 */
{
u8 diag[3] = {(u8)frame_type, (u8)(s_otaHandler ? s_otaHandler->getState() : 0xFFU),
(u8)p_len};
isrLogFrameEx("[OT]", diag, 3);
}
s_otaHandler->handleLinkMessage(msg_type, const_cast<u8 *>(payload), (u8)p_len);
}
isrLogFrameEx("[ISR-DONE]", s_txBuf, (s_txLen < 16U) ? s_txLen : 16U);
/* 精简: 只在非DATA包时记录响应帧内容, DATA包只记录ACK的seq */
if (frame_type != SPI_OTA_CMD_DATA) {
isrLogFrameEx("[RD]", s_txBuf, (s_txLen < 12U) ? s_txLen : 12U);
} else {
/* DATA包响应: 只记录payload前6字节(=BAC0+seq) */
isrLogFrameEx("[RD]", s_txBuf + 4, (s_txLen > 10U) ? 6U : (s_txLen > 4U ? s_txLen - 4U : 0U));
}
s_isrResponded = true;
}
@@ -367,6 +392,7 @@ void SpiOta::init() {
s_txLen = 0U;
s_txPending = false;
s_isrLogPending = false;
s_otaSessionActive = false;
memset(s_rxStream, 0, sizeof(s_rxStream));
memset(s_txBuf, 0xFF, sizeof(s_txBuf));
configureGpio();
@@ -413,6 +439,30 @@ void SpiOta::onCsAssert() {
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) &= ~DMA_CHXCTL_CHEN;
spi_dma_disable(SPI0, SPI_DMA_TRANSMIT);
/* 1.5 覆盖 SPI 发送缓冲区 (TBE) 中的旧字节
*
* 关键修复：CS 高期间，queueTxFrame() 会把新 ACK 帧写入 s_txBuf
* 并启动 DMA，DMA 把 s_txBuf[0] 写入 SPI_DATA (TBE 缓冲区)。
* CS 高时没有外部 SCK，TBE 中的字节停留在发送缓冲区不会被移位输出。
*
* 当 ESP32 下次 CS↓ 时，onCsAssert() 重启 DMA，但 TBE 中已经有
* 旧字节。如果 ESP32 第一个 SCK 边沿在 DMA 写入新数据之前到达，
* MISO 上先输出 TBE 中的旧字节，然后 DMA 才开始推 s_txBuf[0]。
* 这导致 MISO 上第一个字节是旧 ACK 帧的残留，ESP32 的
* spi_ota_find_frame 先匹配到旧帧，拿到比期望少 1 的 seq 号
* （"差一拍" 现象）。
*
* 修复：在重启 DMA 前，写 0xFF 到 SPI_DATA 覆盖 TBE 中的旧字节。
* 这样即使 ESP32 第一个 SCK 先到，MISO 输出的是 0xFF 而非旧 ACK 残留。
* spi_ota_find_frame 会跳过 0xFF（不是 SOF=0xA5），从后面 DMA 推出的
* 正确帧开始匹配。
*/
spi_i2s_data_transmit(SPI0, 0xFFU);
/* 如果 TBE FIFO 有两层，再写一个 0xFF 确保覆盖 */
if (spi_i2s_flag_get(SPI0, SPI_FLAG_TBE) != RESET) {
spi_i2s_data_transmit(SPI0, 0xFFU);
}
/* 2. 清残留错误标志
*
* 关键：这里绝不能在 CS↓ 时“顺手读掉 RBNE”。
@@ -470,8 +520,9 @@ void SpiOta::onCsRelease() {
* 这样能直接判断：
* 1) 是不是完整收到了 ESP32 发来的整帧
* 2) 还是只收到了首字节 A5 / 少数字节，导致永远无法解析回包 */
/* 精简: CS-RX只记录前4字节, 减少ISR日志开销 */
if (s_rxStreamLen > 0U) {
isrLogFrame("[CS-RX]", s_rxStream, (s_rxStreamLen < 12U) ? s_rxStreamLen : 12U);
isrLogFrame("[CR]", s_rxStream, (s_rxStreamLen < 4U) ? s_rxStreamLen : 4U);
}
if (s_rxStreamLen > 0U && !s_isrResponded) {
@@ -511,7 +562,6 @@ void SpiOta::onSpiInterrupt() {
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RXORERR) != RESET) {
(void)spi_i2s_data_receive(SPI0);
s_rxStreamLen = 0U;
isrLogFrame("[RXOR]", (const u8*)"OVR", 3);
}
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_FERR) != RESET) {
spi_i2s_format_error_clear(SPI0, SPI_FLAG_FERR);
@@ -547,14 +597,13 @@ void SpiOta::poll() {
}
if (s_otaHandler != nullptr) { s_otaHandler->process(); }
/* 调试:定期打印 SPI 从机状态 */
/* 调试:定期打印 SPI 从机状态 — 降低频率, 每20000次才打印一次 */
static u32 dbg_tick = 0;
dbg_tick++;
if ((dbg_tick % 5000U) == 0U) {
printf("[SPI] csActive=%u rxLen=%u txPend=%u txLen=%u isrResp=%u otaState=%u\r\n",
if ((dbg_tick % 20000U) == 0U) {
printf("[SPI] st=%u rx=%u tx=%u ota=%u\r\n",
(unsigned)s_csActive, (unsigned)s_rxStreamLen,
(unsigned)s_txPending, (unsigned)s_txLen,
(unsigned)s_isrResponded,
(unsigned)s_txLen,
(unsigned)(s_otaHandler ? s_otaHandler->getState() : 0xFF));
}
}
GD32E50X_BOOT/device/SpiOta.cpp.bak_20260528
+608
View File
@@ -0,0 +1,608 @@
#include "SpiOta.h"
#include "core_cm33.h"
#include "gd32e50x_gpio.h"
#include "gd32e50x_exti.h"
#include "gd32e50x_rcu.h"
#include "gd32e50x_misc.h"
#include "gd32e50x_spi.h"
#include "gd32e50x_dma.h"
#include <stdio.h>
#include <string.h>
/**
* @file SpiOta.cpp
* @brief Bootloader SPI OTA 从机模块实现(DMA 发送版)。
*
* CS 释放后,EXTI ISR 直接完成帧校验+处理+响应准备,
* 响应帧写入 s_txBuf,DMA0_CH2 自动推到 SPI0 TX 寄存器。
* 硬件 DMA 替代 TBE 中断逐字节发送,消除字节错位问题。
*
* GD32E50x DMA 通道映射(固定):
* DMA0_CH0: ADC0, DMA0_CH1: SPI0_RX, DMA0_CH2: SPI0_TX
* DMA0_CH3: SPI1_RX, DMA0_CH4: SPI1_TX
*/
/* SPI0_TX = DMA0_CH2 (GD32E50x 固定映射) */
#define SPI_TX_DMA_PERIPH DMA0
#define SPI_TX_DMA_CH DMA_CH2
/* 调试：多缓冲日志（8 条 ISR 日志缓冲区，避免关键事件丢失） */
static constexpr u16 kLogSlotCount = 8U;
static constexpr u16 kLogSlotSize = 80U;
static u8 s_logSlots[kLogSlotCount][kLogSlotSize] = {};
static u16 s_logSlotLens[kLogSlotCount] = {};
static volatile u8 s_logWriteIdx = 0U;
static volatile u8 s_logReadIdx = 0U;
static volatile u8 s_logCount = 0U;
static void isrLogFrameEx(const char *tag, const u8 *data, u16 len);
OTAHandler *SpiOta::s_otaHandler = nullptr;
volatile bool SpiOta::s_csActive = false;
volatile u16 SpiOta::s_rxStreamLen = 0U;
volatile u16 SpiOta::s_txStreamPos = 0U;
u8 SpiOta::s_rxStream[SpiOta::kRxBufSize] = {};
u8 SpiOta::s_txBuf[SpiOta::kTxBufSize] = {};
volatile u16 SpiOta::s_txLen = 0U;
volatile bool SpiOta::s_txPending = false;
volatile bool SpiOta::s_isrResponded = false;
volatile bool SpiOta::s_isrLogPending = false;
volatile bool SpiOta::s_otaSessionActive = false;
u8 SpiOta::s_isrLogBuf[kIsrLogBufSize] = {};
u16 SpiOta::s_isrLogLen = 0U;
/* ============================================================
* CRC8 / 帧构建 / 帧解析
* ============================================================ */
u8 SpiOta::crc8(const u8 *data, u16 len) {
u8 crc = 0x00U;
for (u16 i = 0; i < len; ++i) { crc ^= data[i]; }
return crc;
}
bool SpiOta::buildFrame(spi_ota_frame_type_t type, const u8 *payload, u16 payload_len,
u8 *out, u16 *out_len) {
if (!out || !out_len) { return false; }
u16 total_len = (u16)(kFrameOverhead + payload_len);
if (total_len > kTxBufSize) { return false; }
out[0] = kSof;
out[1] = (u8)type;
out[2] = (u8)(payload_len & 0xFFU);
out[3] = (u8)((payload_len >> 8) & 0xFFU);
if (payload && payload_len > 0U) { memcpy(&out[4], payload, payload_len); }
out[4 + payload_len] = crc8(out, (u16)(4U + payload_len));
*out_len = total_len;
return true;
}
bool SpiOta::tryParseFrame(const u8 *frame, u16 frame_len,
spi_ota_frame_type_t *type,
const u8 **payload,
u16 *payload_len) {
if (!frame || frame_len < kFrameOverhead) { return false; }
if (frame[0] != kSof) { return false; }
u16 len = (u16)(frame[2] | ((u16)frame[3] << 8));
u16 expected = (u16)(kFrameOverhead + len);
if (expected != frame_len) { return false; }
if (crc8(frame, (u16)(4U + len)) != frame[4U + len]) { return false; }
if (type) { *type = (spi_ota_frame_type_t)frame[1]; }
if (payload) { *payload = &frame[4]; }
if (payload_len){ *payload_len = len; }
return true;
}
ota_link_msg_type_t SpiOta::mapMsgType(spi_ota_frame_type_t type) {
switch (type) {
case SPI_OTA_CMD_REQ: return OTA_LINK_MSG_REQ;
case SPI_OTA_CMD_DATA: return OTA_LINK_MSG_DATA;
default: return OTA_LINK_MSG_CANCEL;
}
}
/* ============================================================
* 回包发送适配器(ISR 安全)
* ============================================================ */
void SpiOta::sender(ota_link_tx_type_t type, u8 len, const u8 *data) {
spi_ota_frame_type_t rsp_type = SPI_OTA_RSP_ACK;
if (type == OTA_LINK_TX_WAIT) { rsp_type = SPI_OTA_RSP_WAIT; }
u8 frame_buf[kTxBufSize] = {};
u16 built_len = 0U;
if (buildFrame(rsp_type, data, len, frame_buf, &built_len)) {
queueTxFrame(frame_buf, built_len);
}
}
uint32_t SpiOta::enterCritical() {
uint32_t primask = __get_PRIMASK();
__disable_irq();
return primask;
}
void SpiOta::exitCritical(uint32_t primask) {
__set_PRIMASK(primask);
}
/** @brief 启动 DMA 传输 s_txBuf → SPI0_DATA */
static void startSpiTxDma(const u8 *buf, u16 len) {
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) &= ~DMA_CHXCTL_CHEN;
DMA_INTC(SPI_TX_DMA_PERIPH) |= DMA_FLAG_ADD(DMA_CHINTF_RESET_VALUE, SPI_TX_DMA_CH);
DMA_CHMADDR(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) = (uint32_t)buf;
DMA_CHCNT(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) = len;
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) |= DMA_CHXCTL_CHEN;
}
void SpiOta::queueTxFrame(const u8 *frame, u16 len) {
if (!frame || len == 0U || len > kTxBufSize) { return; }
uint32_t primask = enterCritical();
memcpy(s_txBuf, frame, len);
s_txLen = len;
s_txPending = true;
s_txStreamPos = 0U;
if (len < kTxBufSize) { memset(&s_txBuf[len], 0xFF, kTxBufSize - len); }
exitCritical(primask);
spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
startSpiTxDma(s_txBuf, s_txLen);
}
/* ============================================================
* RBNE 中断内即时帧检测与处理
* ============================================================ */
void SpiOta::tryProcessCompleteFrame() {
u16 rx_len = s_rxStreamLen;
if (rx_len == 0U) { return; }
if (s_rxStream[0] == SPI_OTA_CMD_BOOT) {
isrProcessFrame();
return;
}
if (s_rxStream[0] != kSof) { return; }
if (rx_len < kFrameOverhead) { return; }
u16 payload_len = (u16)(s_rxStream[2] | ((u16)s_rxStream[3] << 8));
u16 expected = (u16)(kFrameOverhead + payload_len);
if (expected > kRxBufSize) { return; }
if (rx_len < expected) { return; }
isrProcessFrame();
}
/* ============================================================
* CS 释放后 ISR 直接帧处理
* ============================================================ */
void SpiOta::isrProcessFrame() {
u16 rx_len = s_rxStreamLen;
if (rx_len == 0U) { return; }
if (rx_len >= 1U && s_rxStream[0] == SPI_OTA_CMD_BOOT) {
u8 ack[4] = {0xB0U, 0xA5U, 0x4FU, 0x54U};
queueTxFrame(ack, sizeof(ack));
if (s_otaHandler != nullptr) { s_otaHandler->resetToIdle(); }
isrLogFrameEx("[BOOT-CMD]", s_txBuf, s_txLen);
s_isrResponded = true;
return;
}
if (s_rxStream[0] != kSof) {
isrLogFrameEx("[NO-SOF]", s_rxStream, (rx_len < 8U) ? rx_len : 8U);
return;
}
if (rx_len < kFrameOverhead) { return; }
u16 payload_len = (u16)(s_rxStream[2] | ((u16)s_rxStream[3] << 8));
u16 expected = (u16)(kFrameOverhead + payload_len);
if (expected > rx_len) { return; }
if (crc8(s_rxStream, (u16)(4U + payload_len)) != s_rxStream[4U + payload_len]) {
u8 err = 0xEEU;
u8 err_frame[kTxBufSize] = {};
u16 built = 0U;
if (buildFrame(SPI_OTA_RSP_ERROR, &err, 1U, err_frame, &built)) {
queueTxFrame(err_frame, built);
}
isrLogFrameEx("[CRC-ERR]", s_rxStream, (rx_len < 8U) ? rx_len : 8U);
return;
}
spi_ota_frame_type_t frame_type;
const u8 *payload = nullptr;
u16 p_len = 0U;
if (!tryParseFrame(s_rxStream, expected, &frame_type, &payload, &p_len)) {
isrLogFrameEx("[PARSE-ERR]", s_rxStream, (rx_len < 8U) ? rx_len : 8U);
return;
}
if (frame_type == SPI_OTA_CMD_BOOT) {
u8 ack_ok = 0xA5U;
u8 ack_frame[kTxBufSize] = {};
u16 ack_len = 0U;
if (buildFrame(SPI_OTA_RSP_ACK, &ack_ok, 1U, ack_frame, &ack_len)) {
queueTxFrame(ack_frame, ack_len);
}
if (s_otaHandler != nullptr) { s_otaHandler->resetToIdle(); }
isrLogFrameEx("[BOOT-FRAME]", s_txBuf, s_txLen);
s_isrResponded = true;
return;
}
if (s_otaHandler != nullptr) {
s_otaSessionActive = true;
s_otaHandler->setTransportSender(sender);
ota_link_msg_type_t msg_type = mapMsgType(frame_type);
isrLogFrameEx("[OTA-MSG]", (const u8*)&frame_type, 1);
s_otaHandler->handleLinkMessage(msg_type, const_cast<u8 *>(payload), (u8)p_len);
}
isrLogFrameEx("[ISR-DONE]", s_txBuf, (s_txLen < 16U) ? s_txLen : 16U);
s_isrResponded = true;
}
/* ============================================================
* ISR 内延迟日志
* ============================================================ */
void SpiOta::isrLogFrame(const char *tag, const u8 *data, u16 len) {
isrLogFrameEx(tag, data, len);
}
static void isrLogFrameEx(const char *tag, const u8 *data, u16 len) {
if (s_logCount >= kLogSlotCount) { return; }
u8 *buf = s_logSlots[s_logWriteIdx];
u16 pos = 0U;
if (tag) {
while (*tag && pos < kLogSlotSize - 3U) { buf[pos++] = (u8)*tag++; }
buf[pos++] = ' ';
}
const u16 preview = (len < 24U) ? len : 24U;
for (u16 i = 0U; i < preview && pos + 2U < kLogSlotSize; ++i) {
static const char hx[] = "0123456789ABCDEF";
buf[pos++] = (u8)hx[data[i] >> 4];
buf[pos++] = (u8)hx[data[i] & 0x0FU];
}
buf[pos] = 0U;
s_logSlotLens[s_logWriteIdx] = pos;
s_logWriteIdx = (s_logWriteIdx + 1U) % kLogSlotCount;
s_logCount++;
}
/* ============================================================
* 硬件初始化
* ============================================================ */
void SpiOta::configureGpio() {
rcu_periph_clock_enable(RCU_GPIOA);
rcu_periph_clock_enable(RCU_GPIOB);
rcu_periph_clock_enable(RCU_AF);
gpio_pin_remap_config(GPIO_SPI0_REMAP, ENABLE);
gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP, ENABLE);
gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
}
void SpiOta::configureSpi0() {
rcu_periph_clock_enable(RCU_SPI0);
spi_i2s_deinit(SPI0);
(void)spi_i2s_data_receive(SPI0); /* 清空 SPI_DATA 残留值 */
spi_parameter_struct spi_init_struct;
spi_struct_para_init(&spi_init_struct);
spi_init_struct.device_mode = SPI_SLAVE;
spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
spi_init_struct.frame_size = SPI_FRAMESIZE_8BIT;
spi_init_struct.nss = SPI_NSS_SOFT;
spi_init_struct.endian = SPI_ENDIAN_MSB;
/* SPI NSS 由 ESP32 的 CS 线 (GPIO4→PA15) 控制。\外部 CS 高时：
* spi_nss_internal_high(SPI0) 让 SPI 外设进入未选中状态，
* 这样 SPI0_DATA 输出 0xFF（而非 0x00），
* DMA 只在 CS 低时才被 SPI 外设允许推数据到 MISO。 */
spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;
spi_init_struct.prescale = SPI_PSC_8;
spi_init(SPI0, &spi_init_struct);
/* 关键修正：内部 NSS 始终保持 LOW，使 SPI0 从机一直处于“已选中”状态。
*
* APP 侧的稳定实现就是这样做的：PA15 只作为 EXTI 事务边界信号，
* 不再依赖 EXTI ISR 去“赶在首个 SCK 之前”切 internal NSS。
*
* 之前 BOOT 的问题正出在这里：
* - 空闲时 spi_nss_internal_high(SPI0)
* - CS↓ 后靠 EXTI ISR 再切 internal_low
* - 但 ESP32 在 CS↓ 后几乎立刻出时钟
* - 于是 GD32 常常在 internal NSS 真正拉低前丢掉首字节/首几位
* → 请求帧首字节 0xA5 被吃掉，看到 0x80 / 0xFF / 随机 0x07
*
* 现在改为 internal NSS 常低：
* - SPI 从机始终就绪，不会因为 EXTI 延迟丢首字节
* - PA15 仍用于 onCsAssert/onCsRelease 做缓冲区清零和 DMA 重装
*/
spi_nss_internal_low(SPI0);
/* 初始化时清空 SPI_DATA 寄存器，防止残留值影响首次传输 */
(void)spi_i2s_data_receive(SPI0);
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);
/* SPI0 RBNE 中断优先级设为 (2, 0)，低于 EXTI CS 中断 (1, 1)。
* 这确保 CS 下降沿的 onCsAssert() 在任何 RBNE 之前执行，
* 否则 s_csActive 仍为 false，RBNE 中断丢弃接收字节。 */
nvic_irq_enable(SPI0_IRQn, 2U, 0U);
spi_enable(SPI0);
}
void SpiOta::configureDma() {
rcu_periph_clock_enable(RCU_DMA0);
dma_deinit(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH);
dma_parameter_struct dma_init_struct;
dma_struct_para_init(&dma_init_struct);
dma_init_struct.periph_addr = (uint32_t)(SPI0 + 0x0CU);
dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
dma_init_struct.memory_addr = (uint32_t)s_txBuf;
dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
dma_init_struct.number = 0U;
dma_init_struct.priority = DMA_PRIORITY_HIGH;
dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
dma_init(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH, &dma_init_struct);
dma_circulation_disable(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH);
dma_channel_disable(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH);
}
void SpiOta::configureExti() {
gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_15);
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, 1U, 1U);
}
void SpiOta::init() {
s_csActive = false;
s_rxStreamLen = 0U;
s_txStreamPos = 0U;
s_txLen = 0U;
s_txPending = false;
s_isrLogPending = false;
memset(s_rxStream, 0, sizeof(s_rxStream));
memset(s_txBuf, 0xFF, sizeof(s_txBuf));
configureGpio();
configureDma();
configureSpi0();
configureExti();
}
/* ============================================================
* CS 边沿处理
* ============================================================ */
void SpiOta::onCsAssert() {
if (s_csActive) { return; }
s_csActive = true;
s_rxStreamLen = 0U;
s_txStreamPos = 0U;
s_isrResponded = false;
/* 内部 NSS 已在初始化时常置 LOW，这里不再依赖 EXTI 时序切 NSS。
* PA15 仅作为“事务开始”的边界信号，用于清接收缓冲和重装 DMA。 */
/* 关键修复：先彻底停止 DMA，再重新配置并启动。
*
* 上一版预填 SPI_DATA 方案失败原因：
* spi_i2s_data_transmit() 写入的字节进入 TBE 发送缓冲区。
* 当 ESP32 第一个 SCK 边沿到来时，TBE 的预填字节被移入移位
* 寄存器推到 MISO，同时移位寄存器中的 MOSI 数据被推入 RBNE。
* 但 GD32E50x SPI 的 RBNE 标志在 SPI_DATA 写入后可能被误触发，
* 导致 isrLogFrame 报出预填值（如 0x80）而非 MOSI 真实数据。
*
* 正确方案：不预填 SPI_DATA，而是确保 DMA 在 CS↓ 后、ESP32
* 第一个 SCK 边沿之前就绪。DMA 第一拍自动把 s_txBuf[0] 写入
* SPI_DATA，不会产生 RBNE 误触发。
*
* 操作顺序：
* 1. 禁 DMA 通道 + 禁 SPI DMA 请求（彻底停止旧传输）
* 2. 清 RBNE / RXORERR / FERR 等残留标志
* 3. 配置并启动 DMA（此时 RBNE 仍关闭，DMA 写 SPI_DATA 不会触发中断）
* 4. 重新使能 RBNE 中断，开始接收 MOSI 数据
*/
/* 1. 停止旧 DMA */
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) &= ~DMA_CHXCTL_CHEN;
spi_dma_disable(SPI0, SPI_DMA_TRANSMIT);
/* 2. 清残留错误标志
*
* 关键：这里绝不能在 CS↓ 时“顺手读掉 RBNE”。
*
* 因为 internal NSS 现在常 LOW，ESP32 在 CS↓ 后很快就会发出首字节 A5。
* 如果 EXTI ISR 略晚于 SPI 接收，A5 可能已经先进了 RX 缓冲并置位 RBNE。
* 这时若在 onCsAssert() 里执行 spi_i2s_data_receive()，就会把真实首字节 A5
* 当成“残留垃圾”吞掉，导致后续看到的首字节变成 0x01。
*
* 所以这里仅清真正的错误标志，不主动消费 RBNE。
* 已到达的首字节留给 onSpiInterrupt() 正常读走。 */
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RXORERR) != RESET) {
(void)spi_i2s_data_receive(SPI0);
}
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_FERR) != RESET) {
spi_i2s_format_error_clear(SPI0, SPI_FLAG_FERR);
}
/* 3. 配置并启动 DMA（RBNE 仍关闭，DMA 写 SPI_DATA 不会触发中断） */
if (s_txPending && s_txLen > 0U) {
spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
startSpiTxDma(s_txBuf, s_txLen);
} else {
s_txPending = false;
s_txLen = kTxBufSize;
memset(s_txBuf, 0xFF, kTxBufSize);
spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
startSpiTxDma(s_txBuf, s_txLen);
}
/* 4. 重新使能 RBNE 中断，开始接收 MOSI 数据 */
spi_i2s_interrupt_enable(SPI0, SPI_I2S_INT_RBNE);
}
void SpiOta::onCsRelease() {
if (!s_csActive) { return; }
s_csActive = false;
/* 内部 NSS 保持常 LOW，不在 CS↑ 时切回 HIGH。
* 这样 SPI 从机始终处于就绪态，下一次 CS↓ 不会因 EXTI 延迟丢首字节。
*
* 这里只停止 DMA，避免 CS 高期间继续空转消耗 s_txBuf 内容。
* s_txPending 保持不变——如果 ISR 已准备好 ACK 帧，
* 下次 CS↓ 时 onCsAssert 会重启 DMA 推出。 */
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) &= ~DMA_CHXCTL_CHEN;
spi_dma_disable(SPI0, SPI_DMA_TRANSMIT);
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RBNE) != RESET) {
u8 last_byte = (u8)(spi_i2s_data_receive(SPI0) & 0xFFU);
if (s_rxStreamLen < kRxBufSize) {
s_rxStream[s_rxStreamLen++] = last_byte;
}
}
/* 关键调试日志：记录本次 CS 周期结束时到底收到了多少字节。
* 这样能直接判断：
* 1) 是不是完整收到了 ESP32 发来的整帧
* 2) 还是只收到了首字节 A5 / 少数字节，导致永远无法解析回包 */
if (s_rxStreamLen > 0U) {
isrLogFrame("[CS-RX]", s_rxStream, (s_rxStreamLen < 12U) ? s_rxStreamLen : 12U);
}
if (s_rxStreamLen > 0U && !s_isrResponded) {
isrProcessFrame();
}
}
/* ============================================================
* SPI0 中断处理 — 只处理 RBNE（接收）和错误，TBE 已由 DMA 替代
* ============================================================ */
void SpiOta::onSpiInterrupt() {
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RBNE) != RESET) {
/* 与 APP 侧稳定实现保持一致：
* 如果 EXTI 下降沿因为中断时序略晚到达，但此时 PA15 已经为低，
* 则在首个 RBNE 到来时立即补做 onCsAssert()。
*
* 关键限制：只能在“本事务尚未收过任何字节”时补做。
* 否则若 EXTI / SPI 时序偶发抖动，重复 onCsAssert() 会把
* s_rxStreamLen 清零，导致已经收到的半帧被冲掉，最终永远拼不成完整帧。 */
if (!s_csActive && s_rxStreamLen == 0U && gpio_input_bit_get(GPIOA, GPIO_PIN_15) == RESET) {
onCsAssert();
}
u8 byte = (u8)(spi_i2s_data_receive(SPI0) & 0xFFU);
if (s_rxStreamLen < kRxBufSize) {
s_rxStream[s_rxStreamLen++] = byte;
}
/* 调试阶段先关闭 RBNE 首字节日志。
* 原因：ISR 日志缓冲是单槽的，RBNE 一旦先占位，
* onCsRelease() 里的 [CS-RX] 摘要日志就会被丢弃。
* 目前排查重点是“本次 CS 周期总共收到了哪些字节”，
* 所以优先保留 [CS-RX]，暂时关闭 [RBNE]。 */
tryProcessCompleteFrame();
}
/* TBE 已由 DMA 替代，不再处理 */
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RXORERR) != RESET) {
(void)spi_i2s_data_receive(SPI0);
s_rxStreamLen = 0U;
isrLogFrame("[RXOR]", (const u8*)"OVR", 3);
}
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_FERR) != RESET) {
spi_i2s_format_error_clear(SPI0, SPI_FLAG_FERR);
}
}
void SpiOta::onCsExtiInterrupt() {
if (exti_interrupt_flag_get(EXTI_15) != RESET) {
exti_interrupt_flag_clear(EXTI_15);
if (gpio_input_bit_get(GPIOA, GPIO_PIN_15) == RESET) { onCsAssert(); }
else { onCsRelease(); }
}
}
/* ============================================================
* 主循环接口
* ============================================================ */
void SpiOta::poll() {
if (s_isrResponded) {
s_isrResponded = false;
}
/* 打印 ISR 日志缓冲区 */
while (s_logCount > 0U) {
__disable_irq();
if (s_logCount == 0U) { __enable_irq(); break; }
u8 *buf = s_logSlots[s_logReadIdx];
u8 nextRead = (s_logReadIdx + 1U) % kLogSlotCount;
s_logReadIdx = nextRead;
s_logCount--;
__enable_irq();
printf("[SPI] %s\r\n", buf);
}
if (s_otaHandler != nullptr) { s_otaHandler->process(); }
/* 调试:定期打印 SPI 从机状态 */
static u32 dbg_tick = 0;
dbg_tick++;
if ((dbg_tick % 5000U) == 0U) {
printf("[SPI] csActive=%u rxLen=%u txPend=%u txLen=%u isrResp=%u otaState=%u\r\n",
(unsigned)s_csActive, (unsigned)s_rxStreamLen,
(unsigned)s_txPending, (unsigned)s_txLen,
(unsigned)s_isrResponded,
(unsigned)(s_otaHandler ? s_otaHandler->getState() : 0xFF));
}
}
void SpiOta::setSender(OTAHandler *handler) { s_otaHandler = handler; }
void SpiOta::feedRxBytes(const u8 *data, u16 len) {
if (!data || len == 0U || !s_csActive) { return; }
if (len > kRxBufSize) { data += (len - kRxBufSize); len = kRxBufSize; }
memcpy(s_rxStream, data, len);
s_rxStreamLen = len;
}
bool SpiOta::hasTxFrame() { return s_txPending; }
bool SpiOta::hasActiveSession() { return s_otaSessionActive; }
u16 SpiOta::copyTxFrame(u8 *out, u16 max_len) {
if (!out || max_len == 0U) { return 0U; }
uint32_t primask = enterCritical();
if (!s_txPending || s_txLen == 0U) { exitCritical(primask); return 0U; }
u16 copy_len = (s_txLen < max_len) ? s_txLen : max_len;
memcpy(out, s_txBuf, copy_len);
s_txPending = false;
s_txLen = 0U;
s_txStreamPos = 0U;
exitCritical(primask);
return copy_len;
}
/* ============================================================
* C 风格兼容包装
* ============================================================ */
void spi_ota_init(void) { SpiOta::init(); }
void spi_ota_poll(void) { SpiOta::poll(); }
void spi_ota_set_sender(OTAHandler *handler) { SpiOta::setSender(handler); }
void spi_ota_on_cs_assert(void) { SpiOta::onCsAssert(); }
void spi_ota_on_cs_release(void) { SpiOta::onCsRelease(); }
void spi_ota_gpio_init(void) { SpiOta::configureGpio(); }
void spi_ota_spi0_init(void) { SpiOta::configureSpi0(); }
void spi_ota_exti_init(void) { SpiOta::configureExti(); }
void spi_ota_irq_handler(void) { SpiOta::onSpiInterrupt(); }
void spi_ota_cs_exti_handler(void) { SpiOta::onCsExtiInterrupt(); }
void spi_ota_feed_rx_bytes(const u8 *data, u16 len) { SpiOta::feedRxBytes(data, len); }
bool spi_ota_has_tx_frame(void) { return SpiOta::hasTxFrame(); }
u16 spi_ota_copy_tx_frame(u8 *out, u16 max_len) { return SpiOta::copyTxFrame(out, max_len); }
extern "C" void SPI0_IRQHandler(void) {
SpiOta::onSpiInterrupt();
}
GD32E50X_BOOT/device/SpiOta.cpp.bak_20260529_txdebug
+626
View File
@@ -0,0 +1,626 @@
#include "SpiOta.h"
#include "core_cm33.h"
#include "gd32e50x_gpio.h"
#include "gd32e50x_exti.h"
#include "gd32e50x_rcu.h"
#include "gd32e50x_misc.h"
#include "gd32e50x_spi.h"
#include "gd32e50x_dma.h"
#include <stdio.h>
#include <string.h>
/**
* @file SpiOta.cpp
* @brief Bootloader SPI OTA 从机模块实现(DMA 发送版)。
*
* CS 释放后,EXTI ISR 直接完成帧校验+处理+响应准备,
* 响应帧写入 s_txBuf,DMA0_CH2 自动推到 SPI0 TX 寄存器。
* 硬件 DMA 替代 TBE 中断逐字节发送,消除字节错位问题。
*
* GD32E50x DMA 通道映射(固定):
* DMA0_CH0: ADC0, DMA0_CH1: SPI0_RX, DMA0_CH2: SPI0_TX
* DMA0_CH3: SPI1_RX, DMA0_CH4: SPI1_TX
*/
/* SPI0_TX = DMA0_CH2 (GD32E50x 固定映射) */
#define SPI_TX_DMA_PERIPH DMA0
#define SPI_TX_DMA_CH DMA_CH2
/* 调试：多缓冲日志（8 条 ISR 日志缓冲区，避免关键事件丢失） */
static constexpr u16 kLogSlotCount = 8U;
static constexpr u16 kLogSlotSize = 80U;
static u8 s_logSlots[kLogSlotCount][kLogSlotSize] = {};
static u16 s_logSlotLens[kLogSlotCount] = {};
static volatile u8 s_logWriteIdx = 0U;
static volatile u8 s_logReadIdx = 0U;
static volatile u8 s_logCount = 0U;
static void isrLogFrameEx(const char *tag, const u8 *data, u16 len);
OTAHandler *SpiOta::s_otaHandler = nullptr;
volatile bool SpiOta::s_csActive = false;
volatile u16 SpiOta::s_rxStreamLen = 0U;
volatile u16 SpiOta::s_txStreamPos = 0U;
u8 SpiOta::s_rxStream[SpiOta::kRxBufSize] = {};
u8 SpiOta::s_txBuf[SpiOta::kTxBufSize] = {};
volatile u16 SpiOta::s_txLen = 0U;
volatile bool SpiOta::s_txPending = false;
volatile bool SpiOta::s_isrResponded = false;
volatile bool SpiOta::s_isrLogPending = false;
volatile bool SpiOta::s_otaSessionActive = false;
u8 SpiOta::s_isrLogBuf[kIsrLogBufSize] = {};
u16 SpiOta::s_isrLogLen = 0U;
/* ============================================================
* CRC8 / 帧构建 / 帧解析
* ============================================================ */
u8 SpiOta::crc8(const u8 *data, u16 len) {
u8 crc = 0x00U;
for (u16 i = 0; i < len; ++i) { crc ^= data[i]; }
return crc;
}
bool SpiOta::buildFrame(spi_ota_frame_type_t type, const u8 *payload, u16 payload_len,
u8 *out, u16 *out_len) {
if (!out || !out_len) { return false; }
u16 total_len = (u16)(kFrameOverhead + payload_len);
if (total_len > kTxBufSize) { return false; }
out[0] = kSof;
out[1] = (u8)type;
out[2] = (u8)(payload_len & 0xFFU);
out[3] = (u8)((payload_len >> 8) & 0xFFU);
if (payload && payload_len > 0U) { memcpy(&out[4], payload, payload_len); }
out[4 + payload_len] = crc8(out, (u16)(4U + payload_len));
*out_len = total_len;
return true;
}
bool SpiOta::tryParseFrame(const u8 *frame, u16 frame_len,
spi_ota_frame_type_t *type,
const u8 **payload,
u16 *payload_len) {
if (!frame || frame_len < kFrameOverhead) { return false; }
if (frame[0] != kSof) { return false; }
u16 len = (u16)(frame[2] | ((u16)frame[3] << 8));
u16 expected = (u16)(kFrameOverhead + len);
if (expected != frame_len) { return false; }
if (crc8(frame, (u16)(4U + len)) != frame[4U + len]) { return false; }
if (type) { *type = (spi_ota_frame_type_t)frame[1]; }
if (payload) { *payload = &frame[4]; }
if (payload_len){ *payload_len = len; }
return true;
}
ota_link_msg_type_t SpiOta::mapMsgType(spi_ota_frame_type_t type) {
switch (type) {
case SPI_OTA_CMD_REQ: return OTA_LINK_MSG_REQ;
case SPI_OTA_CMD_DATA: return OTA_LINK_MSG_DATA;
default: return OTA_LINK_MSG_CANCEL;
}
}
/* ============================================================
* 回包发送适配器(ISR 安全)
* ============================================================ */
void SpiOta::sender(ota_link_tx_type_t type, u8 len, const u8 *data) {
spi_ota_frame_type_t rsp_type = SPI_OTA_RSP_ACK;
if (type == OTA_LINK_TX_WAIT) { rsp_type = SPI_OTA_RSP_WAIT; }
u8 frame_buf[kTxBufSize] = {};
u16 built_len = 0U;
if (buildFrame(rsp_type, data, len, frame_buf, &built_len)) {
queueTxFrame(frame_buf, built_len);
}
}
uint32_t SpiOta::enterCritical() {
uint32_t primask = __get_PRIMASK();
__disable_irq();
return primask;
}
void SpiOta::exitCritical(uint32_t primask) {
__set_PRIMASK(primask);
}
/** @brief 启动 DMA 传输 s_txBuf → SPI0_DATA */
static void startSpiTxDma(const u8 *buf, u16 len) {
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) &= ~DMA_CHXCTL_CHEN;
DMA_INTC(SPI_TX_DMA_PERIPH) |= DMA_FLAG_ADD(DMA_CHINTF_RESET_VALUE, SPI_TX_DMA_CH);
DMA_CHMADDR(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) = (uint32_t)buf;
DMA_CHCNT(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) = len;
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) |= DMA_CHXCTL_CHEN;
}
void SpiOta::queueTxFrame(const u8 *frame, u16 len) {
if (!frame || len == 0U || len > kTxBufSize) { return; }
uint32_t primask = enterCritical();
memcpy(s_txBuf, frame, len);
s_txLen = len;
s_txPending = true;
s_txStreamPos = 0U;
if (len < kTxBufSize) { memset(&s_txBuf[len], 0xFF, kTxBufSize - len); }
exitCritical(primask);
spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
startSpiTxDma(s_txBuf, s_txLen);
}
/* ============================================================
* RBNE 中断内即时帧检测与处理
* ============================================================ */
void SpiOta::tryProcessCompleteFrame() {
u16 rx_len = s_rxStreamLen;
if (rx_len == 0U) { return; }
if (s_rxStream[0] == SPI_OTA_CMD_BOOT) {
isrProcessFrame();
return;
}
if (s_rxStream[0] != kSof) { return; }
if (rx_len < kFrameOverhead) { return; }
u16 payload_len = (u16)(s_rxStream[2] | ((u16)s_rxStream[3] << 8));
u16 expected = (u16)(kFrameOverhead + payload_len);
if (expected > kRxBufSize) { return; }
if (rx_len < expected) { return; }
isrProcessFrame();
}
/* ============================================================
* CS 释放后 ISR 直接帧处理
* ============================================================ */
void SpiOta::isrProcessFrame() {
u16 rx_len = s_rxStreamLen;
if (rx_len == 0U) { return; }
/* 关键修复：一旦开始处理本次 CS 周期中的完整帧，立刻标记“已响应/已处理”。
*
* 否则会出现这样的竞态：
* 1) SPI0 RBNE IRQ 在收到最后一个字节后调用 isrProcessFrame()
* 2) 还没执行到函数尾部的 s_isrResponded = true
* 3) CS 已经上升，优先级更高的 EXTI IRQ 抢占进来执行 onCsRelease()
* 4) onCsRelease() 看到 s_isrResponded 仍为 false，于是再次调用 isrProcessFrame()
* 5) 同一帧被重复处理一次，状态机被错误推进（如 challenge 又被当 confirm）
*
* 所以必须在函数入口就先置位，防止 REQ/DATA 被双重分发。 */
s_isrResponded = true;
if (rx_len >= 1U && s_rxStream[0] == SPI_OTA_CMD_BOOT) {
u8 ack[4] = {0xB0U, 0xA5U, 0x4FU, 0x54U};
queueTxFrame(ack, sizeof(ack));
if (s_otaHandler != nullptr) { s_otaHandler->resetToIdle(); }
isrLogFrameEx("[BOOT-CMD]", s_txBuf, s_txLen);
s_isrResponded = true;
return;
}
if (s_rxStream[0] != kSof) {
isrLogFrameEx("[NO-SOF]", s_rxStream, (rx_len < 8U) ? rx_len : 8U);
return;
}
if (rx_len < kFrameOverhead) { return; }
u16 payload_len = (u16)(s_rxStream[2] | ((u16)s_rxStream[3] << 8));
u16 expected = (u16)(kFrameOverhead + payload_len);
if (expected > rx_len) { return; }
if (crc8(s_rxStream, (u16)(4U + payload_len)) != s_rxStream[4U + payload_len]) {
u8 err = 0xEEU;
u8 err_frame[kTxBufSize] = {};
u16 built = 0U;
if (buildFrame(SPI_OTA_RSP_ERROR, &err, 1U, err_frame, &built)) {
queueTxFrame(err_frame, built);
}
isrLogFrameEx("[CRC-ERR]", s_rxStream, (rx_len < 8U) ? rx_len : 8U);
return;
}
spi_ota_frame_type_t frame_type;
const u8 *payload = nullptr;
u16 p_len = 0U;
if (!tryParseFrame(s_rxStream, expected, &frame_type, &payload, &p_len)) {
isrLogFrameEx("[PARSE-ERR]", s_rxStream, (rx_len < 8U) ? rx_len : 8U);
return;
}
if (frame_type == SPI_OTA_CMD_BOOT) {
u8 ack_ok = 0xA5U;
u8 ack_frame[kTxBufSize] = {};
u16 ack_len = 0U;
if (buildFrame(SPI_OTA_RSP_ACK, &ack_ok, 1U, ack_frame, &ack_len)) {
queueTxFrame(ack_frame, ack_len);
}
if (s_otaHandler != nullptr) { s_otaHandler->resetToIdle(); }
isrLogFrameEx("[BOOT-FRAME]", s_txBuf, s_txLen);
s_isrResponded = true;
return;
}
if (s_otaHandler != nullptr) {
s_otaSessionActive = true;
s_otaHandler->setTransportSender(sender);
ota_link_msg_type_t msg_type = mapMsgType(frame_type);
isrLogFrameEx("[OTA-MSG]", (const u8*)&frame_type, 1);
/* 诊断: 记录 OTA 状态机当前状态和帧信息 */
{
u8 diag[4] = {(u8)frame_type, (u8)p_len, (u8)(p_len >> 8),
(u8)(s_otaHandler ? s_otaHandler->getState() : 0xFFU)};
isrLogFrameEx("[OTA-DIAG]", diag, 4);
}
s_otaHandler->handleLinkMessage(msg_type, const_cast<u8 *>(payload), (u8)p_len);
}
isrLogFrameEx("[ISR-DONE]", s_txBuf, (s_txLen < 16U) ? s_txLen : 16U);
s_isrResponded = true;
}
/* ============================================================
* ISR 内延迟日志
* ============================================================ */
void SpiOta::isrLogFrame(const char *tag, const u8 *data, u16 len) {
isrLogFrameEx(tag, data, len);
}
static void isrLogFrameEx(const char *tag, const u8 *data, u16 len) {
if (s_logCount >= kLogSlotCount) { return; }
u8 *buf = s_logSlots[s_logWriteIdx];
u16 pos = 0U;
if (tag) {
while (*tag && pos < kLogSlotSize - 3U) { buf[pos++] = (u8)*tag++; }
buf[pos++] = ' ';
}
const u16 preview = (len < 24U) ? len : 24U;
for (u16 i = 0U; i < preview && pos + 2U < kLogSlotSize; ++i) {
static const char hx[] = "0123456789ABCDEF";
buf[pos++] = (u8)hx[data[i] >> 4];
buf[pos++] = (u8)hx[data[i] & 0x0FU];
}
buf[pos] = 0U;
s_logSlotLens[s_logWriteIdx] = pos;
s_logWriteIdx = (s_logWriteIdx + 1U) % kLogSlotCount;
s_logCount++;
}
/* ============================================================
* 硬件初始化
* ============================================================ */
void SpiOta::configureGpio() {
rcu_periph_clock_enable(RCU_GPIOA);
rcu_periph_clock_enable(RCU_GPIOB);
rcu_periph_clock_enable(RCU_AF);
gpio_pin_remap_config(GPIO_SPI0_REMAP, ENABLE);
gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP, ENABLE);
gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
}
void SpiOta::configureSpi0() {
rcu_periph_clock_enable(RCU_SPI0);
spi_i2s_deinit(SPI0);
(void)spi_i2s_data_receive(SPI0); /* 清空 SPI_DATA 残留值 */
spi_parameter_struct spi_init_struct;
spi_struct_para_init(&spi_init_struct);
spi_init_struct.device_mode = SPI_SLAVE;
spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
spi_init_struct.frame_size = SPI_FRAMESIZE_8BIT;
spi_init_struct.nss = SPI_NSS_SOFT;
spi_init_struct.endian = SPI_ENDIAN_MSB;
/* SPI NSS 由 ESP32 的 CS 线 (GPIO4→PA15) 控制。\外部 CS 高时：
* spi_nss_internal_high(SPI0) 让 SPI 外设进入未选中状态，
* 这样 SPI0_DATA 输出 0xFF（而非 0x00），
* DMA 只在 CS 低时才被 SPI 外设允许推数据到 MISO。 */
spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;
spi_init_struct.prescale = SPI_PSC_8;
spi_init(SPI0, &spi_init_struct);
/* 关键修正：内部 NSS 始终保持 LOW，使 SPI0 从机一直处于“已选中”状态。
*
* APP 侧的稳定实现就是这样做的：PA15 只作为 EXTI 事务边界信号，
* 不再依赖 EXTI ISR 去“赶在首个 SCK 之前”切 internal NSS。
*
* 之前 BOOT 的问题正出在这里：
* - 空闲时 spi_nss_internal_high(SPI0)
* - CS↓ 后靠 EXTI ISR 再切 internal_low
* - 但 ESP32 在 CS↓ 后几乎立刻出时钟
* - 于是 GD32 常常在 internal NSS 真正拉低前丢掉首字节/首几位
* → 请求帧首字节 0xA5 被吃掉，看到 0x80 / 0xFF / 随机 0x07
*
* 现在改为 internal NSS 常低：
* - SPI 从机始终就绪，不会因为 EXTI 延迟丢首字节
* - PA15 仍用于 onCsAssert/onCsRelease 做缓冲区清零和 DMA 重装
*/
spi_nss_internal_low(SPI0);
/* 初始化时清空 SPI_DATA 寄存器，防止残留值影响首次传输 */
(void)spi_i2s_data_receive(SPI0);
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);
/* SPI0 RBNE 中断优先级设为 (2, 0)，低于 EXTI CS 中断 (1, 1)。
* 这确保 CS 下降沿的 onCsAssert() 在任何 RBNE 之前执行，
* 否则 s_csActive 仍为 false，RBNE 中断丢弃接收字节。 */
nvic_irq_enable(SPI0_IRQn, 2U, 0U);
spi_enable(SPI0);
}
void SpiOta::configureDma() {
rcu_periph_clock_enable(RCU_DMA0);
dma_deinit(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH);
dma_parameter_struct dma_init_struct;
dma_struct_para_init(&dma_init_struct);
dma_init_struct.periph_addr = (uint32_t)(SPI0 + 0x0CU);
dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
dma_init_struct.memory_addr = (uint32_t)s_txBuf;
dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
dma_init_struct.number = 0U;
dma_init_struct.priority = DMA_PRIORITY_HIGH;
dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
dma_init(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH, &dma_init_struct);
dma_circulation_disable(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH);
dma_channel_disable(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH);
}
void SpiOta::configureExti() {
gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_15);
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, 1U, 1U);
}
void SpiOta::init() {
s_csActive = false;
s_rxStreamLen = 0U;
s_txStreamPos = 0U;
s_txLen = 0U;
s_txPending = false;
s_isrLogPending = false;
memset(s_rxStream, 0, sizeof(s_rxStream));
memset(s_txBuf, 0xFF, sizeof(s_txBuf));
configureGpio();
configureDma();
configureSpi0();
configureExti();
}
/* ============================================================
* CS 边沿处理
* ============================================================ */
void SpiOta::onCsAssert() {
if (s_csActive) { return; }
s_csActive = true;
s_rxStreamLen = 0U;
s_txStreamPos = 0U;
s_isrResponded = false;
/* 内部 NSS 已在初始化时常置 LOW，这里不再依赖 EXTI 时序切 NSS。
* PA15 仅作为“事务开始”的边界信号，用于清接收缓冲和重装 DMA。 */
/* 关键修复：先彻底停止 DMA，再重新配置并启动。
*
* 上一版预填 SPI_DATA 方案失败原因：
* spi_i2s_data_transmit() 写入的字节进入 TBE 发送缓冲区。
* 当 ESP32 第一个 SCK 边沿到来时，TBE 的预填字节被移入移位
* 寄存器推到 MISO，同时移位寄存器中的 MOSI 数据被推入 RBNE。
* 但 GD32E50x SPI 的 RBNE 标志在 SPI_DATA 写入后可能被误触发，
* 导致 isrLogFrame 报出预填值（如 0x80）而非 MOSI 真实数据。
*
* 正确方案：不预填 SPI_DATA，而是确保 DMA 在 CS↓ 后、ESP32
* 第一个 SCK 边沿之前就绪。DMA 第一拍自动把 s_txBuf[0] 写入
* SPI_DATA，不会产生 RBNE 误触发。
*
* 操作顺序：
* 1. 禁 DMA 通道 + 禁 SPI DMA 请求（彻底停止旧传输）
* 2. 清 RBNE / RXORERR / FERR 等残留标志
* 3. 配置并启动 DMA（此时 RBNE 仍关闭，DMA 写 SPI_DATA 不会触发中断）
* 4. 重新使能 RBNE 中断，开始接收 MOSI 数据
*/
/* 1. 停止旧 DMA */
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) &= ~DMA_CHXCTL_CHEN;
spi_dma_disable(SPI0, SPI_DMA_TRANSMIT);
/* 2. 清残留错误标志
*
* 关键：这里绝不能在 CS↓ 时“顺手读掉 RBNE”。
*
* 因为 internal NSS 现在常 LOW，ESP32 在 CS↓ 后很快就会发出首字节 A5。
* 如果 EXTI ISR 略晚于 SPI 接收，A5 可能已经先进了 RX 缓冲并置位 RBNE。
* 这时若在 onCsAssert() 里执行 spi_i2s_data_receive()，就会把真实首字节 A5
* 当成“残留垃圾”吞掉，导致后续看到的首字节变成 0x01。
*
* 所以这里仅清真正的错误标志，不主动消费 RBNE。
* 已到达的首字节留给 onSpiInterrupt() 正常读走。 */
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RXORERR) != RESET) {
(void)spi_i2s_data_receive(SPI0);
}
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_FERR) != RESET) {
spi_i2s_format_error_clear(SPI0, SPI_FLAG_FERR);
}
/* 3. 配置并启动 DMA（RBNE 仍关闭，DMA 写 SPI_DATA 不会触发中断） */
if (s_txPending && s_txLen > 0U) {
spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
startSpiTxDma(s_txBuf, s_txLen);
} else {
s_txPending = false;
s_txLen = kTxBufSize;
memset(s_txBuf, 0xFF, kTxBufSize);
spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
startSpiTxDma(s_txBuf, s_txLen);
}
/* 4. 重新使能 RBNE 中断，开始接收 MOSI 数据 */
spi_i2s_interrupt_enable(SPI0, SPI_I2S_INT_RBNE);
}
void SpiOta::onCsRelease() {
if (!s_csActive) { return; }
s_csActive = false;
/* 内部 NSS 保持常 LOW，不在 CS↑ 时切回 HIGH。
* 这样 SPI 从机始终处于就绪态，下一次 CS↓ 不会因 EXTI 延迟丢首字节。
*
* 这里只停止 DMA，避免 CS 高期间继续空转消耗 s_txBuf 内容。
* s_txPending 保持不变——如果 ISR 已准备好 ACK 帧，
* 下次 CS↓ 时 onCsAssert 会重启 DMA 推出。 */
DMA_CHCTL(SPI_TX_DMA_PERIPH, SPI_TX_DMA_CH) &= ~DMA_CHXCTL_CHEN;
spi_dma_disable(SPI0, SPI_DMA_TRANSMIT);
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RBNE) != RESET) {
u8 last_byte = (u8)(spi_i2s_data_receive(SPI0) & 0xFFU);
if (s_rxStreamLen < kRxBufSize) {
s_rxStream[s_rxStreamLen++] = last_byte;
}
}
/* 关键调试日志：记录本次 CS 周期结束时到底收到了多少字节。
* 这样能直接判断：
* 1) 是不是完整收到了 ESP32 发来的整帧
* 2) 还是只收到了首字节 A5 / 少数字节，导致永远无法解析回包 */
if (s_rxStreamLen > 0U) {
isrLogFrame("[CS-RX]", s_rxStream, (s_rxStreamLen < 12U) ? s_rxStreamLen : 12U);
}
if (s_rxStreamLen > 0U && !s_isrResponded) {
isrProcessFrame();
}
}
/* ============================================================
* SPI0 中断处理 — 只处理 RBNE（接收）和错误，TBE 已由 DMA 替代
* ============================================================ */
void SpiOta::onSpiInterrupt() {
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RBNE) != RESET) {
/* 与 APP 侧稳定实现保持一致：
* 如果 EXTI 下降沿因为中断时序略晚到达，但此时 PA15 已经为低，
* 则在首个 RBNE 到来时立即补做 onCsAssert()。
*
* 关键限制：只能在“本事务尚未收过任何字节”时补做。
* 否则若 EXTI / SPI 时序偶发抖动，重复 onCsAssert() 会把
* s_rxStreamLen 清零，导致已经收到的半帧被冲掉，最终永远拼不成完整帧。 */
if (!s_csActive && s_rxStreamLen == 0U && gpio_input_bit_get(GPIOA, GPIO_PIN_15) == RESET) {
onCsAssert();
}
u8 byte = (u8)(spi_i2s_data_receive(SPI0) & 0xFFU);
if (s_rxStreamLen < kRxBufSize) {
s_rxStream[s_rxStreamLen++] = byte;
}
/* 调试阶段先关闭 RBNE 首字节日志。
* 原因：ISR 日志缓冲是单槽的，RBNE 一旦先占位，
* onCsRelease() 里的 [CS-RX] 摘要日志就会被丢弃。
* 目前排查重点是“本次 CS 周期总共收到了哪些字节”，
* 所以优先保留 [CS-RX]，暂时关闭 [RBNE]。 */
tryProcessCompleteFrame();
}
/* TBE 已由 DMA 替代，不再处理 */
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RXORERR) != RESET) {
(void)spi_i2s_data_receive(SPI0);
s_rxStreamLen = 0U;
isrLogFrame("[RXOR]", (const u8*)"OVR", 3);
}
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_FERR) != RESET) {
spi_i2s_format_error_clear(SPI0, SPI_FLAG_FERR);
}
}
void SpiOta::onCsExtiInterrupt() {
if (exti_interrupt_flag_get(EXTI_15) != RESET) {
exti_interrupt_flag_clear(EXTI_15);
if (gpio_input_bit_get(GPIOA, GPIO_PIN_15) == RESET) { onCsAssert(); }
else { onCsRelease(); }
}
}
/* ============================================================
* 主循环接口
* ============================================================ */
void SpiOta::poll() {
if (s_isrResponded) {
s_isrResponded = false;
}
/* 打印 ISR 日志缓冲区 */
while (s_logCount > 0U) {
__disable_irq();
if (s_logCount == 0U) { __enable_irq(); break; }
u8 *buf = s_logSlots[s_logReadIdx];
u8 nextRead = (s_logReadIdx + 1U) % kLogSlotCount;
s_logReadIdx = nextRead;
s_logCount--;
__enable_irq();
printf("[SPI] %s\r\n", buf);
}
if (s_otaHandler != nullptr) { s_otaHandler->process(); }
/* 调试:定期打印 SPI 从机状态 */
static u32 dbg_tick = 0;
dbg_tick++;
if ((dbg_tick % 5000U) == 0U) {
printf("[SPI] csActive=%u rxLen=%u txPend=%u txLen=%u isrResp=%u otaState=%u\r\n",
(unsigned)s_csActive, (unsigned)s_rxStreamLen,
(unsigned)s_txPending, (unsigned)s_txLen,
(unsigned)s_isrResponded,
(unsigned)(s_otaHandler ? s_otaHandler->getState() : 0xFF));
}
}
void SpiOta::setSender(OTAHandler *handler) { s_otaHandler = handler; }
void SpiOta::feedRxBytes(const u8 *data, u16 len) {
if (!data || len == 0U || !s_csActive) { return; }
if (len > kRxBufSize) { data += (len - kRxBufSize); len = kRxBufSize; }
memcpy(s_rxStream, data, len);
s_rxStreamLen = len;
}
bool SpiOta::hasTxFrame() { return s_txPending; }
bool SpiOta::hasActiveSession() { return s_otaSessionActive; }
u16 SpiOta::copyTxFrame(u8 *out, u16 max_len) {
if (!out || max_len == 0U) { return 0U; }
uint32_t primask = enterCritical();
if (!s_txPending || s_txLen == 0U) { exitCritical(primask); return 0U; }
u16 copy_len = (s_txLen < max_len) ? s_txLen : max_len;
memcpy(out, s_txBuf, copy_len);
s_txPending = false;
s_txLen = 0U;
s_txStreamPos = 0U;
exitCritical(primask);
return copy_len;
}
/* ============================================================
* C 风格兼容包装
* ============================================================ */
void spi_ota_init(void) { SpiOta::init(); }
void spi_ota_poll(void) { SpiOta::poll(); }
void spi_ota_set_sender(OTAHandler *handler) { SpiOta::setSender(handler); }
void spi_ota_on_cs_assert(void) { SpiOta::onCsAssert(); }
void spi_ota_on_cs_release(void) { SpiOta::onCsRelease(); }
void spi_ota_gpio_init(void) { SpiOta::configureGpio(); }
void spi_ota_spi0_init(void) { SpiOta::configureSpi0(); }
void spi_ota_exti_init(void) { SpiOta::configureExti(); }
void spi_ota_irq_handler(void) { SpiOta::onSpiInterrupt(); }
void spi_ota_cs_exti_handler(void) { SpiOta::onCsExtiInterrupt(); }
void spi_ota_feed_rx_bytes(const u8 *data, u16 len) { SpiOta::feedRxBytes(data, len); }
bool spi_ota_has_tx_frame(void) { return SpiOta::hasTxFrame(); }
u16 spi_ota_copy_tx_frame(u8 *out, u16 max_len) { return SpiOta::copyTxFrame(out, max_len); }
extern "C" void SPI0_IRQHandler(void) {
SpiOta::onSpiInterrupt();
}
GD32E50X_BOOT/device/SpiOta.h
+2 -1
View File
@@ -64,6 +64,8 @@ public:
static u8 s_isrLogBuf[kIsrLogBufSize];
static u16 s_isrLogLen;
static void sender(ota_link_tx_type_t type, u8 len, const u8 *data);
private:
static u8 crc8(const u8 *data, u16 len);
static bool buildFrame(spi_ota_frame_type_t type, const u8 *payload, u16 payload_len,
@@ -73,7 +75,6 @@ private:
const u8 **payload,
u16 *payload_len);
static ota_link_msg_type_t mapMsgType(spi_ota_frame_type_t type);
static void sender(ota_link_tx_type_t type, u8 len, const u8 *data);
static void queueTxFrame(const u8 *frame, u16 len);
static uint32_t enterCritical();
static void exitCritical(uint32_t primask);
GD32E50X_BOOT/main.cpp
+23
View File
@@ -114,6 +114,29 @@ void BootloaderSystem::run() {
volatile uint32_t *flash_ptr;
uint32_t app_enable, app_check;
/** 检测 FWDGT 看门狗复位：APP 卡死导致看门狗超时。
* 将 app_enable 标记为 NOT_AVAL，阻止 BOOT 再次跳入卡死的 APP，
* 改为停留在 BOOT 等待 OTA 修复。 */
if (rcu_flag_get(RCU_FLAG_FWDGTRST) != RESET) {
rcu_all_reset_flag_clear();
#if DEBUG_PRINT
printf("[BOOT] FWDGT reset detected, blocking app jump\r\n");
#endif
OTA_SET(n_APP_LATEST_EN_ADDR, OTA_NOT_AVAL);
}
/** 检测看门狗复位：如果上次复位是由 APP 的 FWDGT 超时触发，
* 则将 app_enable 标记为 NOT_AVAL，阻止 BOOT 再次跳入卡死的 APP，
* 让 BOOT 停留在 OTA 稡式等待远程修复。 */
if (rcu_flag_get(RCU_FLAG_FWDGTRST) != RESET) {
#if DEBUG_PRINT
printf("[BOOT] FWDGT reset detected, blocking app jump\r\n");
#endif
OTA_SET(n_APP_LATEST_EN_ADDR, OTA_NOT_AVAL);
}
rcu_all_reset_flag_clear();
flash_ptr = (volatile uint32_t *)n_APP_LATEST_EN_ADDR;
app_enable = *flash_ptr;
flash_ptr = (volatile uint32_t *)n_APP_LATEST_CHECK_ADDR;
GD32E50X_BOOT/sys/OTA.cpp
+73 -12
View File
@@ -1,5 +1,6 @@
#include "OTA.h"
#include "Can.h"
#include "SpiOta.h"
#include "aes128.h"
#include "config.h"
#include "core_cm33.h"
@@ -56,7 +57,7 @@ static void ota_can_sender(ota_link_tx_type_t type, u8 len, const u8 *data) {
}
/**
* @brief SPI 链路回包发送占位适配器。
* @brief SPI 链路回包发送适配器。
*
* @param type OTA 回包类型。
* @param len 有效载荷长度。
@@ -64,14 +65,19 @@ static void ota_can_sender(ota_link_tx_type_t type, u8 len, const u8 *data) {
* @return 无。
*/
static void ota_spi_sender(ota_link_tx_type_t type, u8 len, const u8 *data) {
(void)type;
(void)len;
(void)data;
/**
* 这里仍保留占位实现。
* 当前 SPI OTA 的真正回包发送,是由 device/SpiOta.cpp 内的 spi_ota_sender() 接管的。
* 关键修复：这里不能是空函数！
*
* 之前是占位实现，因为 ISR 内的回包由 SpiOta::isrProcessFrame() 直接调用
* SpiOta::sender() → queueTxFrame() → DMA 推送。
*
* 但 process() 主循环中也会发送 ACK（如擦除完成后的 ACK(seq=0)），
* 这些调用走的是 transport_send = ota_spi_sender。
* 如果这里是空的，ACK 就被吞掉了，ESP32 永远等不到擦除完成的准入信号。
*
* 所以必须委托给 SpiOta::sender()，它会构建帧并推 DMA。
*/
SpiOta::sender(type, len, data);
}
/**
@@ -244,11 +250,31 @@ void OTAHandler::process() {
/**
* 把真正耗时的 Flash 擦除动作推迟到主循环做,
* 避免在接收消息的处理路径里执行过重操作。
*
* 协议关键点：SIZE 阶段不能在“刚收到大小”时立刻 ACK(seq=0)，
* 否则 ESP32 会马上开始发数据包，而此时 BOOT 可能仍在整片擦 Flash。
* 擦除期间本函数会关中断，SPI 无法及时收包/回 ACK，导致包0超时。
*
* 因此改为：
* 1. ISR 收到 SIZE 后只回 WAIT，并置 pending_flash_erase=true
* 2. 这里真正擦除完成后，再切到 RECEIVING_FIRMWARE 并发送 ACK(seq=0)
*/
if (pending_flash_erase) {
pending_flash_erase = false;
eraseApplicationArea();
ota_state = OTA_STATE_RECEIVING_FIRMWARE;
/* 关键修复：SIZE 请求来自 SPI 时，擦除完成后的“准入 ACK(seq=0)”
* 必须强制走 SPI 回包。
*
* 否则如果主循环里恰好有 CAN communication_check() 把 transport_send
* 切回了 CAN，process() 这里发出的 ACK 会跑到 CAN 通道，ESP32 SPI 侧就
* 只能一直读到上一次 WAIT 帧残留（例如 0x27 CRC 尾字节）。 */
ota_bind_spi_transport();
#if DEBUG_PRINT
printf("[OTA] erase done, send SPI ACK seq0\r\n");
#endif
send_structured_ack(0U);
}
if (pending_app_jump) {
@@ -343,6 +369,18 @@ bool validateApplication() {
bool stack_valid = (stack_ptr >= 0x20000000U && stack_ptr < 0x20020000U);
bool reset_valid = (reset_handler >= APPLATEST_START_ADDR &&
reset_handler < (APPLATEST_START_ADDR + APP_MAX_SIZE));
#if DEBUG_PRINT
printf("[BOOT] validateApp: MSP=0x%08lX (%s) Reset=0x%08lX (%s) @0x%08lX\r\n",
(unsigned long)stack_ptr, stack_valid ? "OK" : "INVALID",
(unsigned long)reset_handler, reset_valid ? "OK" : "INVALID",
(unsigned long)APPLATEST_START_ADDR);
/* 额外打印前 4 个 word 帮助诊断固件内容是否正确 */
printf("[BOOT] vector[0..3]=%08lX %08lX %08lX %08lX\r\n",
(unsigned long)app_vector[0], (unsigned long)app_vector[1],
(unsigned long)app_vector[2], (unsigned long)app_vector[3]);
#endif
return stack_valid && reset_valid;
}
@@ -376,6 +414,11 @@ void OTAHandler::jumpToApplication() {
/** 关闭 Bootloader 运行过程中启用过的外设。 */
can_deinit(CAN0);
spi_i2s_deinit(SPI0);
exti_interrupt_disable(EXTI_15);
exti_interrupt_flag_clear(EXTI_15);
DMA_CHCTL(DMA0, DMA_CH1) &= ~DMA_CHXCTL_CHEN;
DMA_CHCTL(DMA0, DMA_CH2) &= ~DMA_CHXCTL_CHEN;
rcu_system_clock_source_config(RCU_CKSYSSRC_IRC8M);
rcu_periph_clock_disable(RCU_GPIOA);
@@ -383,6 +426,8 @@ void OTAHandler::jumpToApplication() {
rcu_periph_clock_disable(RCU_GPIOC);
rcu_periph_clock_disable(RCU_USART0);
rcu_periph_clock_disable(RCU_CAN0);
rcu_periph_clock_disable(RCU_SPI0);
rcu_periph_clock_disable(RCU_AF);
rcu_periph_clock_disable(RCU_TIMER0);
rcu_periph_clock_disable(RCU_DMA0);
@@ -398,6 +443,9 @@ void OTAHandler::jumpToApplication() {
/** 切栈后直接跳转执行主应用。 */
__set_MSP(msp_value);
__set_CONTROL(0);
__DSB();
__ISB();
rcu_all_reset_flag_clear();
app_entry();
}
@@ -469,6 +517,13 @@ void OTAHandler::writeApplicationData(u32 offset, u8 *data, u32 size) {
* @return 无。
*/
void OTAHandler::handleLinkMessage(ota_link_msg_type_t type, u8 *data, u8 len) {
#if DEBUG_PRINT
/* 精简: 只打印关键帧(非DATA包或状态变化时), DATA包省略 */
if (type != OTA_LINK_MSG_DATA || ota_state != OTA_STATE_RECEIVING_FIRMWARE) {
printf("[OTA] hl: t=%u l=%u s=%u\r\n",
(unsigned)type, (unsigned)len, (unsigned)ota_state);
}
#endif
/**
* CANCEL:无条件终止当前 OTA 会话,回到空闲态。
*/
@@ -577,11 +632,14 @@ void OTAHandler::handleLinkMessage(ota_link_msg_type_t type, u8 *data, u8 len) {
return;
}
/** 把擦除动作延后到 process() 中执行。 */
/**
* 不要立刻 ACK(seq=0)。
* 先告诉 ESP32“我在忙(WAIT)”，等 process() 真正擦除完 Flash 后，
* 再发送 ACK(seq=0) 作为“现在可以开始发包”的准入信号。
*/
pending_flash_erase = true;
/** 固件大小合法,返回严格 seq 语义 ACK:阶段起始包号 0。 */
send_structured_ack(0U);
u8 wait_hint[1] = {0x02};
send_wait_frame(1, wait_hint);
}
/** 结束态下要求显式收到 0x0A AC,确认可以切换到 APP。 */
else if (len == 2U && ota_state == OTA_STATE_FINISHED) {
@@ -608,9 +666,12 @@ void OTAHandler::handleLinkMessage(ota_link_msg_type_t type, u8 *data, u8 len) {
send_error_frame(0xFFFFFFFFU, OTA_ERROR_INVALID_PACKET);
return;
}
/** 其它长度 / 状态组合都视作非法包。 */
else {
ota_error = OTA_ERROR_INVALID_PACKET;
#if DEBUG_PRINT
printf("[OTA] INV_PKT: l=%u s=%u\r\n",
(unsigned)len, (unsigned)ota_state);
#endif
ota_state = OTA_STATE_IDLE;
send_error_frame(0xFFFFFFFFU, OTA_ERROR_INVALID_PACKET);
}
GD32E50X_BOOT/sys/OTA.h
+13
View File
@@ -5,7 +5,10 @@
#include "aes128.h"
#include "config.h"
#include "gd32e50x.h"
#include <stdint.h>
#include <string.h>
/**
* @brief OTA 统一链路消息类型。
@@ -88,6 +91,16 @@ class OTAHandler {
ota_state = OTA_STATE_IDLE;
ota_time = 0;
ota_error = OTA_ERROR_NONE;
received_size = 0;
expected_size = 0;
memset(current_K_session, 0, sizeof(current_K_session));
memset(nonce_server, 0, sizeof(nonce_server));
memset(&aes_ctx, 0, sizeof(aes_ctx));
pending_flash_erase = false;
pending_app_jump = false;
pending_flash_offset = 0;
memset(pending_flash_data, 0, sizeof(pending_flash_data));
pending_flash_size = 0;
}
/**