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

feat(CAN): 实现CAN FD协议栈优化和发送队列机制

Browse Source 
- 将CAN收发缓冲区扩展至64字节以支持CAN FD协议
- 添加发送队列机制防止高负载时消息丢失
- 优化中断处理流程，直接读取消息数据避免DMA竞争
- 修改编译配置指向Release版本目录
- 调整OTA处理逻辑将Flash擦除操作移至主循环执行

BREAKING CHANGE: 缓冲区大小调整可能影响现有CAN通信协议实现
This commit is contained in:
cbb
2026-04-26 02:27:34 +08:00
parent 26cf5af14f
commit d019b41ed6
20 changed files with 1783 additions and 1579 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Robot_V2/.clangd
+3 -3
View File
@@ -1,5 +1,5 @@
CompileFlags:
CompilationDatabase: g:\Robot_v2\BOOT\out\Robot_V2\GD32C103CB\Debug
CompilationDatabase: g:\Robot_v2\BOOT\out\Robot_V2\GD32C103CB\Release
Add:
- "-D_ILP32=1\r\n"
- "-D_USE_STATIC_INLINE=1\r\n"
@@ -245,13 +245,13 @@ CompileFlags:
- "-D__MEMORY_SCOPE_SYSTEM=0\r\n"
- "-D__MEMORY_SCOPE_WRKGRP=2\r\n"
- "-D__MEMORY_SCOPE_WVFRNT=3\r\n"
- "-D__NO_INLINE__=1\r\n"
- "-D__OBJC_BOOL_IS_BOOL=0\r\n"
- "-D__OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES=3\r\n"
- "-D__OPENCL_MEMORY_SCOPE_DEVICE=2\r\n"
- "-D__OPENCL_MEMORY_SCOPE_SUB_GROUP=4\r\n"
- "-D__OPENCL_MEMORY_SCOPE_WORK_GROUP=1\r\n"
- "-D__OPENCL_MEMORY_SCOPE_WORK_ITEM=0\r\n"
- "-D__OPTIMIZE__=1\r\n"
- "-D__ORDER_BIG_ENDIAN__=4321\r\n"
- "-D__ORDER_LITTLE_ENDIAN__=1234\r\n"
- "-D__ORDER_PDP_ENDIAN__=3412\r\n"
@@ -411,7 +411,7 @@ CompileFlags:
- "-D__thumb2__=1\r\n"
- "-D__thumb__=1\r\n"
- '-D__ARMCOMPILER_LIBCXX=1'
- '-IG:/Robot_v2/BOOT/Robot_V2/RTE/_Debug_GD32C103CB'
- '-IG:/Robot_v2/BOOT/Robot_V2/RTE/_Release_GD32C103CB'
- '-IC:/Users/cbb/AppData/Local/arm/packs/ARM/CMSIS/4.5.0/CMSIS/Include'
- >-
-IC:/Users/cbb/AppData/Local/arm/packs/GigaDevice/GD32C10x_DFP/1.0.1/Device/Firmware/Peripherals/inc
Robot_V2/device/Can.cpp
+107 -30
View File
@@ -17,8 +17,25 @@ extern OTAHandler ota;
// 添加DMA相关变量
dma_parameter_struct dma_rx_parameter;
dma_parameter_struct dma_tx_parameter;
uint8_t can_rx_buffer[8]; // CAN接收缓冲区
uint8_t can_tx_buffer[8]; // CAN发送缓冲区
uint8_t can_rx_buffer[64]; // CAN接收缓冲区（支持CAN FD最大64字节）
uint8_t can_tx_buffer[64]; // CAN发送缓冲区（支持CAN FD最大64字节）
// CAN发送队列结构
#define CAN_TX_QUEUE_SIZE 8
typedef struct {
u32 id;
u8 length;
u8 data[64];
u8 valid;
} can_tx_queue_item_t;
static can_tx_queue_item_t tx_queue[CAN_TX_QUEUE_SIZE];
static volatile u8 tx_queue_head = 0;
static volatile u8 tx_queue_tail = 0;
static volatile u8 tx_queue_count = 0;
// 发送队列使用的独立消息结构体
static can_trasnmit_message_struct queue_transmit_message;
/*!
\brief initialize CAN GPIO
@@ -107,7 +124,7 @@ void canfd_config(void) {
can_parameter.auto_bus_off_recovery = DISABLE;
can_parameter.auto_wake_up = DISABLE;
can_parameter.auto_retrans = ENABLE;
can_parameter.rec_fifo_overwrite = ENABLE;
can_parameter.rec_fifo_overwrite = ENABLE; // 改回覆盖模式，丢失旧消息比丢失新消息更可取
can_parameter.trans_fifo_order = ENABLE;
can_parameter.working_mode = CAN_NORMAL_MODE;
/* baudrate 1Mbps, sample piont at 80% */
@@ -231,7 +248,7 @@ u8 CAN_transmiter::sendDATA_ACK(u32 packet_num,
}
/**
* @brief CAN0中断服务程序
* @brief CAN0中断服务程序（优化版：直接读取数据，减少DMA竞态条件）
* @retval 无
*/
void CAN0_RX0_IRQHandler(void) {
@@ -240,14 +257,7 @@ void CAN0_RX0_IRQHandler(void) {
// 清除中断标志
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFL0);
// 使用DMA读取接收到的数据
dma_channel_disable(DMA0, DMA_CH4);
dma_rx_parameter.number =
can_receive_message_length_get(CAN0, CAN_FIFO0);
dma_init(DMA0, DMA_CH4, &dma_rx_parameter);
dma_channel_enable(DMA0, DMA_CH4);
// 读取接收到的数据
// 直接读取消息（包括数据），不依赖DMA
can_receive_message_struct temp_message;
can_message_receive(CAN0, CAN_FIFO0, &temp_message);
@@ -257,7 +267,7 @@ void CAN0_RX0_IRQHandler(void) {
temp_message.rx_efid == CANFD_OTA_ACK_ID ||
temp_message.rx_efid == CANFD_OTA_WAIT_ID ||
temp_message.rx_efid == CANFD_OTA_CANCEL_ID) {
// 将消息复制到接收缓冲区
// 将消息复制到接收缓冲区（包括数据）
CAN0_transmiter.receive_message = temp_message;
// 增加待处理消息计数器
if (CAN0_transmiter.can0_receive_count < 255) {
@@ -284,13 +294,12 @@ void CAN0_RX0_IRQHandler(void) {
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFO0);
#if CAN_DEBUG
printf("CAN FIFO0 overflow\n");
#endif
}
}
/**
* @brief DMA通道4中断服务程序(CAN接收DMA)
* @brief DMA通道4中断服务程序(CAN接收DMA) - 优化版：支持64字节
* @retval 无
*/
void DMA0_Channel4_IRQHandler(void) {
@@ -298,9 +307,12 @@ void DMA0_Channel4_IRQHandler(void) {
// 清除DMA传输完成中断标志
dma_interrupt_flag_clear(DMA0, DMA_CH4, DMA_INT_FLAG_G);
// 将DMA缓冲区的数据复制到接收消息结构体
for (int i = 0; i < CAN0_transmiter.receive_message.rx_dlen && i < 8;
i++) {
// 获取实际接收的数据长度
u8 data_len = CAN0_transmiter.receive_message.rx_dlen;
if (data_len > 64) data_len = 64; // 安全限制
// 将DMA缓冲区的数据复制到接收消息结构体（支持最大64字节）
for (int i = 0; i < data_len; i++) {
CAN0_transmiter.receive_message.rx_data[i] = can_rx_buffer[i];
}
}
@@ -320,7 +332,53 @@ void DMA0_Channel5_IRQHandler(void) {
}
/**
* @brief 异步CANFD数据发送(使用DMA和中断机制)
* @brief 向发送队列添加消息
* @param id CAN消息ID
* @param length CAN消息长度
* @param data CAN消息数据
* @retval 1=成功, 0=队列满
*/
static u8 CAN_TX_QueuePush(u32 id, u8 length, u8 *data) {
if (tx_queue_count >= CAN_TX_QUEUE_SIZE) {
#if CAN_DEBUG
printf("TX queue full, message dropped\r\n");
#endif
return 0; // 队列满，丢弃消息
}
tx_queue[tx_queue_tail].id = id;
tx_queue[tx_queue_tail].length = length;
for (int i = 0; i < length && i < 64; i++) {
tx_queue[tx_queue_tail].data[i] = data[i];
}
tx_queue[tx_queue_tail].valid = 1;
tx_queue_tail = (tx_queue_tail + 1) % CAN_TX_QUEUE_SIZE;
tx_queue_count++;
return 1;
}
/**
* @brief 从发送队列取出消息
* @param item 指向队列项的指针
* @retval 1=成功, 0=队列空
*/
static u8 CAN_TX_QueuePop(can_tx_queue_item_t *item) {
if (tx_queue_count == 0) {
return 0; // 队列空
}
*item = tx_queue[tx_queue_head];
tx_queue[tx_queue_head].valid = 0;
tx_queue_head = (tx_queue_head + 1) % CAN_TX_QUEUE_SIZE;
tx_queue_count--;
return 1;
}
/**
* @brief 异步CANFD数据发送(使用队列机制防止丢帧)
* @param id CAN消息ID
* @param length CAN消息长度
* @param data CAN消息数据
@@ -339,7 +397,6 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
if (data == nullptr) {
#if CAN_DEBUG
printf("Invalid data pointer\r\n");
#endif
return 0;
}
@@ -392,29 +449,49 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
// 检查是否成功获取mailbox
if (transmit_mailbox == CAN_NOMAILBOX) {
// 没有可用的mailbox，将消息加入发送队列
#if CAN_DEBUG
// 没有可用的mailbox，启用发送中断以便在邮箱可用时重试
printf("No available mailbox for CANFD transmission, enabling TX "
"interrupt\r\n");
printf("No available mailbox, adding to TX queue\r\n");
#endif
return 0;
return CAN_TX_QueuePush(id, valid_length, data);
}
// 启用CAN发送中断以检测传输完成
// 启用CAN发送中断以检测传输完成（用于队列发送）
can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
return 1;
}
// 添加CAN传输中断处理函数
/**
* @brief CAN传输中断处理函数（支持队列发送）
*/
void CAN0_TX_IRQHandler(void) {
// 检查是否有发送邮箱空闲
if (can_flag_get(CAN0, CAN_FLAG_TME0) != RESET ||
can_flag_get(CAN0, CAN_FLAG_TME1) != RESET ||
can_flag_get(CAN0, CAN_FLAG_TME2) != RESET) {
// 邮箱已空闲，可以发送新消息
// 可以在这里处理待发送队列中的消息
can_tx_queue_item_t next_msg;
// 尝试从队列中取出下一条消息发送
if (CAN_TX_QueuePop(&next_msg)) {
// 配置并发送队列中的消息（使用独立的队列消息结构体）
queue_transmit_message.tx_ft = CAN_FT_DATA;
queue_transmit_message.tx_ff = CAN_FF_EXTENDED;
queue_transmit_message.tx_efid = next_msg.id;
queue_transmit_message.tx_dlen = next_msg.length;
queue_transmit_message.fd_flag = CAN_FDF_FDFRAME;
queue_transmit_message.fd_brs = ENABLE;
queue_transmit_message.fd_esi = DISABLE;
for (int i = 0; i < next_msg.length; i++) {
queue_transmit_message.tx_data[i] = next_msg.data[i];
}
can_message_transmit(CAN0, &queue_transmit_message);
} else {
// 队列为空，禁用发送中断
can_interrupt_disable(CAN0, CAN_INTEN_TMEIE);
}
// 清除发送中断标志
can_flag_clear(CAN0, CAN_FLAG_TME0);
can_flag_clear(CAN0, CAN_FLAG_TME1);
Robot_V2/sys/OTA.cpp
+18 -3
View File
@@ -138,6 +138,20 @@ void OTAHandler::init() {}
* @retval 无
*/
void OTAHandler::process() {
// 执行待处理的Flash擦除操作（在主循环中执行，避免中断中耗时操作）
if (pending_flash_erase) {
pending_flash_erase = false;
#if DEBUG_OTA
printf("Executing pending Flash erase...\r\n");
#endif
eraseApplicationArea();
#if DEBUG_OTA
printf("Flash erase completed.\r\n");
#endif
// Flash擦除完成后，更新状态为接收固件
ota_state = OTA_STATE_RECEIVING_FIRMWARE;
}
if (ota_state == OTA_STATE_IDLE) {
ota_time = 0; // 重置计时器
static u8 zero[1] = {0};
@@ -444,12 +458,13 @@ void OTAHandler::handleOTAMessage(u32 id, u8 *data, u8 len) {
send_error_frame(OTA_ERROR_INVALID_SIZE);
return;
}
// 设置待执行的Flash擦除标志，在process()中执行（避免中断中耗时操作）
pending_flash_erase = true;
// 注意：不立即改变状态，等待Flash擦除完成后在process()中改变
// 发送确认信号，告诉上位机可以开始发送数据
u8 send_data[6] = {0xBA, 0xC0, 0x00,
0x00, 0x00, 0x00}; // 确认开始传输
eraseApplicationArea();
// 发送接收包0请求
CAN0_transmiter.CANFD_AsyncSend(CANFD_OTA_ACK_ID, 6, send_data);
ota_state = OTA_STATE_RECEIVING_FIRMWARE;
} else if (len == 2 and ota_state == OTA_STATE_FINISHED) {
#if DEBUG_OTA
printf("stage--:OTA_STATE_FINISHED\r\n");
Robot_V2/sys/OTA.h
+6
View File
@@ -25,6 +25,12 @@ class OTAHandler {
void eraseApplicationArea();
void writeApplicationData(u32 offset, u8 *data, u32 size);
bool verifyApplicationData(u32 offset, u8 *data, u32 size);
// Flash操作标志（用于延迟执行，避免中断中耗时操作）
bool pending_flash_erase = false;
u32 pending_flash_offset = 0;
u8 pending_flash_data[64];
u8 pending_flash_size = 0;
typedef enum {
OTA_STATE_IDLE = 0,
OTA_STATE_WAITING_RANDOM, // 第二阶段等待随机数