GD32_BOOT/Robot_V2/device/Can.cpp

#include "Can.h"
#include "OTA.h"
#include "config.h"
#include "gd32c10x.h"
#include "gd32c10x_can.h"
#include "gd32c10x_dma.h"
#include "gd32c10x_gpio.h"
#include "main.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

CAN_transmiter CAN0_transmiter; // CAN初始化
extern BootloaderSystem sys;
extern OTAHandler ota;

// 添加DMA相关变量
dma_parameter_struct dma_rx_parameter;
dma_parameter_struct dma_tx_parameter;
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
	\param[in]  none
	\param[out] none
	\retval     ErrStatus: SUCCESS or ERROR
*/
u8 can_gpio_init() {
	/* enable CAN clock */
	rcu_periph_clock_enable(RCU_CAN0);
	rcu_periph_clock_enable(RCU_GPIOB);
	rcu_periph_clock_enable(RCU_AF);

	/* configure CAN0 GPIO */
	gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_50MHZ, GPIO_PIN_8);	  // rx
	gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9); // tx
	gpio_pin_remap_config(GPIO_CAN0_PARTIAL_REMAP, ENABLE);
	/* enable the EN GPIO clock */
	gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_13);
	gpio_bit_reset(GPIOB, GPIO_PIN_13);
	return 0;
}

/*!
	\brief      初始化CAN DMA
	\param[in]  none
	\param[out] none
	\retval     none
*/
void can_dma_init(void) {
	// 使能DMA时钟
	rcu_periph_clock_enable(RCU_DMA0);

	// 配置接收DMA
	dma_struct_para_init(&dma_rx_parameter);
	dma_rx_parameter.periph_addr =
		(uint32_t)(&CAN_RFIFOMDATA0(CAN0, CAN_FIFO0)); // CAN接收数据寄存器地址
	dma_rx_parameter.memory_addr = (uint32_t)can_rx_buffer;	   // 接收缓冲区地址
	dma_rx_parameter.direction = DMA_PERIPHERAL_TO_MEMORY;	   // 外设到内存
	dma_rx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT;	   // 内存宽度8位
	dma_rx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度8位
	dma_rx_parameter.priority = DMA_PRIORITY_HIGH;			   // 高优先级
	dma_rx_parameter.number = 8;							   // 传输字节数
	dma_rx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增
	dma_rx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE;  // 内存地址递增
	dma_init(DMA0, DMA_CH4, &dma_rx_parameter);				   // 使用DMA通道4

	// 配置发送DMA
	dma_struct_para_init(&dma_tx_parameter);
	dma_tx_parameter.periph_addr =
		(uint32_t)(&CAN_TMI0(CAN0)); // CAN发送数据寄存器地址
	dma_tx_parameter.memory_addr = (uint32_t)can_tx_buffer;	   // 发送缓冲区地址
	dma_tx_parameter.direction = DMA_MEMORY_TO_PERIPHERAL;	   // 内存到外设
	dma_tx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT;	   // 内存宽度8位
	dma_tx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度8位
	dma_tx_parameter.priority = DMA_PRIORITY_HIGH;			   // 高优先级
	dma_tx_parameter.number = 8;							   // 传输字节数
	dma_tx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增
	dma_tx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE;  // 内存地址递增
	dma_init(DMA0, DMA_CH5, &dma_tx_parameter);				   // 使用DMA通道5

	// 使能DMA通道
	dma_channel_enable(DMA0, DMA_CH4);
	dma_channel_enable(DMA0, DMA_CH5);
}

/*!
	\brief      初始化CAN0 CANFD模式
	\param[in]  none
	\param[out] none
	\retval     none
*/
void canfd_config(void) {
	can_gpio_init();
	can_dma_init();
	can_parameter_struct can_parameter;
	can_fdframe_struct can_fd_parameter;
	can_fd_tdc_struct can_fd_tdc_parameter;
	can_filter_parameter_struct can_filter;

	/* initialize CAN register */
	can_deinit(CAN0);

	/* initialize CAN */
	can_parameter.time_triggered = DISABLE;
	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.trans_fifo_order = ENABLE;
	can_parameter.working_mode = CAN_NORMAL_MODE;
	/* baudrate 1Mbps, sample piont at 80% */
	can_parameter.resync_jump_width = CAN_BT_SJW_1TQ;
	can_parameter.time_segment_1 = CAN_BT_BS1_7TQ;
	can_parameter.time_segment_2 = CAN_BT_BS2_2TQ;
	can_parameter.prescaler = 6;
	can_init(CAN0, &can_parameter);

	can_struct_para_init(CAN_FD_FRAME_STRUCT, &can_fd_parameter);
	can_fd_parameter.fd_frame = ENABLE;
	can_fd_parameter.excp_event_detect = ENABLE;
	can_fd_parameter.delay_compensation = ENABLE;
	can_fd_tdc_parameter.tdc_filter = 0x04;
	can_fd_tdc_parameter.tdc_mode = CAN_TDCMOD_CALC_AND_OFFSET;
	can_fd_tdc_parameter.tdc_offset = 0x04;
	can_fd_parameter.p_delay_compensation = &can_fd_tdc_parameter;
	can_fd_parameter.iso_bosch = CAN_FDMOD_ISO;
	can_fd_parameter.esi_mode = CAN_ESIMOD_HARDWARE;
	/* FD mode data baudrate 2Mbps, sample piont at 80% */
	can_fd_parameter.data_resync_jump_width = CAN_BT_SJW_1TQ;
	can_fd_parameter.data_time_segment_1 = CAN_BT_BS1_3TQ;
	can_fd_parameter.data_time_segment_2 = CAN_BT_BS2_1TQ;
	/* CAN-FD data segement prescaler should be the same as non-data segement
	 * prescaler */
	can_fd_parameter.data_prescaler = 6;
	can_fd_init(CAN0, &can_fd_parameter);

	/* initialize filter */
	can_filter.filter_mode = CAN_FILTERMODE_MASK;
	can_filter.filter_bits = CAN_FILTERBITS_32BIT;
	/* configure filter ID */
	can_filter.filter_list_high = 0x0000;
	can_filter.filter_list_low = 0x0000;
	/* configure filter mask */
	can_filter.filter_mask_high = 0x0000;
	can_filter.filter_mask_low = 0x0000;
	/* select receiver fifo */
	can_filter.filter_fifo_number = CAN_FIFO0;
	can_filter.filter_enable = ENABLE;
	/* configure filter number */
	can_filter.filter_number = 0;
	can_filter_init(&can_filter);

	/* configure CAN0 NVIC */
	nvic_irq_enable(CAN0_RX0_IRQn, 1, 0);
	/* enable can receive FIFO0 not empty interrupt */
	can_interrupt_enable(CAN0, CAN_INTEN_RFNEIE0);
	// 使能DMA中断
	nvic_irq_enable(DMA0_Channel4_IRQn, 1, 1);
	dma_interrupt_enable(DMA0, DMA_CH4, DMA_INT_FTF);
}

/*!
	\brief CAN_transmiter构造函数
	\note  初始化CAN通信相关参数和硬件配置
*/
u8 CAN_transmiter::init() {
	// 初始化CAN硬件
	canfd_config();

	// 初始化发送消息结构体
	can_struct_para_init(CAN_TX_MESSAGE_STRUCT, &transmit_message);
	/* initialize receive message */
	can_struct_para_init(CAN_RX_MESSAGE_STRUCT, &receive_message);

	// 初始化计数器和标志位
	can0_receive_count = 0;
	can0_send_flag = RESET;

	// 初始化DMA缓冲区
	memset(can_rx_buffer, 0, sizeof(can_rx_buffer));
	memset(can_tx_buffer, 0, sizeof(can_tx_buffer));
	return 0;
}

/**
 * @brief  CAN通信检查函数
 * @retval 无
 */
void CAN_transmiter::communication_check() {
	// CAN0 发送数据标志
	if (SET == can0_send_flag) {
		can0_send_flag = RESET;
	}
	// CAN0 接收数据计数器
	if (can0_receive_count > 0) {
		can0_receive_count--;
		// 处理OTA消息（中断处理程序已确保只接收OTA相关ID）
		ota.handleOTAMessage(receive_message.rx_efid,
							 receive_message.rx_data,
							 receive_message.rx_dlen);
	}
}

u8 CAN_transmiter::sendDATA_ACK(u32 packet_num, u8 *data) { // 握手的时候
	memset(transmit_data, 0, sizeof(transmit_data));
	transmit_data[0] = 0xBA;
	transmit_data[1] = 0xC0;
	// 修复原始代码中不完整的循环
	for (int i = 2; i < 6; i++) {
		transmit_data[i] = data[i - 2];
	}

	return CANFD_AsyncSend(CANFD_OTA_ACK_ID, 6, transmit_data);
}

u8 CAN_transmiter::sendBackup() { // 握手的时候
	return CANFD_AsyncSend(CANFD_OTA_ACK_ID, 0, transmit_data);
}

u8 CAN_transmiter::sendDATA_ACK(u32 packet_num,
								bool if_success) { // 发送数据的时候
	memset(transmit_data, 0, 4);
	if (if_success) {
		transmit_data[0] = 0x01;
		transmit_data[1] = 0x00;
	}

	return CANFD_AsyncSend(CANFD_OTA_ACK_ID, 4, transmit_data);
}

/**
 * @brief  CAN0中断服务程序（优化版：直接读取数据，减少DMA竞态条件）
 * @retval 无
 */
void CAN0_RX0_IRQHandler(void) {
	// 检查是否是FIFO0消息挂起中断
	if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFL0) != RESET) {
		// 清除中断标志
		can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFL0);

		// 直接读取消息（包括数据），不依赖DMA
		can_receive_message_struct temp_message;
		can_message_receive(CAN0, CAN_FIFO0, &temp_message);

		// 只处理指定的OTA相关ID（硬件过滤器已经确保只接收这些ID）
		if (temp_message.rx_efid == CANFD_OTA_DATA_ID ||
			temp_message.rx_efid == CANFD_OTA_REQ_ID ||
			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) {
				CAN0_transmiter.can0_receive_count++;
			}
		} else {
#if CAN_DEBUG
			printf("Unknown CAN ID: %X\n", temp_message.rx_efid);
#endif
		}
	}

	// 检查其他可能的中断源
	if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFF0) != RESET) {
		// FIFO0满中断
		can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFF0);
#if CAN_DEBUG
		printf("CAN FIFO0 full\n");
#endif
	}

	if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFO0) != RESET) {
		// FIFO0溢出中断
		can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFO0);
#if CAN_DEBUG
		printf("CAN FIFO0 overflow\n");
#endif
	}
}

/**
 * @brief  DMA通道4中断服务程序(CAN接收DMA) - 优化版：支持64字节
 * @retval 无
 */
void DMA0_Channel4_IRQHandler(void) {
	if (dma_interrupt_flag_get(DMA0, DMA_CH4, DMA_INT_FLAG_FTF)) {
		// 清除DMA传输完成中断标志
		dma_interrupt_flag_clear(DMA0, DMA_CH4, DMA_INT_FLAG_G);

		// 获取实际接收的数据长度
		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];
		}
	}
}

/**
 * @brief  DMA通道5中断服务程序(CAN/CANFD发送DMA)
 * @retval 无
 */
void DMA0_Channel5_IRQHandler(void) {
	if (dma_interrupt_flag_get(DMA0, DMA_CH5, DMA_INT_FLAG_FTF)) {
		// DMA传输完成，可以在此处执行后续处理
		// 清除DMA传输完成中断标志
		dma_interrupt_flag_clear(DMA0, DMA_CH5, DMA_INT_FLAG_FTF);
		// 可以在此添加后续处理逻辑，如发送下一个数据包等
	}
}

/**
 * @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消息数据
 */
u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
	u8 valid_length = length;
	// 检查CANFD模式是否启用
	if (!(CAN_CTL(CAN0) & CAN_CTL_DFZ)) {
#if CAN_DEBUG
		printf("CANFD mode not enabled\r\n");
#endif
		return 0;
	}

	// 检查数据指针是否有效
	if (data == nullptr) {
#if CAN_DEBUG
		printf("Invalid data pointer\r\n");
#endif
		return 0;
	}

	// 检查数据长度是否符合CANFD规范
	if (length > 8) {
		if (length > 8 and length < 13) {
			valid_length = 12;
		} else if (length > 12 and length < 17) {
			valid_length = 16;
		} else if (length > 16 and length < 21) {
			valid_length = 20;
		} else if (length > 20 and length < 24) {
			valid_length = 24;
		} else if (length > 28 and length < 33) {
			valid_length = 32;
		} else if (length > 32 and length < 49) {
			valid_length = 48;
		} else if (length > 48 and length < 65) {
			valid_length = 64;
		} else {
#if CAN_DEBUG
			printf("CANFD data length error\r\n");
#endif
			return 0;
		}
	}

	/* 配置发送消息参数 */
	transmit_message.tx_ft = CAN_FT_DATA;	  // 数据帧
	transmit_message.tx_ff = CAN_FF_EXTENDED; // 扩展帧格式
	transmit_message.tx_efid = id;			  // 扩展帧ID
	transmit_message.tx_dlen = valid_length;  // 设置数据长度

	// 设置CANFD特定参数
	transmit_message.fd_flag = CAN_FDF_FDFRAME; // CANFD帧格式
	transmit_message.fd_brs = ENABLE;			// 使能比特率切换
	transmit_message.fd_esi = DISABLE;			// 错误状态指示
	// 复制数据到发送缓冲区
	for (int i = 0; i < valid_length; i++) {
		if (i < length) {
			transmit_message.tx_data[i] = *(data + i);
		} else {
			transmit_message.tx_data[i] = 0;
		}
	}

	// 自动选择空闲mailbox发送消息
	transmit_mailbox = can_message_transmit(CAN0, &transmit_message);

	// 检查是否成功获取mailbox
	if (transmit_mailbox == CAN_NOMAILBOX) {
		// 没有可用的mailbox，将消息加入发送队列
#if CAN_DEBUG
		printf("No available mailbox, adding to TX queue\r\n");
#endif
		return CAN_TX_QueuePush(id, valid_length, data);
	}

	// 启用CAN发送中断以检测传输完成（用于队列发送）
	can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
	return 1;
}

/**
 * @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);
		can_flag_clear(CAN0, CAN_FLAG_TME2);
	}
}