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

feat(CAN): 实现多节点CAN总线通信与节点ID管理功能

Browse Source 
- 添加CAN调试宏定义，支持条件编译调试信息输出
- 实现节点ID相关功能，包括构建CAN ID、消息过滤、获取/设置节点ID
- 支持Flash存储节点ID，提供加载和保存功能
- 实现节点ID设置和查询命令处理
- 更新CANFD发送函数使用节点ID构建发送ID
- 添加消息过滤逻辑，只处理目标节点的消息
- 重构DMA中断服务程序，优化数据传输处理
- 替换printf为调试宏，便于生产环境控制调试输出
This commit is contained in:
cbb
2026-03-15 02:38:50 +08:00
parent 2b93a4537c
commit 9f56ab394e
10 changed files with 751 additions and 461 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Robot_V2/device/Can.cpp
+344 -120
View File
@@ -18,6 +18,13 @@
#include <cstring> #include <cstring>
#include <random> #include <random>
// CAN 调试宏定义
#if CAN_DEBUG
#define CAN_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define CAN_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
constexpr u16 CANX = CAN0; constexpr u16 CANX = CAN0;
extern FOC_Controller FOC; extern FOC_Controller FOC;
extern sampler sampler; extern sampler sampler;
@@ -27,33 +34,151 @@ extern EncoderVelocityKalman Vel_kalman; // 速度滤波
extern FlashEEPROM flashEEP; extern FlashEEPROM flashEEP;
extern VersionManager Version; // 声明外部版本管理器实例 extern VersionManager Version; // 声明外部版本管理器实例
// 添加DMA相关变量 // 添加 DMA 相关变量
dma_parameter_struct dma_rx_parameter; dma_parameter_struct dma_rx_parameter;
dma_parameter_struct dma_tx_parameter; dma_parameter_struct dma_tx_parameter;
uint8_t can_rx_buffer[8]; // CAN接收缓冲区 uint8_t can_rx_buffer[8]; // CAN 接收缓冲区
uint8_t can_tx_buffer[8]; // CAN发送缓冲区 uint8_t can_tx_buffer[8]; // CAN 发送缓冲区
CAN_transmiter CAN0_transmiter; // CAN初始化 CAN_transmiter CAN0_transmiter; // CAN 初始化
// ============================================================================
// 节点 ID 相关函数实现 (多电机 CAN 总线隔离)
// 使用高 16 位 (bits 31-16) 存储节点 ID，低 16 位 (bits 15-0) 存储基础 ID
// 格式：[节点 ID(16 位)][基础 ID(16 位)]
// 例如：node_id=1, base_id=0x0200 → 0x00010200
// ============================================================================
// CAN接收缓冲区相关函数实现
/*! /*!
\brief 检查CAN接收缓冲区是否已满 \brief 根据节点 ID 构建 CAN ID
\param[in] base_id 基础 CAN ID(低 16 位)
\param[out] none
\retval 构建后的完整 CAN ID
\note 将节点 ID 放在高 16 位，基础 ID 放在低 16 位
格式：[节点 ID(16 位)][基础 ID(16 位)]
例如：node_id=1, base_id=0x0200 → 0x00010200
*/
u32 CAN_transmiter::build_can_id(u32 base_id) {
return ((u32)node_id << 16) | (base_id & 0xFFFF);
}
/*!
\brief 判断接收到的消息是否是发给本节点的
\param[in] received_id 接收到的 CAN ID
\param[out] none
\retval true: 消息是发给本节点的 (或广播消息)
false: 消息不是发给本节点的
\note 支持广播地址 (0xFFFF)，广播消息所有节点都会响应
提取高 16 位进行节点 ID 匹配
*/
bool CAN_transmiter::is_message_for_me(u32 received_id) {
u16 rx_node_id = (u16)((received_id >> 16) & 0xFFFF);
return (rx_node_id == BROADCAST_NODE_ID) || (rx_node_id == node_id);
}
/*!
\brief 获取当前节点 ID
\param[in] none \param[in] none
\param[out] none \param[out] none
\retval bool 返回true表示缓冲区已满，false表示未满 \retval 当前节点 ID 值 (0-65534)
*/
u16 CAN_transmiter::get_node_id() { return node_id; }
/*!
\brief 设置节点 ID
\param[in] new_id 新的节点 ID 值
\param[out] none
\retval none
\note 节点 ID 范围：0-65534，0xFFFF 保留为广播地址
*/
void CAN_transmiter::set_node_id(u16 new_id) {
if (new_id <= MAX_NODE_ID) {
node_id = new_id;
CAN_DEBUG_PRINT("Node ID set to: %d\r\n", node_id);
}
}
/*!
\brief 从 Flash 加载节点 ID
\param[in] none
\param[out] none
\retval FLASH_EEPROM_OK: 加载成功
其他：加载失败，使用默认值
\note Flash 擦除状态为 0xFFFF，需要特殊处理避免误判
*/
u8 CAN_transmiter::load_node_id_from_flash() {
u16 node_id_temp = 0xFFFF; // 初始化为 Flash 擦除值
FlashEepromStatus status =
flashEEP.read(FlashEEPROM::ADDR_NODE_ID, &node_id_temp);
// 检查 Flash 是否为擦除状态 (0xFFFF 或 0) 或读取失败
// 注意：Flash 未写入时读到的值是 0xFFFF，但有些情况可能读到 0
if (status != FLASH_EEPROM_OK || node_id_temp == 0xFFFF ||
node_id_temp == 0) {
node_id = DEFAULT_NODE_ID;
CAN_DEBUG_PRINT(
"Node ID not found in Flash (status=%d, val=0x%04X), using "
"default: %d\r\n",
status, node_id_temp, node_id);
return FLASH_EEPROM_DATA_NOT_FOUND;
}
// 检查节点 ID 是否有效
if (node_id_temp <= MAX_NODE_ID) {
node_id = node_id_temp;
CAN_DEBUG_PRINT("Node ID loaded from Flash: %d\r\n", node_id);
return FLASH_EEPROM_OK;
} else {
node_id = DEFAULT_NODE_ID;
CAN_DEBUG_PRINT("Invalid Node ID in Flash (%d), using default: %d\r\n",
node_id_temp, node_id);
return FLASH_EEPROM_DATA_NOT_FOUND;
}
}
/*!
\brief 保存节点 ID 到 Flash
\param[in] new_id 要保存的节点 ID
\param[out] none
\retval FLASH_EEPROM_OK: 保存成功
其他：保存失败
*/
u8 CAN_transmiter::save_node_id_to_flash(u16 new_id) {
if (new_id > MAX_NODE_ID) {
CAN_DEBUG_PRINT("Invalid Node ID: %d\r\n", new_id);
return FLASH_EEPROM_INVALID_ADDR;
}
FlashEepromStatus status =
flashEEP.write(FlashEEPROM::ADDR_NODE_ID, new_id);
if (status == FLASH_EEPROM_OK) {
node_id = new_id;
CAN_DEBUG_PRINT("Node ID saved to Flash: %d\r\n", node_id);
return FLASH_EEPROM_OK;
} else {
CAN_DEBUG_PRINT("Failed to save Node ID to Flash\r\n");
return (u8)status;
}
}
// CAN 接收缓冲区相关函数实现
/*!
\brief 检查 CAN 接收缓冲区是否已满
\param[in] none
\param[out] none
\retval bool 返回 true 表示缓冲区已满，false 表示未满
\note 通过比较头指针的下一个位置和尾指针来判断缓冲区是否已满 \note 通过比较头指针的下一个位置和尾指针来判断缓冲区是否已满
使用循环缓冲区策略，当(rx_buffer_head + 1) % 使用循环缓冲区策略，当(rx_buffer_head + 1) % CAN_RX_BUFFER_SIZE
CAN_RX_BUFFER_SIZE等于rx_buffer_tail时， 表示缓冲区已达到最大容量 等于 rx_buffer_tail 时， 表示缓冲区已达到最大容量
*/ */
bool CAN_transmiter::is_rx_buffer_full() { bool CAN_transmiter::is_rx_buffer_full() {
return ((rx_buffer_head + 1) % CAN_RX_BUFFER_SIZE) == rx_buffer_tail; return ((rx_buffer_head + 1) % CAN_RX_BUFFER_SIZE) == rx_buffer_tail;
} }
/*! /*!
\brief 检查CAN接收缓冲区是否为空 \brief 检查 CAN 接收缓冲区是否为空
\param[in] none \param[in] none
\param[out] none \param[out] none
\retval bool 返回true表示缓冲区为空，false表示缓冲区不为空 \retval bool 返回 true 表示缓冲区为空，false 表示缓冲区不为空
\note 通过比较头指针和尾指针是否相等来判断缓冲区是否为空 \note 通过比较头指针和尾指针是否相等来判断缓冲区是否为空
*/ */
bool CAN_transmiter::is_rx_buffer_empty() { bool CAN_transmiter::is_rx_buffer_empty() {
@@ -61,13 +186,13 @@ bool CAN_transmiter::is_rx_buffer_empty() {
} }
/** /**
* @brief 从接收缓冲区中取出一条CAN消息 * @brief 从接收缓冲区中取出一条 CAN 消息
* *
* 该函数检查接收缓冲区是否为空，如果不为空则取出缓冲区队列头部的消息， * 该函数检查接收缓冲区是否为空，如果不为空则取出缓冲区队列头部的消息，
* 并更新队列尾部索引。如果缓冲区为空，则返回false。 * 并更新队列尾部索引。如果缓冲区为空，则返回 false。
* *
* @param message 引用类型的输出参数，用于存储取出的CAN接收消息结构体 * @param message 引用类型的输出参数，用于存储取出的 CAN 接收消息结构体
* @return bool 返回操作是否成功，true表示成功取出消息，false表示缓冲区为空 * @return bool 返回操作是否成功，true 表示成功取出消息，false 表示缓冲区为空
*/ */
bool CAN_transmiter::dequeue_rx_message(can_receive_message_struct &message) { bool CAN_transmiter::dequeue_rx_message(can_receive_message_struct &message) {
if (!is_rx_buffer_empty()) { if (!is_rx_buffer_empty()) {
@@ -103,60 +228,60 @@ u8 can_gpio_init() {
} }
/*! /*!
\brief 初始化CAN DMA \brief 初始化 CAN DMA
\param[in] none \param[in] none
\param[out] none \param[out] none
\retval none \retval none
*/ */
void can_dma_init(void) { void can_dma_init(void) {
// 使能DMA时钟 // 使能 DMA 时钟
rcu_periph_clock_enable(RCU_DMA0); rcu_periph_clock_enable(RCU_DMA0);
// 配置接收DMA // 配置接收 DMA
dma_struct_para_init(&dma_rx_parameter); dma_struct_para_init(&dma_rx_parameter);
dma_rx_parameter.periph_addr = dma_rx_parameter.periph_addr =
(uint32_t)(&CAN_RFIFOMDATA0(CAN0, CAN_FIFO0)); // CAN接收数据寄存器地址 (uint32_t)(&CAN_RFIFOMDATA0(CAN0, CAN_FIFO0)); // CAN 接收数据寄存器地址
dma_rx_parameter.memory_addr = (uint32_t)can_rx_buffer; // 接收缓冲区地址 dma_rx_parameter.memory_addr = (uint32_t)can_rx_buffer; // 接收缓冲区地址
dma_rx_parameter.direction = DMA_PERIPHERAL_TO_MEMORY; // 外设到内存 dma_rx_parameter.direction = DMA_PERIPHERAL_TO_MEMORY; // 外设到内存
dma_rx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT; // 内存宽度8位 dma_rx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT; // 内存宽度 8 位
dma_rx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度8位 dma_rx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度 8 位
dma_rx_parameter.priority = DMA_PRIORITY_HIGH; // 高优先级 dma_rx_parameter.priority = DMA_PRIORITY_HIGH; // 高优先级
dma_rx_parameter.number = 8; // 传输字节数 dma_rx_parameter.number = 8; // 传输字节数
dma_rx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增 dma_rx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增
dma_rx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 内存地址递增 dma_rx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 内存地址递增
dma_init(DMA0, DMA_CH4, &dma_rx_parameter); // 使用DMA通道4 dma_init(DMA0, DMA_CH4, &dma_rx_parameter); // 使用 DMA 通道 4
// 配置发送DMA // 配置发送 DMA
dma_struct_para_init(&dma_tx_parameter); dma_struct_para_init(&dma_tx_parameter);
dma_tx_parameter.periph_addr = dma_tx_parameter.periph_addr =
(uint32_t)(&CAN_TMI0(CAN0)); // CAN发送数据寄存器地址 (uint32_t)(&CAN_TMI0(CAN0)); // CAN 发送数据寄存器地址
dma_tx_parameter.memory_addr = (uint32_t)can_tx_buffer; // 发送缓冲区地址 dma_tx_parameter.memory_addr = (uint32_t)can_tx_buffer; // 发送缓冲区地址
dma_tx_parameter.direction = DMA_MEMORY_TO_PERIPHERAL; // 内存到外设 dma_tx_parameter.direction = DMA_MEMORY_TO_PERIPHERAL; // 内存到外设
dma_tx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT; // 内存宽度8位 dma_tx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT; // 内存宽度 8 位
dma_tx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度8位 dma_tx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度 8 位
dma_tx_parameter.priority = DMA_PRIORITY_HIGH; // 高优先级 dma_tx_parameter.priority = DMA_PRIORITY_HIGH; // 高优先级
dma_tx_parameter.number = 8; // 传输字节数 dma_tx_parameter.number = 8; // 传输字节数
dma_tx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增 dma_tx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增
dma_tx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 内存地址递增 dma_tx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 内存地址递增
dma_init(DMA0, DMA_CH5, &dma_tx_parameter); // 使用DMA通道5 dma_init(DMA0, DMA_CH5, &dma_tx_parameter); // 使用 DMA 通道 5
// 使能DMA通道 // 使能 DMA 通道
dma_channel_enable(DMA0, DMA_CH4); dma_channel_enable(DMA0, DMA_CH4);
dma_channel_enable(DMA0, DMA_CH5); dma_channel_enable(DMA0, DMA_CH5);
// 使能CAN接收DMA // 使能 CAN 接收 DMA
// can_dma_enable(CAN0, CAN_DMA_RECEIVE); // can_dma_enable(CAN0, CAN_DMA_RECEIVE);
} }
/*! /*!
\brief 初始化CAN0 2.0B 模式 \brief 初始化 CAN0 2.0B 模式
\param[in] none \param[in] none
\param[out] none \param[out] none
\retval none \retval none
*/ */
void can_config(void) { void can_config(void) {
can_gpio_init(); can_gpio_init();
can_dma_init(); // 初始化DMA can_dma_init(); // 初始化 DMA
can_parameter_struct can_parameter; can_parameter_struct can_parameter;
can_filter_parameter_struct can_filter; can_filter_parameter_struct can_filter;
@@ -180,7 +305,7 @@ void can_config(void) {
/* initialize CAN */ /* initialize CAN */
if (can_init(CAN0, &can_parameter) != SUCCESS) { if (can_init(CAN0, &can_parameter) != SUCCESS) {
while (1) while (1)
printf("can init error \r\n"); CAN_DEBUG_PRINT("can init error \r\n");
} }
/* initialize filter */ /* initialize filter */
@@ -205,20 +330,20 @@ void can_config(void) {
/* enable can transmit mailbox empty interrupt */ /* enable can transmit mailbox empty interrupt */
can_interrupt_enable(CAN0, CAN_INTEN_TMEIE); can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
// 使能DMA中断 // 使能 DMA 中断
nvic_irq_enable(DMA0_Channel4_IRQn, 1, 1); nvic_irq_enable(DMA0_Channel4_IRQn, 1, 1);
dma_interrupt_enable(DMA0, DMA_CH4, DMA_INT_FTF); dma_interrupt_enable(DMA0, DMA_CH4, DMA_INT_FTF);
} }
/*! /*!
\brief 初始化CAN0 CANFD模式 \brief 初始化 CAN0 CANFD 模式
\param[in] none \param[in] none
\param[out] none \param[out] none
\retval none \retval none
*/ */
void canfd_config(void) { void canfd_config(void) {
can_gpio_init(); can_gpio_init();
can_dma_init(); // 初始化DMA can_dma_init(); // 初始化 DMA
can_parameter_struct can_parameter; can_parameter_struct can_parameter;
can_fdframe_struct can_fd_parameter; can_fdframe_struct can_fd_parameter;
can_fd_tdc_struct can_fd_tdc_parameter; can_fd_tdc_struct can_fd_tdc_parameter;
@@ -281,13 +406,13 @@ void canfd_config(void) {
nvic_irq_enable(CAN0_RX0_IRQn, 1, 0); nvic_irq_enable(CAN0_RX0_IRQn, 1, 0);
/* enable can receive FIFO0 not empty interrupt */ /* enable can receive FIFO0 not empty interrupt */
can_interrupt_enable(CAN0, CAN_INTEN_RFNEIE0); can_interrupt_enable(CAN0, CAN_INTEN_RFNEIE0);
// 使能DMA中断 // 使能 DMA 中断
nvic_irq_enable(DMA0_Channel4_IRQn, 1, 1); nvic_irq_enable(DMA0_Channel4_IRQn, 1, 1);
dma_interrupt_enable(DMA0, DMA_CH4, DMA_INT_FTF); dma_interrupt_enable(DMA0, DMA_CH4, DMA_INT_FTF);
} }
/*! /*!
\brief 初始化CAN0回环测试 \brief 初始化 CAN0 回环测试
\param[in] none \param[in] none
\param[out] none \param[out] none
\retval none \retval none
@@ -316,7 +441,7 @@ void can_loopback_init(void) {
u16 i = 200; u16 i = 200;
while (--i > 0) { while (--i > 0) {
delay_1ms(10); delay_1ms(10);
printf("can init error \r\n"); CAN_DEBUG_PRINT("can init error \r\n");
} }
system_soft_reset(); system_soft_reset();
} }
@@ -341,7 +466,7 @@ void can_loopback_init(void) {
} }
/*! /*!
\brief CAN0 FD回环测试 \brief CAN0 FD 回环测试
\param[in] none \param[in] none
\param[out] none \param[out] none
\retval ErrStatus \retval ErrStatus
@@ -368,7 +493,7 @@ void canfd_loopback_test(void) {
int i = 0; int i = 0;
while (i++ < transmit_message.tx_dlen) { while (i++ < transmit_message.tx_dlen) {
transmit_message.tx_data[i] = dis(gen); transmit_message.tx_data[i] = dis(gen);
std::printf("%x\n", transmit_message.tx_data[i]); CAN_DEBUG_PRINT("%x\n", transmit_message.tx_data[i]);
} }
/* transmit message */ /* transmit message */
@@ -392,10 +517,10 @@ void canfd_loopback_test(void) {
(transmit_message.tx_ff == receive_message.rx_ff) && (transmit_message.tx_ff == receive_message.rx_ff) &&
(transmit_message.tx_dlen == receive_message.rx_dlen)) { (transmit_message.tx_dlen == receive_message.rx_dlen)) {
/* loopback test is success */ /* loopback test is success */
std::printf("CAN LO0PBACK SUCCESS\r\n"); CAN_DEBUG_PRINT("CAN LO0PBACK SUCCESS\r\n");
} else { } else {
/* loopback test is failed */ /* loopback test is failed */
std::printf("CAN LO0PBACK FAIL\r\n"); CAN_DEBUG_PRINT("CAN LO0PBACK FAIL\r\n");
} }
} }
@@ -430,7 +555,8 @@ void can_loopback_test(void) {
/* waiting for transmit completed */ /* waiting for transmit completed */
while ((CAN_TRANSMIT_OK != can_transmit_states(CANX, transmit_mailbox)) && while ((CAN_TRANSMIT_OK != can_transmit_states(CANX, transmit_mailbox)) &&
(0 != timeout)) { (0 != timeout)) {
printf("sending:%x...\n", can_transmit_states(CANX, transmit_mailbox)); CAN_DEBUG_PRINT("sending:%x...\n",
can_transmit_states(CANX, transmit_mailbox));
timeout--; timeout--;
} }
timeout = 0xFF; timeout = 0xFF;
@@ -447,28 +573,29 @@ void can_loopback_test(void) {
(transmit_message.tx_dlen == receive_message.rx_dlen)) { (transmit_message.tx_dlen == receive_message.rx_dlen)) {
i = transmit_message.tx_dlen; i = transmit_message.tx_dlen;
while (i-- > 0) { while (i-- > 0) {
std::printf("rx %d:%x:%x\n", i, transmit_message.tx_data[i], CAN_DEBUG_PRINT("rx %d:%x:%x\n", i, transmit_message.tx_data[i],
receive_message.rx_data[i]); receive_message.rx_data[i]);
} }
if (std::memcmp(receive_message.rx_data, transmit_message.tx_data, if (std::memcmp(receive_message.rx_data, transmit_message.tx_data,
transmit_message.tx_dlen) == 0) { transmit_message.tx_dlen) == 0) {
/* loopback test is success */ /* loopback test is success */
std::printf("loopback success\n"); CAN_DEBUG_PRINT("loopback success\n");
} else { } else {
std::printf("loopback failed\n"); /* loopback test is failed */
CAN_DEBUG_PRINT("loopback failed\n");
} }
} else { } else {
/* loopback test is failed */ /* loopback test is failed */
std::printf("loopback failed\n"); CAN_DEBUG_PRINT("loopback failed\n");
} }
} }
/*! /*!
\brief CAN_transmiter构造函数 \brief CAN_transmiter 构造函数
\note 初始化CAN通信相关参数和硬件配置 \note 初始化 CAN 通信相关参数和硬件配置
*/ */
u8 CAN_transmiter::init() { u8 CAN_transmiter::init() {
// 初始化CAN硬件 // 初始化 CAN 硬件
// can_config(); // can_config();
canfd_config(); canfd_config();
@@ -477,9 +604,15 @@ u8 CAN_transmiter::init() {
/* initialize receive message */ /* initialize receive message */
can_struct_para_init(CAN_RX_MESSAGE_STRUCT, &receive_message); can_struct_para_init(CAN_RX_MESSAGE_STRUCT, &receive_message);
// 初始化DMA缓冲区 // 初始化 DMA 缓冲区
memset(can_rx_buffer, 0, sizeof(can_rx_buffer)); memset(can_rx_buffer, 0, sizeof(can_rx_buffer));
memset(can_tx_buffer, 0, sizeof(can_tx_buffer)); memset(can_tx_buffer, 0, sizeof(can_tx_buffer));
// 初始化节点 ID 为默认值
node_id = DEFAULT_NODE_ID;
// 从 Flash 加载节点 ID (如果 Flash 中有有效值则覆盖默认值)
load_node_id_from_flash();
return 0; return 0;
} }
@@ -511,14 +644,14 @@ void CAN_transmiter::update(void) {
} }
/** /**
* @brief CANFD发送函数 * @brief CANFD 发送函数
* @retval 0: 发送失败 * @retval 0: 发送失败
* 1: 发送成功 * 1: 发送成功
*/ */
u8 CAN_transmiter::CANFD_all_Send() { u8 CAN_transmiter::CANFD_all_Send() {
u32 success_flag = 0; u32 success_flag = 0;
// 打包status数据 - 只清零实际使用的32字节 // 打包 status 数据 - 只清零实际使用的 32 字节
memset(transmit_data, 0, 32); memset(transmit_data, 0, 32);
pack_u16_to_bytes(transmit_data, 0, mcu_temp); pack_u16_to_bytes(transmit_data, 0, mcu_temp);
pack_u16_to_bytes(transmit_data, 2, motor_temp); pack_u16_to_bytes(transmit_data, 2, motor_temp);
@@ -535,43 +668,56 @@ u8 CAN_transmiter::CANFD_all_Send() {
pack_float_to_bytes(transmit_data, 21, rt_current_union); pack_float_to_bytes(transmit_data, 21, rt_current_union);
pack_float_to_bytes(transmit_data, 25, testfloat_union); pack_float_to_bytes(transmit_data, 25, testfloat_union);
pack_u16_to_bytes(transmit_data, 29, test_u16); pack_u16_to_bytes(transmit_data, 29, test_u16);
success_flag += CANFD_AsyncSend(CANFD_STATUS_ID, 32, transmit_data); // 使用节点 ID 构建发送 ID (高 16 位为节点 ID)
success_flag +=
CANFD_AsyncSend(build_can_id(CANFD_STATUS_ID), 32, transmit_data);
// 打包config数据 - 只清零实际使用的24字节 // 打包 config 数据 - 只清零实际使用的 24 字节
memset(transmit_data, 0, 24); memset(transmit_data, 0, 24);
transmit_data[0] = controller_Mode; transmit_data[0] = controller_Mode;
pack_u16_to_bytes(transmit_data, 1, limit_voltage); pack_u16_to_bytes(transmit_data, 1, limit_voltage);
pack_float_to_bytes(transmit_data, 3, target_current_union); pack_float_to_bytes(transmit_data, 3, target_current_union);
pack_float_to_bytes(transmit_data, 7, target_velocity_union); pack_float_to_bytes(transmit_data, 7, target_velocity_union);
pack_float_to_bytes(transmit_data, 11, target_angle_union); pack_float_to_bytes(transmit_data, 11, target_angle_union);
success_flag += CANFD_AsyncSend(CANFD_CONFIG_ID, 24, transmit_data); // 使用节点 ID 构建发送 ID (高 16 位为节点 ID)
success_flag +=
CANFD_AsyncSend(build_can_id(CANFD_CONFIG_ID), 24, transmit_data);
return success_flag; return success_flag;
} }
/** /**
* @brief CAN通信检查函数 * @brief CAN 通信检查函数
* @retval 0: 无新消息 * @retval 0: 无新消息
* 1: 有新消息 * 1: 有新消息
*/ */
void CAN_transmiter::communication_check() { void CAN_transmiter::communication_check() {
// CAN0 发送数据标志 // CAN0 发送数据标志
if (SET == can0_send_flag) { if (SET == can0_send_flag) {
// printf("\r\n can0 %X receive data:", receive_message.rx_efid); // CAN_DEBUG_PRINT("\r\n can0 %X receive data:",
// receive_message.rx_efid);
update(); update();
// CAN0_transmiter.CAN_all_Send(); // CAN0_transmiter.CAN_all_Send();
CANFD_all_Send(); CANFD_all_Send();
can0_send_flag = RESET; can0_send_flag = RESET;
} }
// 处理所有接收到的CAN消息（从环形缓冲区中） // 处理所有接收到的 CAN 消息（从环形缓冲区中）
can_receive_message_struct current_message; can_receive_message_struct current_message;
while (dequeue_rx_message(current_message)) { while (dequeue_rx_message(current_message)) {
// printf("\r\n can0 %X receive data:", current_message.rx_efid); // CAN_DEBUG_PRINT("\r\n can0 %X receive data:",
// for (i = 0; i < current_message.rx_dlen; i++) { // current_message.rx_efid); for (i = 0; i < current_message.rx_dlen;
// printf(" %02x", current_message.rx_data[i]); // i++) { CAN_DEBUG_PRINT(" %02x", current_message.rx_data[i]);
// } // }
if (current_message.rx_efid == CANFD_CMD_ID) { // 检查消息是否是发给本节点的 (检查高 16 位)
if (!is_message_for_me(current_message.rx_efid)) {
continue; // 不是发给本节点的消息，跳过
}
// 提取基础 ID (低 16 位，去除高 16 位节点 ID 部分)
u32 base_id = current_message.rx_efid & 0xFFFF;
if (base_id == CANFD_CMD_ID) {
// 控制模式 // 控制模式
FOC.control_mode = current_message.rx_data[0]; FOC.control_mode = current_message.rx_data[0];
// 目标电压限制 // 目标电压限制
@@ -595,9 +741,9 @@ void CAN_transmiter::communication_check() {
FOC.target_velocity = target_velocity_union.f; FOC.target_velocity = target_velocity_union.f;
FOC.target_current = target_current_union.f; FOC.target_current = target_current_union.f;
// 解析PID参数 // 解析 PID 参数
float voltage = FOC.limit_voltage; float voltage = FOC.limit_voltage;
// PID参数 // PID 参数
u16 P_config = unpack_bytes_to_u16(current_message.rx_data, 15); u16 P_config = unpack_bytes_to_u16(current_message.rx_data, 15);
FOC.cur_loop_p = DEFAULT_current_loop_p * P_config / voltage; FOC.cur_loop_p = DEFAULT_current_loop_p * P_config / voltage;
FOC.cur_MIT_p = DEFAULT_current_MIT_p * P_config / voltage; FOC.cur_MIT_p = DEFAULT_current_MIT_p * P_config / voltage;
@@ -611,7 +757,7 @@ void CAN_transmiter::communication_check() {
FOC.ang_loop_p = DEFAULT_angle_loop_p * P_config / voltage; FOC.ang_loop_p = DEFAULT_angle_loop_p * P_config / voltage;
FOC.ang_angloop_p = DEFAULT_angle_angloop_p * P_config / voltage; FOC.ang_angloop_p = DEFAULT_angle_angloop_p * P_config / voltage;
FOC.ang_MIT_p = DEFAULT_angle_MIT_p * P_config / voltage; FOC.ang_MIT_p = DEFAULT_angle_MIT_p * P_config / voltage;
} else if (current_message.rx_efid == CANFD_RESET_ID) { } else if (base_id == CANFD_RESET_ID) {
u8 first_byte = current_message.rx_data[0]; u8 first_byte = current_message.rx_data[0];
u8 eigth_byte = current_message.rx_data[7]; u8 eigth_byte = current_message.rx_data[7];
// 电机重置 // 电机重置
@@ -619,7 +765,7 @@ void CAN_transmiter::communication_check() {
motor_reset(); motor_reset();
testfloat_union.f = KTH7823.getcurrent_sensorangle(); testfloat_union.f = KTH7823.getcurrent_sensorangle();
} }
// EEPROM重置 // EEPROM 重置
if (first_byte >> 1 & 0x01) { if (first_byte >> 1 & 0x01) {
// flashEEP.format(); // flashEEP.format();
} }
@@ -638,17 +784,17 @@ void CAN_transmiter::communication_check() {
app_prepare_deep_sleep(true); app_prepare_deep_sleep(true);
// CAN_Sleep(); // CAN_Sleep();
} }
} else if (current_message.rx_efid == CANFD_VERSION_ID) { } else if (base_id == CANFD_VERSION_ID) {
// 处理版本号请求，发送当前系统版本信息 // 处理版本号请求，发送当前系统版本信息
Version.sendVersionInfoViaCan(); Version.sendVersionInfoViaCan();
} else if (current_message.rx_efid == CANFD_BOOT_ID) { } else if (base_id == CANFD_BOOT_ID) {
motor_sleep(); motor_sleep();
flashEEP.save_system_config(false); flashEEP.save_system_config(false);
fmc_unlock(); fmc_unlock();
OTA_SET(n_APP_LATEST_EN_ADDR, OTA_NOT_AVAL); // 设置APP为不激活 OTA_SET(n_APP_LATEST_EN_ADDR, OTA_NOT_AVAL); // 设置 APP 为不激活
fmc_lock(); fmc_lock();
jumpToBOOT(); jumpToBOOT();
} else if (current_message.rx_efid == 0x00000102) { } else if (base_id == CANFD_OTA_ACK_ID) {
volatile u32 *flash_ptr = (volatile u32 *)n_APP_LATEST_EN_ADDR; volatile u32 *flash_ptr = (volatile u32 *)n_APP_LATEST_EN_ADDR;
u32 app_enable = *flash_ptr; u32 app_enable = *flash_ptr;
flash_ptr = (volatile u32 *)n_APP_LATEST_CHECK_ADDR; flash_ptr = (volatile u32 *)n_APP_LATEST_CHECK_ADDR;
@@ -657,16 +803,92 @@ void CAN_transmiter::communication_check() {
transmit_data[1] = 0xAC; transmit_data[1] = 0xAC;
delay_1ms(1); delay_1ms(1);
if (app_enable == OTA_AVAL && app_check == OTA_AVAL) { if (app_enable == OTA_AVAL && app_check == OTA_AVAL) {
CANFD_AsyncSend(CANFD_OTA_ACK_ID, 2, transmit_data); CANFD_AsyncSend(build_can_id(CANFD_OTA_ACK_ID), 2,
transmit_data);
}
}
// 设置节点 ID 命令 (基础 ID: 0x0400)
else if (base_id == CANFD_SET_NODE_ID) {
// 打印接收到的原始数据
CAN_DEBUG_PRINT(
"SET_NODE_ID: rx_dlen=%d, data[0]=%02X data[1]=%02X\r\n",
current_message.rx_dlen, current_message.rx_data[0],
current_message.rx_data[1]);
// 解析新节点 ID - 支持 1 字节或 2 字节格式
u16 new_node_id;
if (current_message.rx_dlen >= 2) {
new_node_id = unpack_bytes_to_u16(current_message.rx_data, 0);
} else {
new_node_id =
current_message.rx_data[0]; // 只发送 1 字节时直接使用
}
u16 old_node_id = node_id; // 保存旧节点 ID 用于构建响应 ID
CAN_DEBUG_PRINT(
"SET_NODE_ID: recv new_id=%d (0x%04X), old_id=%d\r\n",
new_node_id, new_node_id, old_node_id);
if (new_node_id <= MAX_NODE_ID) {
u8 save_status = save_node_id_to_flash(new_node_id);
CAN_DEBUG_PRINT(
"SET_NODE_ID: save_status=%d, current node_id=%d\r\n",
save_status, node_id);
if (save_status == FLASH_EEPROM_OK) {
// 发送确认响应 - 使用旧节点 ID 构建响应 ID
// 响应数据格式：[status:1byte][new_node_id:2byte] = 3 字节
transmit_data[0] = 0x01; // 成功
transmit_data[1] = (u8)(new_node_id & 0xFF); // 新 ID 低字节
transmit_data[2] =
(u8)((new_node_id >> 8) & 0xFF); // 新 ID 高字节
CAN_DEBUG_PRINT("SET_NODE_ID: SUCCESS, send response with "
"old_id=%d, new_id_bytes=%02X %02X\r\n",
old_node_id, transmit_data[1],
transmit_data[2]);
// 注意：这里不修改 node_id，因为 save_node_id_to_flash
// 已经更新了 但构建响应时需要用旧 ID，所以临时修改
node_id = old_node_id;
CANFD_AsyncSend(build_can_id(CANFD_SET_NODE_ID), 3,
transmit_data); // 发送 3 字节
node_id = new_node_id; // 恢复新 ID
CAN_DEBUG_PRINT("SET_NODE_ID: node_id updated to %d\r\n",
node_id);
} else {
// Flash 写入失败，发送错误响应
CAN_DEBUG_PRINT(
"SET_NODE_ID: Flash write FAILED, status=%d\r\n",
save_status);
transmit_data[0] = 0x00; // 失败
transmit_data[1] = (u8)(new_node_id & 0xFF);
transmit_data[2] = (u8)((new_node_id >> 8) & 0xFF);
node_id = old_node_id;
CANFD_AsyncSend(build_can_id(CANFD_SET_NODE_ID), 3,
transmit_data);
} }
} else { } else {
printf("Unknown CAN ID: %X\n", current_message.rx_efid); // 发送错误响应 - 使用旧节点 ID 构建响应 ID
CAN_DEBUG_PRINT("SET_NODE_ID: invalid new_id=%d (max=%d)\r\n",
new_node_id, MAX_NODE_ID);
transmit_data[0] = 0x00; // 失败
transmit_data[1] = (u8)(new_node_id & 0xFF);
transmit_data[2] = (u8)((new_node_id >> 8) & 0xFF);
node_id = old_node_id; // 临时恢复旧 ID 用于构建响应
CANFD_AsyncSend(build_can_id(CANFD_SET_NODE_ID), 3,
transmit_data);
// 保持原 ID 不变
}
}
// 查询节点 ID 命令 (基础 ID: 0x0402)
else if (base_id == CANFD_GET_NODE_ID) {
pack_u16_to_bytes(transmit_data, 0, get_node_id());
CANFD_AsyncSend(build_can_id(CANFD_GET_NODE_ID), 2, transmit_data);
} else {
CAN_DEBUG_PRINT("Unknown CAN ID: %X (node_id=%d)\n",
current_message.rx_efid, node_id);
} }
} }
} }
/** /**
* @brief CAN睡眠 * @brief CAN 睡眠
* @param None * @param None
* @retval None * @retval None
*/ */
@@ -677,12 +899,12 @@ u8 CAN_transmiter::CAN_Sleep() {
} }
/** /**
* @brief CAN唤醒 * @brief CAN 唤醒
* @param None * @param None
* @retval None * @retval None
*/ */
u8 CAN_transmiter::CAN_Wakeup() { u8 CAN_transmiter::CAN_Wakeup() {
printf("can wake\r\n"); CAN_DEBUG_PRINT("can wake\r\n");
is_sleep = false; is_sleep = false;
canfd_config(); canfd_config();
@@ -690,16 +912,16 @@ u8 CAN_transmiter::CAN_Wakeup() {
} }
/** /**
* @brief CAN0中断服务程序 * @brief CAN0 中断服务程序
* @retval 无 * @retval 无
*/ */
void CAN0_RX0_IRQHandler(void) { void CAN0_RX0_IRQHandler(void) {
// 检查是否是FIFO0消息挂起中断 // 检查是否是 FIFO0 消息挂起中断
if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFL0) != RESET) { if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFL0) != RESET) {
// 清除中断标志 // 清除中断标志
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFL0); can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFL0);
// 使用DMA读取接收到的数据 // 使用 DMA 读取接收到的数据
dma_channel_disable(DMA0, DMA_CH4); dma_channel_disable(DMA0, DMA_CH4);
dma_rx_parameter.number = dma_rx_parameter.number =
can_receive_message_length_get(CAN0, CAN_FIFO0); can_receive_message_length_get(CAN0, CAN_FIFO0);
@@ -716,27 +938,27 @@ void CAN0_RX0_IRQHandler(void) {
// 检查其他可能的中断源 // 检查其他可能的中断源
if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFF0) != RESET) { if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFF0) != RESET) {
// FIFO0满中断 // FIFO0 满中断
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFF0); can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFF0);
printf("CAN FIFO0 full\n"); CAN_DEBUG_PRINT("CAN FIFO0 full\n");
} }
if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFO0) != RESET) { if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFO0) != RESET) {
// FIFO0溢出中断 // FIFO0 溢出中断
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFO0); can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFO0);
printf("CAN FIFO0 overflow\n"); CAN_DEBUG_PRINT("CAN FIFO0 overflow\n");
} }
} }
/** /**
* @brief DMA通道4中断服务程序(CAN接收DMA) * @brief DMA 通道 4 中断服务程序 (CAN 接收 DMA)
* @retval 无 * @retval 无
*/ */
void DMA0_Channel4_IRQHandler(void) { void DMA0_Channel4_IRQHandler(void) {
if (dma_interrupt_flag_get(DMA0, DMA_CH4, DMA_INT_FLAG_FTF)) { if (dma_interrupt_flag_get(DMA0, DMA_CH4, DMA_INT_FLAG_FTF)) {
// 清除DMA传输完成中断标志 // 清除 DMA 传输完成中断标志
dma_interrupt_flag_clear(DMA0, DMA_CH4, DMA_INT_FLAG_G); dma_interrupt_flag_clear(DMA0, DMA_CH4, DMA_INT_FLAG_G);
// 将DMA缓冲区的数据复制到接收消息结构体 // 将 DMA 缓冲区的数据复制到接收消息结构体
for (int i = 0; i < CAN0_transmiter.receive_message.rx_dlen && i < 8; for (int i = 0; i < CAN0_transmiter.receive_message.rx_dlen && i < 8;
i++) { i++) {
CAN0_transmiter.receive_message.rx_data[i] = can_rx_buffer[i]; CAN0_transmiter.receive_message.rx_data[i] = can_rx_buffer[i];
@@ -745,41 +967,41 @@ void DMA0_Channel4_IRQHandler(void) {
} }
/** /**
* @brief DMA通道5中断服务程序(CAN/CANFD发送DMA) * @brief DMA 通道 5 中断服务程序 (CAN/CANFD 发送 DMA)
* @retval 无 * @retval 无
*/ */
void DMA0_Channel5_IRQHandler(void) { void DMA0_Channel5_IRQHandler(void) {
if (dma_interrupt_flag_get(DMA0, DMA_CH5, DMA_INT_FLAG_FTF)) { if (dma_interrupt_flag_get(DMA0, DMA_CH5, DMA_INT_FLAG_FTF)) {
// DMA传输完成，可以在此处执行后续处理 // DMA 传输完成，可以在此处执行后续处理
// 清除DMA传输完成中断标志 // 清除 DMA 传输完成中断标志
dma_interrupt_flag_clear(DMA0, DMA_CH5, DMA_INT_FLAG_FTF); dma_interrupt_flag_clear(DMA0, DMA_CH5, DMA_INT_FLAG_FTF);
// 可以在此添加后续处理逻辑，如发送下一个数据包等 // 可以在此添加后续处理逻辑，如发送下一个数据包等
} }
} }
/** /**
* @brief 异步CAN数据发送(使用DMA和中断机制) * @brief 异步 CAN 数据发送 (使用 DMA 和中断机制)
* @param id CAN消息ID * @param id CAN 消息 ID
* @param length CAN消息长度 * @param length CAN 消息长度
* @param data CAN消息数据 * @param data CAN 消息数据
*/ */
u8 CAN_transmiter::CAN_AsyncSend(u32 id, u8 length, u8 *data) { u8 CAN_transmiter::CAN_AsyncSend(u32 id, u8 length, u8 *data) {
// 检查数据长度是否符合CAN规范 // 检查数据长度是否符合 CAN 规范
if (length > 8) { if (length > 8) {
printf("CAN data length exceeds maximum of 8 bytes\r\n"); CAN_DEBUG_PRINT("CAN data length exceeds maximum of 8 bytes\r\n");
return 0; return 0;
} }
// 检查数据指针是否有效 // 检查数据指针是否有效
if (data == nullptr) { if (data == nullptr) {
printf("Invalid data pointer\r\n"); CAN_DEBUG_PRINT("Invalid data pointer\r\n");
return 0; return 0;
} }
/* 配置发送消息参数 */ /* 配置发送消息参数 */
transmit_message.tx_ft = CAN_FT_DATA; // 数据帧 transmit_message.tx_ft = CAN_FT_DATA; // 数据帧
transmit_message.tx_ff = CAN_FF_STANDARD; // 标准帧格式 transmit_message.tx_ff = CAN_FF_STANDARD; // 标准帧格式
transmit_message.tx_sfid = id; // 设置帧ID transmit_message.tx_sfid = id; // 设置帧 ID
transmit_message.tx_dlen = length; // 设置数据长度 transmit_message.tx_dlen = length; // 设置数据长度
// 复制数据到发送缓冲区 // 复制数据到发送缓冲区
@@ -787,45 +1009,46 @@ u8 CAN_transmiter::CAN_AsyncSend(u32 id, u8 length, u8 *data) {
transmit_message.tx_data[i] = *(data + i); transmit_message.tx_data[i] = *(data + i);
} }
// 自动选择空闲mailbox发送消息 // 自动选择空闲 mailbox 发送消息
transmit_mailbox = can_message_transmit(CAN0, &transmit_message); transmit_mailbox = can_message_transmit(CAN0, &transmit_message);
// 检查是否成功获取mailbox // 检查是否成功获取 mailbox
if (transmit_mailbox == CAN_NOMAILBOX) { if (transmit_mailbox == CAN_NOMAILBOX) {
// 没有可用的mailbox，启用发送中断以便在邮箱可用时重试 // 没有可用的 mailbox，启用发送中断以便在邮箱可用时重试
printf("No available mailbox for CAN transmission, enabling TX " CAN_DEBUG_PRINT(
"No available mailbox for CAN transmission, enabling TX "
"interrupt\r\n"); "interrupt\r\n");
// 可以设置一个标志位，当邮箱可用时发送 // 可以设置一个标志位，当邮箱可用时发送
// 在实际应用中，可以维护一个待发送队列 // 在实际应用中，可以维护一个待发送队列
return 0; return 0;
} }
// 启用CAN发送中断以检测传输完成 // 启用 CAN 发送中断以检测传输完成
can_interrupt_enable(CAN0, CAN_INTEN_TMEIE); can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
return 1; return 1;
} }
/** /**
* @brief 异步CANFD数据发送(使用DMA和中断机制) * @brief 异步 CANFD 数据发送 (使用 DMA 和中断机制)
* @param id CAN消息ID * @param id CAN 消息 ID
* @param length CAN消息长度 * @param length CAN 消息长度
* @param data CAN消息数据 * @param data CAN 消息数据
*/ */
u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) { u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
u8 valid_length = length; u8 valid_length = length;
// 检查CANFD模式是否启用 // 检查 CANFD 模式是否启用
if (!(CAN_CTL(CAN0) & CAN_CTL_DFZ)) { if (!(CAN_CTL(CAN0) & CAN_CTL_DFZ)) {
printf("CANFD mode not enabled\r\n"); CAN_DEBUG_PRINT("CANFD mode not enabled\r\n");
return 0; return 0;
} }
// 检查数据指针是否有效 // 检查数据指针是否有效
if (data == nullptr) { if (data == nullptr) {
printf("Invalid data pointer\r\n"); CAN_DEBUG_PRINT("Invalid data pointer\r\n");
return 0; return 0;
} }
// 检查数据长度是否符合CANFD规范 // 检查数据长度是否符合 CANFD 规范
if (length > 8) { if (length > 8) {
if (length > 8 and length < 13) { if (length > 8 and length < 13) {
valid_length = 12; valid_length = 12;
@@ -842,7 +1065,7 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
} else if (length > 48 and length < 65) { } else if (length > 48 and length < 65) {
valid_length = 64; valid_length = 64;
} else { } else {
printf("CANFD data length error\r\n"); CAN_DEBUG_PRINT("CANFD data length error\r\n");
return 0; return 0;
} }
} }
@@ -850,11 +1073,11 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
/* 配置发送消息参数 */ /* 配置发送消息参数 */
transmit_message.tx_ft = CAN_FT_DATA; // 数据帧 transmit_message.tx_ft = CAN_FT_DATA; // 数据帧
transmit_message.tx_ff = CAN_FF_EXTENDED; // 扩展帧格式 transmit_message.tx_ff = CAN_FF_EXTENDED; // 扩展帧格式
transmit_message.tx_efid = id; // 扩展帧ID transmit_message.tx_efid = id; // 扩展帧 ID
transmit_message.tx_dlen = valid_length; // 设置数据长度 transmit_message.tx_dlen = valid_length; // 设置数据长度
// 设置CANFD特定参数 // 设置 CANFD 特定参数
transmit_message.fd_flag = CAN_FDF_FDFRAME; // CANFD帧格式 transmit_message.fd_flag = CAN_FDF_FDFRAME; // CANFD 帧格式
transmit_message.fd_brs = ENABLE; // 使能比特率切换 transmit_message.fd_brs = ENABLE; // 使能比特率切换
transmit_message.fd_esi = DISABLE; // 错误状态指示 transmit_message.fd_esi = DISABLE; // 错误状态指示
// 复制数据到发送缓冲区 // 复制数据到发送缓冲区
@@ -866,23 +1089,24 @@ u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
} }
} }
// 自动选择空闲mailbox发送消息 // 自动选择空闲 mailbox 发送消息
transmit_mailbox = can_message_transmit(CAN0, &transmit_message); transmit_mailbox = can_message_transmit(CAN0, &transmit_message);
// 检查是否成功获取mailbox // 检查是否成功获取 mailbox
if (transmit_mailbox == CAN_NOMAILBOX) { if (transmit_mailbox == CAN_NOMAILBOX) {
// 没有可用的mailbox，启用发送中断以便在邮箱可用时重试 // 没有可用的 mailbox，启用发送中断以便在邮箱可用时重试
printf("No available mailbox for CANFD transmission, enabling TX " CAN_DEBUG_PRINT(
"No available mailbox for CANFD transmission, enabling TX "
"interrupt\r\n"); "interrupt\r\n");
return 0; return 0;
} }
// 启用CAN发送中断以检测传输完成 // 启用 CAN 发送中断以检测传输完成
can_interrupt_enable(CAN0, CAN_INTEN_TMEIE); can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
return 1; return 1;
} }
// 添加CAN传输中断处理函数 // 添加 CAN 传输中断处理函数
void CAN0_TX_IRQHandler(void) { void CAN0_TX_IRQHandler(void) {
// 检查是否有发送邮箱空闲 // 检查是否有发送邮箱空闲
if (can_flag_get(CAN0, CAN_FLAG_TME0) != RESET || if (can_flag_get(CAN0, CAN_FLAG_TME0) != RESET ||
Robot_V2/device/Can.h
+46 -33
View File
@@ -8,20 +8,21 @@ extern "C" {
#include <cstdint> #include <cstdint>
#include "gd32c10x_can.h" #include "gd32c10x_can.h"
#include "config.h"
// 定义一个联合体类型用于float和byte数组之间的转换 // 定义一个联合体类型用于 float 和 byte 数组之间的转换
typedef union { typedef union {
float f; float f;
u8 b[4]; u8 b[4];
} float_union_t; } float_union_t;
// 添加辅助函数用于将u16类型数据打包到u8数组中 // 添加辅助函数用于将 u16 类型数据打包到 u8 数组中
static inline void pack_u16_to_bytes(u8 *buffer, u16 offset, u16 value) { static inline void pack_u16_to_bytes(u8 *buffer, u16 offset, u16 value) {
buffer[offset] = (u8)(value & 0xFF); buffer[offset] = (u8)(value & 0xFF);
buffer[offset + 1] = (u8)((value >> 8) & 0xFF); buffer[offset + 1] = (u8)((value >> 8) & 0xFF);
} }
// 添加辅助函数用于将float类型数据打包到u8数组中 // 添加辅助函数用于将 float 类型数据打包到 u8 数组中
static inline void pack_float_to_bytes(u8 *buffer, u16 offset, static inline void pack_float_to_bytes(u8 *buffer, u16 offset,
float_union_t &float_union) { float_union_t &float_union) {
buffer[offset] = float_union.b[0]; buffer[offset] = float_union.b[0];
@@ -30,19 +31,19 @@ static inline void pack_float_to_bytes(u8 *buffer, u16 offset,
buffer[offset + 3] = float_union.b[3]; buffer[offset + 3] = float_union.b[3];
} }
// 添加辅助函数用于从u8数组中解包short类型数据 // 添加辅助函数用于从 u8 数组中解包 short 类型数据
static inline short unpack_bytes_to_short(u8 *buffer, u16 offset) { static inline short unpack_bytes_to_short(u8 *buffer, u16 offset) {
short value = (short)(buffer[offset] | (buffer[offset + 1] << 8)); short value = (short)(buffer[offset] | (buffer[offset + 1] << 8));
return value; return value;
} }
// 添加辅助函数用于从u8数组中解包u16类型数据 // 添加辅助函数用于从 u8 数组中解包 u16 类型数据
static inline u16 unpack_bytes_to_u16(u8 *buffer, u16 offset) { static inline u16 unpack_bytes_to_u16(u8 *buffer, u16 offset) {
u16 value = (u16)(buffer[offset] | (buffer[offset + 1] << 8)); u16 value = (u16)(buffer[offset] | (buffer[offset + 1] << 8));
return value; return value;
} }
// 添加辅助函数用于从u8数组中解包float类型数据 // 添加辅助函数用于从 u8 数组中解包 float 类型数据
static inline float_union_t unpack_bytes_to_float(u8 *buffer, u16 offset) { static inline float_union_t unpack_bytes_to_float(u8 *buffer, u16 offset) {
float_union_t float_union; float_union_t float_union;
float_union.b[0] = buffer[offset]; float_union.b[0] = buffer[offset];
@@ -52,32 +53,33 @@ static inline float_union_t unpack_bytes_to_float(u8 *buffer, u16 offset) {
return float_union; return float_union;
} }
u8 can_gpio_init(void); // CAN引脚初始化 u8 can_gpio_init(void); // CAN 引脚初始化
void can_config(void); // CAN初始化 void can_config(void); // CAN 初始化
void canfd_config(void); // CANFD初始化 void canfd_config(void); // CANFD 初始化
void can_dma_init(void); // CAN DMA初始化 void can_dma_init(void); // CAN DMA 初始化
void CAN0_RX0_IRQHandler(void); // CAN接收中断处理函数 void CAN0_RX0_IRQHandler(void); // CAN 接收中断处理函数
void DMA0_Channel4_IRQHandler(void); // DMA通道4中断处理函数(CAN接收) void DMA0_Channel4_IRQHandler(void); // DMA 通道 4 中断处理函数 (CAN 接收)
void DMA0_Channel5_IRQHandler(void); // DMA通道5中断处理函数(CAN发送) void DMA0_Channel5_IRQHandler(void); // DMA 通道 5 中断处理函数 (CAN 发送)
void jumpToBOOT(); void jumpToBOOT();
void can_loopback_init(void); void can_loopback_init(void);
void can_loopback_test(void); void can_loopback_test(void);
/*! /*!
\brief CAN通信类 \brief CAN 通信类
\note 封装CAN发送和接收功能 \note 封装 CAN 发送和接收功能，支持多电机节点 ID 隔离
*/ */
class CAN_transmiter { class CAN_transmiter {
private: private:
static const uint8_t CAN_RX_BUFFER_SIZE = 8; // CAN接收缓冲区大小 static const uint8_t CAN_RX_BUFFER_SIZE = 8; // CAN 接收缓冲区大小
bool is_sleep = false; // 是否休眠 bool is_sleep = false; // 是否休眠
u16 node_id; // 本节点 ID(0-254)，使用 CAN ID 高 8 位存储 (在 init() 中初始化为 DEFAULT_NODE_ID)
u8 Target_Control_Mode = 0; // 目标控制模式 u8 Target_Control_Mode = 0; // 目标控制模式
u8 controller_Mode = 0; // 当前模式 u8 controller_Mode = 0; // 当前模式
short mcu_temp = 0; // MCU温度 short mcu_temp = 0; // MCU 温度
short motor_temp = 0; // 电机温度 short motor_temp = 0; // 电机温度
u16 Power_Voltage = 0; // 电源电压 u16 Power_Voltage = 0; // 电源电压
@@ -91,47 +93,58 @@ class CAN_transmiter {
float_union_t target_velocity_union = {0}; // 目标速度 float_union_t target_velocity_union = {0}; // 目标速度
float_union_t target_current_union = {0}; // 目标电流 float_union_t target_current_union = {0}; // 目标电流
float_union_t u_current_union = {0}; // U相电流 float_union_t u_current_union = {0}; // U 相电流
float_union_t w_current_union = {0}; // W相电流 float_union_t w_current_union = {0}; // W 相电流
float_union_t v_current_union = {0}; // V相电流 float_union_t v_current_union = {0}; // V 相电流
bool MotorStatus = 0; // 电机状态码 bool MotorStatus = 0; // 电机状态码
u8 EEPROMStatus = 0; // EEPROM状态码 u8 EEPROMStatus = 0; // EEPROM 状态码
can_trasnmit_message_struct transmit_message; // 发送消息结构体 can_trasnmit_message_struct transmit_message; // 发送消息结构体
u8 transmit_mailbox = CAN_NOMAILBOX; // 初始化为无mailbox状态 u8 transmit_mailbox = CAN_NOMAILBOX; // 初始化为无 mailbox 状态
u8 transmit_data[64]; // CANFD最大64字节 u8 transmit_data[64]; // CANFD 最大 64 字节
// CAN接收消息队列 // CAN 接收消息队列
can_receive_message_struct rx_message_buffer[CAN_RX_BUFFER_SIZE]; can_receive_message_struct rx_message_buffer[CAN_RX_BUFFER_SIZE];
volatile uint8_t rx_buffer_head = 0; volatile uint8_t rx_buffer_head = 0;
volatile uint8_t rx_buffer_tail = 0; volatile uint8_t rx_buffer_tail = 0;
void update(); // 更新数据 void update(); // 更新数据
u8 CAN_Receive(); // CAN接收 u8 CAN_Receive(); // CAN 接收
u8 CANFD_Receive(); // CANFD接收 u8 CANFD_Receive(); // CANFD 接收
bool is_rx_buffer_full(); bool is_rx_buffer_full();
bool is_rx_buffer_empty(); bool is_rx_buffer_empty();
bool dequeue_rx_message(can_receive_message_struct& message); bool dequeue_rx_message(can_receive_message_struct& message);
public:
// 节点 ID 相关辅助函数 (使用高 16 位存储节点 ID)
u32 build_can_id(u32 base_id); // 根据节点 ID 构建 CAN ID，格式：[节点 ID(16 位)][基础 ID(16 位)]
bool is_message_for_me(u32 received_id); // 判断消息是否发给本节点
public: public:
// 添加构造函数声明 // 添加构造函数声明
u8 init(void); u8 init(void);
can_receive_message_struct receive_message; // 接收消息结构体 can_receive_message_struct receive_message; // 接收消息结构体
FlagStatus can0_send_flag; // CAN0发送标志 FlagStatus can0_send_flag; // CAN0 发送标志
float_union_t testfloat_union = {0}; // 测试用 float_union_t testfloat_union = {0}; // 测试用
u16 test_u16 = 0; u16 test_u16 = 0;
bool MagStatus = 0; // 磁状态码 bool MagStatus = 0; // 磁状态码
bool ThermalStatus = 0; // 热能状态码 bool ThermalStatus = 0; // 热能状态码
void communication_check(); // 通信检查 void communication_check(); // 通信检查
u8 CAN_Sleep(); // CAN进入睡眠 u8 CAN_Sleep(); // CAN 进入睡眠
u8 CAN_Wakeup(); // CAN进入睡眠 u8 CAN_Wakeup(); // CAN 唤醒
u8 CAN_AsyncSend(u32 ID, u8 length, u8 *data); // CAN异步发送(使用DMA) u8 CAN_AsyncSend(u32 ID, u8 length, u8 *data); // CAN 异步发送 (使用 DMA)
u8 CANFD_AsyncSend(u32 ID, u8 length, u8 *data); // CANFD异步发送(使用DMA) u8 CANFD_AsyncSend(u32 ID, u8 length, u8 *data); // CANFD 异步发送 (使用 DMA)
u8 CAN_all_Send(); // CAN发送 u8 CAN_all_Send(); // CAN 发送
u8 CANFD_all_Send(); // CANFD发送 u8 CANFD_all_Send(); // CANFD 发送
// 节点 ID 管理接口
u16 get_node_id(); // 获取当前节点 ID
void set_node_id(u16 new_id); // 设置节点 ID
u8 load_node_id_from_flash(); // 从 Flash 加载节点 ID
u8 save_node_id_to_flash(u16 new_id); // 保存节点 ID 到 Flash
// 中断处理函数需要访问的公共接口 // 中断处理函数需要访问的公共接口
void enqueue_rx_message_from_isr(const can_receive_message_struct& message) { void enqueue_rx_message_from_isr(const can_receive_message_struct& message) {
Robot_V2/device/ang_sensor.cpp
+38 -32
View File
@@ -11,12 +11,19 @@
#include <cstring> #include <cstring>
#include <stdint.h> #include <stdint.h>
// ANG_SENS 调试宏定义
#if ANG_SENS_DEBUG
#define ANG_SENS_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define ANG_SENS_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
#define ANG_SPI_CS_ENABLE() gpio_bit_reset(GPIOA, GPIO_PIN_15) #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 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_ENABLE() gpio_bit_reset(GPIOB, GPIO_PIN_14)
#define DRV_SPI_CS_DISABLE() gpio_bit_set(GPIOB, GPIO_PIN_14) #define DRV_SPI_CS_DISABLE() gpio_bit_set(GPIOB, GPIO_PIN_14)
// DMA传输完成标志 // DMA 传输完成标志
volatile bool spi_dma_tx_complete = false; volatile bool spi_dma_tx_complete = false;
volatile bool spi_dma_rx_complete = false; volatile bool spi_dma_rx_complete = false;
@@ -24,7 +31,7 @@ angle_sensor KTH7823; // 角度传感器初始化
extern FlashEEPROM flashEEP; extern FlashEEPROM flashEEP;
extern EncoderAngleKalman Angle_kalman; extern EncoderAngleKalman Angle_kalman;
extern EncoderVelocityKalman Vel_kalman; extern EncoderVelocityKalman Vel_kalman;
extern CAN_transmiter CAN0_transmiter; // CAN初始化 extern CAN_transmiter CAN0_transmiter; // CAN 初始化
/** /**
* @brief SPI DMA initialization * @brief SPI DMA initialization
@@ -32,10 +39,10 @@ extern CAN_transmiter CAN0_transmiter; // CAN初始化
void spi_dma_init(void) { void spi_dma_init(void) {
dma_parameter_struct dma_init_struct; dma_parameter_struct dma_init_struct;
// 使能DMA时钟 // 使能 DMA 时钟
rcu_periph_clock_enable(RCU_DMA0); rcu_periph_clock_enable(RCU_DMA0);
// 初始化发送DMA通道 // 初始化发送 DMA 通道
dma_deinit(DMA0, DMA_CH2); dma_deinit(DMA0, DMA_CH2);
dma_struct_para_init(&dma_init_struct); dma_struct_para_init(&dma_init_struct);
dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL; dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
@@ -49,7 +56,7 @@ void spi_dma_init(void) {
dma_init_struct.priority = DMA_PRIORITY_HIGH; dma_init_struct.priority = DMA_PRIORITY_HIGH;
dma_init(DMA0, DMA_CH2, &dma_init_struct); dma_init(DMA0, DMA_CH2, &dma_init_struct);
// 初始化接收DMA通道 // 初始化接收 DMA 通道
dma_deinit(DMA0, DMA_CH1); dma_deinit(DMA0, DMA_CH1);
dma_struct_para_init(&dma_init_struct); dma_struct_para_init(&dma_init_struct);
dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY; dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
@@ -63,15 +70,15 @@ void spi_dma_init(void) {
dma_init_struct.priority = DMA_PRIORITY_HIGH; dma_init_struct.priority = DMA_PRIORITY_HIGH;
dma_init(DMA0, DMA_CH1, &dma_init_struct); dma_init(DMA0, DMA_CH1, &dma_init_struct);
// 使能SPI的DMA发送和接收功能 // 使能 SPI 的 DMA 发送和接收功能
spi_dma_enable(SPI0, SPI_DMA_TRANSMIT); spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
spi_dma_enable(SPI0, SPI_DMA_RECEIVE); spi_dma_enable(SPI0, SPI_DMA_RECEIVE);
// 配置DMA中断 // 配置 DMA 中断
nvic_irq_enable(DMA0_Channel2_IRQn, 0, 1); nvic_irq_enable(DMA0_Channel2_IRQn, 0, 1);
nvic_irq_enable(DMA0_Channel1_IRQn, 0, 1); nvic_irq_enable(DMA0_Channel1_IRQn, 0, 1);
// 使能DMA传输完成中断 // 使能 DMA 传输完成中断
dma_interrupt_enable(DMA0, DMA_CH2, DMA_INT_FTF); dma_interrupt_enable(DMA0, DMA_CH2, DMA_INT_FTF);
dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF); dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);
} }
@@ -90,30 +97,30 @@ int spi_rw_half_word_dma(uint32_t spi_periph, uint16_t tx_data,
spi_dma_tx_complete = false; spi_dma_tx_complete = false;
spi_dma_rx_complete = false; spi_dma_rx_complete = false;
// 配置发送DMA // 配置发送 DMA
dma_channel_disable(DMA0, DMA_CH2); dma_channel_disable(DMA0, DMA_CH2);
dma_memory_address_config(DMA0, DMA_CH2, (uint32_t)&tx_data); dma_memory_address_config(DMA0, DMA_CH2, (uint32_t)&tx_data);
dma_transfer_number_config(DMA0, DMA_CH2, 1); dma_transfer_number_config(DMA0, DMA_CH2, 1);
dma_channel_enable(DMA0, DMA_CH2); dma_channel_enable(DMA0, DMA_CH2);
// 配置接收DMA // 配置接收 DMA
dma_channel_disable(DMA0, DMA_CH1); dma_channel_disable(DMA0, DMA_CH1);
dma_memory_address_config(DMA0, DMA_CH1, (uint32_t)rx_data); dma_memory_address_config(DMA0, DMA_CH1, (uint32_t)rx_data);
dma_transfer_number_config(DMA0, DMA_CH1, 1); dma_transfer_number_config(DMA0, DMA_CH1, 1);
dma_channel_enable(DMA0, DMA_CH1); dma_channel_enable(DMA0, DMA_CH1);
// 等待传输完成，超时时间为100个循环 // 等待传输完成，超时时间为 100 个循环
uint32_t timeout = 100; uint32_t timeout = 100;
while ((!spi_dma_tx_complete || !spi_dma_rx_complete) && --timeout) { while ((!spi_dma_tx_complete || !spi_dma_rx_complete) && --timeout) {
// 空循环等待DMA传输完成 // 空循环等待 DMA 传输完成
} }
// 检查是否超时 // 检查是否超时
if (timeout == 0) { if (timeout == 0) {
// 禁用DMA通道 // 禁用 DMA 通道
dma_channel_disable(DMA0, DMA_CH2); dma_channel_disable(DMA0, DMA_CH2);
dma_channel_disable(DMA0, DMA_CH1); dma_channel_disable(DMA0, DMA_CH1);
printf("SPI DMA transfer timeout\r\n"); ANG_SENS_DEBUG_PRINT("SPI DMA transfer timeout\r\n");
return -1; return -1;
} }
@@ -121,7 +128,7 @@ int spi_rw_half_word_dma(uint32_t spi_periph, uint16_t tx_data,
} }
/** /**
* @brief DMA0_Channel2中断处理函数 * @brief DMA0_Channel2 中断处理函数
* @param 无 * @param 无
*/ */
extern "C" void DMA0_Channel2_IRQHandler(void) { extern "C" void DMA0_Channel2_IRQHandler(void) {
@@ -132,7 +139,7 @@ extern "C" void DMA0_Channel2_IRQHandler(void) {
} }
/** /**
* @brief DMA0_Channel1中断处理函数 * @brief DMA0_Channel1 中断处理函数
* @param 无 * @param 无
*/ */
extern "C" void DMA0_Channel1_IRQHandler(void) { extern "C" void DMA0_Channel1_IRQHandler(void) {
@@ -174,7 +181,7 @@ void KTH7823_spi_init(void) {
spi_parameter_struct spi_init_str; spi_parameter_struct spi_init_str;
spi_struct_para_init(&spi_init_str); spi_struct_para_init(&spi_init_str);
/* SPI参数：16bit, 主机, 全双工, CPOL=1 CPHA=1, MSB first */ /* SPI 参数：16bit, 主机，全双工，CPOL=1 CPHA=1, MSB first */
spi_init_str.device_mode = SPI_MASTER; spi_init_str.device_mode = SPI_MASTER;
spi_init_str.trans_mode = SPI_TRANSMODE_FULLDUPLEX; spi_init_str.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
spi_init_str.frame_size = SPI_FRAMESIZE_16BIT; spi_init_str.frame_size = SPI_FRAMESIZE_16BIT;
@@ -194,16 +201,16 @@ void KTH7823_spi_init(void) {
* @return 0:初始化成功 1:初始化失败 * @return 0:初始化成功 1:初始化失败
*/ */
u8 angle_sensor::init(void) { u8 angle_sensor::init(void) {
KTH7823_gpio_init(); // GPIO初始化 KTH7823_gpio_init(); // GPIO 初始化
KTH7823_spi_init(); // SPI初始化 KTH7823_spi_init(); // SPI 初始化
spi_dma_init(); // DMA初始化 spi_dma_init(); // DMA 初始化
return 0; return 0;
} }
/** /**
* @ 角度传感器类 设置当前角度 * @ 角度传感器类 设置当前角度
* @param angle 输出级角度值 * @param angle 输出级角度值
* @return 0成功/1失败 * @return 0 成功/1 失败
*/ */
u8 angle_sensor::angle_set(float angle) { u8 angle_sensor::angle_set(float angle) {
m_cumulativeAngle = angle * REDUCTION_RATIO; m_cumulativeAngle = angle * REDUCTION_RATIO;
@@ -230,10 +237,9 @@ inline float angle_sensor::read_sensorAngle(void) {
return angle_deg; return angle_deg;
} }
// 仅在调试模式下输出错误，避免发布版本中的I/O开销 // 仅在调试模式下输出错误，避免发布版本中的 I/O 开销
if (result != 0) { if (result != 0) {
// 使用更高效的串口输出替代printf（如果可用） ANG_SENS_DEBUG_PRINT("Error reading angle from sensor.\n");
printf("Error reading angle from sensor.\n");
} }
return (float)FAULT_RECEIVE; return (float)FAULT_RECEIVE;
@@ -255,13 +261,13 @@ float angle_sensor::update(void) {
// 计算角度变化 // 计算角度变化
float delta = current_angle_deg - m_lastAngle; float delta = current_angle_deg - m_lastAngle;
// 处理角度绕回情况（0度和360度之间的跳变） // 处理角度绕回情况（0 度和 360 度之间的跳变）
// 如果变化超过300度，说明发生了绕回 // 如果变化超过 300 度，说明发生了绕回
if (delta > ANGLE_WRAP_THRESHOLD) { if (delta > ANGLE_WRAP_THRESHOLD) {
// 从接近360度绕回到接近0度 // 从接近 360 度绕回到接近 0 度
delta -= ANGLE_WRAP_VALUE; delta -= ANGLE_WRAP_VALUE;
} else if (delta < -ANGLE_WRAP_THRESHOLD) { } else if (delta < -ANGLE_WRAP_THRESHOLD) {
// 从接近0度绕到接近360度 // 从接近 0 度绕到接近 360 度
delta += ANGLE_WRAP_VALUE; delta += ANGLE_WRAP_VALUE;
} }
@@ -271,7 +277,7 @@ float angle_sensor::update(void) {
} }
/** /**
* @brief 获取累积角度值(输出级) * @brief 获取累积角度值 (输出级)
* @return 累积角度值 * @return 累积角度值
*/ */
float angle_sensor::getAngle(void) const { float angle_sensor::getAngle(void) const {
@@ -279,14 +285,14 @@ float angle_sensor::getAngle(void) const {
} }
/** /**
* @brief 获取累积角度值(原始级) * @brief 获取累积角度值 (原始级)
* @return 累积角度值 * @return 累积角度值
*/ */
float angle_sensor::getRawAngle(void) const { return m_cumulativeAngle; } float angle_sensor::getRawAngle(void) const { return m_cumulativeAngle; }
/** /**
* @brief 获取角度值(原始级) * @brief 获取角度值 (原始级)
* @return 角度值(原始级) * @return 角度值 (原始级)
*/ */
float angle_sensor::getcurrent_sensorangle(void) const{ float angle_sensor::getcurrent_sensorangle(void) const{
return current_angle_deg; return current_angle_deg;
Robot_V2/device/test.cpp
+17 -9
View File
@@ -1,25 +1,33 @@
#include "adc.h" #include "adc.h"
#include "config.h"
#include <cstdio> #include <cstdio>
// TEST 调试宏定义
#if TEST_DEBUG
#define TEST_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define TEST_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
constexpr int status_print = 0; constexpr int status_print = 0;
extern sampler sampler; extern sampler sampler;
void test_1111() { void test_1111() {
// 初始化CAN回环测试 // 初始化 CAN 回环测试
// can_loopback_init(); // can_loopback_init();
// can_config(); // can_config();
if (status_print) { if (status_print) {
/* value print */ /* value print */
printf(" the temperature data is %2.2f degrees Celsius\r\n", TEST_DEBUG_PRINT(" the temperature data is %2.2f degrees Celsius\r\n",
sampler.get_mcu_temp()); sampler.get_mcu_temp());
printf(" the drv_temperature data is %2.2f degrees Celsius\r\n", TEST_DEBUG_PRINT(" the drv_temperature data is %2.2f degrees Celsius\r\n",
sampler.get_drv_temp()); sampler.get_drv_temp());
printf(" the U current data is %2.2f mA\r\n", sampler.get_current('U')); TEST_DEBUG_PRINT(" the U current data is %2.2f mA\r\n", sampler.get_current('U'));
printf(" the V current data is %2.2f mA\r\n", sampler.get_current('V')); TEST_DEBUG_PRINT(" the V current data is %2.2f mA\r\n", sampler.get_current('V'));
printf(" the W current data is %2.2f mA\r\n", sampler.get_current('W')); TEST_DEBUG_PRINT(" the W current data is %2.2f mA\r\n", sampler.get_current('W'));
printf(" the VBUS is %2.2f V\r\n", sampler.get_vbus_voltage()); TEST_DEBUG_PRINT(" the VBUS is %2.2f V\r\n", sampler.get_vbus_voltage());
// printf(" the angle is %2.2f\r\n", tle5012b_read()); // TEST_DEBUG_PRINT(" the angle is %2.2f\r\n", tle5012b_read());
printf("\n----------------------------------------------------\n"); TEST_DEBUG_PRINT("\n----------------------------------------------------\n");
} }
// can_loopback_test(); // can_loopback_test();
} }
Robot_V2/main.cpp
+28 -16
View File
@@ -10,14 +10,21 @@
#include "initial.h" #include "initial.h"
#include "systick.h" #include "systick.h"
extern CAN_transmiter CAN0_transmiter; // CAN初始化 // MAIN 调试宏定义
#if MAIN_DEBUG
#define MAIN_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define MAIN_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
extern CAN_transmiter CAN0_transmiter; // CAN 初始化
extern sampler sampler; // 采样器 extern sampler sampler; // 采样器
extern angle_sensor KTH7823; // 角度传感器 extern angle_sensor KTH7823; // 角度传感器
extern EncoderVelocityKalman Vel_kalman; // 速度滤波 extern EncoderVelocityKalman Vel_kalman; // 速度滤波
extern EncoderAngleKalman Angle_kalman; // 角度滤波 extern EncoderAngleKalman Angle_kalman; // 角度滤波
extern ThermalController thermalController; // 热量控制器 extern ThermalController thermalController; // 热量控制器
extern FOC_Controller FOC; // FOC控制 extern FOC_Controller FOC; // FOC 控制
extern FlashEEPROM flashEEP; // EEPROM类 extern FlashEEPROM flashEEP; // EEPROM 类
extern VersionManager Version; extern VersionManager Version;
// 全局版本管理器实例 // 全局版本管理器实例
@@ -41,9 +48,9 @@ int main(void) {
u8 init_status = hardware_init(); u8 init_status = hardware_init();
while (init_status) { // 初始化检测 while (init_status) { // 初始化检测
std::printf("初始化失败\r\n"); MAIN_DEBUG_PRINT("初始化失败\r\n");
} }
OTA_initial(); // OTA初始化,A/B分区处理 OTA_initial(); // OTA 初始化，A/B 分区处理
angsens_MG_check(); // 角度传感器磁感应强度测试 angsens_MG_check(); // 角度传感器磁感应强度测试
watchdog_init(50); // 看门狗初始化 watchdog_init(50); // 看门狗初始化
@@ -65,17 +72,22 @@ u8 hardware_init(void) {
systick_config(); // 系统时钟初始化 systick_config(); // 系统时钟初始化
unused_pin_init(); // 未使用引脚初始化 unused_pin_init(); // 未使用引脚初始化
USART0_init(); // 调试串口初始化 USART0_init(); // 调试串口初始化
User_timer_init(); // 任务Timer初始化 User_timer_init(); // 任务 Timer 初始化
u8 init_status = 0; u8 init_status = 0;
init_status += KTH7823.init(); // 角度传感器初始化 init_status += KTH7823.init(); // 角度传感器初始化
init_status += sampler.init(); // 采样器初始化 init_status += sampler.init(); // 采样器初始化
flashEEP.init(); // EEPROM初始化，必须放在角度卡尔曼之前，角度传感器之后
// 先初始化 CAN，确保节点 ID 被正确设置
// CAN 初始化会先设置默认节点 ID，然后从 Flash 加载
init_status += CAN0_transmiter.init(); // CAN 初始化
// EEPROM 初始化 (必须在 CAN 初始化之后，因为会读取节点 ID)
flashEEP.init(); // EEPROM 初始化
init_status += Angle_kalman.init(KTH7823.getAngle()); // 角度滤波初始化 init_status += Angle_kalman.init(KTH7823.getAngle()); // 角度滤波初始化
init_status += Vel_kalman.init(0.0f); // 速度滤波初始化 init_status += Vel_kalman.init(0.0f); // 速度滤波初始化
init_status += CAN0_transmiter.init(); // CAN初始化 init_status += FOC.init(); // FOC 初始化
init_status += FOC.init(); // FOC初始化
return init_status; return init_status;
} }
@@ -92,7 +104,7 @@ void do_task(u32 currentTasks) {
if (currentTasks & (1 << TASK_VELOCITY_UPDATE)) { // 更新速度传感器值 if (currentTasks & (1 << TASK_VELOCITY_UPDATE)) { // 更新速度传感器值
FOC.rt_velocity = Vel_kalman.update(Angle_kalman.getVelocity()); FOC.rt_velocity = Vel_kalman.update(Angle_kalman.getVelocity());
} }
if (currentTasks & (1 << TASK_MOTOR_CONTROL)) { // 电机控制任务(最高优先级) if (currentTasks & (1 << TASK_MOTOR_CONTROL)) { // 电机控制任务 (最高优先级)
motor_runtime_50us++; motor_runtime_50us++;
// 静态变量用于跟踪上一次的控制模式 // 静态变量用于跟踪上一次的控制模式
@@ -100,11 +112,11 @@ void do_task(u32 currentTasks) {
// 边界检查，防止数组越界 // 边界检查，防止数组越界
if (FOC.control_mode >= 0 && if (FOC.control_mode >= 0 &&
FOC.control_mode < 7) { // 更新为7个控制模式 FOC.control_mode < 7) { // 更新为 7 个控制模式
// 检查控制模式是否发生变化 // 检查控制模式是否发生变化
if (FOC.control_mode != last_control_mode) { if (FOC.control_mode != last_control_mode) {
// 重置所有PID控制器的状态，避免积分项累积 // 重置所有 PID 控制器的状态，避免积分项累积
FOC.vel_loop.reset(); FOC.vel_loop.reset();
FOC.angle_loop.reset(); FOC.angle_loop.reset();
FOC.current_loop.reset(); FOC.current_loop.reset();
@@ -126,7 +138,7 @@ void do_task(u32 currentTasks) {
} }
} }
} }
if (currentTasks & (1 << TASK_MCU_TEMP_UPDATE)) { // 更新mcu温度传感器值 if (currentTasks & (1 << TASK_MCU_TEMP_UPDATE)) { // 更新 mcu 温度传感器值
sampler.update_mcu_temp(); sampler.update_mcu_temp();
} }
if (currentTasks & (1 << TASK_DRV_TEMP_UPDATE)) { // 更新电机温度传感器值 if (currentTasks & (1 << TASK_DRV_TEMP_UPDATE)) { // 更新电机温度传感器值
@@ -138,11 +150,11 @@ void do_task(u32 currentTasks) {
if (currentTasks & (1 << TASK_MAGNETIC_CHECK)) { // 磁感应强度检测 if (currentTasks & (1 << TASK_MAGNETIC_CHECK)) { // 磁感应强度检测
angsens_MG_check(); angsens_MG_check();
} }
if (currentTasks & (1 << TASK_VBUS_UPDATE)) { // 更新vbus电压值 if (currentTasks & (1 << TASK_VBUS_UPDATE)) { // 更新 vbus 电压值
power_manage(); power_manage();
} }
if (currentTasks & (1 << TASK_CAN_TRANSMIT)) { // CAN通信 if (currentTasks & (1 << TASK_CAN_TRANSMIT)) { // CAN 通信
CAN0_transmiter.test_u16 = cnt_test; // 负载检测 CAN0_transmiter.test_u16 = CAN0_transmiter.get_node_id(); // 负载检测
cnt_test = 0; cnt_test = 0;
CAN0_transmiter.can0_send_flag = SET; CAN0_transmiter.can0_send_flag = SET;
CAN0_transmiter.communication_check(); CAN0_transmiter.communication_check();
Robot_V2/sys/config.h
+67 -48
View File
@@ -3,19 +3,22 @@
#include "gd32c10x_eval.h" #include "gd32c10x_eval.h"
#include <cstdint> #include <cstdint>
// 如果使用CMSIS DSP库，需要定义ARM_MATH_CM4 // 如果使用 CMSIS DSP 库，需要定义 ARM_MATH_CM4
#define ARM_MATH_CM4 #define ARM_MATH_CM4
#define EEP_DEBUG 1 #define EEP_DEBUG 1
#define OTA_DEBUG 1 #define OTA_DEBUG 1
#define SLEEP_DEBUG 1 #define SLEEP_DEBUG 1
#define ANG_SENS_DEBUG 1 #define ANG_SENS_DEBUG 1
#define CAN_DEBUG 1
#define MAIN_DEBUG 1
#define TEST_DEBUG 1
// 版本号定义 - 可根据实际项目进行调整 // 版本号定义 - 可根据实际项目进行调整
constexpr u16 SOFTWARE_VERSION_MAJOR = 26; constexpr u16 SOFTWARE_VERSION_MAJOR = 26;
constexpr u16 SOFTWARE_VERSION_MINOR = 3; constexpr u16 SOFTWARE_VERSION_MINOR = 3;
constexpr u16 SOFTWARE_VERSION_PATCH = 9; constexpr u16 SOFTWARE_VERSION_PATCH = 15;
constexpr u16 SOFTWARE_VERSION_BUILD = 1; constexpr u16 SOFTWARE_VERSION_BUILD = 4;
constexpr u16 HARDWARE_VERSION_MAJOR = 25; constexpr u16 HARDWARE_VERSION_MAJOR = 25;
constexpr u16 HARDWARE_VERSION_MINOR = 12; constexpr u16 HARDWARE_VERSION_MINOR = 12;
@@ -27,11 +30,11 @@ constexpr u16 BOOT_VERSION_MINOR = 1;
constexpr u16 BOOT_VERSION_PATCH = 12; constexpr u16 BOOT_VERSION_PATCH = 12;
constexpr u16 BOOT_VERSION_BUILD = 0; constexpr u16 BOOT_VERSION_BUILD = 0;
// Flash分区配置 // Flash 分区配置
constexpr u32 BOOTLOADER_SIZE = 0x6000; // 24KB constexpr u32 BOOTLOADER_SIZE = 0x6000; // 24KB
constexpr u32 BOOTLOADER_START_ADDR = 0x08000000; // BOOT起始地址 constexpr u32 BOOTLOADER_START_ADDR = 0x08000000; // BOOT 起始地址
constexpr u32 APPLATEST_START_ADDR = 0x08012000; // APP起始地址 constexpr u32 APPLATEST_START_ADDR = 0x08012000; // APP 起始地址
constexpr u32 APPBACK_START_ADDR = 0x08006000; // APPBACK起始地址 constexpr u32 APPBACK_START_ADDR = 0x08006000; // APPBACK 起始地址
constexpr u32 APP_MAX_SIZE = 0xC000; // 48KB constexpr u32 APP_MAX_SIZE = 0xC000; // 48KB
constexpr u32 FMC_PAGE_SIZE = 0x400; // 1KB constexpr u32 FMC_PAGE_SIZE = 0x400; // 1KB
constexpr u32 SLEEP_CONFIG_START = 0x0801E400; // 睡眠配置起始地址 constexpr u32 SLEEP_CONFIG_START = 0x0801E400; // 睡眠配置起始地址
@@ -40,14 +43,22 @@ constexpr u32 FLASH_EMPTY = 0xFFFFFFFF; // 空数据
constexpr u32 SLEEP_ENABLE = 0x11111111; // 睡眠使能 constexpr u32 SLEEP_ENABLE = 0x11111111; // 睡眠使能
constexpr u32 SLEEP_DISABLE = 0x00000000; // 睡眠禁止 constexpr u32 SLEEP_DISABLE = 0x00000000; // 睡眠禁止
// 节点 ID 配置 (用于多电机 CAN 总线隔离)
// 使用 CAN ID 高 16 位 (bits 31-16) 存储节点 ID，低 16 位 (bits 15-0) 存储基础 ID
// 格式：[节点 ID(16 位)][基础 ID(16 位)]，例如：node_id=1, base_id=0x0200 → 0x00010200
constexpr u32 NODE_ID_CONFIG_ADDR = 0x0801E800; // 节点 ID 存储地址
constexpr u16 DEFAULT_NODE_ID = 1; // 默认节点 ID
constexpr u16 BROADCAST_NODE_ID = 0xFFFF; // 广播 ID (所有节点响应)
constexpr u16 MAX_NODE_ID = 0xFFFE; // 最大有效节点 ID (0~0xFFFE)
// BOOT 相关 // BOOT 相关
constexpr u32 OTA_CONFIG_NUM = 6; constexpr u32 OTA_CONFIG_NUM = 6;
constexpr u32 n_APP_LATEST_AVAL_ADDR = 0x0801E000; // 最新APP可用地址 constexpr u32 n_APP_LATEST_AVAL_ADDR = 0x0801E000; // 最新 APP 可用地址
constexpr u32 n_APP_BACKUP_AVAL_ADDR = 0x0801E004; // 备份APP可用地址 constexpr u32 n_APP_BACKUP_AVAL_ADDR = 0x0801E004; // 备份 APP 可用地址
constexpr u32 n_APP_LATEST_EN_ADDR = 0x0801E008; // 最新APP激活 constexpr u32 n_APP_LATEST_EN_ADDR = 0x0801E008; // 最新 APP 激活
constexpr u32 n_APP_BACKUP_EN_ADDR = 0x0801E00C; // 备份APP激活 constexpr u32 n_APP_BACKUP_EN_ADDR = 0x0801E00C; // 备份 APP 激活
constexpr u32 n_APP_LATEST_CHECK_ADDR = 0x0801E010; // 最新APP校验 constexpr u32 n_APP_LATEST_CHECK_ADDR = 0x0801E010; // 最新 APP 校验
constexpr u32 n_APP_BACKUP_CHECK_ADDR = 0x0801E014; // 备份APP校验 constexpr u32 n_APP_BACKUP_CHECK_ADDR = 0x0801E014; // 备份 APP 校验
constexpr u32 OTA_NOT_AVAL = 0xFFFFFFFF; constexpr u32 OTA_NOT_AVAL = 0xFFFFFFFF;
constexpr u32 OTA_AVAL = 0x00000000; // 全零表示可用 constexpr u32 OTA_AVAL = 0x00000000; // 全零表示可用
@@ -62,10 +73,10 @@ constexpr float KE_FACTOR = 0.0f;
// 角度卡尔曼滤波器参数 // 角度卡尔曼滤波器参数
// 参数调节建议： // 参数调节建议：
// - 增大Q值：增加对测量的信任，提高响应速度 // - 增大 Q 值：增加对测量的信任，提高响应速度
// - 减小Q值：增加对预测的信任，提高平滑度 // - 减小 Q 值：增加对预测的信任，提高平滑度
// - 增大R值：增加平滑度，减少噪声，但会降低响应速度 // - 增大 R 值：增加平滑度，减少噪声，但会降低响应速度
// - 减小R值：提高响应速度，但会增加噪声 // - 减小 R 值：提高响应速度，但会增加噪声
constexpr float ANGLE_KALMAN_INITIAL_STATE = 0.0f; constexpr float ANGLE_KALMAN_INITIAL_STATE = 0.0f;
constexpr float ANGLE_KALMAN_INITIAL_COVARIANCE = 0.0f; constexpr float ANGLE_KALMAN_INITIAL_COVARIANCE = 0.0f;
constexpr float ANGLE_KALMAN_PROCESS_NOISE_Q = constexpr float ANGLE_KALMAN_PROCESS_NOISE_Q =
@@ -79,7 +90,7 @@ constexpr float VELOCITY_KALMAN_INITIAL_COVARIANCE = 1e-5f;
constexpr float VELOCITY_KALMAN_PROCESS_NOISE_Q = constexpr float VELOCITY_KALMAN_PROCESS_NOISE_Q =
1e-6f; // 过程噪声协方差 - 通常保持较小 1e-6f; // 过程噪声协方差 - 通常保持较小
constexpr float VELOCITY_KALMAN_MEASUREMENT_NOISE_R = constexpr float VELOCITY_KALMAN_MEASUREMENT_NOISE_R =
1.0f; // 测量噪声协方差 - 主要调节参数1.0 1.0f; // 测量噪声协方差 - 主要调节参数 1.0
// 电流卡尔曼滤波器参数 // 电流卡尔曼滤波器参数
constexpr float CURRENT_KALMAN_INITIAL_STATE = 0.0f; constexpr float CURRENT_KALMAN_INITIAL_STATE = 0.0f;
@@ -87,26 +98,27 @@ constexpr float CURRENT_KALMAN_INITIAL_COVARIANCE = 100.0f; // 增大初始协
constexpr float CURRENT_KALMAN_PROCESS_NOISE_Q = 10.0f; // 降低过程噪声 constexpr float CURRENT_KALMAN_PROCESS_NOISE_Q = 10.0f; // 降低过程噪声
constexpr float CURRENT_KALMAN_MEASUREMENT_NOISE_R = 5e-5f; // 增大测量噪声 constexpr float CURRENT_KALMAN_MEASUREMENT_NOISE_R = 5e-5f; // 增大测量噪声
// PID配置 // PID 配置
constexpr float DEFAULT_current_loop_p = 0.1f / 100 * 12; // 电流P constexpr float DEFAULT_current_loop_p = 0.1f / 100 * 12; // 电流 P
constexpr float current_loop_Ki = 0.55f; // 电流P constexpr float current_loop_Ki = 0.55f; // 电流 P
constexpr float current_loop_Kd = 3e-4f; // 电流P constexpr float current_loop_Kd = 3e-4f; // 电流 P
constexpr float DEFAULT_vel_loop_p = 0.018f / 100 * 12; // 速度P constexpr float DEFAULT_vel_loop_p = 0.018f / 100 * 12; // 速度 P
constexpr float vel_loop_Ku = 3.600000e-03 * 0.7 * 100 / 12; constexpr float vel_loop_Ku = 3.600000e-03 * 0.7 * 100 / 12;
constexpr float vel_loop_Tu = 17.0f * 1e-3f; constexpr float vel_loop_Tu = 17.0f * 1e-3f;
constexpr float vel_loop_Ki = 1.2 * vel_loop_Ku / vel_loop_Tu; constexpr float vel_loop_Ki = 1.2 * vel_loop_Ku / vel_loop_Tu;
constexpr float vel_loop_Kd = 0.075 * vel_loop_Ku * vel_loop_Tu * 2; constexpr float vel_loop_Kd = 0.075 * vel_loop_Ku * vel_loop_Tu * 2;
constexpr float DEFAULT_vel_angloop_p = 0.4f / 100; // 速度 速度-角度P constexpr float DEFAULT_vel_angloop_p = 0.4f / 100; // 速度 速度 - 角度 P
constexpr float vel_angloop_Ki = 5.0f; // 速度 速度-角度I constexpr float vel_angloop_Ki = 5.0f; // 速度 速度 - 角度 I
constexpr float vel_angloop_Kd = 5e-05f; // 速度 速度-角度D constexpr float vel_angloop_Kd = 5e-05f; // 速度 速度 - 角度 D
constexpr float DEFAULT_angle_angloop_p = 150.0f / 100 * 12; // 角度 速度-角度P constexpr float DEFAULT_angle_angloop_p =
constexpr float ang_angloop_Ki = 0.00f; // 角度 速度-角度I 150.0f / 100 * 12; // 角度 速度 - 角度 P
constexpr float ang_angloop_Kd = 8e-04f; // 角度 速度-角度D constexpr float ang_angloop_Ki = 0.00f; // 角度 速度 - 角度 I
constexpr float ang_angloop_Kd = 8e-04f; // 角度 速度 - 角度 D
constexpr float DEFAULT_angle_loop_p = 60.0f / 100 * 12; // 角度P constexpr float DEFAULT_angle_loop_p = 60.0f / 100 * 12; // 角度 P
constexpr float DEFAULT_angle_MIT_p = 100.0f / 100 * 12; // 角度 MIT P constexpr float DEFAULT_angle_MIT_p = 100.0f / 100 * 12; // 角度 MIT P
constexpr float angle_MIT_Ki = 0.0f; constexpr float angle_MIT_Ki = 0.0f;
@@ -133,32 +145,39 @@ constexpr float SQRT3DV2 = 0.8660254037844386f; // sqrt(3)/2
constexpr float COS_PI_3 = 0.5f; constexpr float COS_PI_3 = 0.5f;
constexpr float ANGLE_FACTOR = 25.0f / 180.0f * PI; constexpr float ANGLE_FACTOR = 25.0f / 180.0f * PI;
constexpr float DEG2RAD = 1.0f / 180.0f * PI; constexpr float DEG2RAD = 1.0f / 180.0f * PI;
constexpr float RAD2DEG = 180.0f / PI; // 修正RAD2DEG定义，应该是180/π constexpr float RAD2DEG = 180.0f / PI; // 修正 RAD2DEG 定义，应该是 180/π
constexpr u8 DEFAULT_VALUE = 0; constexpr u8 DEFAULT_VALUE = 0;
constexpr u8 CONFIG_SAVED_NUM = 6; constexpr u8 CONFIG_SAVED_NUM = 6;
// 三角函数快速计算LUT // 三角函数快速计算 LUT
constexpr u16 LUT_SIZE = 1024; constexpr u16 LUT_SIZE = 1024;
constexpr u16 LUT_MASK = (LUT_SIZE - 1); constexpr u16 LUT_MASK = (LUT_SIZE - 1);
constexpr u16 LUT_SCALE = (LUT_SIZE / (2.0f * PI)); constexpr u16 LUT_SCALE = (LUT_SIZE / (2.0f * PI));
// CAN相关 // CAN 相关
// 注意：以下为 CAN 基础 ID（只保留低 16 位），实际发送/接收时会自动叠加节点 ID
// 到高 16 位 格式：[节点 ID(16 位)][基础 ID(16 位)] 例如：节点 ID=1，发送命令
// ID = (1 << 16) | CANFD_CMD_ID = 0x00010200
constexpr u16 DEV_CAN0_ID = 0x0000; constexpr u16 DEV_CAN0_ID = 0x0000;
constexpr u16 DEV_CAN0_MASK = 0x0000; constexpr u16 DEV_CAN0_MASK = 0x0000;
constexpr u16 DEV_CAN_LOOPBACK_ID = 0x0000; constexpr u16 DEV_CAN_LOOPBACK_ID = 0x0000;
// 反馈ID // 反馈基础 ID
constexpr u32 CANFD_STATUS_ID = 0x00010100; constexpr u16 CANFD_STATUS_ID = 0x0100; // 状态反馈基础 ID
constexpr u32 CANFD_CONFIG_ID = 0x00010101; constexpr u16 CANFD_CONFIG_ID = 0x0101; // 配置信息基础 ID
constexpr u32 CANFD_VERSION_ID = 0x00010000; constexpr u16 CANFD_VERSION_ID = 0x00FF; // 版本信息基础 ID
// 命令ID // 命令基础 ID
constexpr u32 CANFD_CMD_ID = 0x00010200; constexpr u16 CANFD_CMD_ID = 0x0200; // 控制命令基础 ID
constexpr u32 CANFD_RESET_ID = 0x00010301; constexpr u16 CANFD_RESET_ID = 0x0301; // 重置命令基础 ID
// OTA相关ID // 节点 ID 管理基础 ID
constexpr u32 CANFD_BOOT_ID = 0x00000000; constexpr u16 CANFD_SET_NODE_ID = 0x0400; // 设置节点 ID 基础 ID
constexpr u32 CANFD_OTA_REQ_ID = 0x00000100; constexpr u16 CANFD_GET_NODE_ID = 0x0401; // 查询节点 ID 基础 ID
constexpr u32 CANFD_OTA_DATA_ID = 0x00000101;
constexpr u32 CANFD_OTA_ACK_ID = 0x00000102; // OTA 相关基础 ID 不受到node ID影响
constexpr u32 CANFD_OTA_WAIT_ID = 0x00000103; constexpr u16 CANFD_BOOT_ID = 0x0000; // BOOT 模式基础 ID (进入 BOOT 使用此 ID)
constexpr u16 CANFD_OTA_REQ_ID = 0x0100; // OTA 请求基础 ID
constexpr u16 CANFD_OTA_DATA_ID = 0x0101; // OTA 数据基础 ID
constexpr u16 CANFD_OTA_ACK_ID = 0x0102; // OTA 确认基础 ID
constexpr u16 CANFD_OTA_WAIT_ID = 0x0103; // OTA 等待基础 ID
// ADC // ADC
constexpr u8 ADC_FILTER_SIZE = 6; constexpr u8 ADC_FILTER_SIZE = 6;
@@ -190,10 +209,10 @@ constexpr float TIMER2_FREQUENCY = 1 / TIME_SLICE; // 频率
constexpr float MOTOR_FREQUENCY = 1 / TIME_SLICE / MOTOR_PERIOD; // 频率 constexpr float MOTOR_FREQUENCY = 1 / TIME_SLICE / MOTOR_PERIOD; // 频率
// TIMER1-PWM // TIMER1-PWM
constexpr int TIMER1_PRESCALER = 0; // 不分频，计数器时钟为120MHz constexpr int TIMER1_PRESCALER = 0; // 不分频，计数器时钟为 120MHz
constexpr int TIMER1_PERIOD = 5999; // 120MHz / (0+1) / (5999+1) = 20kHz constexpr int TIMER1_PERIOD = 5999; // 120MHz / (0+1) / (5999+1) = 20kHz
constexpr int TIMER1_DEFAULT_PULSE = 0; constexpr int TIMER1_DEFAULT_PULSE = 0;
constexpr int TIMER1_CH3_COMPARE_VALUE = constexpr int TIMER1_CH3_COMPARE_VALUE =
(TIMER1_PERIOD + 1) * 0.41 - 1; // PWM周期50%位置触发中断 (TIMER1_PERIOD + 1) * 0.41 - 1; // PWM 周期 50% 位置触发中断
#endif #endif
Robot_V2/sys/flash.cpp
+129 -135
View File
@@ -2,7 +2,7 @@
#include "FOC.h" #include "FOC.h"
#include "ang_sensor.h" #include "ang_sensor.h"
#include "config.h" #include "config.h"
#include "gd32c10x.h" // GD32主头文件，确保外设函数声明可用 #include "gd32c10x.h" // GD32 主头文件，确保外设函数声明可用
#include "gd32c10x_crc.h" #include "gd32c10x_crc.h"
#include "gd32c10x_fmc.h" #include "gd32c10x_fmc.h"
#include "systick.h" #include "systick.h"
@@ -10,10 +10,24 @@
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
// EEP 调试宏定义
#if EEP_DEBUG
#define EEP_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define EEP_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
// OTA 调试宏定义
#if OTA_DEBUG
#define OTA_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define OTA_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
FlashEEPROM flashEEP = FlashEEPROM(); FlashEEPROM flashEEP = FlashEEPROM();
extern angle_sensor KTH7823; extern angle_sensor KTH7823;
extern CAN_transmiter CAN0_transmiter; extern CAN_transmiter CAN0_transmiter;
extern FOC_Controller FOC; // FOC控制 extern FOC_Controller FOC; // FOC 控制
fmc_state_enum write_ADDRESS(u32 address, u32 data) { fmc_state_enum write_ADDRESS(u32 address, u32 data) {
fmc_unlock(); fmc_unlock();
@@ -25,19 +39,19 @@ fmc_state_enum write_ADDRESS(u32 address, u32 data) {
fmc_lock(); fmc_lock();
return fmc_status; return fmc_status;
} }
// FlashEEPROM类实现 // FlashEEPROM 类实现
FlashEEPROM::FlashEEPROM() { FlashEEPROM::FlashEEPROM() {
// 构造函数可以为空，或者做一些初始化工作 // 构造函数可以为空，或者做一些初始化工作
} }
/** /**
* @brief 初始化Flash EEPROM模拟 * @brief 初始化 Flash EEPROM 模拟
* @param None * @param None
* @retval None * @retval None
*/ */
u8 FlashEEPROM::init() { u8 FlashEEPROM::init() {
rcu_periph_clock_enable(RCU_CRC); rcu_periph_clock_enable(RCU_CRC);
crc_deinit(); // 初始化CRC模块 crc_deinit(); // 初始化 CRC 模块
FlashEepromStatus status = FLASH_EEPROM_OK; FlashEepromStatus status = FLASH_EEPROM_OK;
// 读取系统配置 // 读取系统配置
@@ -52,7 +66,7 @@ u8 FlashEEPROM::init() {
} }
/** /**
* @brief 读取EEPROM数据 * @brief 读取 EEPROM 数据
* @param virtualAddr: 虚拟地址 * @param virtualAddr: 虚拟地址
* @param data: 存储读取数据的指针 * @param data: 存储读取数据的指针
* @retval EEPROMStatus: 是否成功 * @retval EEPROMStatus: 是否成功
@@ -62,7 +76,7 @@ u8 FlashEEPROM::read_saved_system_config(void) {
u32 CRC_NUM = 0x0000; u32 CRC_NUM = 0x0000;
FlashEepromStatus status_read[CONFIG_SAVED_NUM + 1] = {FLASH_EEPROM_OK}; FlashEepromStatus status_read[CONFIG_SAVED_NUM + 1] = {FLASH_EEPROM_OK};
float data[CONFIG_SAVED_NUM] = {0.0f}; float data[CONFIG_SAVED_NUM] = {0.0f};
// 尝试从Flash读取参数，如果不存在则使用默认值 // 尝试从 Flash 读取参数，如果不存在则使用默认值
status_read[1] = readFloat(ADDR_CONTROL_MODE, &data[0]); status_read[1] = readFloat(ADDR_CONTROL_MODE, &data[0]);
status_read[2] = readFloat(ADDR_VOLTAGE_LIMIT, &data[1]); status_read[2] = readFloat(ADDR_VOLTAGE_LIMIT, &data[1]);
status_read[3] = readFloat(ADDR_VEL_LIMIT, &data[2]); status_read[3] = readFloat(ADDR_VEL_LIMIT, &data[2]);
@@ -83,10 +97,10 @@ u8 FlashEEPROM::read_saved_system_config(void) {
// 读取到全部数据 // 读取到全部数据
if (status_read[0] == FLASH_EEPROM_OK) { if (status_read[0] == FLASH_EEPROM_OK) {
u32 next_address = EEPROM_END_ADDRESS; u32 next_address = EEPROM_END_ADDRESS;
// 遍历Flash页面寻找下一个可写入位置 // 遍历 Flash 页面寻找下一个可写入位置
for (u32 address = EEPROM_DATA_START_ADDRESS - SIZE_U32; for (u32 address = EEPROM_DATA_START_ADDRESS - SIZE_U32;
address > EEPROM_START_ADDRESS; address -= SIZE_U32) { address > EEPROM_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据 // 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word = *flash_ptr; u32 data_word = *flash_ptr;
// 找到空位置 // 找到空位置
@@ -102,18 +116,16 @@ u8 FlashEEPROM::read_saved_system_config(void) {
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
} }
crc_data_register_reset(); // 确保CRC计算从初始状态开始 crc_data_register_reset(); // 确保 CRC 计算从初始状态开始
CRC_NUM = crc_block_data_calculate((uint32_t *)data, CONFIG_SAVED_NUM); CRC_NUM = crc_block_data_calculate((uint32_t *)data, CONFIG_SAVED_NUM);
EEP_DEBUG_PRINT("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM,
#if EEP_DEBUG *((u32 *)next_address));
printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32 *)next_address)); if (CRC_NUM != *((u32 *)next_address)) { // CRC 错误
#endif
if (CRC_NUM != *((u32 *)next_address)) { // CRC错误
for (u8 i = 0; i < CONFIG_SAVED_NUM; i++) { for (u8 i = 0; i < CONFIG_SAVED_NUM; i++) {
data[i] = DEFAULT_VALUE; data[i] = DEFAULT_VALUE;
} }
EEPROMStatus = FLASH_EEPROM_CRC_ERROR; EEPROMStatus = FLASH_EEPROM_CRC_ERROR;
} else { // CRC正确 } else { // CRC 正确
EEPROMStatus = FLASH_EEPROM_OK; EEPROMStatus = FLASH_EEPROM_OK;
} }
} else { } else {
@@ -133,7 +145,7 @@ u8 FlashEEPROM::read_saved_system_config(void) {
} }
/** /**
* @brief 从Flash EEPROM读取数据 * @brief 从 Flash EEPROM 读取数据
* @param virtualAddr: 虚拟地址 * @param virtualAddr: 虚拟地址
* @param data: 指向存储读取数据的指针 * @param data: 指向存储读取数据的指针
* @retval FlashEepromStatus: 操作状态 * @retval FlashEepromStatus: 操作状态
@@ -144,7 +156,7 @@ FlashEepromStatus FlashEEPROM::read(u8 virtualAddr, u16 *data) const {
return FLASH_EEPROM_INVALID_ADDR; return FLASH_EEPROM_INVALID_ADDR;
} }
// 从Flash末尾开始向前搜索，找到最新的数据 // 从 Flash 末尾开始向前搜索，找到最新的数据
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32; for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_START_ADDRESS; address -= SIZE_U32) { address >= EEPROM_START_ADDRESS; address -= SIZE_U32) {
u32 data_word = *((u32 *)address); u32 data_word = *((u32 *)address);
@@ -162,7 +174,7 @@ FlashEepromStatus FlashEEPROM::read(u8 virtualAddr, u16 *data) const {
} }
/** /**
* @brief 从Flash EEPROM读取float数据 * @brief 从 Flash EEPROM 读取 float 数据
* @param virtualAddr: 虚拟地址 * @param virtualAddr: 虚拟地址
* @param data: 指向存储读取数据的指针 * @param data: 指向存储读取数据的指针
* @retval FlashEepromStatus: 操作状态 * @retval FlashEepromStatus: 操作状态
@@ -173,10 +185,10 @@ FlashEepromStatus FlashEEPROM::readFloat(u8 virtualAddr, float *data) const {
return FLASH_EEPROM_INVALID_ADDR; return FLASH_EEPROM_INVALID_ADDR;
} }
// 从Flash末尾开始向前搜索，找到最新的数据 // 从 Flash 末尾开始向前搜索，找到最新的数据
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32; for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_START_ADDRESS; address -= SIZE_U32) { address >= EEPROM_START_ADDRESS; address -= SIZE_U32) {
// 使用volatile确保每次都从内存读取，防止编译器优化 // 使用 volatile 确保每次都从内存读取，防止编译器优化
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word = *flash_ptr; u32 data_word = *flash_ptr;
@@ -185,13 +197,11 @@ FlashEepromStatus FlashEEPROM::readFloat(u8 virtualAddr, float *data) const {
u8 addr = (u8)(data_word & DATA_ADDR_MASK); u8 addr = (u8)(data_word & DATA_ADDR_MASK);
// 找到匹配的虚拟地址 // 找到匹配的虚拟地址
if (addr == virtualAddr) { if (addr == virtualAddr) {
// 清除最低的8位地址信息，保留高24位数据 // 清除最低的 8 位地址信息，保留高 24 位数据
u32 float_data = data_word & DATA_FLOAT_MASK; u32 float_data = data_word & DATA_FLOAT_MASK;
// 使用内存拷贝将处理后的数据解释为float // 使用内存拷贝将处理后的数据解释为 float
memcpy(data, &float_data, SIZE_FLOAT); memcpy(data, &float_data, SIZE_FLOAT);
#if EEP_DEBUG EEP_DEBUG_PRINT("read:0x%x=%f\r\n", address, *data);
printf("read:0x%x=%f\r\n", address, *data);
#endif
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
} }
} }
@@ -201,7 +211,7 @@ FlashEepromStatus FlashEEPROM::readFloat(u8 virtualAddr, float *data) const {
} }
/** /**
* @brief 向Flash EEPROM写入数据 * @brief 向 Flash EEPROM 写入数据
* @param virtualAddr: 虚拟地址 * @param virtualAddr: 虚拟地址
* @param data: 要写入的数据 * @param data: 要写入的数据
* @retval FlashEepromStatus: 操作状态 * @retval FlashEepromStatus: 操作状态
@@ -210,22 +220,23 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
// 查找下一个可写入的位置 // 查找下一个可写入的位置
u32 next_address = EEPROM_START_ADDRESS; u32 next_address = EEPROM_START_ADDRESS;
u32 data_read; u32 data_read;
// 插入虚拟地址到低8位 格式: [data:16bit][reserved:8bit][addr:8bit] // 构建要写入的 32 位数据：格式 [data:16bit][reserved:8bit][addr:8bit]
data = (data & DATA_U16_MASK) | (u32)virtualAddr; u32 data_word_to_write = ((u32)data << 16) | (u32)virtualAddr;
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32; for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_DATA_START_ADDRESS; address -= SIZE_U32) { address >= EEPROM_DATA_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据 // 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
data_read = *flash_ptr; data_read = *flash_ptr;
if ((data_read & DATA_ADDR_MASK) == (u32)virtualAddr) { // 虚拟地址相同 if ((data_read & DATA_ADDR_MASK) == (u32)virtualAddr) { // 虚拟地址相同
if ((data_read & DATA_U16_MASK) == if ((data_read & DATA_U16_MASK) ==
(data & DATA_U16_MASK)) { // 数据相同 (data_word_to_write & DATA_U16_MASK)) { // 数据相同
#if EEP_DEBUG #if EEP_DEBUG
data_read = data_read & DATA_U16_MASK; data_read = data_read & DATA_U16_MASK;
u16 float_data_read = *((u16 *)&data_read); u16 float_data_read = *((u16 *)&data_read);
printf("Found data in:0x%x=%u\r\n", address, data_read); EEP_DEBUG_PRINT("Found data in:0x%x=%u\r\n", address,
data_read);
#endif #endif
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
} else { } else {
@@ -234,10 +245,10 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
} }
} }
// 遍历Flash页面寻找下一个可写入位置 // 遍历 Flash 页面寻找下一个可写入位置
for (u32 address = EEPROM_DATA_START_ADDRESS; address < EEPROM_END_ADDRESS; for (u32 address = EEPROM_DATA_START_ADDRESS; address < EEPROM_END_ADDRESS;
address += SIZE_U32) { address += SIZE_U32) {
// 安全读取Flash数据 // 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word = *flash_ptr; u32 data_word = *flash_ptr;
// 找到空位置 // 找到空位置
@@ -251,18 +262,15 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
// 如果有足够空间，直接写入 // 如果有足够空间，直接写入
if (next_address < EEPROM_END_ADDRESS) { if (next_address < EEPROM_END_ADDRESS) {
u32 data_word = ((u32)data << 16) | (u32)virtualAddr; fmc_state_enum fmc_status =
write_ADDRESS(next_address, data_word_to_write);
fmc_state_enum fmc_status = write_ADDRESS(next_address, data_word);
if (fmc_status != FMC_READY) { if (fmc_status != FMC_READY) {
return FLASH_EEPROM_WRITE_ERROR; return FLASH_EEPROM_WRITE_ERROR;
} }
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
} else { // 空间不足，需要格式化页面 } else { // 空间不足，需要格式化页面
#if EEP_DEBUG EEP_DEBUG_PRINT("no enough space\r\n");
printf("no enough space\r\n");
#endif
FlashEepromStatus status = format(); FlashEepromStatus status = format();
if (status == FLASH_EEPROM_OK) { if (status == FLASH_EEPROM_OK) {
status = save_system_config(false); status = save_system_config(false);
@@ -274,7 +282,7 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
} }
/** /**
* @brief 向Flash EEPROM写入float数据 * @brief 向 Flash EEPROM 写入 float 数据
* @param virtualAddr: 虚拟地址 * @param virtualAddr: 虚拟地址
* @param data: 要写入的数据 * @param data: 要写入的数据
* @retval FlashEepromStatus: 操作状态 * @retval FlashEepromStatus: 操作状态
@@ -284,15 +292,15 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
u32 next_address = EEPROM_START_ADDRESS; u32 next_address = EEPROM_START_ADDRESS;
u32 data_word; u32 data_word;
// 将完整的float数据复制到32位变量中 // 将完整的 float 数据复制到 32 位变量中
memcpy(&data_word, &data, SIZE_FLOAT); memcpy(&data_word, &data, SIZE_FLOAT);
// 插入虚拟地址到低8位 格式: [data:24bit][addr:8bit] // 插入虚拟地址到低 8 位 格式：[data:24bit][addr:8bit]
data_word = (data_word & DATA_FLOAT_MASK) | (u32)virtualAddr; data_word = (data_word & DATA_FLOAT_MASK) | (u32)virtualAddr;
// 从Flash末尾开始向前搜索，找到最新的数据 // 从 Flash 末尾开始向前搜索，找到最新的数据
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32; for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_DATA_START_ADDRESS; address -= SIZE_U32) { address >= EEPROM_DATA_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据 // 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word_read = *flash_ptr; u32 data_word_read = *flash_ptr;
@@ -303,7 +311,8 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
#if EEP_DEBUG #if EEP_DEBUG
data_word_read = data_word_read & DATA_FLOAT_MASK; data_word_read = data_word_read & DATA_FLOAT_MASK;
float float_data_read = *((float *)&data_word_read); float float_data_read = *((float *)&data_word_read);
printf("Found data in:0x%x=%f\r\n", address, float_data_read); EEP_DEBUG_PRINT("Found data in:0x%x=%f\r\n", address,
float_data_read);
#endif #endif
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
} else { } else {
@@ -312,10 +321,10 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
} }
} }
// 遍历Flash页面寻找下一个可写入位置 // 遍历 Flash 页面寻找下一个可写入位置
for (u32 address = EEPROM_DATA_START_ADDRESS; address < EEPROM_END_ADDRESS; for (u32 address = EEPROM_DATA_START_ADDRESS; address < EEPROM_END_ADDRESS;
address += SIZE_U32) { address += SIZE_U32) {
// 安全读取Flash数据 // 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word_read = *flash_ptr; u32 data_word_read = *flash_ptr;
// 找到空位置 // 找到空位置
@@ -334,7 +343,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
u32 data_word_c = *((u32 *)next_address); u32 data_word_c = *((u32 *)next_address);
data_word_c = data_word_c & DATA_FLOAT_MASK; data_word_c = data_word_c & DATA_FLOAT_MASK;
float float_data = *((float *)&data_word_c); float float_data = *((float *)&data_word_c);
printf("save:0x%x=%f\r\n", next_address, float_data); EEP_DEBUG_PRINT("save:0x%x=%f\r\n", next_address, float_data);
#endif #endif
if (fmc_status != FMC_READY) { if (fmc_status != FMC_READY) {
return FLASH_EEPROM_WRITE_ERROR; return FLASH_EEPROM_WRITE_ERROR;
@@ -343,7 +352,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
} else { } else {
// 空间不足，需要格式化页面 // 空间不足，需要格式化页面
#if EEP_DEBUG #if EEP_DEBUG
printf("no enough space\r\n"); EEP_DEBUG_PRINT("no enough space\r\n");
#endif #endif
FlashEepromStatus status = format(); FlashEepromStatus status = format();
if (status == FLASH_EEPROM_OK) { if (status == FLASH_EEPROM_OK) {
@@ -356,15 +365,13 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
} }
/** /**
* @brief 格式化Flash EEPROM页面 * @brief 格式化 Flash EEPROM 页面
* @param None * @param None
* @retval FlashEepromStatus: 操作状态 * @retval FlashEepromStatus: 操作状态
*/ */
FlashEepromStatus FlashEEPROM::format() { FlashEepromStatus FlashEEPROM::format() {
fmc_state_enum fmc_status; fmc_state_enum fmc_status;
#if EEP_DEBUG EEP_DEBUG_PRINT("擦除页面\r\n");
printf("擦除页面\r\n");
#endif
fmc_unlock(); fmc_unlock();
fmc_status = fmc_page_erase(EEPROM_START_ADDRESS); // 擦除第一页 fmc_status = fmc_page_erase(EEPROM_START_ADDRESS); // 擦除第一页
@@ -382,7 +389,7 @@ FlashEepromStatus FlashEEPROM::format() {
} }
/** /**
* @brief 更新系统配置并保存到Flash * @brief 更新系统配置并保存到 Flash
* @param config 新的系统配置值 * @param config 新的系统配置值
*/ */
FlashEepromStatus FlashEEPROM::save_system_config(bool saved) { FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
@@ -437,18 +444,18 @@ FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
return status; return status;
} }
// 创建用于CRC计算的模拟数据数组，模拟实际存储到Flash中的数据格式 // 创建用于 CRC 计算的模拟数据数组，模拟实际存储到 Flash 中的数据格式
u32 crc_data_words[CONFIG_SAVED_NUM]; u32 crc_data_words[CONFIG_SAVED_NUM];
// 按照writeFloat函数的方式处理数据 // 按照 writeFloat 函数的方式处理数据
for (u8 i = 0; i < CONFIG_SAVED_NUM; i++) { for (u8 i = 0; i < CONFIG_SAVED_NUM; i++) {
// 将完整的float数据复制到32位变量中 // 将完整的 float 数据复制到 32 位变量中
memcpy(&crc_data_words[i], &data[i], SIZE_FLOAT); memcpy(&crc_data_words[i], &data[i], SIZE_FLOAT);
// 去除最后2位精度 // 去除最后 2 位精度
crc_data_words[i] = crc_data_words[i] & DATA_FLOAT_MASK; crc_data_words[i] = crc_data_words[i] & DATA_FLOAT_MASK;
} }
crc_data_register_reset(); // 确保CRC计算从初始状态开始 crc_data_register_reset(); // 确保 CRC 计算从初始状态开始
CRC_NUM = crc_block_data_calculate(crc_data_words, CONFIG_SAVED_NUM); CRC_NUM = crc_block_data_calculate(crc_data_words, CONFIG_SAVED_NUM);
writeCRC(CRC_NUM, saved); writeCRC(CRC_NUM, saved);
@@ -457,7 +464,7 @@ FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
} }
/** /**
* @brief 读取角度数据从Flash * @brief 读取角度数据从 Flash
* @return float: 角度数据 * @return float: 角度数据
*/ */
float FlashEEPROM::read_angle() { float FlashEEPROM::read_angle() {
@@ -469,16 +476,16 @@ float FlashEEPROM::read_angle() {
} }
/** /**
* @brief 保存CRC数据到Flash * @brief 保存 CRC 数据到 Flash
* @param saved: 是否一次性保存 * @param saved: 是否一次性保存
* @return FlashEepromStatus: 状态 * @return FlashEepromStatus: 状态
*/ */
FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) { FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
static u32 next_address; static u32 next_address;
// 遍历Flash页面寻找下一个可写入crc的位置 // 遍历 Flash 页面寻找下一个可写入 crc 的位置
for (u32 address = EEPROM_DATA_START_ADDRESS - SIZE_U32; for (u32 address = EEPROM_DATA_START_ADDRESS - SIZE_U32;
address > EEPROM_START_ADDRESS; address -= SIZE_U32) { address > EEPROM_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据 // 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word = *flash_ptr; u32 data_word = *flash_ptr;
// 找到空位置 // 找到空位置
@@ -490,14 +497,13 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
next_address = address - SIZE_U32; next_address = address - SIZE_U32;
} }
// 如果当前CRC与现在的crc值不同，则写入 // 如果当前 CRC 与现在的 crc 值不同，则写入
if (*((u32 *)next_address) != CRC_NUM) { if (*((u32 *)next_address) != CRC_NUM) {
// 如果有足够空间，直接写入crc值 // 如果有足够空间，直接写入 crc 值
if (next_address > EEPROM_START_ADDRESS) { if (next_address > EEPROM_START_ADDRESS) {
fmc_state_enum fmc_status = write_ADDRESS(next_address, CRC_NUM); fmc_state_enum fmc_status = write_ADDRESS(next_address, CRC_NUM);
#if EEP_DEBUG EEP_DEBUG_PRINT("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM,
printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32 *)next_address)); *((u32 *)next_address));
#endif
// 检查写入是否成功 // 检查写入是否成功
if (fmc_status != FMC_READY) { if (fmc_status != FMC_READY) {
EEPROMStatus = fmc_status; EEPROMStatus = fmc_status;
@@ -505,9 +511,7 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
} }
} else { } else {
// 空间不足，需要格式化页面 // 空间不足，需要格式化页面
#if EEP_DEBUG EEP_DEBUG_PRINT("no enough space\r\n");
printf("no enough space\r\n");
#endif
FlashEepromStatus status = format(); FlashEepromStatus status = format();
if (status == FLASH_EEPROM_OK) { if (status == FLASH_EEPROM_OK) {
status = save_system_config(false); status = save_system_config(false);
@@ -519,33 +523,33 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
} }
} }
// 重新读取CRC校验 // 重新读取 CRC 校验
if (CRC_NUM == *((u32 *)next_address)) { if (CRC_NUM == *((u32 *)next_address)) {
system_config_saved = saved; // 标记已保存过 system_config_saved = saved; // 标记已保存过
EEPROMStatus = FLASH_EEPROM_OK; // 设置EEPROM状态 EEPROMStatus = FLASH_EEPROM_OK; // 设置 EEPROM 状态
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
} else { } else {
EEPROMStatus = FLASH_EEPROM_CRC_ERROR; // 设置EEPROM错误状态 EEPROMStatus = FLASH_EEPROM_CRC_ERROR; // 设置 EEPROM 错误状态
return FLASH_EEPROM_CRC_ERROR; return FLASH_EEPROM_CRC_ERROR;
} }
} }
/** /**
* @brief 设置OTA配置参数到Flash * @brief 设置 OTA 配置参数到 Flash
* *
* 此函数用于更新存储在Flash中的OTA相关标志位（如APP可用、启用、校验等）。 * 此函数用于更新存储在 Flash 中的 OTA 相关标志位（如 APP 可用、启用、校验等）。
* GD32的Flash特性是：只能将1写为0，不能将0写为1。若要将0变为1，必须先擦除整个页面。 * GD32 的 Flash 特性是：只能将 1 写为 0，不能将 0 写为 1。若要将 0 写为
* 因此，本函数通过读取同一页内的所有参数，擦除该页，然后重新写入有效的参数来实现“写1”操作。 * 1，必须先擦除整个页面。
* 因此，本函数通过读取同一页内的所有参数，擦除该页，然后重新写入有效的参数来实现"写
* 1"操作。
* *
* @param addr: 要设置的Flash地址 * @param addr: 要设置的 Flash 地址
* @param data: 要写入的数据 (通常为OTA_AVAL=0x00000000 或 * @param data: 要写入的数据 (通常为 OTA_AVAL=0x00000000 或
* OTA_NOT_AVAL=0xFFFFFFFF) * OTA_NOT_AVAL=0xFFFFFFFF)
* @retval FLASH_EEPROM_OK (0) 表示成功, 其他值表示失败 * @retval FLASH_EEPROM_OK (0) 表示成功，其他值表示失败
*/ */
u8 OTA_SET(u32 addr, u32 data) { u8 OTA_SET(u32 addr, u32 data) {
#if EEP_DEBUG EEP_DEBUG_PRINT("OTA_prepare write%08x at %08x\r\n", data, addr);
printf("OTA_prepare write%08x at %08x\r\n", data, addr);
#endif
fmc_state_enum fmc_status; fmc_state_enum fmc_status;
u32 temp_val[OTA_CONFIG_NUM]; // 临时数组，用于存储当前所有配置参数的值 u32 temp_val[OTA_CONFIG_NUM]; // 临时数组，用于存储当前所有配置参数的值
volatile u32 *flash_ptr = (volatile u32 *)addr; volatile u32 *flash_ptr = (volatile u32 *)addr;
@@ -556,17 +560,17 @@ u8 OTA_SET(u32 addr, u32 data) {
return FLASH_EEPROM_OK; // 值已正确，直接返回成功 return FLASH_EEPROM_OK; // 值已正确，直接返回成功
} }
// 2. 尝试直接写入数据。这适用于将1修改为0的情况（因为Flash允许1->0） // 2. 尝试直接写入数据。这适用于将 1 修改为 0 的情况（因为 Flash 允许 1->0）
if (data == OTA_AVAL) { if (data == OTA_AVAL) {
fmc_status = write_ADDRESS(addr, data); fmc_status = write_ADDRESS(addr, data);
// 如果写入成功，则返回成功 // 如果写入成功，则返回成功
if (fmc_status == FMC_READY) { if (fmc_status == FMC_READY) {
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
} }
// 如果写入失败（例如地址已被写为0），则继续执行后续的擦除-重写流程 // 如果写入失败（例如地址已被写为 0），则继续执行后续的擦除 - 重写流程
} }
// 3. 对于需要将0改回1的操作，必须先擦除整个Flash页 // 3. 对于需要将 0 改回 1 的操作，必须先擦除整个 Flash 页
flash_ptr = (volatile u32 *)n_APP_LATEST_AVAL_ADDR; flash_ptr = (volatile u32 *)n_APP_LATEST_AVAL_ADDR;
temp_val[0] = *flash_ptr; temp_val[0] = *flash_ptr;
flash_ptr = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR; flash_ptr = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR;
@@ -580,20 +584,17 @@ u8 OTA_SET(u32 addr, u32 data) {
flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR; flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
temp_val[5] = *flash_ptr; temp_val[5] = *flash_ptr;
#if EEP_DEBUG EEP_DEBUG_PRINT("OTA_prepare write%08x at %08x\r\n", data, addr);
printf("OTA_prepare write%08x at %08x\r\n", data, addr); // 修复：完整输出所有 6 个配置项的值，便于调试
// 修复：完整输出所有6个配置项的值，便于调试 EEP_DEBUG_PRINT("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
printf("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n", "BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n",
temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4], temp_val[0], temp_val[1], temp_val[2], temp_val[3],
temp_val[5]); temp_val[4], temp_val[5]);
#endif // 4. 擦除包含所有配置参数的 Flash 页
// 4. 擦除包含所有配置参数的Flash页
fmc_status = fmc_page_erase(n_APP_LATEST_AVAL_ADDR); fmc_status = fmc_page_erase(n_APP_LATEST_AVAL_ADDR);
if (fmc_status != FMC_READY) { if (fmc_status != FMC_READY) {
#if EEP_DEBUG EEP_DEBUG_PRINT("OTA_SET - Page erase failed! Status: %d\r\n",
printf("OTA_SET - Page erase failed! Status: %d\r\n", fmc_status); fmc_status);
#endif
return FLASH_EEPROM_ERASE_ERROR; return FLASH_EEPROM_ERASE_ERROR;
} }
@@ -604,18 +605,16 @@ u8 OTA_SET(u32 addr, u32 data) {
if (current_addr != addr and temp_val[i] != OTA_NOT_AVAL) { if (current_addr != addr and temp_val[i] != OTA_NOT_AVAL) {
fmc_status = write_ADDRESS(current_addr, temp_val[i]); fmc_status = write_ADDRESS(current_addr, temp_val[i]);
if (fmc_status != FMC_READY) { if (fmc_status != FMC_READY) {
#if EEP_DEBUG EEP_DEBUG_PRINT("OTA_SET - Write backup value %08X failed at "
printf("OTA_SET - Write backup value %08X failed at "
"0x%08X!status:%d\r\n", "0x%08X!status:%d\r\n",
temp_val[i], current_addr, fmc_status); temp_val[i], current_addr, fmc_status);
#endif
return FLASH_EEPROM_WRITE_ERROR; return FLASH_EEPROM_WRITE_ERROR;
} }
} }
} }
#if EEP_DEBUG #if EEP_DEBUG
// 3. 对于需要将0改回1的操作，必须先擦除整个Flash页 // 3. 对于需要将 0 改回 1 的操作，必须先擦除整个 Flash 页
flash_ptr = (volatile u32 *)n_APP_LATEST_AVAL_ADDR; flash_ptr = (volatile u32 *)n_APP_LATEST_AVAL_ADDR;
temp_val[0] = *flash_ptr; temp_val[0] = *flash_ptr;
flash_ptr = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR; flash_ptr = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR;
@@ -628,11 +627,11 @@ u8 OTA_SET(u32 addr, u32 data) {
temp_val[4] = *flash_ptr; temp_val[4] = *flash_ptr;
flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR; flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
temp_val[5] = *flash_ptr; temp_val[5] = *flash_ptr;
// 修复：完整输出所有6个配置项的值，便于调试 // 修复：完整输出所有 6 个配置项的值，便于调试
printf("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, " EEP_DEBUG_PRINT("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n", "BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n",
temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4], temp_val[0], temp_val[1], temp_val[2], temp_val[3],
temp_val[5]); temp_val[4], temp_val[5]);
#endif #endif
return FLASH_EEPROM_OK; return FLASH_EEPROM_OK;
@@ -649,7 +648,7 @@ void jumpToBOOT() {
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
NVIC->ICER[i] = 0xFFFFFFFF; NVIC->ICER[i] = 0xFFFFFFFF;
} }
// 2. 重置外设（特别是CAN，防止冲突） // 2. 重置外设（特别是 CAN，防止冲突）
can_deinit(CAN0); can_deinit(CAN0);
// 3. 重置系统时钟到默认状态 // 3. 重置系统时钟到默认状态
@@ -667,7 +666,7 @@ void jumpToBOOT() {
// 5. 设置中断向量表偏移到应用程序起始地址 // 5. 设置中断向量表偏移到应用程序起始地址
SCB->VTOR = BOOTLOADER_START_ADDR; SCB->VTOR = BOOTLOADER_START_ADDR;
// 6. 设置MSP并跳转 // 6. 设置 MSP 并跳转
uint32_t msp_value = *(__IO uint32_t *)BOOTLOADER_START_ADDR; uint32_t msp_value = *(__IO uint32_t *)BOOTLOADER_START_ADDR;
uint32_t reset_handler = *(__IO uint32_t *)(BOOTLOADER_START_ADDR + 4); uint32_t reset_handler = *(__IO uint32_t *)(BOOTLOADER_START_ADDR + 4);
typedef void (*AppEntryFunc)(void); typedef void (*AppEntryFunc)(void);
@@ -677,28 +676,26 @@ void jumpToBOOT() {
app_entry(); app_entry();
// 如果程序执行到这里，说明跳转失败 // 如果程序执行到这里，说明跳转失败
printf("Jump to application failed!\r\n"); EEP_DEBUG_PRINT("Jump to application failed!\r\n");
} }
/** /**
* @brief 将0x08011000地址后0xC000大小区域内的数据搬运到0x08005000地址 * @brief 将 0x08011000 地址后 0xC000 大小区域内的数据搬运到 0x08005000 地址
* @param None * @param None
* @retval fmc_state_enum: 操作状态 * @retval fmc_state_enum: 操作状态
*/ */
fmc_state_enum move_app_data() { fmc_state_enum move_app_data() {
// 源地址: APPLATEST_START_ADDR (0x08011000) // 源地址：APPLATEST_START_ADDR (0x08011000)
// 目标地址: APPBACK_START_ADDR (0x08005000) // 目标地址：APPBACK_START_ADDR (0x08005000)
// 数据大小: APP_MAX_SIZE (0xC000 = 48KB) // 数据大小：APP_MAX_SIZE (0xC000 = 48KB)
fmc_state_enum fmc_status = FMC_READY; fmc_state_enum fmc_status = FMC_READY;
#if OTA_DEBUG OTA_DEBUG_PRINT("move_app_data\r\n");
printf("move_app_data\r\n"); // 关闭全局中断以防止 Flash 操作期间的中断干扰
#endif
// 关闭全局中断以防止Flash操作期间的中断干扰
__disable_irq(); __disable_irq();
fmc_unlock(); fmc_unlock();
// 首先擦除目标地址的Flash页面 // 首先擦除目标地址的 Flash 页面
uint32_t num_pages = uint32_t num_pages =
(APP_MAX_SIZE + FMC_PAGE_SIZE - 1) / FMC_PAGE_SIZE; // 向上取整 (APP_MAX_SIZE + FMC_PAGE_SIZE - 1) / FMC_PAGE_SIZE; // 向上取整
@@ -710,7 +707,7 @@ fmc_state_enum move_app_data() {
if (fmc_status != FMC_READY) { if (fmc_status != FMC_READY) {
fmc_lock(); fmc_lock();
#if OTA_DEBUG #if OTA_DEBUG
printf("move_app_data erase error\r\n"); OTA_DEBUG_PRINT("move_app_data erase error\r\n");
delay_1ms(1000); delay_1ms(1000);
#endif #endif
__enable_irq(); // 重新开启中断 __enable_irq(); // 重新开启中断
@@ -718,13 +715,13 @@ fmc_state_enum move_app_data() {
} }
} }
// 复制数据 - 按字（32位）进行复制以提高效率 // 复制数据 - 按字（32 位）进行复制以提高效率
uint32_t offset = 0; uint32_t offset = 0;
uint32_t write_count = 0; // 记录实际写入的字数 uint32_t write_count = 0; // 记录实际写入的字数
const uint32_t *src_ptr = (const uint32_t *)APPLATEST_START_ADDR; const uint32_t *src_ptr = (const uint32_t *)APPLATEST_START_ADDR;
uint32_t *dst_ptr = (uint32_t *)APPBACK_START_ADDR; uint32_t *dst_ptr = (uint32_t *)APPBACK_START_ADDR;
// 预计算源数据的CRC，避免重复访问内存 // 预计算源数据的 CRC，避免重复访问内存
crc_deinit(); crc_deinit();
crc_data_register_reset(); crc_data_register_reset();
uint32_t src_crc = crc_block_data_calculate( uint32_t src_crc = crc_block_data_calculate(
@@ -733,7 +730,7 @@ fmc_state_enum move_app_data() {
while (offset < APP_MAX_SIZE) { while (offset < APP_MAX_SIZE) {
uint32_t src_data = src_ptr[offset / 4]; uint32_t src_data = src_ptr[offset / 4];
// 检查源地址是否为有效的Flash数据（非0xFFFFFFFF表示有数据） // 检查源地址是否为有效的 Flash 数据（非 0xFFFFFFFF 表示有数据）
if (src_data != 0xFFFFFFFF) { if (src_data != 0xFFFFFFFF) {
fmc_unlock(); fmc_unlock();
// 清除之前的标志位 // 清除之前的标志位
@@ -745,7 +742,7 @@ fmc_state_enum move_app_data() {
// 检查写入操作是否成功 // 检查写入操作是否成功
if (fmc_status != FMC_READY) { if (fmc_status != FMC_READY) {
#if OTA_DEBUG #if OTA_DEBUG
printf( OTA_DEBUG_PRINT(
"Flash write failed at offset 0x%08X with status: %d\r\n", "Flash write failed at offset 0x%08X with status: %d\r\n",
offset, fmc_status); offset, fmc_status);
delay_1ms(1000); delay_1ms(1000);
@@ -759,7 +756,7 @@ fmc_state_enum move_app_data() {
offset += 4; offset += 4;
// 每写入一定数量的数据后，喂狗一次 // 每写入一定数量的数据后，喂狗一次
if ((offset % 4096) == 0) { // 每4KB喂狗一次 if ((offset % 4096) == 0) { // 每 4KB 喂狗一次
fwdgt_counter_reload(); fwdgt_counter_reload();
} }
} }
@@ -768,23 +765,20 @@ fmc_state_enum move_app_data() {
// 重新开启全局中断 // 重新开启全局中断
__enable_irq(); __enable_irq();
crc_data_register_reset(); // 确保CRC计算从初始状态开始 crc_data_register_reset(); // 确保 CRC 计算从初始状态开始
// 计算目标数据的CRC值 // 计算目标数据的 CRC 值
uint32_t dst_crc = crc_block_data_calculate((uint32_t *)APPBACK_START_ADDR, uint32_t dst_crc = crc_block_data_calculate((uint32_t *)APPBACK_START_ADDR,
APP_MAX_SIZE / 4); APP_MAX_SIZE / 4);
// 比较CRC值，确保数据完整性 // 比较 CRC 值，确保数据完整性
if (src_crc != dst_crc) { if (src_crc != dst_crc) {
#if OTA_DEBUG OTA_DEBUG_PRINT(
printf("APPbackup CRC mismatch: src_crc=0x%08X, dst_crc=0x%08X\r\n", "APPbackup CRC mismatch: src_crc=0x%08X, dst_crc=0x%08X\r\n",
src_crc, dst_crc); src_crc, dst_crc);
#endif return (fmc_state_enum)0xFF; // CRC 校验失败
return (fmc_state_enum)0xFF; // CRC校验失败
} }
#if OTA_DEBUG OTA_DEBUG_PRINT("APPbackup CRC OK\r\n");
printf("APPbackup CRC OK\r\n");
#endif
// 设置备份应用可用标志 // 设置备份应用可用标志
fmc_unlock(); fmc_unlock();
OTA_SET(n_APP_BACKUP_AVAL_ADDR, OTA_AVAL); OTA_SET(n_APP_BACKUP_AVAL_ADDR, OTA_AVAL);
Robot_V2/sys/flash.h
+1
View File
@@ -40,6 +40,7 @@ class FlashEEPROM {
static constexpr u8 ADDR_TARGET_VEL = 0x03; // 速度命令数据存储地址 static constexpr u8 ADDR_TARGET_VEL = 0x03; // 速度命令数据存储地址
static constexpr u8 ADDR_VOLTAGE_LIMIT = 0x4; // 电压限制 static constexpr u8 ADDR_VOLTAGE_LIMIT = 0x4; // 电压限制
static constexpr u8 ADDR_VEL_LIMIT = 0x05; // 角度数据存储地址 static constexpr u8 ADDR_VEL_LIMIT = 0x05; // 角度数据存储地址
static constexpr u8 ADDR_NODE_ID = 0x06; // 节点 ID 存储地址
bool angle_saved = false; bool angle_saved = false;
bool system_config_saved = false; bool system_config_saved = false;
Robot_V2/sys/initial.cpp
+51 -39
View File
@@ -11,7 +11,21 @@
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
extern CAN_transmiter CAN0_transmiter; // CAN初始化 // OTA 调试宏定义
#if OTA_DEBUG
#define OTA_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define OTA_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
// EEP 调试宏定义
#if EEP_DEBUG
#define EEP_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define EEP_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
extern CAN_transmiter CAN0_transmiter; // CAN 初始化
VersionManager Version; VersionManager Version;
VersionManager::VersionManager() { VersionManager::VersionManager() {
@@ -74,11 +88,11 @@ char *VersionManager::versionToString(const VersionInfo &version, char *buffer,
void VersionManager::sendVersionInfoViaCan() const { void VersionManager::sendVersionInfoViaCan() const {
// 准备发送版本信息 (ID: CANFD_VERSION_ID) // 准备发送版本信息 (ID: CANFD_VERSION_ID)
// 只使用必要的字节数（24字节）来传输三个版本的信息（每个版本6字节） // 只使用必要的字节数（24 字节）来传输三个版本的信息（每个版本 6 字节）
u8 versionData[24] = {0}; u8 versionData[24] = {0};
// 将版本信息打包到24字节数组中 // 将版本信息打包到 24 字节数组中
// 前8字节：软件版本信息 (4个uint16_t，每个占2字节) // 前 8 字节：软件版本信息 (4 个 uint16_t，每个占 2 字节)
versionData[0] = softwareVersion.major & 0xFF; // 低字节 versionData[0] = softwareVersion.major & 0xFF; // 低字节
versionData[1] = (softwareVersion.major >> 8) & 0xFF; // 高字节 versionData[1] = (softwareVersion.major >> 8) & 0xFF; // 高字节
versionData[2] = softwareVersion.minor & 0xFF; // 低字节 versionData[2] = softwareVersion.minor & 0xFF; // 低字节
@@ -88,7 +102,7 @@ void VersionManager::sendVersionInfoViaCan() const {
versionData[6] = softwareVersion.build & 0xFF; // 低字节 versionData[6] = softwareVersion.build & 0xFF; // 低字节
versionData[7] = (softwareVersion.build >> 8) & 0xFF; // 高字节 versionData[7] = (softwareVersion.build >> 8) & 0xFF; // 高字节
// 8-15字节：硬件版本信息 (4个uint16_t，每个占2字节) // 8-15 字节：硬件版本信息 (4 个 uint16_t，每个占 2 字节)
versionData[8] = hardwareVersion.major & 0xFF; // 低字节 versionData[8] = hardwareVersion.major & 0xFF; // 低字节
versionData[9] = (hardwareVersion.major >> 8) & 0xFF; // 高字节 versionData[9] = (hardwareVersion.major >> 8) & 0xFF; // 高字节
versionData[10] = hardwareVersion.minor & 0xFF; // 低字节 versionData[10] = hardwareVersion.minor & 0xFF; // 低字节
@@ -98,7 +112,7 @@ void VersionManager::sendVersionInfoViaCan() const {
versionData[14] = hardwareVersion.build & 0xFF; // 低字节 versionData[14] = hardwareVersion.build & 0xFF; // 低字节
versionData[15] = (hardwareVersion.build >> 8) & 0xFF; // 高字节 versionData[15] = (hardwareVersion.build >> 8) & 0xFF; // 高字节
// 16-23字节：BOOT版本信息 (4个uint16_t，每个占2字节) // 16-23 字节：BOOT 版本信息 (4 个 uint16_t，每个占 2 字节)
versionData[16] = bootVersion.major & 0xFF; // 低字节 versionData[16] = bootVersion.major & 0xFF; // 低字节
versionData[17] = (bootVersion.major >> 8) & 0xFF; // 高字节 versionData[17] = (bootVersion.major >> 8) & 0xFF; // 高字节
versionData[18] = bootVersion.minor & 0xFF; // 低字节 versionData[18] = bootVersion.minor & 0xFF; // 低字节
@@ -108,20 +122,23 @@ void VersionManager::sendVersionInfoViaCan() const {
versionData[22] = bootVersion.build & 0xFF; // 低字节 versionData[22] = bootVersion.build & 0xFF; // 低字节
versionData[23] = (bootVersion.build >> 8) & 0xFF; // 高字节 versionData[23] = (bootVersion.build >> 8) & 0xFF; // 高字节
// 使用CANFD发送函数发送版本信息 // 使用 CANFD 发送函数发送版本信息，使用 build_can_id 构建带 node_id 的 CAN
CAN0_transmiter.CANFD_AsyncSend(CANFD_VERSION_ID, 24, versionData); // ID
CAN0_transmiter.CANFD_AsyncSend(
CAN0_transmiter.build_can_id(CANFD_VERSION_ID), 24, versionData);
} }
void VersionManager::printVersions() const { void VersionManager::printVersions() const {
char versionStr[32]; char versionStr[32];
printf( OTA_DEBUG_PRINT(
"Software Version: %s\r\n", "Software Version: %s\r\n",
versionToString(getSoftwareVersion(), versionStr, sizeof(versionStr))); versionToString(getSoftwareVersion(), versionStr, sizeof(versionStr)));
printf( OTA_DEBUG_PRINT(
"Hardware Version: %s\r\n", "Hardware Version: %s\r\n",
versionToString(getHardwareVersion(), versionStr, sizeof(versionStr))); versionToString(getHardwareVersion(), versionStr, sizeof(versionStr)));
printf("BOOT Version: %s\r\n", OTA_DEBUG_PRINT(
"BOOT Version: %s\r\n",
versionToString(getBootVersion(), versionStr, sizeof(versionStr))); versionToString(getBootVersion(), versionStr, sizeof(versionStr)));
} }
@@ -154,9 +171,9 @@ int fputc(int ch, FILE *f) throw() {
} }
void unused_pin_init() { void unused_pin_init() {
rcu_periph_clock_enable(RCU_GPIOA); // 使能GPIOA时钟 rcu_periph_clock_enable(RCU_GPIOA); // 使能 GPIOA 时钟
rcu_periph_clock_enable(RCU_GPIOB); // 使能GPIOB时钟 rcu_periph_clock_enable(RCU_GPIOB); // 使能 GPIOB 时钟
rcu_periph_clock_enable(RCU_GPIOC); // 使能GPIOC时钟 rcu_periph_clock_enable(RCU_GPIOC); // 使能 GPIOC 时钟
gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ, gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12); GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12);
gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ, gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
@@ -177,43 +194,43 @@ void unused_pin_init() {
u16 get_reset_cause(void) { u16 get_reset_cause(void) {
u16 cause = 0; u16 cause = 0;
if (RESET != rcu_flag_get(RCU_FLAG_FWDGTRST)) { if (RESET != rcu_flag_get(RCU_FLAG_FWDGTRST)) {
// printf("Free Watchdog Timer Reset\r\n"); // OTA_DEBUG_PRINT("Free Watchdog Timer Reset\r\n");
cause = RCU_FLAG_FWDGTRST; cause = RCU_FLAG_FWDGTRST;
} }
if (RESET != rcu_flag_get(RCU_FLAG_EPRST)) { if (RESET != rcu_flag_get(RCU_FLAG_EPRST)) {
// printf("External Pin Reset\r\n"); // OTA_DEBUG_PRINT("External Pin Reset\r\n");
cause = RCU_FLAG_EPRST; cause = RCU_FLAG_EPRST;
} }
if (RESET != rcu_flag_get(RCU_FLAG_PORRST)) { if (RESET != rcu_flag_get(RCU_FLAG_PORRST)) {
// printf("Power Reset\r\n"); // OTA_DEBUG_PRINT("Power Reset\r\n");
cause = RCU_FLAG_PORRST; cause = RCU_FLAG_PORRST;
} }
if (RESET != rcu_flag_get(RCU_FLAG_WWDGTRST)) { if (RESET != rcu_flag_get(RCU_FLAG_WWDGTRST)) {
// printf("Window Watchdog Timer Reset\r\n"); // OTA_DEBUG_PRINT("Window Watchdog Timer Reset\r\n");
cause = RCU_FLAG_WWDGTRST; cause = RCU_FLAG_WWDGTRST;
} }
if (RESET != rcu_flag_get(RCU_FLAG_LPRST)) { if (RESET != rcu_flag_get(RCU_FLAG_LPRST)) {
// printf("Low Power Reset\r\n"); // OTA_DEBUG_PRINT("Low Power Reset\r\n");
cause = RCU_FLAG_LPRST; cause = RCU_FLAG_LPRST;
} }
if (RESET != rcu_flag_get(RCU_FLAG_SWRST)) { if (RESET != rcu_flag_get(RCU_FLAG_SWRST)) {
// printf("Software Reset\r\n"); // OTA_DEBUG_PRINT("Software Reset\r\n");
cause = RCU_FLAG_SWRST; cause = RCU_FLAG_SWRST;
} }
// 清除所有复位标志 // 清除所有复位标志
rcu_all_reset_flag_clear(); rcu_all_reset_flag_clear();
// printf("cause:%d\r\n", cause); // OTA_DEBUG_PRINT("cause:%d\r\n", cause);
return cause; return cause;
} }
void OTA_initial(void) { void OTA_initial(void) {
#if OTA_DEBUG #if OTA_DEBUG
u32 temp_val[6]; u32 temp_val[6];
// 3. 对于需要将0改回1的操作，必须先擦除整个Flash页 // 3. 对于需要将 0 改回 1 的操作，必须先擦除整个 Flash 页
volatile u32 *flash_ptr1 = (volatile u32 *)n_APP_LATEST_AVAL_ADDR; volatile u32 *flash_ptr1 = (volatile u32 *)n_APP_LATEST_AVAL_ADDR;
temp_val[0] = *flash_ptr1; temp_val[0] = *flash_ptr1;
flash_ptr1 = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR; flash_ptr1 = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR;
@@ -226,20 +243,19 @@ void OTA_initial(void) {
temp_val[4] = *flash_ptr1; temp_val[4] = *flash_ptr1;
flash_ptr1 = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR; flash_ptr1 = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
temp_val[5] = *flash_ptr1; temp_val[5] = *flash_ptr1;
// 修复：完整输出所有6个配置项的值，便于调试 // 修复：完整输出所有 6 个配置项的值，便于调试
printf("APP:CHECK LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, " OTA_DEBUG_PRINT(
"APP:CHECK LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n", "BackupEn:0x%x, LatestCheck:0x%x, BackupCheck:0x%x\r\n",
temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4], temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4],
temp_val[5]); temp_val[5]);
#endif #endif
// 确认当前APP可用 // 确认当前 APP 可用
volatile u32 *flash_ptr = (volatile u32 *)n_APP_LATEST_CHECK_ADDR; volatile u32 *flash_ptr = (volatile u32 *)n_APP_LATEST_CHECK_ADDR;
u32 app_check = *flash_ptr; u32 app_check = *flash_ptr;
if (app_check == OTA_NOT_AVAL) { // 新的APP刷入后第一次启动 if (app_check == OTA_NOT_AVAL) { // 新的 APP 刷入后第一次启动
#if OTA_DEBUG OTA_DEBUG_PRINT("APP enabled\r\n");
std::printf("APP enabled\r\n");
#endif
move_app_data(); move_app_data();
} }
@@ -248,7 +264,7 @@ void OTA_initial(void) {
fmc_lock(); fmc_lock();
u8 transmit_data[2] = {0x0A, 0xAC}; u8 transmit_data[2] = {0x0A, 0xAC};
// 确认APP可用 // 确认 APP 可用
CAN0_transmiter.CANFD_AsyncSend(CANFD_OTA_ACK_ID, 2, transmit_data); CAN0_transmiter.CANFD_AsyncSend(CANFD_OTA_ACK_ID, 2, transmit_data);
flash_ptr = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR; flash_ptr = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR;
@@ -256,18 +272,14 @@ void OTA_initial(void) {
flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR; flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
u32 back_check = *flash_ptr; u32 back_check = *flash_ptr;
if (back_aval == OTA_NOT_AVAL) { // 如果BACK不可用 if (back_aval == OTA_NOT_AVAL) { // 如果 BACK 不可用
#if OTA_DEBUG OTA_DEBUG_PRINT("notaval\r\n");
std::printf("notaval\r\n");
#endif
move_app_data(); move_app_data();
} else if (back_aval == OTA_AVAL && } else if (back_aval == OTA_AVAL &&
back_check == OTA_NOT_AVAL) { // BACK已刷写，但未检查 back_check == OTA_NOT_AVAL) { // BACK 已刷写，但未检查
#if OTA_DEBUG OTA_DEBUG_PRINT("aval\r\n");
std::printf("aval\r\n");
#endif
move_app_data(); move_app_data();
} else { } else {
printf("check\r\n"); EEP_DEBUG_PRINT("check\r\n");
} }
} }
Robot_V2/sys/systick.cpp
+14 -13
View File
@@ -44,6 +44,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "motor.h" #include "motor.h"
#include <cstdio> #include <cstdio>
// SLEEP 调试宏定义
#if SLEEP_DEBUG
#define SLEEP_DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define SLEEP_DEBUG_PRINT(fmt, ...) ((void)0)
#endif
volatile static uint32_t delay; volatile static uint32_t delay;
extern CAN_transmiter CAN0_transmiter; extern CAN_transmiter CAN0_transmiter;
extern FlashEEPROM flashEEP; extern FlashEEPROM flashEEP;
@@ -131,7 +138,7 @@ void app_prepare_deep_sleep(bool save_data) {
if (save_data) { if (save_data) {
flashEEP.save_system_config(true); flashEEP.save_system_config(true);
} }
// 将SIT1044设置为低功耗待机模式 // 将 SIT1044 设置为低功耗待机模式
// CAN0_transmiter.CAN_Sleep(); // CAN0_transmiter.CAN_Sleep();
motor_sleep(); motor_sleep();
// 在睡眠前调整看门狗超时时间为最大值，使其在唤醒前不会触发 // 在睡眠前调整看门狗超时时间为最大值，使其在唤醒前不会触发
@@ -140,7 +147,7 @@ void app_prepare_deep_sleep(bool save_data) {
fwdgt_write_disable(); fwdgt_write_disable();
__disable_irq(); __disable_irq();
// 遍历最后一个数字，后一个地址写+1 // 遍历最后一个数字，后一个地址写 +1
for (u32 address = SLEEP_CONFIG_END - SIZE_U32; for (u32 address = SLEEP_CONFIG_END - SIZE_U32;
address >= SLEEP_CONFIG_START; address -= SIZE_U32) { // 遍历睡眠存储区 address >= SLEEP_CONFIG_START; address -= SIZE_U32) { // 遍历睡眠存储区
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
@@ -149,9 +156,7 @@ void app_prepare_deep_sleep(bool save_data) {
address > SLEEP_CONFIG_START) { // 空数据且未到头跳过 address > SLEEP_CONFIG_START) { // 空数据且未到头跳过
continue; continue;
} else { // 有数据的话读取 } else { // 有数据的话读取
#if SLEEP_DEBUG SLEEP_DEBUG_PRINT("app sleep found %08x at %08x\r\n", sleep_enable, address);
printf("app sleep found %08x at %08x\r\n", sleep_enable, address);
#endif
if (address == SLEEP_CONFIG_END - SIZE_U32) { if (address == SLEEP_CONFIG_END - SIZE_U32) {
fmc_unlock(); fmc_unlock();
fmc_state_enum fmc_status = fmc_state_enum fmc_status =
@@ -164,27 +169,23 @@ void app_prepare_deep_sleep(bool save_data) {
address = SLEEP_CONFIG_START - SIZE_U32; // 重新开始写入 address = SLEEP_CONFIG_START - SIZE_U32; // 重新开始写入
} }
address += SIZE_U32; address += SIZE_U32;
#if SLEEP_DEBUG SLEEP_DEBUG_PRINT("app sleep prepare write %08x at %08x\r\n", SLEEP_ENABLE,
printf("app sleep prepare write %08x at %08x\r\n", SLEEP_ENABLE,
address); address);
#endif
fmc_state_enum fmc_status = fmc_state_enum fmc_status =
write_ADDRESS(address, SLEEP_ENABLE); // 写入数据 write_ADDRESS(address, SLEEP_ENABLE); // 写入数据
#if SLEEP_DEBUG #if SLEEP_DEBUG
volatile u32 *flash_ptr = (volatile u32 *)address; volatile u32 *flash_ptr = (volatile u32 *)address;
u32 sleep_check = *flash_ptr; u32 sleep_check = *flash_ptr;
printf("app sleep wrote %08x at %08x\r\n", sleep_check, address); SLEEP_DEBUG_PRINT("app sleep wrote %08x at %08x\r\n", sleep_check, address);
#endif #endif
if (fmc_status != FMC_READY) { // 写入失败报错 if (fmc_status != FMC_READY) { // 写入失败报错
flashEEP.EEPROMStatus = FLASH_EEPROM_WRITE_ERROR; flashEEP.EEPROMStatus = FLASH_EEPROM_WRITE_ERROR;
#if SLEEP_DEBUG SLEEP_DEBUG_PRINT("app wrote %08x at %08x ERROR\r\n", SLEEP_ENABLE,
printf("app wrote %08x at %08x ERROR\r\n", SLEEP_ENABLE,
address); address);
#endif
return; return;
} }
break; break;
} }
} }
jumpToBOOT(); // 跳转到bootloader正式休眠，进入低功耗待机模式 jumpToBOOT(); // 跳转到 bootloader 正式休眠，进入低功耗待机模式
} }