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

feat(ota): 优化 GD32 OTA 流程和 CAN 反馈机制

Browse Source 
- 实现 GD32 主动推送 CAN 反馈架构，替代 ESP32 1Hz 轮询方式，
  减少 SPI 总线占用提升带宽效率

- 添加 GD32 Bootloader 就绪检测机制，通过 PB6 硬件信号等待
  保证 OTA 过程稳定可靠

- 集成 CREDIT 感知功能，当 GD32 写 Flash 缓冲时自动等待，
  避免数据包丢失提高传输成功率

- 重构 canFdPollFeedback 为 canFdParseFeedbackPage 函数，
  支持被动解析 GD32 主动推送的数据页

- 更新版本号从 0.37 到 0.3.38 并添加 Kconfig 配置选项支持
This commit is contained in:
小龙虾
2026-07-08 02:51:38 +08:00
parent 069ce8e6a5
commit 661ae54424
13 changed files with 974 additions and 595 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/monitor/can_feedback_task.cpp
+65 -44
View File
@@ -1,15 +1,23 @@
/*
* can_feedback_task.cpp - 周期性轮询 GD32 三路 CAN 1Hz 反馈快照
* can_feedback_task.cpp - 被动监听 GD32 主动推送的 CAN 反馈快照
*
* 通过 SPI 协议帧 0xC1 拉取 GD32 端的通道统计与最近一帧信息，
* 用调试日志输出；其它消费者（Web/WebSocket）可直接读取
* CanFeedbackTask::snapshot(channel) 拷贝最新一份数据。
* 架构（GD32 主动推送，ESP32 被动接收）：
* GD32 APP 在主循环中调用 canFeedbackPushStep()，循环遍历 3 通道 × 2 页，
* 通过 requestEsp32Read(0xC1) 下拉 SPIready 主动按铃，将每页反馈 payload
* 推送给 ESP32。ESP32 本任务调用 checkGd32Request() 阻塞等待按铃，读到
* 一帧后用 canFdParseFeedbackPage() 解析并累积到 s_work[channel]，再
* publish() 到 s_latest[channel] 供 Web/WebSocket 读取。
*
* 替代了原先 ESP32 1Hz 主动发 0xC1 轮询的逻辑，避免占用主线 SPI 带宽。
*
* OTA 期间通过 pauseCanFeedbackTask(true) 暂停本任务，避免与 OTA 抢占 SPI。
*/
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "transport/canfd_bridge.h"
#include "transport/spi_master.h"
#include "monitor/debug_log.h"
#include "monitor/can_feedback_task.h"
@@ -17,17 +25,20 @@
namespace {
constexpr uint32_t kPollIntervalMs = 1000U; ///< 1Hz 拉取节拍
constexpr uint32_t kPollTimeoutMs = 200U; ///< 单次 SPI 事务超时
constexpr uint32_t kWaitRingMs = 500U; ///< 单次等待 GD32 按铃超时
constexpr uint32_t kPauseDelayMs = 100U; ///< 暂停时的轮询间隔
constexpr uint8_t kSpiCanFeedbackType = 0xC1U;
constexpr size_t kRingPayloadMax = 128U; ///< 反馈 payload 最大长度
constexpr const char *kTag = "CAN_FB";
static can_feedback_result_t s_latest[CAN_CHANNEL_MAX];
static bool s_valid [CAN_CHANNEL_MAX];
static SemaphoreHandle_t s_mutex = nullptr;
static volatile bool s_paused = false;
static can_channel_feedback_t s_prev_stats[CAN_CHANNEL_MAX];
static bool s_prev_valid[CAN_CHANNEL_MAX];
static bool s_prev_poll_ok[CAN_CHANNEL_MAX];
/* 累积工作缓冲：跨 page 0/1 累积每通道的完整反馈 */
static can_feedback_result_t s_work [CAN_CHANNEL_MAX];
static uint8_t s_workIdx[CAN_CHANNEL_MAX];
static void publish(uint8_t ch, const can_feedback_result_t &fb)
{
@@ -41,55 +52,63 @@ static void publish(uint8_t ch, const can_feedback_result_t &fb)
static void taskLoop(void *)
{
DEBUG_INFO(kTag, "CAN 反馈轮询任务启动 (1Hz, 0xC1)");
DEBUG_INFO(kTag, "CAN 反馈被动监听任务启动 (GD32 主动推送, 0xC1)");
uint8_t ring_type = 0U;
uint8_t ring_payload[kRingPayloadMax] = {};
size_t ring_len = 0U;
can_feedback_result_t fb{};
for (;;) {
/* OTA 进行中时暂停 CAN 轮询，避免抢占 SPI 导致 OTA 握手失败 */
if (s_paused) {
vTaskDelay(pdMS_TO_TICKS(kPollIntervalMs));
vTaskDelay(pdMS_TO_TICKS(kPauseDelayMs));
continue;
}
for (uint8_t ch = 0U; ch < CAN_CHANNEL_MAX; ++ch) {
const int rc = canFdPollFeedback(static_cast<can_channel_t>(ch),
&fb, kPollTimeoutMs);
if (rc == 0) {
publish(ch, fb);
/* 阻塞等待 GD32 按铃并读取一帧（超时则重试） */
esp_err_t ret = SpiMaster::instance().checkGd32Request(kWaitRingMs);
if (ret != ESP_OK) {
continue;
}
if (fb.stats.error_count != 0U) {
DEBUG_INFO(kTag,
"CH%u seq=%lu mode=%u rx=%lu tx=%lu drop=%lu err=%lu ids=%u",
static_cast<unsigned>(ch),
static_cast<unsigned long>(fb.stats.snapshot_seq),
static_cast<unsigned>(fb.stats.mode),
static_cast<unsigned long>(fb.stats.rx_count),
static_cast<unsigned long>(fb.stats.tx_count),
static_cast<unsigned long>(fb.stats.rx_drop_count),
static_cast<unsigned long>(fb.stats.error_count),
static_cast<unsigned>(fb.valid));
}
/* 取出 checkGd32Request 存入的 type/payload */
if (!SpiMaster::instance().takeRingRx(&ring_type, ring_payload,
sizeof(ring_payload), &ring_len)) {
continue;
}
s_prev_stats[ch] = fb.stats;
s_prev_valid[ch] = true;
s_prev_poll_ok[ch] = true;
} else {
if (s_prev_poll_ok[ch]) {
DEBUG_WARN(kTag, "CH%u 轮询失败", static_cast<unsigned>(ch));
}
s_prev_stats[ch] = {};
s_prev_valid[ch] = false;
s_prev_poll_ok[ch] = false;
if (ring_type != kSpiCanFeedbackType || ring_len < 28U) {
continue;
}
const uint8_t ch = ring_payload[0];
if (ch >= CAN_CHANNEL_MAX) {
continue;
}
/* 解析本页并累积到工作缓冲，page=0 会自动重置 */
if (canFdParseFeedbackPage(ring_payload, ring_len,
&s_work[ch], &s_workIdx[ch]) == 0) {
publish(ch, s_work[ch]);
if (s_work[ch].stats.error_count != 0U) {
DEBUG_INFO(kTag,
"CH%u seq=%lu mode=%u rx=%lu tx=%lu drop=%lu err=%lu",
static_cast<unsigned>(ch),
static_cast<unsigned long>(s_work[ch].stats.snapshot_seq),
static_cast<unsigned>(s_work[ch].stats.mode),
static_cast<unsigned long>(s_work[ch].stats.rx_count),
static_cast<unsigned long>(s_work[ch].stats.tx_count),
static_cast<unsigned long>(s_work[ch].stats.rx_drop_count),
static_cast<unsigned long>(s_work[ch].stats.error_count));
}
}
vTaskDelay(pdMS_TO_TICKS(kPollIntervalMs));
}
}
} // namespace
/**
* @brief 启动 1Hz CAN 反馈轮询任务（幂等）。
* @brief 启动 CAN 反馈被动监听任务（幂等）。
* @return true 表示任务已存在或创建成功。
*/
bool startCanFeedbackTask()
@@ -106,6 +125,8 @@ bool startCanFeedbackTask()
}
memset(s_latest, 0, sizeof(s_latest));
memset(s_valid, 0, sizeof(s_valid));
memset(s_work, 0, sizeof(s_work));
memset(s_workIdx, 0, sizeof(s_workIdx));
BaseType_t xRet = xTaskCreatePinnedToCore(
taskLoop,
@@ -127,9 +148,9 @@ void pauseCanFeedbackTask(bool pause)
{
s_paused = pause;
if (pause) {
DEBUG_INFO(kTag, "CAN 轮询已暂停（OTA 进行中）");
DEBUG_INFO(kTag, "CAN 监听已暂停（OTA 进行中）");
} else {
DEBUG_INFO(kTag, "CAN 轮询已恢复");
DEBUG_INFO(kTag, "CAN 监听已恢复");
}
}