更新OTA功能，config独立成文件统一定义

refactor(build): 更新项目配置和链接器设置
- 修改GD32C103CB的ROM基地址和大小配置
- 更新系统时钟向量表偏移量设置
- 在cproject.yml中添加BIN输出格式支持
- 增加-O3优化级别和代码移除选项
- 更新csolution版本依赖

feat(device): 优化ADC采样和配置管理
- 将DengFOC依赖替换为FOC模块
- 从config.h引入配置常量
- 重命名FILTER_SIZE为ADC_FILTER_SIZE以提高清晰度
- 优化温度和电流采样滤波实现

refactor(algorithm): 简化FOC控制函数接口
- 为angle_control、velocity_control等函数移除不必要的参数
- 统一函数指针类型定义
- 优化电流计算函数的代码格式
- 调整PID控制器初始化参数

Robot_V2/device/ADC.cpp

@@ -1,29 +1,22 @@
 #include "adc.h"
 #include "Can.h"
-#include "DengFOC.h"
+#include "FOC.h"
 #include "Filter.h"
+#include "config.h"
 #include "math.h"
+#include "systick.h"
 #include <cstring>
 #include <gd32c10x_dma.h>
 #include <stdint.h>
-#include "systick.h"
 
-constexpr float ERROR_ADC_VAL = 255.0f;
 constexpr float ADC_SCALE = 3.3f / 4096.0f;
 constexpr float TEMP_FACTOR = 1000.0f / 4.3f;
 constexpr float VCC_FACTOR = 11.0f;
-constexpr float CURRENT_OFFSET = -1.60f;
 constexpr float CURRENT_FACTOR =
 	1.0f / 50.0f * 100.0f; // 50倍放大，100倍电流采样电阻, 单位mA
-constexpr float MAX_TEMP = 150.0f;
-constexpr float MIN_TEMP = -40.0f;
-constexpr float MAX_CURRENT = 40.0f;
-constexpr float MIN_CURRENT = -40.0f;
-constexpr float MAX_VCC = 65.0f;
-constexpr float MIN_VCC = -0.1f;
 extern CAN_transmiter CAN0_transmiter;
 extern FOC_Controlroller FOC;
-sampler sampler; // 采样器初始化
+sampler sampler;		// 采样器初始化
 u16 adc_value[6] = {0}; // 显式初始化数组元素为0
 /*!
 	\brief      configure the DMA peripheral
@@ -116,7 +109,7 @@ u8 sampler::init() {
 	adc_config(); // ADC初始化
 	delay_1ms(1);
 	// 初始采样
-	for (int i = 0; i < FILTER_SIZE + 1; i++) {
+	for (int i = 0; i < ADC_FILTER_SIZE + 1; i++) {
 		mcu_temp_samples[i] =
 			(1.43f - adc_value[0] * ADC_SCALE) * TEMP_FACTOR + 35.0f;
 
@@ -142,7 +135,7 @@ u8 sampler::init() {
  * 温度值，单位为摄氏度，范围应在-40到145之间，如果读取失败则返回0.0f
  */
 float sampler::get_mcu_temp() {
-	tempora_sample = medium_filter(mcu_temp_samples, FILTER_SIZE + 1);
+	tempora_sample = medium_filter(mcu_temp_samples, ADC_FILTER_SIZE + 1);
 	// 检查温度读数是否在有效范围内
 	if (tempora_sample < MIN_TEMP or tempora_sample > MAX_TEMP) {
 		return ERROR_ADC_VAL;
@@ -158,7 +151,7 @@ float sampler::get_mcu_temp() {
  * 如果计算结果超出有效范围(-40到255摄氏度)，则重新采样计算。
  */
 float sampler::get_drv_temp() {
-	tempora_sample = medium_filter(drv_temp_samples, FILTER_SIZE + 1);
+	tempora_sample = medium_filter(drv_temp_samples, ADC_FILTER_SIZE + 1);
 	// 检查温度读数是否在有效范围内
 	if (tempora_sample < MIN_TEMP || tempora_sample > MAX_TEMP) {
 		return ERROR_ADC_VAL;
@@ -177,17 +170,17 @@ float sampler::get_current(char type) {
 	switch (type) {
 	case 'U': {
 		// return currU_samples[current_sample_index];
-		tempora_sample = medium_filter(currU_samples, FILTER_SIZE + 1);
+		tempora_sample = medium_filter(currU_samples, ADC_FILTER_SIZE + 1);
 		break;
 	}
 	case 'V': {
 		// return currV_samples[current_sample_index];
-		tempora_sample = medium_filter(currV_samples, FILTER_SIZE + 1);
+		tempora_sample = medium_filter(currV_samples, ADC_FILTER_SIZE + 1);
 		break;
 	}
 	case 'W': {
 		// return currW_samples[current_sample_index];
-		tempora_sample = medium_filter(currW_samples, FILTER_SIZE + 1);
+		tempora_sample = medium_filter(currW_samples, ADC_FILTER_SIZE + 1);
 		break;
 	}
 	default: {
@@ -209,10 +202,10 @@ float sampler::get_current(char type) {
  * 如果计算结果超出有效范围(-40到255伏特)，则重新采样计算。
  */
 float sampler::get_vbus_voltage() {
-	tempora_sample = medium_filter(vbus_samples, FILTER_SIZE + 1);
+	tempora_sample = medium_filter(vbus_samples, ADC_FILTER_SIZE + 1);
 	// 检查电压读数是否在有效范围内
-	if (vbus_samples[FILTER_SIZE / 2] > MAX_VCC or
-		vbus_samples[FILTER_SIZE / 2] < MIN_VCC) {
+	if (vbus_samples[ADC_FILTER_SIZE / 2] > MAX_VCC or
+		vbus_samples[ADC_FILTER_SIZE / 2] < MIN_VCC) {
 		return ERROR_ADC_VAL;
 	}
 	return tempora_sample;
@@ -226,8 +219,8 @@ float sampler::get_vbus_voltage() {
  */
 void sampler::update_mcu_temp() {
 	memmove(mcu_temp_samples, mcu_temp_samples + 1,
-			FILTER_SIZE * sizeof(float));
-	mcu_temp_samples[FILTER_SIZE] =
+			ADC_FILTER_SIZE * sizeof(float));
+	mcu_temp_samples[ADC_FILTER_SIZE] =
 		(1.43f - adc_value[0] * ADC_SCALE) * TEMP_FACTOR + 35.0f;
 }
 
@@ -236,9 +229,9 @@ void sampler::update_mcu_temp() {
  */
 void sampler::update_drv_temp() {
 	memmove(drv_temp_samples, drv_temp_samples + 1,
-			FILTER_SIZE * sizeof(float));
+			ADC_FILTER_SIZE * sizeof(float));
 	float R_now = (float)adc_value[1] / (4096 - (float)adc_value[1]) * 4700;
-	drv_temp_samples[FILTER_SIZE] =
+	drv_temp_samples[ADC_FILTER_SIZE] =
 		1.0f / (0.00335f + 0.00025f * log(R_now / 10000.0f)) - 273.15f;
 }
 
@@ -258,7 +251,7 @@ void sampler::update_current() {
 
 	// 更新索引
 	current_sample_index++;
-	if (current_sample_index >= FILTER_SIZE - 1) {
+	if (current_sample_index >= ADC_FILTER_SIZE - 1) {
 		current_sample_index = 0;
 	}
 	// 卡尔曼滤波更新
@@ -269,6 +262,6 @@ void sampler::update_current() {
  * @brief 更新供电电压
  */
 void sampler::update_vbus_voltage() {
-	memmove(vbus_samples, vbus_samples + 1, FILTER_SIZE * sizeof(float));
-	vbus_samples[FILTER_SIZE] = adc_value[5] * ADC_SCALE * VCC_FACTOR;
+	memmove(vbus_samples, vbus_samples + 1, ADC_FILTER_SIZE * sizeof(float));
+	vbus_samples[ADC_FILTER_SIZE] = adc_value[5] * ADC_SCALE * VCC_FACTOR;
 }

Robot_V2/device/Can.cpp

@@ -1,8 +1,9 @@
 #include "Can.h"
-#include "DengFOC.h"
+#include "FOC.h"
 #include "Filter.h"
 #include "adc.h"
 #include "ang_sensor.h"
+#include "config.h"
 #include "flash.h"
 #include "gd32c10x.h"
 #include "gd32c10x_can.h"
@@ -19,10 +20,6 @@
 #include <stdlib.h>
 
 constexpr u16 CANX = CAN0;
-constexpr u16 DEV_CAN0_ID = 0x0000;
-constexpr u16 DEV_CAN0_MASK = 0x0000;
-constexpr u16 DEV_CAN_LOOPBACK_ID = 0x0000;
-constexpr float ANGLE_FACTOR = 25.0f / 360.0f * 2.0f * 3.14159265358979323846f;
 
 CAN_transmiter CAN0_transmiter; // CAN初始化
 extern FOC_Controlroller FOC;
@@ -157,8 +154,11 @@ void can_config(void) {
 
 	/* configure CAN0 NVIC */
 	nvic_irq_enable(CAN0_RX0_IRQn, 1, 0);
+	nvic_irq_enable(CAN0_TX_IRQn, 1, 1); // 添加发送中断
 	/* enable can receive FIFO0 not empty interrupt */
 	can_interrupt_enable(CAN0, CAN_INTEN_RFNEIE0);
+	/* enable can transmit mailbox empty interrupt */
+	can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
 
 	// 使能DMA中断
 	nvic_irq_enable(DMA0_Channel4_IRQn, 1, 1);
@@ -173,6 +173,7 @@ void can_config(void) {
 */
 void canfd_config(void) {
 	can_gpio_init();
+	can_dma_init(); // 初始化DMA
 	can_parameter_struct can_parameter;
 	can_fdframe_struct can_fd_parameter;
 	can_fd_tdc_struct can_fd_tdc_parameter;
@@ -235,6 +236,9 @@ void canfd_config(void) {
 	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);
 }
 
 /*!
@@ -458,128 +462,6 @@ void CAN_transmiter::update(void) {
 	v_current_union.f = sampler.get_current('V') * 1000;
 }
 
-/*!
-	\brief CAN 数据发送
-	\param id CAN ID
-	\param length 数据长度
-	\param data 数据
-*/
-u8 CAN_transmiter::CAN_Send(u32 id, u8 length, u8 *data) {
-	// 检查数据长度是否符合CAN规范
-	if (length > 8) {
-		printf("CAN data length exceeds maximum of 8 bytes\r\n");
-		return 0;
-	}
-
-	// 检查数据指针是否有效
-	if (data == nullptr) {
-		printf("Invalid data pointer\r\n");
-		return 0;
-	}
-
-	/* 配置发送消息参数 */
-	transmit_message.tx_ft = CAN_FT_DATA;	  // 数据帧
-	transmit_message.tx_ff = CAN_FF_STANDARD; // 标准帧格式
-	transmit_message.tx_sfid = id;			  // 设置帧ID
-	transmit_message.tx_dlen = length;		  // 设置数据长度
-
-	// 复制数据到发送缓冲区
-	for (int i = 0; i < length && i < 8; i++) {
-		transmit_message.tx_data[i] = *(data + i);
-	}
-
-	// 将数据复制到DMA缓冲区
-	memcpy(can_tx_buffer, data, length);
-
-	// 配置DMA发送参数
-	dma_tx_parameter.number = length;
-	dma_init(DMA0, DMA_CH5, &dma_tx_parameter);
-
-	// 启动DMA传输
-	dma_channel_enable(DMA0, DMA_CH5);
-
-	// 自动选择空闲mailbox发送消息，不需要人为指定
-	transmit_mailbox = can_message_transmit(CAN0, &transmit_message);
-
-	// 检查是否成功获取mailbox
-	if (CAN_NOMAILBOX == transmit_mailbox) {
-		// 没有可用的mailbox，可能所有mailbox都在使用中
-		printf("No available mailbox for CAN transmission\r\n");
-		return 0;
-	}
-	return 1;
-}
-
-/*!
-	\brief CANFD 数据发送
-	\param id CAN消息ID
-	\param length CAN消息长度
-	\param data CAN消息数据
-*/
-u8 CAN_transmiter::CANFD_Send(u32 id, u8 length, u8 *data) {
-	// 检查CANFD模式是否启用
-	if (!(CAN_CTL(CAN0) & CAN_CTL_DFZ)) {
-		printf("CANFD mode not enabled\r\n");
-		return 0;
-	}
-
-	// 检查数据指针是否有效
-	if (data == nullptr) {
-		printf("Invalid data pointer\r\n");
-		return 0;
-	}
-
-	// 检查数据长度是否符合CANFD规范
-	if (length > 64) {
-		printf("CANFD data length exceeds maximum of 64 bytes\r\n");
-		return 0;
-	}
-
-	/* 配置发送消息参数 */
-	transmit_message.tx_ft = CAN_FT_DATA;	  // 数据帧
-	transmit_message.tx_ff = CAN_FF_EXTENDED; // 扩展帧格式
-	// transmit_message.tx_sfid = id;			  // 设置帧ID
-	transmit_message.tx_efid = id;	   // 扩展帧ID
-	transmit_message.tx_dlen = 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 < length && i < 64; i++) {
-		transmit_message.tx_data[i] = *(data + i);
-	}
-
-	// 将数据复制到DMA缓冲区
-	memcpy(can_tx_buffer, data, length);
-
-	// 配置DMA发送参数
-	dma_tx_parameter.number = length;
-	dma_init(DMA0, DMA_CH5, &dma_tx_parameter);
-
-	// 启动DMA传输
-	dma_channel_enable(DMA0, DMA_CH5);
-
-	// 自动选择空闲mailbox发送消息，不需要人为指定
-	transmit_mailbox = can_message_transmit(CAN0, &transmit_message);
-
-	// 检查是否成功获取mailbox
-	if (CAN_NOMAILBOX == transmit_mailbox) {
-		static u32 count = 0;
-		// 没有可用的mailbox，可能所有mailbox都在使用中
-		count++;
-		printf("No available mailbox for CANFD transmission\r\n");
-		if (count > 0xff and !is_sleep) {
-			init();
-			count = 0;
-		}
-		return 0;
-	}
-	return 1;
-}
-
 /**
  * @brief  CAN发送函数
  * @retval 0: 发送失败
@@ -594,31 +476,39 @@ u8 CAN_transmiter::CAN_all_Send() {
 	constexpr u32 Status_FEED = 0x118;
 	constexpr u32 Limit_Vel_Vol_FEED = 0x119;
 
-	// 打包RT_Vel_Ang_FEED
+	// 打包RT_Vel_Ang_FEED - 只清零实际使用的8字节
+	memset(transmit_data, 0, 8);
 	pack_float_to_bytes(transmit_data, 0, rt_angle_union);
 	pack_float_to_bytes(transmit_data, 4, rt_velocity_union);
-	success_flag += CAN_Send(RT_Vel_Ang_FEED, 8, transmit_data);
-	// 打包SET_Vel_Ang_FEED
+	success_flag += CAN_AsyncSend(RT_Vel_Ang_FEED, 8, transmit_data);
+
+	// 打包SET_Vel_Ang_FEED - 只清零实际使用的8字节
+	memset(transmit_data, 0, 8);
 	pack_float_to_bytes(transmit_data, 0, target_angle_union);
 	pack_float_to_bytes(transmit_data, 4, target_velocity_union);
-	success_flag += CAN_Send(SET_Vel_Ang_FEED, 8, transmit_data);
-	// 打包Current_FEED
+	success_flag += CAN_AsyncSend(SET_Vel_Ang_FEED, 8, transmit_data);
+
+	// 打包Current_FEED - 只清零实际使用的6字节
+	memset(transmit_data, 0, 6);
 	pack_u16_to_bytes(transmit_data, 0, u16(u_current_union.f));
 	pack_u16_to_bytes(transmit_data, 2, u16(w_current_union.f));
 	pack_u16_to_bytes(transmit_data, 4, u16(v_current_union.f));
-	success_flag += CAN_Send(Current_FEED, 6, transmit_data);
+	success_flag += CAN_AsyncSend(Current_FEED, 6, transmit_data);
 
-	// 打包Status_FEED
+	// 打包Status_FEED - 只清零实际使用的8字节
+	memset(transmit_data, 0, 8);
 	transmit_data[0] = MotorStatus;
 	transmit_data[1] = controller_Mode;
 	pack_u16_to_bytes(transmit_data, 2, motor_temp);
 	pack_u16_to_bytes(transmit_data, 4, mcu_temp);
 	pack_u16_to_bytes(transmit_data, 6, Power_Voltage);
-	success_flag += CAN_Send(Status_FEED, 8, transmit_data);
-	// 打包Limit_Vel_Vol_FEED
+	success_flag += CAN_AsyncSend(Status_FEED, 8, transmit_data);
+
+	// 打包Limit_Vel_Vol_FEED - 只清零实际使用的6字节
+	memset(transmit_data, 0, 6);
 	pack_float_to_bytes(transmit_data, 0, limit_velocity_union);
 	pack_u16_to_bytes(transmit_data, 4, limit_voltage);
-	success_flag += CAN_Send(Limit_Vel_Vol_FEED, 6, transmit_data);
+	success_flag += CAN_AsyncSend(Limit_Vel_Vol_FEED, 6, transmit_data);
 
 	return success_flag;
 }
@@ -631,9 +521,8 @@ u8 CAN_transmiter::CAN_all_Send() {
 u8 CAN_transmiter::CANFD_all_Send() {
 	u32 success_flag = 0;
 
-	constexpr u32 STATUS_ID = 0x00010100;
-	constexpr u32 CONFIG_ID = 0x00010101;
-	// 打包status数据
+	// 打包status数据 - 只清零实际使用的32字节
+	memset(transmit_data, 0, 32);
 	pack_u16_to_bytes(transmit_data, 0, mcu_temp);
 	pack_u16_to_bytes(transmit_data, 2, motor_temp);
 	pack_u16_to_bytes(transmit_data, 4, u16(u_current_union.f));
@@ -647,15 +536,16 @@ u8 CAN_transmiter::CANFD_all_Send() {
 	pack_float_to_bytes(transmit_data, 13, rt_angle_union);
 	pack_float_to_bytes(transmit_data, 17, rt_velocity_union);
 	pack_float_to_bytes(transmit_data, 21, testfloat_union);
-	success_flag += CANFD_Send(STATUS_ID, 32, transmit_data);
+	success_flag += CANFD_AsyncSend(CANFD_STATUS_ID, 32, transmit_data);
 
-	// 打包config数据
+	// 打包config数据 - 只清零实际使用的16字节
+	memset(transmit_data, 0, 16);
 	transmit_data[0] = controller_Mode;
 	pack_u16_to_bytes(transmit_data, 1, limit_voltage);
 	pack_float_to_bytes(transmit_data, 3, limit_velocity_union);
 	pack_float_to_bytes(transmit_data, 7, target_angle_union);
 	pack_float_to_bytes(transmit_data, 11, target_velocity_union);
-	success_flag += CANFD_Send(CONFIG_ID, 16, transmit_data);
+	success_flag += CANFD_AsyncSend(CANFD_CONFIG_ID, 16, transmit_data);
 
 	return success_flag;
 }
@@ -669,9 +559,9 @@ void CAN_transmiter::communication_check() {
 	// CAN0 发送数据标志
 	if (SET == can0_send_flag) {
 		// printf("\r\n can0 %X receive data:", receive_message.rx_efid);
-		CAN0_transmiter.update();
+		update();
 		// CAN0_transmiter.CAN_all_Send();
-		CAN0_transmiter.CANFD_all_Send();
+		CANFD_all_Send();
 		can0_send_flag = RESET;
 	}
 
@@ -681,7 +571,7 @@ void CAN_transmiter::communication_check() {
 		// for (i = 0; i < receive_message.rx_dlen; i++) {
 		// 	printf(" %02x", receive_message.rx_data[i]);
 		// }
-		if (receive_message.rx_efid == 0x00010200) {
+		if (receive_message.rx_efid == CANFD_CMD_ID) {
 			FOC.control_mode = receive_message.rx_data[0];
 			if (float(unpack_bytes_to_u16(receive_message.rx_data, 1)) / 1000 !=
 				FOC.limit_voltage) {
@@ -701,7 +591,7 @@ void CAN_transmiter::communication_check() {
 			target_velocity_union.f =
 				unpack_bytes_to_float(receive_message.rx_data, 11).f;
 			FOC.target_velocity = target_velocity_union.f;
-		} else if (receive_message.rx_efid == 0x00010301) {
+		} else if (receive_message.rx_efid == CANFD_RESET_ID) {
 			u8 first_byte = receive_message.rx_data[0];
 			u8 eigth_byte = receive_message.rx_data[7];
 			if (first_byte & 0x01) {
@@ -722,7 +612,8 @@ void CAN_transmiter::communication_check() {
 				prepare_deep_sleep(true);
 				// CAN_Sleep();
 			}
-
+		} else if (receive_message.rx_efid == CANFD_BOOT_ID) {
+			jumpToBOOT();
 		} else {
 			printf("Unknown CAN ID: %X\n", receive_message.rx_efid);
 		}
@@ -800,7 +691,6 @@ 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);
-
 		// 将DMA缓冲区的数据复制到接收消息结构体
 		for (int i = 0; i < CAN0_transmiter.receive_message.rx_dlen && i < 8;
 			 i++) {
@@ -815,7 +705,149 @@ void DMA0_Channel4_IRQHandler(void) {
  */
 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_G);
+		dma_interrupt_flag_clear(DMA0, DMA_CH5, DMA_INT_FLAG_FTF);
+		// 可以在此添加后续处理逻辑，如发送下一个数据包等
+	}
+}
+
+/**
+ * @brief  异步CAN数据发送(使用DMA和中断机制)
+ * @param  id CAN消息ID
+ * @param  length CAN消息长度
+ * @param  data CAN消息数据
+ */
+u8 CAN_transmiter::CAN_AsyncSend(u32 id, u8 length, u8 *data) {
+	// 检查数据长度是否符合CAN规范
+	if (length > 8) {
+		printf("CAN data length exceeds maximum of 8 bytes\r\n");
+		return 0;
+	}
+
+	// 检查数据指针是否有效
+	if (data == nullptr) {
+		printf("Invalid data pointer\r\n");
+		return 0;
+	}
+
+	/* 配置发送消息参数 */
+	transmit_message.tx_ft = CAN_FT_DATA;	  // 数据帧
+	transmit_message.tx_ff = CAN_FF_STANDARD; // 标准帧格式
+	transmit_message.tx_sfid = id;			  // 设置帧ID
+	transmit_message.tx_dlen = length;		  // 设置数据长度
+
+	// 复制数据到发送缓冲区
+	for (int i = 0; i < length && i < 8; i++) {
+		transmit_message.tx_data[i] = *(data + i);
+	}
+
+	// 自动选择空闲mailbox发送消息
+	transmit_mailbox = can_message_transmit(CAN0, &transmit_message);
+
+	// 检查是否成功获取mailbox
+	if (transmit_mailbox == CAN_NOMAILBOX) {
+		// 没有可用的mailbox，启用发送中断以便在邮箱可用时重试
+		printf("No available mailbox for CAN transmission, enabling TX "
+			   "interrupt\r\n");
+		// 可以设置一个标志位，当邮箱可用时发送
+		// 在实际应用中，可以维护一个待发送队列
+		return 0;
+	}
+
+	// 启用CAN发送中断以检测传输完成
+	can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
+	return 1;
+}
+
+/**
+ * @brief  异步CANFD数据发送(使用DMA和中断机制)
+ * @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)) {
+		printf("CANFD mode not enabled\r\n");
+		return 0;
+	}
+
+	// 检查数据指针是否有效
+	if (data == nullptr) {
+		printf("Invalid data pointer\r\n");
+		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 {
+			printf("CANFD data length error\r\n");
+			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，启用发送中断以便在邮箱可用时重试
+		printf("No available mailbox for CANFD transmission, enabling TX "
+			   "interrupt\r\n");
+		return 0;
+	}
+
+	// 启用CAN发送中断以检测传输完成
+	can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
+	return 1;
+}
+
+// 添加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_flag_clear(CAN0, CAN_FLAG_TME0);
+		can_flag_clear(CAN0, CAN_FLAG_TME1);
+		can_flag_clear(CAN0, CAN_FLAG_TME2);
 	}
 }

Robot_V2/device/Can.h

@@ -60,6 +60,7 @@ void can_dma_init(void);			 // CAN DMA初始化
 void CAN0_RX0_IRQHandler(void);		 // CAN接收中断处理函数
 void DMA0_Channel4_IRQHandler(void); // DMA通道4中断处理函数(CAN接收)
 void DMA0_Channel5_IRQHandler(void); // DMA通道5中断处理函数(CAN发送)
+void jumpToBOOT();
 
 void can_loopback_init(void);
 void can_loopback_test(void);
@@ -97,8 +98,8 @@ class CAN_transmiter {
 	void update();								// 更新数据
 	u8 CAN_Receive();							// CAN接收
 	u8 CANFD_Receive();							// CANFD接收
-	u8 CAN_Send(u32 ID, u8 length, u8 *data);	// CAN发送
-	u8 CANFD_Send(u32 ID, u8 length, u8 *data); // CANFD发送
+	u8 CAN_AsyncSend(u32 ID, u8 length, u8 *data); // CAN异步发送(使用DMA)
+	u8 CANFD_AsyncSend(u32 ID, u8 length, u8 *data); // CANFD异步发送(使用DMA)
 	u8 CAN_all_Send();							// CAN发送
 	u8 CANFD_all_Send();						// CANFD发送
 

Robot_V2/device/Timer.cpp

@@ -1,6 +1,6 @@
 #include "Timer.h"
 #include "Can.h"
-#include "DengFOC.h"
+#include "FOC.h"
 #include "Timer.h"
 #include "gd32c10x.h"
 #include "gd32c10x_gpio.h"
@@ -12,16 +12,6 @@
 #include <stdint.h>
 #include <stdio.h>
 
-constexpr int TIMER2_PRESCALER = 119; // 120MHz / 120 = 1MHz
-constexpr int TIMER2_PERIOD = 99;	  // 1MHz / 100 = 100us
-
-constexpr int TIMER1_PRESCALER = 0; // 不分频，计数器时钟为120MHz
-constexpr int TIMER1_PERIOD = 5999; // 120MHz / (0+1) / (5999+1) = 20kHz
-constexpr int TIMER1_CH0_PULSE = 0;
-constexpr int TIMER1_CH1_PULSE = 0;
-constexpr int TIMER1_CH2_PULSE = 0;
-constexpr int TIMER1_CH3_COMPARE_VALUE =
-	(TIMER1_PERIOD + 1) * 0.5 - 1; // PWM周期50%位置触发中断
 
 volatile u32 total_us100_counter = 0; // 总计数器，每100微秒增加1
 extern u16 adc_value[7];
@@ -46,7 +36,7 @@ void nvic_config(void) {
 }
 
 /**
- * @brief 配置定时器2
+ * @brief 配置定时器2-任务管理
  * @return void
  *
  *配置定时器2，用于定时执行FOC控制、采样、CAN发送等任务
@@ -87,7 +77,7 @@ void TIMER2_config(void) {
 }
 
 /**
- * @brief   配置TIMER2中断
+ * @brief   配置TIMER2-任务管理中断
  * @return void
  */
 void User_timer_init(void) {
@@ -98,7 +88,7 @@ void User_timer_init(void) {
 }
 
 /**
- * @brief   TIMER2中断处理函数
+ * @brief   TIMER2-任务管理中断处理函数
  * @return void
  */
 void TIMER2_IRQHandler(void) {
@@ -174,7 +164,7 @@ void TIMER2_IRQHandler(void) {
 }
 
 /**
- * @brief  TIMER1 GPIO配置函数
+ * @brief  TIMER1-PWM GPIO配置函数
  */
 void timer1_gpio_config(void) {
 	// 时钟使能
@@ -198,7 +188,7 @@ void timer1_gpio_config(void) {
 }
 
 /**
- * @brief  TIMER1 配置函数
+ * @brief  TIMER1-PWM 配置函数
  */
 void timer1_pwm_config(void) {
 	timer_parameter_struct timer_initpara;
@@ -242,11 +232,11 @@ void timer1_pwm_config(void) {
 									 TIMER_OC_MODE_PWM0); // CH3也设为PWM模式
 
 	timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_0,
-											TIMER1_CH0_PULSE);
+											TIMER1_DEFAULT_PULSE);
 	timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_1,
-											TIMER1_CH1_PULSE);
+											TIMER1_DEFAULT_PULSE);
 	timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_2,
-											TIMER1_CH2_PULSE);
+											TIMER1_DEFAULT_PULSE);
 	// 设置CH3比较值为PWM周期x%位置
 	timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_3,
 											TIMER1_CH3_COMPARE_VALUE);
@@ -262,7 +252,7 @@ void timer1_pwm_config(void) {
 	timer_enable(TIMER1);
 }
 
-// 添加TIMER1中断处理函数
+// 添加TIMER1-PWM中断处理函数
 /**
  * @brief   TIMER1中断处理函数
  * @return void

Robot_V2/device/Timer.h

@@ -16,10 +16,6 @@ void timer1_pwm_config(void);
 void timer1_gpio_config(void);
 void TIMER1_IRQHandler(void); // 添加TIMER1中断处理函数声明
 
-/* 获取系统运行时间 */
-uint64_t  get_system_runtime_us(void);
-
-
 #ifdef __cplusplus
 }
 #endif

Robot_V2/device/adc.h

@@ -6,16 +6,16 @@ extern "C" {
 #endif
 
 #include "stdint.h"
-constexpr u8 FILTER_SIZE = 6;
-constexpr u8 BLOCK_SIZE = FILTER_SIZE * sizeof(float);
+#include "config.h"
+
 class sampler {
   private:
-	float vbus_samples[FILTER_SIZE + 1];
-	float currU_samples[FILTER_SIZE + 1];
-	float currV_samples[FILTER_SIZE + 1];
-	float currW_samples[FILTER_SIZE + 1];
-	float mcu_temp_samples[FILTER_SIZE + 1];
-	float drv_temp_samples[FILTER_SIZE + 1];
+	float vbus_samples[ADC_FILTER_SIZE + 1];
+	float currU_samples[ADC_FILTER_SIZE + 1];
+	float currV_samples[ADC_FILTER_SIZE + 1];
+	float currW_samples[ADC_FILTER_SIZE + 1];
+	float mcu_temp_samples[ADC_FILTER_SIZE + 1];
+	float drv_temp_samples[ADC_FILTER_SIZE + 1];
 	u8 current_sample_index;
 
 	float tempora_sample;

Robot_V2/device/ang_sensor.cpp

@@ -1,31 +1,20 @@
 #include "ang_sensor.h"
+#include "Can.h"
 #include "Filter.h"
-#include "core_cmFunc.h"
-#include "gd32c10x_can.h"
+#include "flash.h"
 #include "gd32c10x_dma.h"
 #include "gd32c10x_gpio.h"
 #include "gd32c10x_spi.h"
-#include "initial.h"
-#include "flash.h"
 #include <cstdio>
 #include <cstring>
-#include "Can.h"
 #include <stdint.h>
+#define ANG_SENS_DEBUG 1
 
 #define ANG_SPI_CS_ENABLE() gpio_bit_reset(GPIOA, GPIO_PIN_15)
 #define ANG_SPI_CS_DISABLE() gpio_bit_set(GPIOA, GPIO_PIN_15)
 #define DRV_SPI_CS_ENABLE() gpio_bit_reset(GPIOB, GPIO_PIN_14)
 #define DRV_SPI_CS_DISABLE() gpio_bit_set(GPIOB, GPIO_PIN_14)
 
-constexpr float ANGLE_FACTOR = 1.0f / 65536.0f * 360.0f;
-constexpr float RAD_FACTOR = 1.0f / 65536.0f * 2.0f * 3.14159265358979323846f;
-constexpr u16 DEFAULT_COMMAND = 0x0000;
-constexpr u16 FAULT_RECEIVE = 0xFFFF;
-constexpr float VELOCITY_SCALE = 1e4f;
-constexpr float ANGLE_WRAP_THRESHOLD = 300.0f;
-constexpr float ANGLE_WRAP_VALUE = 360.0f;
-constexpr u8 SIZE_FLOAT = sizeof(float);
-
 // DMA传输完成标志
 volatile bool spi_dma_tx_complete = false;
 volatile bool spi_dma_rx_complete = false;
@@ -34,7 +23,7 @@ angle_sensor KTH7823; // 角度传感器初始化
 extern FlashEEPROM flashEEP;
 extern EncoderAngleKalman Angle_kalman;
 extern EncoderVelocityKalman Vel_kalman;
-	extern CAN_transmiter CAN0_transmiter;		// CAN初始化
+extern CAN_transmiter CAN0_transmiter; // CAN初始化
 
 /**
  * @brief SPI DMA initialization
@@ -199,10 +188,9 @@ void KTH7823_spi_init(void) {
 	spi_enable(SPI0);
 }
 
-
 /**
-* @ 角度传感器类 初始化
-* @return 0:初始化成功 1:初始化失败
+ * @ 角度传感器类 初始化
+ * @return 0:初始化成功 1:初始化失败
  */
 u8 angle_sensor::init(void) {
 	KTH7823_gpio_init(); // GPIO初始化
@@ -211,17 +199,16 @@ u8 angle_sensor::init(void) {
 	return 0;
 }
 /**
-* @ 角度传感器类 设置当前角度
-* @param angle 输出级角度值
-* @return 0成功/1失败
+ * @ 角度传感器类 设置当前角度
+ * @param angle 输出级角度值
+ * @return 0成功/1失败
  */
-u8 angle_sensor::angle_set(float angle){
-	m_cumulativeAngle = angle*REDUCTION_RATIO; // 从Flash读取上次保存的角度
+u8 angle_sensor::angle_set(float angle) {
+	m_cumulativeAngle = angle * REDUCTION_RATIO; // 从Flash读取上次保存的角度
 	m_firstUpdate = true;
 	return 0;
 }
 
-
 /**
  * @brief 读取传感器数据
  * @return 传感器数据
@@ -235,19 +222,17 @@ inline float angle_sensor::read_sensorAngle(void) {
 
 	if (result == 0) {
 		// 单次浮点乘法优化：只计算一次度数，然后转换为弧度
-		float angle_deg = (float)raw_data * ANGLE_FACTOR;
+		float angle_deg = (float)raw_data * ANGLESENS_FACTOR;
 		current_angle_deg = angle_deg;
 		current_angle_rad = angle_deg * DEG2RAD; // M_PI/180.0f
 		return angle_deg;
 	}
 
-#ifdef DEBUG
 	// 仅在调试模式下输出错误，避免发布版本中的I/O开销
 	if (result != 0) {
 		// 使用更高效的串口输出替代printf（如果可用）
 		printf("Error reading angle from sensor.\n");
 	}
-#endif
 
 	return (float)FAULT_RECEIVE;
 }

Robot_V2/device/ang_sensor.h

@@ -5,12 +5,12 @@ extern "C" {
 #endif
 #include "gd32c10x_eval.h"
 #include "stdio.h"
+#include "config.h"
 
 u16 spi_rw_half_word(u32 spi_periph, const u16 i_HalfWord);
 int spi_rw_half_word_dma(uint32_t spi_periph, uint16_t tx_data,
 						 uint16_t *rx_data);
 
-constexpr u16 VEL_FILTER_SIZE = 4;
 
 class angle_sensor {
   public: