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

feat(canfd): 添加收发器静默模式支持和SPI命令接口

Browse Source 
添加了CAN FD收发器静默模式功能，允许通过硬件引脚控制发送使能：
- 新增setTxSilent/isTxSilent接口控制TCAN1057收发器Silent模式
- 静默时驱动器关断但接收机继续工作，支持只听不发场景
- 添加SPI命令0xC8用于ESP32远程控制静默模式切换
- 在总线状态位图中增加bit5表示静默状态
- 新增canBusyWaitUs函数用于ISR安全的微秒延时

fix(esc_lan9252): 改进warm jump后LAN9252探测逻辑

修复warm jump导致的LAN9252初始化问题：
- 识别warm jump后芯片非POR状态(idx0!=0x1234)的情况
- 自动补发硬件复位对齐到POR状态后再进行正常探测
- 改进调试信息输出，区分POR状态和warm jump残值情况
- 修正失败路径的复位标志初始化逻辑

refactor(spi): 整理SPI命令文件结构

调整SPI命令相关文件的组织结构：
- 移动诊断相关文件到更合适的位置
- 重新整理SPI命令处理文件的分组
This commit is contained in:
cbb
2026-10-10 02:25:56 +08:00
parent a777be1cb4
commit f3d7fc0c30
13 changed files with 1247 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
GD32E508_DCU_APP/device/spi/app_spi_cmd_can_feedback.cpp
+70 -5
View File
@@ -21,7 +21,7 @@
* [21..24] error_count (LE)
* [25] tec 硬件发送错误计数器 (0~255)
* [26] rec 硬件接收错误计数器 (0~255)
* [27] bus_state 总线状态位图：bit0=init,bit1=sleep,bit2=error_passive,bit3=bus_off,bit4=error_warning
* [27] bus_state 总线状态位图：bit0=init,bit1=控制器sleep,bit2=error_passive,bit3=bus_off,bit4=error_warning,bit5=tx_silent(收发器Silent)
* [28..] 条目逐条拼接：
* id(4LE) + dlc(1) + flags(1) + reserved(2) + data(dlc)
* 每条 = 8 + dlc 字节
@@ -31,6 +31,16 @@
* [0] mode 0=全部接收, 1=按 ID 过滤；其它值返回 kRspError。
* 应答 payload：
* [0] 实际生效的 mode。
*
* 3) kTypeCanSetSilent (0xC8)：ESP32 切换指定通道收发器 Silent（只听不发）。
* 请求 payload：
* [0] channel 0/1/2
* [1] silent 1=进 Silent（S 脚置高：驱动关断、接收机照常）, 0=回 Normal
* 应答 payload：
* [0] channel [1] 实际生效的 silent（与发送门控同一个值） [2] 该通道使能位
* ERROR：0xE0=payload 过短, 0xE1=通道非法/未使能, 0xE2=S 脚回读与意图不符（标志已回滚）。
* 生效期间该通道所有发送入口（0xC0/0xC7/桥接/relay）回 0xE6=kErrSilent，
* 不计错误计数；静默不持久化，上电 init 一律回 Normal。
*/
#include "device/spi/spi_command_handler.h"
@@ -138,18 +148,19 @@ static uint16_t buildFeedbackPayload(uint8_t channel, uint8_t page,
namespace {
/** @brief SPI 0xC1 反馈查询 + 0xC2 模式切换处理器。 */
/** @brief SPI 0xC1 反馈查询 + 0xC2 模式切换 + 0xC8 收发器 Silent 开关处理器。 */
class SpiCanFeedbackHandler final : public ISpiCommandHandler {
public:
/** @brief 是否处理 0xC1 / 0xC2。 */
/** @brief 是否处理 0xC1 / 0xC2 / 0xC8。 */
bool canHandle(uint8_t frame_type) const override
{
return (frame_type == SpiDefs::kTypeCanFeedback)
|| (frame_type == SpiDefs::kTypeCanSetMode);
|| (frame_type == SpiDefs::kTypeCanSetMode)
|| (frame_type == SpiDefs::kTypeCanSetSilent);
}
/**
* @brief 分发到 handleFeedback / handleSetMode。
* @brief 分发到 handleFeedback / handleSetMode / handleSetSilent。
* @param bus 命令总线
* @param ctx 请求上下文
*/
@@ -157,6 +168,8 @@ public:
{
if (ctx.frame_type == SpiDefs::kTypeCanFeedback) {
handleFeedback(bus, ctx);
} else if (ctx.frame_type == SpiDefs::kTypeCanSetSilent) {
handleSetSilent(bus, ctx);
} else {
handleSetMode(bus, ctx);
}
@@ -237,6 +250,58 @@ private:
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspAck, &actual, 1U);
}
/**
* @brief 0xC8：切换指定通道收发器 Silent（只听不发，S 脚控制）。
* @param bus 命令总线
* @param ctx 请求上下文（payload[0]=ch, [1]=silent 1/0）
* @note 运行在 SPI CS EXTI ISR 上下文：只做 GPIO + 标志位；退 Silent 的 20µs
* 收发器建立时间由 CanFd::setTxSilent 内部用 DWT 忙等，禁止 SysTick delayMs。
*/
void handleSetSilent(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 bool silent = (ctx.payload[1] != 0U);
if (!CanFd::isChannelEnabled(channel)) {
uint8_t err = 0xE1U;
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspError, &err, 1U);
return;
}
const bool ok = CanFd::setTxSilent(channel, silent);
const uint8_t actual = CanFd::isTxSilent(channel) ? 1U : 0U;
if (!ok) {
/* S 脚回读与意图不符（被别处抢改 / GPIO 配置未生效）：如实报错，不报成功 */
uint8_t err = 0xE2U;
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspError, &err, 1U);
return;
}
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
char log_msg[AppSpiCommand::kLogBufSize] = {};
(void)snprintf(log_msg, sizeof(log_msg),
"CAN_SILENT ch=%u set=%u -> %u",
static_cast<unsigned>(channel),
static_cast<unsigned>(silent ? 1U : 0U),
static_cast<unsigned>(actual));
bus.postLog(log_msg);
#endif
const uint8_t rsp[3] = { channel, actual, 1U };
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspAck, rsp, 3U);
}
};
static SpiCanFeedbackHandler s_handler;
GD32E508_DCU_APP/device/spi/app_spi_cmd_spi_diag.cpp
+118
View File
@@ -0,0 +1,118 @@
/**
* @file app_spi_cmd_spi_diag.cpp
* @brief SPI 0xA4 链路全量诊断命令处理器。
*
* 供主机 (ESP32 / 调试脚本) 查询 GD32 侧 SPI0 从机实时运行诊断指标与异常现场快照：
* payload[0]=sub_cmd:
* 0 (或空载荷) -> 读取 ~88 字节全量诊断快照 (ACK)
* 1 -> 复位清零所有诊断计数器 (ACK 1B: 0x00)
* 2 -> 立即输出完整 ASCII 格式化报告到 GD32 USART0 串口 (ACK 1B: 0x00)
*/
#include "device/spi/spi_command_handler.h"
#include "device/spi/app_spi_command.h"
#include "device/spi/app_spi_command_defs.h"
#include "device/spi/app_spi_diag.h"
#include "gd32e50x_gpio.h"
#include "sys/config.h"
#include <cstring>
#if (CONFIG_SPI_DIAG_ENABLE != 0)
namespace {
class SpiDiagHandler final : public ISpiCommandHandler {
public:
bool canHandle(uint8_t frame_type) const override
{
return frame_type == SpiDefs::kTypeSpiDiag;
}
void handle(AppSpiCommand &bus, const SpiCommandContext &ctx) override
{
uint8_t sub_cmd = 0U;
if (ctx.payload_len >= 1U && ctx.payload != nullptr) {
sub_cmd = ctx.payload[0];
}
if (sub_cmd == 1U) {
// 复位清零诊断计数器
resetSpiDiagStats();
uint8_t status = 0x00U;
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspAck, &status, 1U);
return;
}
if (sub_cmd == 2U) {
// 立即向串口输出全量 ASCII 诊断报告
dumpSpiDiag();
uint8_t status = 0x00U;
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspAck, &status, 1U);
return;
}
// 默认 / sub_cmd == 0: 返回二进制全量指标快照
const SpiDiagStats &st = getSpiDiagStats();
uint8_t buf[88] = {};
buf[0] = 0x00U; // status OK
buf[1] = bus.isV2Active() ? 1U : 0U;
writeU32Le(&buf[2], bus.getSessionId());
buf[6] = bus.getLocalCredit();
buf[7] = (gpio_input_bit_get(GPIOA, GPIO_PIN_15) == SET) ? 1U : 0U;
buf[8] = (gpio_input_bit_get(CONFIG_SPI_READY_PORT, CONFIG_SPI_READY_PIN) == SET) ? 1U : 0U;
buf[9] = bus.isCsActive() ? 1U : 0U;
buf[10] = bus.isRingPending() ? 1U : 0U;
writeU16Le(&buf[11], st.last_spi_stat);
writeU32Le(&buf[13], st.total_cs_assert);
writeU32Le(&buf[17], st.total_cs_release);
writeU32Le(&buf[21], st.valid_v2_frames);
writeU32Le(&buf[25], st.parse_fail_count);
writeU32Le(&buf[29], st.err_crc_mismatch);
writeU16Le(&buf[33], (uint16_t)st.err_no_sof);
writeU16Le(&buf[35], (uint16_t)st.err_sof_drift);
writeU16Le(&buf[37], (uint16_t)st.err_bad_len);
writeU16Le(&buf[39], (uint16_t)st.rx_overrun_count);
writeU16Le(&buf[41], (uint16_t)st.short_rx_len_count);
writeU16Le(&buf[43], (uint16_t)st.zero_rx_len_count);
writeU16Le(&buf[45], (uint16_t)st.all_ff_count);
writeU16Le(&buf[47], (uint16_t)st.all_00_count);
writeU16Le(&buf[49], (uint16_t)st.session_mismatch);
writeU16Le(&buf[51], (uint16_t)st.seq_jump_count);
writeU16Le(&buf[53], (uint16_t)st.ring_timeout_count);
writeU16Le(&buf[55], (uint16_t)st.unknown_type_count);
writeU16Le(&buf[57], (uint16_t)st.handler_empty_count);
buf[59] = st.last_rx_type;
buf[60] = st.last_tx_type;
buf[61] = st.last_error_code;
buf[62] = st.last_error_reason;
writeU16Le(&buf[63], (uint16_t)st.last_rx_len);
writeU16Le(&buf[65], (uint16_t)st.last_error_rx_len);
memcpy(&buf[67], st.last_error_bytes, 8);
writeU32Le(&buf[75], st.last_error_calc_crc);
writeU32Le(&buf[79], st.last_error_expected_crc);
writeU32Le(&buf[83], st.last_error_uptime_ms);
buf[87] = st.last_error_sof_offset;
bus.buildResponse(ctx.tx_buf, ctx.tx_buf_size, ctx.tx_len,
SpiDefs::kRspAck, buf, sizeof(buf));
}
};
static SpiDiagHandler s_handler;
} // namespace
void registerSpiDiagCommand(AppSpiCommand &bus)
{
bus.registerHandler(&s_handler);
}
#else /* CONFIG_SPI_DIAG_ENABLE == 0 */
void registerSpiDiagCommand(AppSpiCommand & /*bus*/) {}
#endif
GD32E508_DCU_APP/device/spi/app_spi_command.cpp
+500 -82
View File
@@ -23,6 +23,7 @@
#include "device/spi/app_spi_command.h"
#include "device/spi/spi_command_handler.h"
#include "device/spi/app_spi_command_defs.h"
#include "device/spi/app_spi_diag.h"
#include "spi_link_v2.h"
#include "sys/ota_boot_request.h"
@@ -168,7 +169,113 @@ static uint16_t s_lastRespLen = 0;
static bool s_hasCachedResp = false;
/* ============================================================
* v2 帧构建 / 帧解析（委托 spi_link_v2.h，三工程共用）
* SPI 诊断统计与现场快照
* ============================================================ */
#if (CONFIG_SPI_DIAG_ENABLE != 0)
#define SPI_DIAG_RECORD(...) do { __VA_ARGS__; } while (0)
static SpiDiagStats s_diag = {};
const SpiDiagStats& getSpiDiagStats()
{
s_diag.current_local_credit = (uint8_t)g_localCredit;
s_diag.expected_rx_seq = g_expectedRxSeq;
return s_diag;
}
void resetSpiDiagStats()
{
memset(&s_diag, 0, sizeof(s_diag));
}
const char* spiParseResultToString(SpiParseResult res)
{
switch (res) {
case SPI_PARSE_OK: return "OK";
case SPI_PARSE_ERR_TOO_SHORT: return "TOO_SHORT";
case SPI_PARSE_ERR_ALL_FF: return "ALL_FF";
case SPI_PARSE_ERR_ALL_00: return "ALL_00";
case SPI_PARSE_ERR_NO_SOF: return "NO_SOF";
case SPI_PARSE_ERR_BAD_VERSION: return "BAD_VERSION";
case SPI_PARSE_ERR_BAD_LEN: return "BAD_LEN";
case SPI_PARSE_ERR_CRC_MISMATCH: return "CRC_MISMATCH";
default: return "UNKNOWN";
}
}
#else
#define SPI_DIAG_RECORD(...) ((void)0)
#endif
bool AppSpiCommand::isV2Active() const { return g_v2Active; }
uint32_t AppSpiCommand::getSessionId() const { return g_sessionId; }
uint8_t AppSpiCommand::getLocalCredit() const { return (uint8_t)g_localCredit; }
void AppSpiCommand::dumpDiag() const { dumpSpiDiag(); }
#if (CONFIG_SPI_DIAG_ENABLE != 0)
void dumpSpiDiag()
{
const SpiDiagStats &st = getSpiDiagStats();
const uint32_t now = SysTickTimer::getMs();
const uint8_t cs_pin = (gpio_input_bit_get(GPIOA, GPIO_PIN_15) == SET) ? 1U : 0U;
const uint8_t rdy_pin = (gpio_input_bit_get(CONFIG_SPI_READY_PORT, CONFIG_SPI_READY_PIN) == SET) ? 1U : 0U;
const uint16_t stat = (uint16_t)SPI_STAT(SPI0);
printf("\r\n==================== [GD32 SPI0 LINK DIAGNOSTICS] ====================\r\n");
printf("Status : v2_active=%d session_id=0x%08lX local_credit=%u uptime=%lums\r\n",
AppSpiCommandBus.isV2Active() ? 1 : 0, (unsigned long)AppSpiCommandBus.getSessionId(),
(unsigned)AppSpiCommandBus.getLocalCredit(), (unsigned long)now);
printf("Pins & HW: CS(PA15)=%u DATA_READY(PB6)=%u ring_pending=%d cs_active=%d\r\n",
cs_pin, rdy_pin, AppSpiCommandBus.isRingPending() ? 1 : 0, AppSpiCommandBus.isCsActive() ? 1 : 0);
printf("SPI_STAT : 0x%04X (TRANS:%d TBE:%d RBNE:%d OVR:%d FERR:%d)\r\n",
stat, (stat & SPI_FLAG_TRANS) ? 1 : 0, (stat & SPI_FLAG_TBE) ? 1 : 0,
(stat & SPI_FLAG_RBNE) ? 1 : 0, (stat & SPI_FLAG_RXORERR) ? 1 : 0,
(stat & SPI_FLAG_FERR) ? 1 : 0);
printf("CS Stats : assert=%lu release=%lu missed=%lu short(<20B)=%lu zero_len=%lu\r\n",
(unsigned long)st.total_cs_assert, (unsigned long)st.total_cs_release,
(unsigned long)st.missed_cs_assert, (unsigned long)st.short_rx_len_count,
(unsigned long)st.zero_rx_len_count);
printf("Frames : valid_v2=%lu parse_fail=%lu all_FF=%lu all_00=%lu\r\n",
(unsigned long)st.valid_v2_frames, (unsigned long)st.parse_fail_count,
(unsigned long)st.all_ff_count, (unsigned long)st.all_00_count);
printf("ParseErr : CRC_err=%lu no_SOF=%lu SOF_drift=%lu bad_ver=%lu bad_len=%lu\r\n",
(unsigned long)st.err_crc_mismatch, (unsigned long)st.err_no_sof,
(unsigned long)st.err_sof_drift, (unsigned long)st.err_bad_version,
(unsigned long)st.err_bad_len);
printf("Hw Errors: RXORERR(ovr)=%lu FERR(fmt)=%lu\r\n",
(unsigned long)st.rx_overrun_count, (unsigned long)st.format_error_count);
printf("Session : HELLO_cnt=%lu mismatch=%lu seq_ok=%lu seq_jump=%lu seq_dup=%lu\r\n",
(unsigned long)st.hello_count, (unsigned long)st.session_mismatch,
(unsigned long)st.seq_ok_count, (unsigned long)st.seq_jump_count,
(unsigned long)st.seq_dup_count);
printf("Sequences: last_rx_seq=0x%02X exp_rx_seq=0x%02X last_tx_seq=0x%02X\r\n",
st.last_rx_seq, st.expected_rx_seq, st.last_tx_seq);
printf("Commands : last_rx_type=0x%02X last_tx_type=0x%02X error_rsp(0x82)=%lu (last_code=0x%02X)\r\n",
st.last_rx_type, st.last_tx_type, (unsigned long)st.error_rsp_count, st.last_error_code);
printf("Routing : unknown_type=%lu (last=0x%02X) handler_empty=%lu (last=0x%02X)\r\n",
(unsigned long)st.unknown_type_count, st.last_unknown_type,
(unsigned long)st.handler_empty_count, st.last_empty_type);
printf("Ring Push: req=%lu timeout=%lu collision=%lu\r\n",
(unsigned long)st.ring_request_count, (unsigned long)st.ring_timeout_count,
(unsigned long)st.ring_collision_count);
if (st.last_error_uptime_ms > 0U) {
printf("LastErr : at %lums, rxLen=%u, reason=%s(0x%02X), SOF_off=%u\r\n",
(unsigned long)st.last_error_uptime_ms, (unsigned)st.last_error_rx_len,
spiParseResultToString((SpiParseResult)st.last_error_reason),
st.last_error_code, (unsigned)st.last_error_sof_offset);
printf("LastBytes: [%02X %02X %02X %02X %02X %02X %02X %02X]\r\n",
st.last_error_bytes[0], st.last_error_bytes[1], st.last_error_bytes[2], st.last_error_bytes[3],
st.last_error_bytes[4], st.last_error_bytes[5], st.last_error_bytes[6], st.last_error_bytes[7]);
if (st.last_error_reason == SPI_PARSE_ERR_CRC_MISMATCH) {
printf("LastCRC : calc=0x%08lX exp=0x%08lX\r\n",
(unsigned long)st.last_error_calc_crc, (unsigned long)st.last_error_expected_crc);
}
}
printf("======================================================================\r\n\r\n");
}
#endif
/* ============================================================
* v2 帧构建 / 诊断帧解析（委托 spi_link_v2.h，三工程共用）
* ============================================================ */
/* 构建响应帧；上层接口（type/payload）保持不变，handler 无需改动。
@@ -192,36 +299,120 @@ static bool spi_build_frame(uint8_t type, const uint8_t *payload, uint16_t paylo
return true;
}
/* 解析 v2 帧；委托 v2_parse_frame，扫描 SOF 并校验 VERSION/CRC32。
* 仅 v2：v2_parse_frame 扫 SOF0/SOF1 + CRC32；禁止再加 v1 CRC8 分支。 */
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,
v2_header_t *out_hdr = nullptr)
/* 细粒度诊断帧解析：逐项分析失败原因（无SOF/相位漂移/版本不符/长度截断/CRC位错）。 */
static bool spi_diagnose_and_parse_frame(
const uint8_t *buf, size_t buf_len,
uint8_t *out_type, const uint8_t **out_payload, uint16_t *out_payload_len,
v2_header_t *out_hdr,
SpiParseResult *out_res,
uint32_t *out_calc_crc, uint32_t *out_exp_crc,
uint8_t *out_sof_offset)
{
if (!frame || !type || !payload || !payload_len) { return false; }
if (!buf || buf_len == 0U) {
if (out_res) *out_res = SPI_PARSE_ERR_TOO_SHORT;
if (out_sof_offset) *out_sof_offset = 0xFFU;
return false;
}
v2_header_t hdr;
const uint8_t *pload = nullptr;
const bool ok = v2_parse_frame(frame, frame_len, &hdr, &pload);
if (!ok) { return false; }
if (isAllBytesValue(buf, (uint16_t)buf_len, 0xFFU)) {
if (out_res) *out_res = SPI_PARSE_ERR_ALL_FF;
if (out_sof_offset) *out_sof_offset = 0xFFU;
return false;
}
*type = hdr.type;
*payload = pload;
*payload_len = hdr.payload_len;
if (out_hdr) { *out_hdr = hdr; }
return true;
if (isAllBytesValue(buf, (uint16_t)buf_len, 0x00U)) {
if (out_res) *out_res = SPI_PARSE_ERR_ALL_00;
if (out_sof_offset) *out_sof_offset = 0xFFU;
return false;
}
if (buf_len < V2_OVERHEAD) {
if (out_res) *out_res = SPI_PARSE_ERR_TOO_SHORT;
if (out_sof_offset) *out_sof_offset = 0xFFU;
return false;
}
bool found_sof = false;
size_t first_sof_offset = 0xFFU;
SpiParseResult best_err = SPI_PARSE_ERR_NO_SOF;
for (size_t i = 0; i + V2_OVERHEAD <= buf_len; ++i) {
if (buf[i + V2_OFF_SOF0] != V2_SOF0 || buf[i + V2_OFF_SOF1] != V2_SOF1) {
continue;
}
if (!found_sof) {
found_sof = true;
first_sof_offset = i;
}
const uint8_t version = buf[i + V2_OFF_VERSION];
if (version != V2_VERSION) {
best_err = SPI_PARSE_ERR_BAD_VERSION;
continue;
}
const uint16_t plen = v2_get_u16le(&buf[i + V2_OFF_LEN]);
if (plen > V2_MAX_PAYLOAD) {
best_err = SPI_PARSE_ERR_BAD_LEN;
continue;
}
const size_t total = V2_OVERHEAD + plen;
if (i + total > buf_len) {
best_err = SPI_PARSE_ERR_BAD_LEN;
continue;
}
const uint32_t expect = v2_get_u32le(&buf[i + V2_HEADER_LEN + plen]);
const uint32_t calc = v2_crc32(&buf[i], V2_HEADER_LEN + plen);
if (expect != calc) {
best_err = SPI_PARSE_ERR_CRC_MISMATCH;
if (out_calc_crc) *out_calc_crc = calc;
if (out_exp_crc) *out_exp_crc = expect;
continue;
}
if (out_hdr) {
out_hdr->version = version;
out_hdr->flags = buf[i + V2_OFF_FLAGS];
out_hdr->session_id = v2_get_u32le(&buf[i + V2_OFF_SESSION]);
out_hdr->tx_seq = buf[i + V2_OFF_TX_SEQ];
out_hdr->ack_seq = buf[i + V2_OFF_ACK_SEQ];
out_hdr->credit = buf[i + V2_OFF_CREDIT];
out_hdr->type = buf[i + V2_OFF_TYPE];
out_hdr->payload_len = plen;
out_hdr->frame_offset = i;
}
if (out_type) *out_type = buf[i + V2_OFF_TYPE];
if (out_payload) *out_payload = (plen > 0U) ? &buf[i + V2_HEADER_LEN] : nullptr;
if (out_payload_len) *out_payload_len = plen;
if (out_res) *out_res = SPI_PARSE_OK;
if (out_sof_offset) *out_sof_offset = (uint8_t)i;
if (out_calc_crc) *out_calc_crc = calc;
if (out_exp_crc) *out_exp_crc = expect;
return true;
}
if (out_res) *out_res = best_err;
if (out_sof_offset) *out_sof_offset = (uint8_t)first_sof_offset;
return false;
}
/* ============================================================
* 调试日志辅助
* 调试日志辅助（环形队列，避免事件并发时丢日志）
* ============================================================ */
void AppSpiCommand::postLog(const char *msg)
{
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
if (!msg) return;
snprintf(m_logBuf, kLogBufSize, "[SPI-APP] %s", msg);
m_logPending = true;
uint8_t next = (uint8_t)((m_logHead + 1U) % kLogSlotCount);
if (next != m_logTail) {
strncpy(m_logQueue[m_logHead], msg, kLogSlotLen - 1U);
m_logQueue[m_logHead][kLogSlotLen - 1U] = '\0';
m_logHead = next;
}
#else
(void)msg;
#endif
@@ -231,14 +422,29 @@ void AppSpiCommand::postLogFmt(const char *fmt, uint8_t val)
{
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
if (!fmt) return;
snprintf(m_logBuf, kLogBufSize, fmt, val);
m_logPending = true;
char tmp[kLogSlotLen];
snprintf(tmp, sizeof(tmp), fmt, val);
postLog(tmp);
#else
(void)fmt;
(void)val;
#endif
}
void AppSpiCommand::postLogFmt32(const char *fmt, uint32_t v1, uint32_t v2)
{
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
if (!fmt) return;
char tmp[kLogSlotLen];
snprintf(tmp, sizeof(tmp), fmt, (unsigned long)v1, (unsigned long)v2);
postLog(tmp);
#else
(void)fmt;
(void)v1;
(void)v2;
#endif
}
void AppSpiCommand::buildResponse(uint8_t *tx_buf, uint16_t tx_buf_size,
uint16_t *tx_len, uint8_t rsp_type,
const uint8_t *payload, uint16_t payload_len)
@@ -402,18 +608,20 @@ extern void registerSpiAdcFeedbackCommand(AppSpiCommand &bus);
extern void registerSpiMotorStateCommand(AppSpiCommand &bus);
extern void registerSpiMotorOtaCommand(AppSpiCommand &bus);
extern void registerSpiExmcDiagCommand(AppSpiCommand &bus);
extern void registerSpiDiagCommand(AppSpiCommand &bus);
AppSpiCommand AppSpiCommandBus;
void AppSpiCommand::init()
{
m_csActive = false;
m_rxLen = 0U;
m_txLen = 0U;
m_logPending = false;
m_logHead = 0U;
m_logTail = 0U;
m_commandCount = 0U;
m_ringPending = false;
m_ringDeadline = 0U;
memset(m_txBuf, 0xFF, sizeof(m_txBuf));
memset(m_logBuf, 0, sizeof(m_logBuf));
memset(m_logQueue, 0, sizeof(m_logQueue));
memset(m_commands, 0, sizeof(m_commands));
registerSpiBootRequestCommand(AppSpiCommandBus);
@@ -428,6 +636,7 @@ void AppSpiCommand::init()
registerSpiMotorStateCommand(AppSpiCommandBus); /* CONFIG 关时为空注册 */
registerSpiMotorOtaCommand(AppSpiCommandBus);
registerSpiExmcDiagCommand(AppSpiCommandBus);
registerSpiDiagCommand(AppSpiCommandBus);
configureGpio();
configureDma();
@@ -530,47 +739,122 @@ void AppSpiCommand::processCommand()
const uint8_t *payload = nullptr;
uint16_t payload_len = 0U;
v2_header_t hdr;
SpiParseResult parse_res = SPI_PARSE_OK;
uint32_t calc_crc = 0U;
uint32_t exp_crc = 0U;
uint8_t sof_offset = 0xFFU;
if (!spi_try_parse_frame(m_rxBuf, m_rxLen, &frame_type, &payload, &payload_len, &hdr)) {
postLogFmt("[SPI-APP] 非v2帧 0x%02X -> ERROR", m_rxBuf[0]);
/* 0xE8 payload 携带接收诊断——[0]=0xE8, [1]=rxLen, [2..5]=rxBuf 前 4 字节。
* ESP32 /system/status rsp_err_last_p0..p3 直读，无需串口即可判定损坏形态
* （全FF=DMA 未装/CS 丢失；SOF 错位=相位漂移；SOF 对但 CRC 败=帧内位错）。 */
const bool parse_ok = spi_diagnose_and_parse_frame(
m_rxBuf, m_rxLen, &frame_type, &payload, &payload_len, &hdr,
&parse_res, &calc_crc, &exp_crc, &sof_offset);
if (!parse_ok) {
SPI_DIAG_RECORD(
s_diag.parse_fail_count++;
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
s_diag.last_error_rx_len = m_rxLen;
s_diag.last_error_calc_crc = calc_crc;
s_diag.last_error_expected_crc = exp_crc;
s_diag.last_error_sof_offset = sof_offset;
s_diag.last_error_reason = (uint8_t)parse_res;
s_diag.last_error_code = 0xE8U;
memcpy(s_diag.last_error_bytes, m_rxBuf, (m_rxLen < 8U) ? m_rxLen : 8U);
);
#if (CONFIG_SPI_APP_LOG_ENABLE != 0 && CONFIG_SPI_DIAG_ENABLE != 0)
switch (parse_res) {
case SPI_PARSE_ERR_CRC_MISMATCH: {
SPI_DIAG_RECORD(s_diag.err_crc_mismatch++);
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] CRC mismatch: calc=0x%08lX exp=0x%08lX rxLen=%u",
(unsigned long)calc_crc, (unsigned long)exp_crc, (unsigned)m_rxLen);
postLog(log_msg);
break;
}
case SPI_PARSE_ERR_NO_SOF: {
SPI_DIAG_RECORD(s_diag.err_no_sof++);
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] No SOF: rxLen=%u raw=[%02X %02X %02X %02X]",
(unsigned)m_rxLen, m_rxBuf[0], m_rxBuf[1], m_rxBuf[2], m_rxBuf[3]);
postLog(log_msg);
break;
}
case SPI_PARSE_ERR_BAD_VERSION: {
SPI_DIAG_RECORD(s_diag.err_bad_version++);
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] Bad ver=0x%02X (exp 0x02) SOF_off=%u rxLen=%u",
(sof_offset < m_rxLen - 2) ? m_rxBuf[sof_offset + 2] : 0xFFU,
(unsigned)sof_offset, (unsigned)m_rxLen);
postLog(log_msg);
break;
}
case SPI_PARSE_ERR_BAD_LEN: {
SPI_DIAG_RECORD(s_diag.err_bad_len++);
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] Bad len at SOF_off=%u rxLen=%u",
(unsigned)sof_offset, (unsigned)m_rxLen);
postLog(log_msg);
break;
}
default: {
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] Parse fail res=%d rxLen=%u",
(int)parse_res, (unsigned)m_rxLen);
postLog(log_msg);
break;
}
}
#endif
if (sof_offset > 0U && sof_offset != 0xFFU) {
SPI_DIAG_RECORD(s_diag.err_sof_drift++);
}
/* 0xE8 payload 携带接收诊断——[0]=0xE8, [1]=rxLen, [2..3]=rxBuf 前 2 字节, [4]=parse_res, [5]=sof_offset */
uint16_t tx_len = 0U;
uint8_t diag[8];
diag[0] = 0xE8U;
diag[1] = (m_rxLen > 255U) ? 255U : (uint8_t)m_rxLen;
diag[2] = (m_rxLen > 0U) ? m_rxBuf[0] : 0xFFU;
diag[3] = (m_rxLen > 1U) ? m_rxBuf[1] : 0xFFU;
diag[4] = (m_rxLen > 2U) ? m_rxBuf[2] : 0xFFU;
diag[5] = (m_rxLen > 3U) ? m_rxBuf[3] : 0xFFU;
diag[4] = (uint8_t)parse_res;
diag[5] = sof_offset;
diag[6] = 0x5AU;
diag[7] = 0xA5U;
/* 非v2帧时 hdr 未初始化：禁止缓存/推进序号（垃圾缓存会被 dup 重放） */
SPI_DIAG_RECORD(s_diag.error_rsp_count++);
spi_build_frame(kRspError, diag, sizeof(diag), m_txBuf, &tx_len);
m_txLen = tx_len;
finishResponseAndReady();
return;
}
/* 正常帧不打日志（避免 UART 刷屏）；CONFIG_SPI_APP_LOG_ENABLE
* 只覆盖异常路径（非v2帧/未知type/SEQ跳变/session不匹配），正常态静默。 */
// 解析合法 v2 帧成功
SPI_DIAG_RECORD(
s_diag.valid_v2_frames++;
s_diag.last_rx_type = frame_type;
s_diag.last_rx_seq = hdr.tx_seq;
);
if (sof_offset > 0U && sof_offset != 0xFFU) {
SPI_DIAG_RECORD(s_diag.err_sof_drift++);
}
g_pendingAckSeq = hdr.tx_seq;
if (frame_type == V2_TYPE_LINK_HELLO) {
/* 合法 HELLO 已到：停掉起机补清，避免 reset 打断建连 */
SPI_DIAG_RECORD(s_diag.hello_count++);
Esp32En::cancelRelinkFromSpi();
g_sessionId = hdr.session_id;
g_txSeq = 0;
g_expectedRxSeq = 0;
g_v2Active = true;
s_hasCachedResp = false;
/* 与 requestEsp32Read() 一致（L5 8bc01dd）：建帧前 credit=1，
* 避免 TX 占用时 g_localCredit=0 写入 HELLO_ACK，导致主机 remoteCredit=0 拒发 PING。 */
g_localCredit = 1U;
/* 建连 + 开机身份一次完成：HELLO_ACK = 6B 链路 + 16B 身份（版本/开关） */
uint8_t identity[V2_APP_IDENTITY_LEN];
fillGd32AppIdentityPayload(identity);
size_t built_len = 0U;
@@ -583,6 +867,10 @@ void AppSpiCommand::processCommand()
memcpy(s_lastRespBuf, m_txBuf, m_txLen);
s_lastRespLen = m_txLen;
s_hasCachedResp = true;
SPI_DIAG_RECORD(
s_diag.last_tx_type = V2_TYPE_LINK_HELLO;
s_diag.last_tx_seq = 0;
);
finishResponseAndReady();
return;
@@ -590,42 +878,77 @@ void AppSpiCommand::processCommand()
if (g_v2Active) {
if (hdr.session_id != g_sessionId) {
postLogFmt("[SPI-APP] session 不匹配 0x%02X -> LINK_ERROR",
(uint8_t)(hdr.session_id & 0xFFU));
SPI_DIAG_RECORD(
s_diag.session_mismatch++;
s_diag.last_error_code = V2_ERR_SESSION;
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
s_diag.error_rsp_count++;
);
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] Session mismatch: rx=0x%08lX != cur=0x%08lX",
(unsigned long)hdr.session_id, (unsigned long)g_sessionId);
postLog(log_msg);
#endif
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;
SPI_DIAG_RECORD(
s_diag.last_tx_type = V2_TYPE_LINK_ERROR;
s_diag.last_tx_seq = g_txSeq;
);
finishResponseAndReady();
return;
}
const uint8_t dist = v2_seq_distance(hdr.tx_seq, g_expectedRxSeq);
if (dist == 0U) {
SPI_DIAG_RECORD(s_diag.seq_ok_count++);
g_expectedRxSeq = (uint8_t)(g_expectedRxSeq + 1U);
} else if (dist >= 128U) {
SPI_DIAG_RECORD(s_diag.seq_dup_count++);
if (s_hasCachedResp && hdr.tx_seq == s_lastReqSeq) {
postLogFmt("[SPI-APP] 重复请求 seq=0x%02X -> 重发缓存", hdr.tx_seq);
postLogFmt("[SPI-DIAG][INFO] 重复请求 seq=0x%02X -> 重发缓存", hdr.tx_seq);
memcpy(m_txBuf, s_lastRespBuf, s_lastRespLen);
m_txLen = s_lastRespLen;
finishResponseAndReady();
return;
}
} else {
postLogFmt("[SPI-APP] SEQ jump rx=0x%02X", hdr.tx_seq);
SPI_DIAG_RECORD(
s_diag.seq_jump_count++;
s_diag.last_error_code = V2_ERR_SEQ_JUMP;
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
);
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][WARN] SEQ jump: rx=0x%02X exp=0x%02X (gap=%u)",
hdr.tx_seq, g_expectedRxSeq, (unsigned)dist);
postLog(log_msg);
#endif
g_expectedRxSeq = (uint8_t)(hdr.tx_seq + 1U);
if (frame_type != kTypeBootReq) {
SPI_DIAG_RECORD(s_diag.error_rsp_count++);
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;
SPI_DIAG_RECORD(
s_diag.last_tx_type = V2_TYPE_LINK_ERROR;
s_diag.last_tx_seq = g_txSeq;
);
finishResponseAndReady();
return;
}
postLog("SEQ jump but BOOT_REQ still handled");
postLog("[SPI-DIAG] SEQ jump but BOOT_REQ still handled");
}
}
@@ -650,19 +973,46 @@ void AppSpiCommand::processCommand()
}
if (!handled) {
postLogFmt("[SPI-APP] 未知 type=0x%02X -> ERROR", frame_type);
SPI_DIAG_RECORD(
s_diag.unknown_type_count++;
s_diag.last_unknown_type = frame_type;
s_diag.last_error_code = 0xE9U;
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
s_diag.error_rsp_count++;
);
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] 未知 type=0x%02X -> ERROR 0xE9", frame_type);
postLog(log_msg);
#endif
uint8_t err = 0xE9U; /* E9=无 handler 认领 */
spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
}
if (tx_len == 0U) {
SPI_DIAG_RECORD(
s_diag.handler_empty_count++;
s_diag.last_empty_type = frame_type;
s_diag.last_error_code = 0xEAU;
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
s_diag.error_rsp_count++;
);
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
char log_msg[128];
snprintf(log_msg, sizeof(log_msg),
"[SPI-DIAG][ERR] handler t=0x%02X tx_len=0 -> ERROR 0xEA", frame_type);
postLog(log_msg);
#endif
uint8_t err = 0xEAU; /* EA=handler 命中但未产出响应 */
spi_build_frame(kRspError, &err, 1U, m_txBuf, &tx_len);
/* handler 命中但没产出响应（典型=buildResponse 构帧失败/业务拒绝）走此兜底错误路径。 */
postLogFmt("[SPI-APP] handler t=0x%02X tx_len=0 -> ERROR", frame_type);
}
m_txLen = tx_len;
SPI_DIAG_RECORD(
s_diag.last_tx_type = m_txBuf[V2_OFF_TYPE];
s_diag.last_tx_seq = g_txSeq;
);
if (g_v2Active) {
s_lastReqSeq = hdr.tx_seq;
@@ -728,11 +1078,15 @@ void AppSpiCommand::resetEsp32Link()
armSpiDmasForNextCs();
updateDataReady();
configureExti();
#if (CONFIG_SPI_APP_LOG_ENABLE != 0)
printf("[SPI-APP] resetEsp32Link: SPI0/DMA/EXTI re-init done\r\n");
#endif
}
bool AppSpiCommand::requestEsp32Read(uint8_t frame_type, const uint8_t *payload, uint16_t payload_len)
{
SPI_DIAG_RECORD(s_diag.ring_request_count++);
/* 若上一次按铃尚未被 ESP32 读走，拒绝重复按铃 */
if (m_ringPending) {
return false;
@@ -765,39 +1119,61 @@ bool AppSpiCommand::requestEsp32Read(uint8_t frame_type, const uint8_t *payload,
}
/* ============================================================
* 主循环轮询：打印延迟日志 + 按铃超时看护
* 主循环轮询：打印延迟日志 + 按铃超时看护 + 周期/异常诊断报告
* ============================================================ */
void AppSpiCommand::poll()
{
/* 打印 ISR 推迟的日志 */
char log_copy[kLogBufSize] = {};
bool has_log = false;
uint32_t save = RT_CRITICAL_SAVE();
if (m_logPending) {
memcpy(log_copy, m_logBuf, sizeof(log_copy));
m_logPending = false;
has_log = true;
}
RT_CRITICAL_RESTORE(save);
if (has_log) {
printf("%s\r\n", log_copy);
/* 1. 打印 ISR 推迟的日志队列（环形缓冲，避免丢弃） */
while (m_logTail != m_logHead) {
printf("%s\r\n", m_logQueue[m_logTail]);
m_logTail = (uint8_t)((m_logTail + 1U) % kLogSlotCount);
}
/* 按铃超时看护：ESP32 未在 kRingTimeoutMs 内来读则放弃本次按铃。
/* 2. 按铃超时看护：ESP32 未在 kRingTimeoutMs 内来读则放弃本次按铃。
* 防止 ESP32 不响应时永久占用 SPIready 线导致双方死锁。 */
if (m_ringPending) {
uint32_t save2 = RT_CRITICAL_SAVE();
if (m_ringPending) {
if ((int32_t)(SysTickTimer::getMs() - m_ringDeadline) >= 0) {
printf("[SPI-APP] 按铃超时取消 (ESP32 未响应, 释放 SPIready 重试)\r\n");
SPI_DIAG_RECORD(s_diag.ring_timeout_count++);
#if (CONFIG_SPI_DIAG_PERIODIC_PRINT != 0)
printf("[SPI-DIAG][WARN] 按铃超时取消 (ESP32 未在 %lums 内响应, 释放 SPIready 重试)\r\n",
(unsigned long)kRingTimeoutMs);
#endif
cancelRing();
}
}
RT_CRITICAL_RESTORE(save2);
}
#if (CONFIG_SPI_DIAG_ENABLE != 0 && CONFIG_SPI_DIAG_PERIODIC_PRINT != 0)
/* 3. 定期 / 增量打印 SPI 诊断摘要 */
static uint32_t s_lastDiagPrintMs = 0;
static uint32_t s_lastDiagErrCount = 0;
const uint32_t now = SysTickTimer::getMs();
const uint32_t totalErrs = s_diag.parse_fail_count + s_diag.rx_overrun_count +
s_diag.short_rx_len_count + s_diag.session_mismatch +
s_diag.seq_jump_count + s_diag.ring_timeout_count +
s_diag.unknown_type_count + s_diag.handler_empty_count;
const bool hasNewError = (totalErrs > s_lastDiagErrCount && (now - s_lastDiagPrintMs >= 2000U));
const bool periodicCheck = (s_diag.total_cs_assert > 0U && (now - s_lastDiagPrintMs >= 5000U));
if (hasNewError || periodicCheck) {
s_lastDiagPrintMs = now;
s_lastDiagErrCount = totalErrs;
const uint8_t cs_pin = (gpio_input_bit_get(GPIOA, GPIO_PIN_15) == SET) ? 1U : 0U;
const uint8_t rdy_pin = (gpio_input_bit_get(CONFIG_SPI_READY_PORT, CONFIG_SPI_READY_PIN) == SET) ? 1U : 0U;
printf("[SPI-DIAG] CS:assert=%lu rls=%lu ok_v2=%lu | err[CRC:%lu noSOF:%lu short:%lu ovr:%lu sessMis:%lu jmp:%lu tmo:%lu] pins[CS:%d RDY:%d STAT:0x%02X]\r\n",
(unsigned long)s_diag.total_cs_assert, (unsigned long)s_diag.total_cs_release,
(unsigned long)s_diag.valid_v2_frames,
(unsigned long)s_diag.err_crc_mismatch, (unsigned long)s_diag.err_no_sof,
(unsigned long)s_diag.short_rx_len_count, (unsigned long)s_diag.rx_overrun_count,
(unsigned long)s_diag.session_mismatch, (unsigned long)s_diag.seq_jump_count,
(unsigned long)s_diag.ring_timeout_count, cs_pin, rdy_pin, (unsigned)(s_diag.last_spi_stat & 0xFFU));
}
#endif
}
/* ============================================================
@@ -806,6 +1182,7 @@ void AppSpiCommand::poll()
void AppSpiCommand::onCsAssert()
{
SPI_DIAG_RECORD(s_diag.total_cs_assert++);
if (m_csActive) {
return;
}
@@ -817,9 +1194,16 @@ void AppSpiCommand::onCsAssert()
void AppSpiCommand::onCsRelease()
{
SPI_DIAG_RECORD(s_diag.total_cs_release++);
if (!m_csActive) {
/* EXTI 丢失下降沿时：仍尝试收尾并 re-arm，避免永久失步（对齐 BOOT） */
m_rxLen = stopSpiDmas(kRxBufSize);
SPI_DIAG_RECORD(
s_diag.missed_cs_assert++;
s_diag.last_rx_len = m_rxLen;
s_diag.last_spi_stat = (uint16_t)SPI_STAT(SPI0);
);
postLogFmt("[SPI-DIAG][WARN] CS release without assert (got %u B)", (uint8_t)m_rxLen);
drainSpiRxHw();
if (m_txLen > 0U) {
m_txLen = 0U;
@@ -839,18 +1223,15 @@ void AppSpiCommand::onCsRelease()
/* 停 DMA 并取本笔 RX 长度（先读 CHCNT 再 disable，否则计数器被清） */
m_rxLen = stopSpiDmas(kRxBufSize);
SPI_DIAG_RECORD(
s_diag.last_rx_len = m_rxLen;
s_diag.last_spi_stat = (uint16_t)SPI_STAT(SPI0);
);
drainSpiRxHw();
/* 若本次 CS 事务是 ESP32 响应 GD32 按铃来读请求帧，
* 则 GD32 的请求帧已通过 DMA 输出到 MISO，取消按铃状态。
*
* 但需区分：ESP32 发的是 dummy 读（按铃响应）还是 v2 协议帧（如 PING/OTA/0xB0）。
* 若 GD32 正在按铃时 ESP32 发协议帧，会因 m_ringPending=true 被误吞，
* 导致命令无法处理。检测到 v2 SOF 时取消按铃并走正常命令处理。 */
* 则 GD32 的请求帧已通过 DMA 输出到 MISO，取消按铃状态。 */
if (m_ringPending) {
/* 判断本次收到的数据是否为 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;
@@ -862,9 +1243,8 @@ void AppSpiCommand::onCsRelease()
}
}
if (is_v2_frame) {
/* ESP32 发的是 v2 协议帧（如 PING/OTA/0xB0 等），不是按铃响应。
* 取消按铃，清空 TX 让 processCommand() 重新装载对应应答。
* processCommand() 末尾由 updateDataReady() 依据新 m_txLen 驱动 PB6。 */
SPI_DIAG_RECORD(s_diag.ring_collision_count++);
postLog("[SPI-DIAG][INFO] Ring collision: host sent v2 frame while ring pending");
m_ringPending = false;
m_txLen = 0U;
memset(m_txBuf, 0xFF, sizeof(m_txBuf));
@@ -883,6 +1263,42 @@ void AppSpiCommand::onCsRelease()
}
if (shouldIgnoreTransaction(m_rxBuf, m_rxLen)) {
if (m_rxLen == 0U) {
SPI_DIAG_RECORD(
s_diag.zero_rx_len_count++;
s_diag.last_error_reason = (uint8_t)SPI_PARSE_ERR_TOO_SHORT;
s_diag.last_error_rx_len = 0U;
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
);
postLog("[SPI-DIAG][WARN] Ignored 0-byte transaction (SCK did not toggle)");
} else if (isAllBytesValue(m_rxBuf, m_rxLen, 0xFFU)) {
SPI_DIAG_RECORD(
s_diag.all_ff_count++;
s_diag.last_error_reason = (uint8_t)SPI_PARSE_ERR_ALL_FF;
s_diag.last_error_rx_len = m_rxLen;
memcpy(s_diag.last_error_bytes, m_rxBuf, (m_rxLen < 8U) ? m_rxLen : 8U);
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
);
postLogFmt("[SPI-DIAG][WARN] Ignored all-0xFF transaction (%u bytes)", (uint8_t)m_rxLen);
} else if (isAllBytesValue(m_rxBuf, m_rxLen, 0x00U)) {
SPI_DIAG_RECORD(
s_diag.all_00_count++;
s_diag.last_error_reason = (uint8_t)SPI_PARSE_ERR_ALL_00;
s_diag.last_error_rx_len = m_rxLen;
memcpy(s_diag.last_error_bytes, m_rxBuf, (m_rxLen < 8U) ? m_rxLen : 8U);
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
);
postLogFmt("[SPI-DIAG][WARN] Ignored all-0x00 transaction (%u bytes)", (uint8_t)m_rxLen);
} else {
SPI_DIAG_RECORD(
s_diag.short_rx_len_count++;
s_diag.last_error_reason = (uint8_t)SPI_PARSE_ERR_TOO_SHORT;
s_diag.last_error_rx_len = m_rxLen;
memcpy(s_diag.last_error_bytes, m_rxBuf, (m_rxLen < 8U) ? m_rxLen : 8U);
s_diag.last_error_uptime_ms = SysTickTimer::getMs();
);
postLogFmt("[SPI-DIAG][WARN] Ignored short transaction (%u bytes < 20B)", (uint8_t)m_rxLen);
}
m_rxLen = 0U;
/* 起机毛刺/相位漂移后仅 re-arm DMA 不够：SPI0 可能已 OVR 卡死。
* 顺手重配 SPI0+DMA（不动 EXTI/session），下一笔 HELLO 才能收进来。 */
@@ -894,12 +1310,6 @@ void AppSpiCommand::onCsRelease()
m_txLen = 0U;
memset(m_txBuf, 0xFF, sizeof(m_txBuf));
/* ★ 关键：在 processCommand 之前同步 g_localCredit。
* 此时 m_txLen=0, m_ringPending=false → g_localCredit=1。
* 若不做，buildResponse 会读到上一次 pushStatus/requestEsp32Read 留下的
* g_localCredit=0 → 响应帧携带 credit=0 → ESP32 m_remoteCredit=0 → 后续发送死锁。
* 这是电机 OTA 吐量只有 1 chunk/2s 的根因。 */
updateDataReady();
/* 命令处理在 EXTI ISR 内同步完成（对齐 BOOT 的 isrProcessFrame 模式），
@@ -920,12 +1330,20 @@ void AppSpiCommand::onInterrupt()
/* RX 已改走 DMA0_CH1：RBNE 逐字节中断已禁用，本 ISR 只保留错误标志清理。
* CS 边沿处理全部在 onCsExtiInterrupt 的 EXTI15 ISR 里完成。 */
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_RXORERR) != RESET) {
/* RXORERR 理论上不应再出现（RX 走 DMA），但兜底清理避免标志卡死。
* 读 SPI_DATA + SPI_STAT 清除 OVR 标志。 */
SPI_DIAG_RECORD(
s_diag.rx_overrun_count++;
s_diag.last_spi_stat = (uint16_t)SPI_STAT(SPI0);
);
postLog("[SPI-DIAG][ERR] SPI0 RXORERR (RX Overrun Error)!");
(void)spi_i2s_data_receive(SPI0);
(void)SPI_STAT(SPI0);
}
if (spi_i2s_interrupt_flag_get(SPI0, SPI_I2S_INT_FLAG_FERR) != RESET) {
SPI_DIAG_RECORD(
s_diag.format_error_count++;
s_diag.last_spi_stat = (uint16_t)SPI_STAT(SPI0);
);
postLog("[SPI-DIAG][ERR] SPI0 FERR (Frame Format Error)!");
spi_i2s_format_error_clear(SPI0, SPI_FLAG_FERR);
}
}
GD32E508_DCU_APP/device/spi/app_spi_command.h
+25 -1
View File
@@ -3,6 +3,7 @@
#include <cstdint>
#include "sys/config.h"
#include "device/spi/app_spi_diag.h"
class ISpiCommandHandler;
@@ -51,6 +52,9 @@ public:
/** @brief 记录一条带 1 字节参数的待输出日志。 */
void postLogFmt(const char *fmt, uint8_t val);
/** @brief 记录一条带双 32 位参数的待输出日志。 */
void postLogFmt32(const char *fmt, uint32_t v1, uint32_t v2);
/**
* @brief 将应答帧构建到指定发送缓冲区。
* @param[out] tx_buf 发送缓冲区。
@@ -85,6 +89,21 @@ public:
/** @brief 查询当前是否有未读按铃（ESP32 尚未来读）。 */
bool isRingPending() const { return m_ringPending; }
/** @brief 查询 v2 会话是否已建立。 */
bool isV2Active() const;
/** @brief 查询当前 v2 会话 ID。 */
uint32_t getSessionId() const;
/** @brief 查询当前 local credit。 */
uint8_t getLocalCredit() const;
/** @brief 查询 CS 是否当前处于激活（低电平）状态。 */
bool isCsActive() const { return m_csActive; }
/** @brief 打印完整 ASCII SPI 链路诊断报告。 */
void dumpDiag() const;
/** @brief 取消未完成的按铃（释放 SPIready、清 m_ringPending）。
* 0xB0 进 BOOT 等路径需公开调用，避免 0xC1 残留盖住 ACK。 */
void cancelRing();
@@ -111,7 +130,12 @@ private:
/** 本笔 CS 实际收到的字节数（CS 上升沿时由 RX DMA CHCNT 反算得到）。 */
volatile uint16_t m_rxLen = 0U;
volatile uint16_t m_txLen = 0U;
volatile bool m_logPending = false;
/** 日志环形缓冲区：避免高频/多事件并发时单缓冲覆盖丢日志。 */
static constexpr uint8_t kLogSlotCount = 8U;
static constexpr uint8_t kLogSlotLen = 128U;
char m_logQueue[kLogSlotCount][kLogSlotLen] = {};
volatile uint8_t m_logHead = 0U;
volatile uint8_t m_logTail = 0U;
/** RX DMA 接收缓冲（替代旧 RBNE 逐字节累积的 m_rxBuf）。
* CS 上升沿时 m_rxLen 为本笔实际收到的字节数，本缓冲前 m_rxLen 字节有效。 */
uint8_t m_rxBuf[kRxBufSize] = {};
GD32E508_DCU_APP/device/spi/app_spi_command_defs.h
+12
View File
@@ -35,6 +35,10 @@ static constexpr uint8_t kTypeExmcDiag = 0xA2U;
* [12..24] fault_codes[13]（每模块 1B 故障码，0=成功；编码见 sys/initial.h，
* canfd = 原因码|(首个失败通道<<4)）。位定义与 sys/initial.h 一致。 */
static constexpr uint8_t kTypeInitStatus = 0xA3U;
/** @brief SPI 链路全量诊断查询与控制（ESP32→GD32）：
* payload[0]=sub_cmd: 0=读取全量诊断快照 (ACK ~88B), 1=复位诊断计数器, 2=打印完整报告到 GD32 串口。
* 若 payload 为空，默认执行 sub_cmd=0。 */
static constexpr uint8_t kTypeSpiDiag = 0xA4U;
static constexpr uint8_t kTypeBootReq = 0xB0U;
static constexpr uint8_t kTypeCanSend = 0xC0U;
static constexpr uint8_t kTypeCanFeedback = 0xC1U; /**< ESP32 -> GD32 轮询 CAN 反馈快照 */
@@ -58,6 +62,14 @@ static constexpr uint8_t kTypeMotorVersion = 0xC6U;
* 响应 ACK: count(1) + 每条目 1 字节状态（CanTxResult 码）。 */
static constexpr uint8_t kTypeCanBurstSend = 0xC7U;
/** @brief CAN 通道收发器 Silent 开关（ESP32→GD32）：只听不发（驱动关断、接收照常）。
* 请求 payload: [0] channel 0/1/2, [1] silent 1=进 Silent / 0=回 Normal。
* 应答 ACK: [0] channel, [1] 实际生效的 silent（与发送门控同一个值），[2] 该通道是否使能。
* ERROR: 0xE0=payload 过短, 0xE1=通道未使能/非法, 0xE2=S 脚回读与意图不符（标志已回滚）。
* 生效期间该通道所有发送入口（0xC0/0xC7/桥接/relay）返回 0xE6=kErrSilent，
* 不计错误计数；静默不持久化，上电 init 一律回 Normal。 */
static constexpr uint8_t kTypeCanSetSilent = 0xC8U;
/** @brief 电机 OTA relay 命令（ESP32→GD32）：start / cancel / query。
* payload[0]=cmd(0=start,1=cancel,2=query), start 时 payload[1]=ch, payload[2..5]=fw_size LE */
static constexpr uint8_t kTypeMotorOtaCmd = 0xD0U;
GD32E508_DCU_APP/device/spi/app_spi_diag.h
+122
View File
@@ -0,0 +1,122 @@
#ifndef DEVICE_APP_SPI_DIAG_H
#define DEVICE_APP_SPI_DIAG_H
#include <cstdint>
#include <cstddef>
#include "sys/config.h"
/**
* @file app_spi_diag.h
* @brief SPI 链路全量硬件与协议诊断模块声明。
*
* 用于快速量化与定位 SPI 通信故障根因：
* - 物理/时序层：CS 边沿跳变、丢失下降沿、0 字节事务(SCK未走/DMA落后)、短包(<20B)、全FF/全00
* - 硬件状态：SPI0 RXORERR (接收FIFO溢出)、FERR (格式错误)、SPI_STAT 寄存器值
* - 协议/帧层：SOF丢失、相位偏移(SOF drift)、版本错误、超长/截断、CRC32位跳变(附带期望值与计算值)
* - 状态机/会话：Session ID脱节、序号跳变(丢包)、序号重复(重发)、未处理命令TYPE、空响应
* - 握手/流控：PB6 DATA_READY 引脚电平、PA15 CS 引脚电平、主动按铃超时、按铃竞争碰撞
* - 现场快照：记录最近一次异常发生时刻、实际接收长度、前导原始字节及 CRC 对比
*/
/**
* @brief SPI 帧解析失败原因细分
*/
enum SpiParseResult : uint8_t {
SPI_PARSE_OK = 0U, ///< 成功解析合法 v2 帧
SPI_PARSE_ERR_TOO_SHORT = 1U, ///< 事务长度小于 v2 最小帧头 (rxLen < 20)
SPI_PARSE_ERR_ALL_FF = 2U, ///< 接收数据全为 0xFF (从机浮空/DMA未就绪/MISO未连接)
SPI_PARSE_ERR_ALL_00 = 3U, ///< 接收数据全为 0x00 (地电平短路或总线死锁)
SPI_PARSE_ERR_NO_SOF = 4U, ///< 未扫描到 SOF 同步字 (0xA5 0x5A)
SPI_PARSE_ERR_BAD_VERSION = 5U, ///< 找到 SOF，但 VERSION != 0x02
SPI_PARSE_ERR_BAD_LEN = 6U, ///< 长度异常 (payload_len > 236 或帧总长超出实际收到的 rxLen)
SPI_PARSE_ERR_CRC_MISMATCH = 7U, ///< CRC32 校验失败 (物理信号干扰/位跳变)
};
/**
* @brief SPI 链路全量诊断计数器与状态快照
*/
struct SpiDiagStats {
/* 1. CS 边沿与事务统计 */
uint32_t total_cs_assert; ///< CS 下降沿次数
uint32_t total_cs_release; ///< CS 上升沿次数
uint32_t missed_cs_assert; ///< 丢失 CS 下降沿异常次数
uint32_t zero_rx_len_count; ///< RX 收到 0 字节 (SCK 未时钟化或 DMA 启动严重落后)
uint32_t short_rx_len_count; ///< RX 收到 1~19 字节 (<20B 残包)
uint32_t all_ff_count; ///< 全 0xFF 事务数
uint32_t all_00_count; ///< 全 0x00 事务数
/* 2. 硬件外设与状态 */
uint32_t rx_overrun_count; ///< SPI0 RXORERR (接收 FIFO 溢出)
uint32_t format_error_count; ///< SPI0 FERR (帧格式错误)
uint16_t last_spi_stat; ///< 最近一笔事务结束时的 SPI_STAT 寄存器值
/* 3. 帧解析统计 */
uint32_t valid_v2_frames; ///< 成功解析的合法 v2 帧总数
uint32_t parse_fail_count; ///< 帧解析失败总数
uint32_t err_no_sof; ///< 未找到 SOF0(0xA5)+SOF1(0x5A)
uint32_t err_sof_drift; ///< SOF 偏移不在索引 0 (前导毛刺或字节时序偏移)
uint32_t err_bad_version; ///< 版本不匹配
uint32_t err_bad_len; ///< 长度字段错误或事务截断
uint32_t err_crc_mismatch; ///< CRC32 校验失败
/* 4. 会话与序号流控 */
uint32_t hello_count; ///< 收到 LINK_HELLO 次数
uint32_t session_mismatch; ///< Session ID 不匹配 (对端重置或会话脱节)
uint32_t seq_ok_count; ///< 序号严格递增正常次数
uint32_t seq_jump_count; ///< 序号跳变 (丢帧)
uint32_t seq_dup_count; ///< 序号重复 (重发包)
uint16_t last_rx_len; ///< 最近收到的 rx_len (字节数)
uint8_t last_rx_seq; ///< 最近收到的 rx_seq
uint8_t expected_rx_seq; ///< 当前期望的 rx_seq
uint8_t last_tx_seq; ///< 最近发送的 tx_seq
/* 5. 命令路由与处理 */
uint8_t last_rx_type; ///< 最近收到的命令 TYPE
uint8_t last_tx_type; ///< 最近构建的响应 TYPE
uint32_t unknown_type_count; ///< 未知命令 TYPE (无 handler 注册)
uint8_t last_unknown_type; ///< 最近未知的 TYPE 值
uint32_t handler_empty_count; ///< Handler 执行但返回 tx_len == 0
uint8_t last_empty_type; ///< 最近产出 0 字节的 TYPE 值
uint32_t error_rsp_count; ///< GD32 主动返回 0x82 ERROR 响应次数
uint8_t last_error_code; ///< 最近一次返回 0x82 的错误码 (0xE8/0xE9/0xEA/V2_ERR_*)
/* 6. 握手引脚与流控 */
uint32_t ring_request_count; ///< 主动按铃请求次数
uint32_t ring_timeout_count; ///< 按铃超时 (ESP32 未在期限内读走)
uint32_t ring_collision_count; ///< 按铃与 ESP32 主动发帧竞争碰撞次数
uint8_t current_local_credit; ///< 当前 local credit (0 或 1)
/* 7. 最近异常快照 (用于定位具体错误现场) */
uint32_t last_error_uptime_ms; ///< 异常发生时刻 SysTick 毫秒数
uint16_t last_error_rx_len; ///< 异常事务收到的字节数
uint8_t last_error_bytes[8]; ///< 异常事务前 8 字节原始数据
uint32_t last_error_calc_crc; ///< CRC 错误时: 计算出的 CRC
uint32_t last_error_expected_crc;///< CRC 错误时: 帧内携带的 CRC
uint8_t last_error_sof_offset; ///< SOF 所在的偏移位置 (255 表示未找到)
uint8_t last_error_reason; ///< SpiParseResult 错误原因枚举
};
#if (CONFIG_SPI_DIAG_ENABLE != 0)
/** @brief 获取当前全局 SPI 诊断统计快照引用 */
const SpiDiagStats& getSpiDiagStats();
/** @brief 复位清零所有 SPI 诊断统计计数器 */
void resetSpiDiagStats();
/** @brief 将解析结果枚举转换为可读字符串 */
const char* spiParseResultToString(SpiParseResult res);
/** @brief 打印完整 SPI 链路诊断报告到串口 (ASCII 表格) */
void dumpSpiDiag();
#else
inline const SpiDiagStats& getSpiDiagStats()
{
static const SpiDiagStats s_empty{};
return s_empty;
}
inline void resetSpiDiagStats() {}
inline const char* spiParseResultToString(SpiParseResult /*res*/) { return "DISABLED"; }
inline void dumpSpiDiag() {}
#endif
#endif /* DEVICE_APP_SPI_DIAG_H */