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/sys/config.h
+67 -48
View File
@@ -3,19 +3,22 @@
#include "gd32c10x_eval.h"
#include <cstdint>
// 如果使用CMSIS DSP库，需要定义ARM_MATH_CM4
// 如果使用 CMSIS DSP 库，需要定义 ARM_MATH_CM4
#define ARM_MATH_CM4
#define EEP_DEBUG 1
#define OTA_DEBUG 1
#define SLEEP_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_MINOR = 3;
constexpr u16 SOFTWARE_VERSION_PATCH = 9;
constexpr u16 SOFTWARE_VERSION_BUILD = 1;
constexpr u16 SOFTWARE_VERSION_PATCH = 15;
constexpr u16 SOFTWARE_VERSION_BUILD = 4;
constexpr u16 HARDWARE_VERSION_MAJOR = 25;
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_BUILD = 0;
// Flash分区配置
// Flash 分区配置
constexpr u32 BOOTLOADER_SIZE = 0x6000; // 24KB
constexpr u32 BOOTLOADER_START_ADDR = 0x08000000; // BOOT起始地址
constexpr u32 APPLATEST_START_ADDR = 0x08012000; // APP起始地址
constexpr u32 APPBACK_START_ADDR = 0x08006000; // APPBACK起始地址
constexpr u32 BOOTLOADER_START_ADDR = 0x08000000; // BOOT 起始地址
constexpr u32 APPLATEST_START_ADDR = 0x08012000; // APP 起始地址
constexpr u32 APPBACK_START_ADDR = 0x08006000; // APPBACK 起始地址
constexpr u32 APP_MAX_SIZE = 0xC000; // 48KB
constexpr u32 FMC_PAGE_SIZE = 0x400; // 1KB
constexpr u32 SLEEP_CONFIG_START = 0x0801E400; // 睡眠配置起始地址
@@ -40,14 +43,22 @@ constexpr u32 FLASH_EMPTY = 0xFFFFFFFF; // 空数据
constexpr u32 SLEEP_ENABLE = 0x11111111; // 睡眠使能
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 相关
constexpr u32 OTA_CONFIG_NUM = 6;
constexpr u32 n_APP_LATEST_AVAL_ADDR = 0x0801E000; // 最新APP可用地址
constexpr u32 n_APP_BACKUP_AVAL_ADDR = 0x0801E004; // 备份APP可用地址
constexpr u32 n_APP_LATEST_EN_ADDR = 0x0801E008; // 最新APP激活
constexpr u32 n_APP_BACKUP_EN_ADDR = 0x0801E00C; // 备份APP激活
constexpr u32 n_APP_LATEST_CHECK_ADDR = 0x0801E010; // 最新APP校验
constexpr u32 n_APP_BACKUP_CHECK_ADDR = 0x0801E014; // 备份APP校验
constexpr u32 n_APP_LATEST_AVAL_ADDR = 0x0801E000; // 最新 APP 可用地址
constexpr u32 n_APP_BACKUP_AVAL_ADDR = 0x0801E004; // 备份 APP 可用地址
constexpr u32 n_APP_LATEST_EN_ADDR = 0x0801E008; // 最新 APP 激活
constexpr u32 n_APP_BACKUP_EN_ADDR = 0x0801E00C; // 备份 APP 激活
constexpr u32 n_APP_LATEST_CHECK_ADDR = 0x0801E010; // 最新 APP 校验
constexpr u32 n_APP_BACKUP_CHECK_ADDR = 0x0801E014; // 备份 APP 校验
constexpr u32 OTA_NOT_AVAL = 0xFFFFFFFF;
constexpr u32 OTA_AVAL = 0x00000000; // 全零表示可用
@@ -62,10 +73,10 @@ constexpr float KE_FACTOR = 0.0f;
// 角度卡尔曼滤波器参数
// 参数调节建议：
// - 增大Q值：增加对测量的信任，提高响应速度
// - 减小Q值：增加对预测的信任，提高平滑度
// - 增大R值：增加平滑度，减少噪声，但会降低响应速度
// - 减小R值：提高响应速度，但会增加噪声
// - 增大 Q 值：增加对测量的信任，提高响应速度
// - 减小 Q 值：增加对预测的信任，提高平滑度
// - 增大 R 值：增加平滑度，减少噪声，但会降低响应速度
// - 减小 R 值：提高响应速度，但会增加噪声
constexpr float ANGLE_KALMAN_INITIAL_STATE = 0.0f;
constexpr float ANGLE_KALMAN_INITIAL_COVARIANCE = 0.0f;
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 =
1e-6f; // 过程噪声协方差 - 通常保持较小
constexpr float VELOCITY_KALMAN_MEASUREMENT_NOISE_R =
1.0f; // 测量噪声协方差 - 主要调节参数1.0
1.0f; // 测量噪声协方差 - 主要调节参数 1.0
// 电流卡尔曼滤波器参数
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_MEASUREMENT_NOISE_R = 5e-5f; // 增大测量噪声
// PID配置
constexpr float DEFAULT_current_loop_p = 0.1f / 100 * 12; // 电流P
constexpr float current_loop_Ki = 0.55f; // 电流P
constexpr float current_loop_Kd = 3e-4f; // 电流P
// PID 配置
constexpr float DEFAULT_current_loop_p = 0.1f / 100 * 12; // 电流 P
constexpr float current_loop_Ki = 0.55f; // 电流 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_Tu = 17.0f * 1e-3f;
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 DEFAULT_vel_angloop_p = 0.4f / 100; // 速度 速度-角度P
constexpr float vel_angloop_Ki = 5.0f; // 速度 速度-角度I
constexpr float vel_angloop_Kd = 5e-05f; // 速度 速度-角度D
constexpr float DEFAULT_vel_angloop_p = 0.4f / 100; // 速度 速度 - 角度 P
constexpr float vel_angloop_Ki = 5.0f; // 速度 速度 - 角度 I
constexpr float vel_angloop_Kd = 5e-05f; // 速度 速度 - 角度 D
constexpr float DEFAULT_angle_angloop_p = 150.0f / 100 * 12; // 角度 速度-角度P
constexpr float ang_angloop_Ki = 0.00f; // 角度 速度-角度I
constexpr float ang_angloop_Kd = 8e-04f; // 角度 速度-角度D
constexpr float DEFAULT_angle_angloop_p =
150.0f / 100 * 12; // 角度 速度 - 角度 P
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 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 ANGLE_FACTOR = 25.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 CONFIG_SAVED_NUM = 6;
// 三角函数快速计算LUT
// 三角函数快速计算 LUT
constexpr u16 LUT_SIZE = 1024;
constexpr u16 LUT_MASK = (LUT_SIZE - 1);
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_MASK = 0x0000;
constexpr u16 DEV_CAN_LOOPBACK_ID = 0x0000;
// 反馈ID
constexpr u32 CANFD_STATUS_ID = 0x00010100;
constexpr u32 CANFD_CONFIG_ID = 0x00010101;
constexpr u32 CANFD_VERSION_ID = 0x00010000;
// 命令ID
constexpr u32 CANFD_CMD_ID = 0x00010200;
constexpr u32 CANFD_RESET_ID = 0x00010301;
// OTA相关ID
constexpr u32 CANFD_BOOT_ID = 0x00000000;
constexpr u32 CANFD_OTA_REQ_ID = 0x00000100;
constexpr u32 CANFD_OTA_DATA_ID = 0x00000101;
constexpr u32 CANFD_OTA_ACK_ID = 0x00000102;
constexpr u32 CANFD_OTA_WAIT_ID = 0x00000103;
// 反馈基础 ID
constexpr u16 CANFD_STATUS_ID = 0x0100; // 状态反馈基础 ID
constexpr u16 CANFD_CONFIG_ID = 0x0101; // 配置信息基础 ID
constexpr u16 CANFD_VERSION_ID = 0x00FF; // 版本信息基础 ID
// 命令基础 ID
constexpr u16 CANFD_CMD_ID = 0x0200; // 控制命令基础 ID
constexpr u16 CANFD_RESET_ID = 0x0301; // 重置命令基础 ID
// 节点 ID 管理基础 ID
constexpr u16 CANFD_SET_NODE_ID = 0x0400; // 设置节点 ID 基础 ID
constexpr u16 CANFD_GET_NODE_ID = 0x0401; // 查询节点 ID 基础 ID
// OTA 相关基础 ID 不受到node ID影响
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
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; // 频率
// 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_DEFAULT_PULSE = 0;
constexpr int TIMER1_CH3_COMPARE_VALUE =
(TIMER1_PERIOD + 1) * 0.41 - 1; // PWM周期50%位置触发中断
(TIMER1_PERIOD + 1) * 0.41 - 1; // PWM 周期 50% 位置触发中断
#endif
Robot_V2/sys/flash.cpp
+135 -141
View File
@@ -2,7 +2,7 @@
#include "FOC.h"
#include "ang_sensor.h"
#include "config.h"
#include "gd32c10x.h" // GD32主头文件，确保外设函数声明可用
#include "gd32c10x.h" // GD32 主头文件，确保外设函数声明可用
#include "gd32c10x_crc.h"
#include "gd32c10x_fmc.h"
#include "systick.h"
@@ -10,10 +10,24 @@
#include <cstdio>
#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();
extern angle_sensor KTH7823;
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_unlock();
@@ -25,19 +39,19 @@ fmc_state_enum write_ADDRESS(u32 address, u32 data) {
fmc_lock();
return fmc_status;
}
// FlashEEPROM类实现
// FlashEEPROM 类实现
FlashEEPROM::FlashEEPROM() {
// 构造函数可以为空，或者做一些初始化工作
}
/**
* @brief 初始化Flash EEPROM模拟
* @brief 初始化 Flash EEPROM 模拟
* @param None
* @retval None
*/
u8 FlashEEPROM::init() {
rcu_periph_clock_enable(RCU_CRC);
crc_deinit(); // 初始化CRC模块
crc_deinit(); // 初始化 CRC 模块
FlashEepromStatus status = FLASH_EEPROM_OK;
// 读取系统配置
@@ -52,7 +66,7 @@ u8 FlashEEPROM::init() {
}
/**
* @brief 读取EEPROM数据
* @brief 读取 EEPROM 数据
* @param virtualAddr: 虚拟地址
* @param data: 存储读取数据的指针
* @retval EEPROMStatus: 是否成功
@@ -62,7 +76,7 @@ u8 FlashEEPROM::read_saved_system_config(void) {
u32 CRC_NUM = 0x0000;
FlashEepromStatus status_read[CONFIG_SAVED_NUM + 1] = {FLASH_EEPROM_OK};
float data[CONFIG_SAVED_NUM] = {0.0f};
// 尝试从Flash读取参数，如果不存在则使用默认值
// 尝试从 Flash 读取参数，如果不存在则使用默认值
status_read[1] = readFloat(ADDR_CONTROL_MODE, &data[0]);
status_read[2] = readFloat(ADDR_VOLTAGE_LIMIT, &data[1]);
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) {
u32 next_address = EEPROM_END_ADDRESS;
// 遍历Flash页面寻找下一个可写入位置
// 遍历 Flash 页面寻找下一个可写入位置
for (u32 address = EEPROM_DATA_START_ADDRESS - SIZE_U32;
address > EEPROM_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据
// 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word = *flash_ptr;
// 找到空位置
@@ -102,18 +116,16 @@ u8 FlashEEPROM::read_saved_system_config(void) {
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);
#if EEP_DEBUG
printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32 *)next_address));
#endif
if (CRC_NUM != *((u32 *)next_address)) { // CRC错误
EEP_DEBUG_PRINT("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM,
*((u32 *)next_address));
if (CRC_NUM != *((u32 *)next_address)) { // CRC 错误
for (u8 i = 0; i < CONFIG_SAVED_NUM; i++) {
data[i] = DEFAULT_VALUE;
}
EEPROMStatus = FLASH_EEPROM_CRC_ERROR;
} else { // CRC正确
} else { // CRC 正确
EEPROMStatus = FLASH_EEPROM_OK;
}
} else {
@@ -133,7 +145,7 @@ u8 FlashEEPROM::read_saved_system_config(void) {
}
/**
* @brief 从Flash EEPROM读取数据
* @brief 从 Flash EEPROM 读取数据
* @param virtualAddr: 虚拟地址
* @param data: 指向存储读取数据的指针
* @retval FlashEepromStatus: 操作状态
@@ -144,7 +156,7 @@ FlashEepromStatus FlashEEPROM::read(u8 virtualAddr, u16 *data) const {
return FLASH_EEPROM_INVALID_ADDR;
}
// 从Flash末尾开始向前搜索，找到最新的数据
// 从 Flash 末尾开始向前搜索，找到最新的数据
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_START_ADDRESS; address -= SIZE_U32) {
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 data: 指向存储读取数据的指针
* @retval FlashEepromStatus: 操作状态
@@ -173,10 +185,10 @@ FlashEepromStatus FlashEEPROM::readFloat(u8 virtualAddr, float *data) const {
return FLASH_EEPROM_INVALID_ADDR;
}
// 从Flash末尾开始向前搜索，找到最新的数据
// 从 Flash 末尾开始向前搜索，找到最新的数据
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_START_ADDRESS; address -= SIZE_U32) {
// 使用volatile确保每次都从内存读取，防止编译器优化
// 使用 volatile 确保每次都从内存读取，防止编译器优化
volatile u32 *flash_ptr = (volatile u32 *)address;
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);
// 找到匹配的虚拟地址
if (addr == virtualAddr) {
// 清除最低的8位地址信息，保留高24位数据
// 清除最低的 8 位地址信息，保留高 24 位数据
u32 float_data = data_word & DATA_FLOAT_MASK;
// 使用内存拷贝将处理后的数据解释为float
// 使用内存拷贝将处理后的数据解释为 float
memcpy(data, &float_data, SIZE_FLOAT);
#if EEP_DEBUG
printf("read:0x%x=%f\r\n", address, *data);
#endif
EEP_DEBUG_PRINT("read:0x%x=%f\r\n", address, *data);
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 data: 要写入的数据
* @retval FlashEepromStatus: 操作状态
@@ -210,22 +220,23 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
// 查找下一个可写入的位置
u32 next_address = EEPROM_START_ADDRESS;
u32 data_read;
// 插入虚拟地址到低8位 格式: [data:16bit][reserved:8bit][addr:8bit]
data = (data & DATA_U16_MASK) | (u32)virtualAddr;
// 构建要写入的 32 位数据：格式 [data:16bit][reserved:8bit][addr:8bit]
u32 data_word_to_write = ((u32)data << 16) | (u32)virtualAddr;
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_DATA_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据
// 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address;
data_read = *flash_ptr;
if ((data_read & DATA_ADDR_MASK) == (u32)virtualAddr) { // 虚拟地址相同
if ((data_read & DATA_U16_MASK) ==
(data & DATA_U16_MASK)) { // 数据相同
(data_word_to_write & DATA_U16_MASK)) { // 数据相同
#if EEP_DEBUG
data_read = data_read & DATA_U16_MASK;
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
return FLASH_EEPROM_OK;
} 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;
address += SIZE_U32) {
// 安全读取Flash数据
// 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word = *flash_ptr;
// 找到空位置
@@ -251,18 +262,15 @@ FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
// 如果有足够空间，直接写入
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);
fmc_state_enum fmc_status =
write_ADDRESS(next_address, data_word_to_write);
if (fmc_status != FMC_READY) {
return FLASH_EEPROM_WRITE_ERROR;
}
return FLASH_EEPROM_OK;
} else { // 空间不足，需要格式化页面
#if EEP_DEBUG
printf("no enough space\r\n");
#endif
EEP_DEBUG_PRINT("no enough space\r\n");
FlashEepromStatus status = format();
if (status == FLASH_EEPROM_OK) {
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 data: 要写入的数据
* @retval FlashEepromStatus: 操作状态
@@ -284,15 +292,15 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
u32 next_address = EEPROM_START_ADDRESS;
u32 data_word;
// 将完整的float数据复制到32位变量中
// 将完整的 float 数据复制到 32 位变量中
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;
// 从Flash末尾开始向前搜索，找到最新的数据
// 从 Flash 末尾开始向前搜索，找到最新的数据
for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
address >= EEPROM_DATA_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据
// 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word_read = *flash_ptr;
@@ -303,7 +311,8 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
#if EEP_DEBUG
data_word_read = data_word_read & DATA_FLOAT_MASK;
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
return FLASH_EEPROM_OK;
} 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;
address += SIZE_U32) {
// 安全读取Flash数据
// 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word_read = *flash_ptr;
// 找到空位置
@@ -334,7 +343,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
u32 data_word_c = *((u32 *)next_address);
data_word_c = data_word_c & DATA_FLOAT_MASK;
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
if (fmc_status != FMC_READY) {
return FLASH_EEPROM_WRITE_ERROR;
@@ -343,7 +352,7 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
} else {
// 空间不足，需要格式化页面
#if EEP_DEBUG
printf("no enough space\r\n");
EEP_DEBUG_PRINT("no enough space\r\n");
#endif
FlashEepromStatus status = format();
if (status == FLASH_EEPROM_OK) {
@@ -356,15 +365,13 @@ FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
}
/**
* @brief 格式化Flash EEPROM页面
* @brief 格式化 Flash EEPROM 页面
* @param None
* @retval FlashEepromStatus: 操作状态
*/
FlashEepromStatus FlashEEPROM::format() {
fmc_state_enum fmc_status;
#if EEP_DEBUG
printf("擦除页面\r\n");
#endif
EEP_DEBUG_PRINT("擦除页面\r\n");
fmc_unlock();
fmc_status = fmc_page_erase(EEPROM_START_ADDRESS); // 擦除第一页
@@ -382,7 +389,7 @@ FlashEepromStatus FlashEEPROM::format() {
}
/**
* @brief 更新系统配置并保存到Flash
* @brief 更新系统配置并保存到 Flash
* @param config 新的系统配置值
*/
FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
@@ -437,18 +444,18 @@ FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
return status;
}
// 创建用于CRC计算的模拟数据数组，模拟实际存储到Flash中的数据格式
// 创建用于 CRC 计算的模拟数据数组，模拟实际存储到 Flash 中的数据格式
u32 crc_data_words[CONFIG_SAVED_NUM];
// 按照writeFloat函数的方式处理数据
// 按照 writeFloat 函数的方式处理数据
for (u8 i = 0; i < CONFIG_SAVED_NUM; i++) {
// 将完整的float数据复制到32位变量中
// 将完整的 float 数据复制到 32 位变量中
memcpy(&crc_data_words[i], &data[i], SIZE_FLOAT);
// 去除最后2位精度
// 去除最后 2 位精度
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);
writeCRC(CRC_NUM, saved);
@@ -457,7 +464,7 @@ FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
}
/**
* @brief 读取角度数据从Flash
* @brief 读取角度数据从 Flash
* @return float: 角度数据
*/
float FlashEEPROM::read_angle() {
@@ -469,16 +476,16 @@ float FlashEEPROM::read_angle() {
}
/**
* @brief 保存CRC数据到Flash
* @brief 保存 CRC 数据到 Flash
* @param saved: 是否一次性保存
* @return FlashEepromStatus: 状态
*/
FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
static u32 next_address;
// 遍历Flash页面寻找下一个可写入crc的位置
// 遍历 Flash 页面寻找下一个可写入 crc 的位置
for (u32 address = EEPROM_DATA_START_ADDRESS - SIZE_U32;
address > EEPROM_START_ADDRESS; address -= SIZE_U32) {
// 安全读取Flash数据
// 安全读取 Flash 数据
volatile u32 *flash_ptr = (volatile u32 *)address;
u32 data_word = *flash_ptr;
// 找到空位置
@@ -490,14 +497,13 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
next_address = address - SIZE_U32;
}
// 如果当前CRC与现在的crc值不同，则写入
// 如果当前 CRC 与现在的 crc 值不同，则写入
if (*((u32 *)next_address) != CRC_NUM) {
// 如果有足够空间，直接写入crc值
// 如果有足够空间，直接写入 crc 值
if (next_address > EEPROM_START_ADDRESS) {
fmc_state_enum fmc_status = write_ADDRESS(next_address, CRC_NUM);
#if EEP_DEBUG
printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32 *)next_address));
#endif
EEP_DEBUG_PRINT("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM,
*((u32 *)next_address));
// 检查写入是否成功
if (fmc_status != FMC_READY) {
EEPROMStatus = fmc_status;
@@ -505,9 +511,7 @@ FlashEepromStatus FlashEEPROM::writeCRC(u32 CRC_NUM, bool saved) {
}
} else {
// 空间不足，需要格式化页面
#if EEP_DEBUG
printf("no enough space\r\n");
#endif
EEP_DEBUG_PRINT("no enough space\r\n");
FlashEepromStatus status = format();
if (status == FLASH_EEPROM_OK) {
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)) {
system_config_saved = saved; // 标记已保存过
EEPROMStatus = FLASH_EEPROM_OK; // 设置EEPROM状态
EEPROMStatus = FLASH_EEPROM_OK; // 设置 EEPROM 状态
return FLASH_EEPROM_OK;
} else {
EEPROMStatus = FLASH_EEPROM_CRC_ERROR; // 设置EEPROM错误状态
EEPROMStatus = FLASH_EEPROM_CRC_ERROR; // 设置 EEPROM 错误状态
return FLASH_EEPROM_CRC_ERROR;
}
}
/**
* @brief 设置OTA配置参数到Flash
* @brief 设置 OTA 配置参数到 Flash
*
* 此函数用于更新存储在Flash中的OTA相关标志位（如APP可用、启用、校验等）。
* GD32的Flash特性是：只能将1写为0，不能将0写为1。若要将0变为1，必须先擦除整个页面。
* 因此，本函数通过读取同一页内的所有参数，擦除该页，然后重新写入有效的参数来实现“写1”操作。
* 此函数用于更新存储在 Flash 中的 OTA 相关标志位（如 APP 可用、启用、校验等）。
* GD32 的 Flash 特性是：只能将 1 写为 0，不能将 0 写为 1。若要将 0 写为
* 1，必须先擦除整个页面。
* 因此，本函数通过读取同一页内的所有参数，擦除该页，然后重新写入有效的参数来实现"写
* 1"操作。
*
* @param addr: 要设置的Flash地址
* @param data: 要写入的数据 (通常为OTA_AVAL=0x00000000 或
* @param addr: 要设置的 Flash 地址
* @param data: 要写入的数据 (通常为 OTA_AVAL=0x00000000 或
* OTA_NOT_AVAL=0xFFFFFFFF)
* @retval FLASH_EEPROM_OK (0) 表示成功, 其他值表示失败
* @retval FLASH_EEPROM_OK (0) 表示成功，其他值表示失败
*/
u8 OTA_SET(u32 addr, u32 data) {
#if EEP_DEBUG
printf("OTA_prepare write%08x at %08x\r\n", data, addr);
#endif
EEP_DEBUG_PRINT("OTA_prepare write%08x at %08x\r\n", data, addr);
fmc_state_enum fmc_status;
u32 temp_val[OTA_CONFIG_NUM]; // 临时数组，用于存储当前所有配置参数的值
volatile u32 *flash_ptr = (volatile u32 *)addr;
@@ -556,17 +560,17 @@ u8 OTA_SET(u32 addr, u32 data) {
return FLASH_EEPROM_OK; // 值已正确，直接返回成功
}
// 2. 尝试直接写入数据。这适用于将1修改为0的情况（因为Flash允许1->0）
// 2. 尝试直接写入数据。这适用于将 1 修改为 0 的情况（因为 Flash 允许 1->0）
if (data == OTA_AVAL) {
fmc_status = write_ADDRESS(addr, data);
// 如果写入成功，则返回成功
if (fmc_status == FMC_READY) {
return FLASH_EEPROM_OK;
}
// 如果写入失败（例如地址已被写为0），则继续执行后续的擦除-重写流程
// 如果写入失败（例如地址已被写为 0），则继续执行后续的擦除 - 重写流程
}
// 3. 对于需要将0改回1的操作，必须先擦除整个Flash页
// 3. 对于需要将 0 改回 1 的操作，必须先擦除整个 Flash 页
flash_ptr = (volatile u32 *)n_APP_LATEST_AVAL_ADDR;
temp_val[0] = *flash_ptr;
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;
temp_val[5] = *flash_ptr;
#if EEP_DEBUG
printf("OTA_prepare write%08x at %08x\r\n", data, addr);
// 修复：完整输出所有6个配置项的值，便于调试
printf("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"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[5]);
#endif
// 4. 擦除包含所有配置参数的Flash页
EEP_DEBUG_PRINT("OTA_prepare write%08x at %08x\r\n", data, addr);
// 修复：完整输出所有 6 个配置项的值，便于调试
EEP_DEBUG_PRINT("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"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[5]);
// 4. 擦除包含所有配置参数的 Flash 页
fmc_status = fmc_page_erase(n_APP_LATEST_AVAL_ADDR);
if (fmc_status != FMC_READY) {
#if EEP_DEBUG
printf("OTA_SET - Page erase failed! Status: %d\r\n", fmc_status);
#endif
EEP_DEBUG_PRINT("OTA_SET - Page erase failed! Status: %d\r\n",
fmc_status);
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) {
fmc_status = write_ADDRESS(current_addr, temp_val[i]);
if (fmc_status != FMC_READY) {
#if EEP_DEBUG
printf("OTA_SET - Write backup value %08X failed at "
"0x%08X!status:%d\r\n",
temp_val[i], current_addr, fmc_status);
#endif
EEP_DEBUG_PRINT("OTA_SET - Write backup value %08X failed at "
"0x%08X!status:%d\r\n",
temp_val[i], current_addr, fmc_status);
return FLASH_EEPROM_WRITE_ERROR;
}
}
}
#if EEP_DEBUG
// 3. 对于需要将0改回1的操作，必须先擦除整个Flash页
// 3. 对于需要将 0 改回 1 的操作，必须先擦除整个 Flash 页
flash_ptr = (volatile u32 *)n_APP_LATEST_AVAL_ADDR;
temp_val[0] = *flash_ptr;
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;
flash_ptr = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
temp_val[5] = *flash_ptr;
// 修复：完整输出所有6个配置项的值，便于调试
printf("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"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[5]);
// 修复：完整输出所有 6 个配置项的值，便于调试
EEP_DEBUG_PRINT("LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"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[5]);
#endif
return FLASH_EEPROM_OK;
@@ -649,7 +648,7 @@ void jumpToBOOT() {
for (int i = 0; i < 8; i++) {
NVIC->ICER[i] = 0xFFFFFFFF;
}
// 2. 重置外设（特别是CAN，防止冲突）
// 2. 重置外设（特别是 CAN，防止冲突）
can_deinit(CAN0);
// 3. 重置系统时钟到默认状态
@@ -667,7 +666,7 @@ void jumpToBOOT() {
// 5. 设置中断向量表偏移到应用程序起始地址
SCB->VTOR = BOOTLOADER_START_ADDR;
// 6. 设置MSP并跳转
// 6. 设置 MSP 并跳转
uint32_t msp_value = *(__IO uint32_t *)BOOTLOADER_START_ADDR;
uint32_t reset_handler = *(__IO uint32_t *)(BOOTLOADER_START_ADDR + 4);
typedef void (*AppEntryFunc)(void);
@@ -677,28 +676,26 @@ void jumpToBOOT() {
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
* @retval fmc_state_enum: 操作状态
*/
fmc_state_enum move_app_data() {
// 源地址: APPLATEST_START_ADDR (0x08011000)
// 目标地址: APPBACK_START_ADDR (0x08005000)
// 数据大小: APP_MAX_SIZE (0xC000 = 48KB)
// 源地址：APPLATEST_START_ADDR (0x08011000)
// 目标地址：APPBACK_START_ADDR (0x08005000)
// 数据大小：APP_MAX_SIZE (0xC000 = 48KB)
fmc_state_enum fmc_status = FMC_READY;
#if OTA_DEBUG
printf("move_app_data\r\n");
#endif
// 关闭全局中断以防止Flash操作期间的中断干扰
OTA_DEBUG_PRINT("move_app_data\r\n");
// 关闭全局中断以防止 Flash 操作期间的中断干扰
__disable_irq();
fmc_unlock();
// 首先擦除目标地址的Flash页面
// 首先擦除目标地址的 Flash 页面
uint32_t num_pages =
(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) {
fmc_lock();
#if OTA_DEBUG
printf("move_app_data erase error\r\n");
OTA_DEBUG_PRINT("move_app_data erase error\r\n");
delay_1ms(1000);
#endif
__enable_irq(); // 重新开启中断
@@ -718,13 +715,13 @@ fmc_state_enum move_app_data() {
}
}
// 复制数据 - 按字（32位）进行复制以提高效率
// 复制数据 - 按字（32 位）进行复制以提高效率
uint32_t offset = 0;
uint32_t write_count = 0; // 记录实际写入的字数
const uint32_t *src_ptr = (const uint32_t *)APPLATEST_START_ADDR;
uint32_t *dst_ptr = (uint32_t *)APPBACK_START_ADDR;
// 预计算源数据的CRC，避免重复访问内存
// 预计算源数据的 CRC，避免重复访问内存
crc_deinit();
crc_data_register_reset();
uint32_t src_crc = crc_block_data_calculate(
@@ -733,7 +730,7 @@ fmc_state_enum move_app_data() {
while (offset < APP_MAX_SIZE) {
uint32_t src_data = src_ptr[offset / 4];
// 检查源地址是否为有效的Flash数据（非0xFFFFFFFF表示有数据）
// 检查源地址是否为有效的 Flash 数据（非 0xFFFFFFFF 表示有数据）
if (src_data != 0xFFFFFFFF) {
fmc_unlock();
// 清除之前的标志位
@@ -745,7 +742,7 @@ fmc_state_enum move_app_data() {
// 检查写入操作是否成功
if (fmc_status != FMC_READY) {
#if OTA_DEBUG
printf(
OTA_DEBUG_PRINT(
"Flash write failed at offset 0x%08X with status: %d\r\n",
offset, fmc_status);
delay_1ms(1000);
@@ -759,7 +756,7 @@ fmc_state_enum move_app_data() {
offset += 4;
// 每写入一定数量的数据后，喂狗一次
if ((offset % 4096) == 0) { // 每4KB喂狗一次
if ((offset % 4096) == 0) { // 每 4KB 喂狗一次
fwdgt_counter_reload();
}
}
@@ -768,23 +765,20 @@ fmc_state_enum move_app_data() {
// 重新开启全局中断
__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,
APP_MAX_SIZE / 4);
// 比较CRC值，确保数据完整性
// 比较 CRC 值，确保数据完整性
if (src_crc != dst_crc) {
#if OTA_DEBUG
printf("APPbackup CRC mismatch: src_crc=0x%08X, dst_crc=0x%08X\r\n",
src_crc, dst_crc);
#endif
return (fmc_state_enum)0xFF; // CRC校验失败
OTA_DEBUG_PRINT(
"APPbackup CRC mismatch: src_crc=0x%08X, dst_crc=0x%08X\r\n",
src_crc, dst_crc);
return (fmc_state_enum)0xFF; // CRC 校验失败
}
#if OTA_DEBUG
printf("APPbackup CRC OK\r\n");
#endif
OTA_DEBUG_PRINT("APPbackup CRC OK\r\n");
// 设置备份应用可用标志
fmc_unlock();
OTA_SET(n_APP_BACKUP_AVAL_ADDR, OTA_AVAL);
@@ -792,4 +786,4 @@ fmc_state_enum move_app_data() {
fmc_lock();
return fmc_status;
}
}
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_VOLTAGE_LIMIT = 0x4; // 电压限制
static constexpr u8 ADDR_VEL_LIMIT = 0x05; // 角度数据存储地址
static constexpr u8 ADDR_NODE_ID = 0x06; // 节点 ID 存储地址
bool angle_saved = false;
bool system_config_saved = false;
Robot_V2/sys/initial.cpp
+55 -43
View File
@@ -11,7 +11,21 @@
#include <cstdio>
#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::VersionManager() {
@@ -74,11 +88,11 @@ char *VersionManager::versionToString(const VersionInfo &version, char *buffer,
void VersionManager::sendVersionInfoViaCan() const {
// 准备发送版本信息 (ID: CANFD_VERSION_ID)
// 只使用必要的字节数（24字节）来传输三个版本的信息（每个版本6字节）
// 只使用必要的字节数（24 字节）来传输三个版本的信息（每个版本 6 字节）
u8 versionData[24] = {0};
// 将版本信息打包到24字节数组中
// 前8字节：软件版本信息 (4个uint16_t，每个占2字节)
// 将版本信息打包到 24 字节数组中
// 前 8 字节：软件版本信息 (4 个 uint16_t，每个占 2 字节)
versionData[0] = softwareVersion.major & 0xFF; // 低字节
versionData[1] = (softwareVersion.major >> 8) & 0xFF; // 高字节
versionData[2] = softwareVersion.minor & 0xFF; // 低字节
@@ -88,7 +102,7 @@ void VersionManager::sendVersionInfoViaCan() const {
versionData[6] = softwareVersion.build & 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[9] = (hardwareVersion.major >> 8) & 0xFF; // 高字节
versionData[10] = hardwareVersion.minor & 0xFF; // 低字节
@@ -98,7 +112,7 @@ void VersionManager::sendVersionInfoViaCan() const {
versionData[14] = hardwareVersion.build & 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[17] = (bootVersion.major >> 8) & 0xFF; // 高字节
versionData[18] = bootVersion.minor & 0xFF; // 低字节
@@ -108,21 +122,24 @@ void VersionManager::sendVersionInfoViaCan() const {
versionData[22] = bootVersion.build & 0xFF; // 低字节
versionData[23] = (bootVersion.build >> 8) & 0xFF; // 高字节
// 使用CANFD发送函数发送版本信息
CAN0_transmiter.CANFD_AsyncSend(CANFD_VERSION_ID, 24, versionData);
// 使用 CANFD 发送函数发送版本信息，使用 build_can_id 构建带 node_id 的 CAN
// ID
CAN0_transmiter.CANFD_AsyncSend(
CAN0_transmiter.build_can_id(CANFD_VERSION_ID), 24, versionData);
}
void VersionManager::printVersions() const {
char versionStr[32];
printf(
OTA_DEBUG_PRINT(
"Software Version: %s\r\n",
versionToString(getSoftwareVersion(), versionStr, sizeof(versionStr)));
printf(
OTA_DEBUG_PRINT(
"Hardware Version: %s\r\n",
versionToString(getHardwareVersion(), versionStr, sizeof(versionStr)));
printf("BOOT Version: %s\r\n",
versionToString(getBootVersion(), versionStr, sizeof(versionStr)));
OTA_DEBUG_PRINT(
"BOOT Version: %s\r\n",
versionToString(getBootVersion(), versionStr, sizeof(versionStr)));
}
/* retarget the C library printf function to the USART */
@@ -154,9 +171,9 @@ int fputc(int ch, FILE *f) throw() {
}
void unused_pin_init() {
rcu_periph_clock_enable(RCU_GPIOA); // 使能GPIOA时钟
rcu_periph_clock_enable(RCU_GPIOB); // 使能GPIOB时钟
rcu_periph_clock_enable(RCU_GPIOC); // 使能GPIOC时钟
rcu_periph_clock_enable(RCU_GPIOA); // 使能 GPIOA 时钟
rcu_periph_clock_enable(RCU_GPIOB); // 使能 GPIOB 时钟
rcu_periph_clock_enable(RCU_GPIOC); // 使能 GPIOC 时钟
gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12);
gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
@@ -177,43 +194,43 @@ void unused_pin_init() {
u16 get_reset_cause(void) {
u16 cause = 0;
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;
}
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;
}
if (RESET != rcu_flag_get(RCU_FLAG_PORRST)) {
// printf("Power Reset\r\n");
// OTA_DEBUG_PRINT("Power Reset\r\n");
cause = RCU_FLAG_PORRST;
}
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;
}
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;
}
if (RESET != rcu_flag_get(RCU_FLAG_SWRST)) {
// printf("Software Reset\r\n");
// OTA_DEBUG_PRINT("Software Reset\r\n");
cause = RCU_FLAG_SWRST;
}
// 清除所有复位标志
rcu_all_reset_flag_clear();
// printf("cause:%d\r\n", cause);
// OTA_DEBUG_PRINT("cause:%d\r\n", cause);
return cause;
}
void OTA_initial(void) {
#if OTA_DEBUG
u32 temp_val[6];
// 3. 对于需要将0改回1的操作，必须先擦除整个Flash页
// 3. 对于需要将 0 改回 1 的操作，必须先擦除整个 Flash 页
volatile u32 *flash_ptr1 = (volatile u32 *)n_APP_LATEST_AVAL_ADDR;
temp_val[0] = *flash_ptr1;
flash_ptr1 = (volatile u32 *)n_APP_BACKUP_AVAL_ADDR;
@@ -226,20 +243,19 @@ void OTA_initial(void) {
temp_val[4] = *flash_ptr1;
flash_ptr1 = (volatile u32 *)n_APP_BACKUP_CHECK_ADDR;
temp_val[5] = *flash_ptr1;
// 修复：完整输出所有6个配置项的值，便于调试
printf("APP:CHECK LatestAval:0x%x, BackupAval:0x%x, LatestEn:0x%x, "
"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[5]);
// 修复：完整输出所有 6 个配置项的值，便于调试
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",
temp_val[0], temp_val[1], temp_val[2], temp_val[3], temp_val[4],
temp_val[5]);
#endif
// 确认当前APP可用
// 确认当前 APP 可用
volatile u32 *flash_ptr = (volatile u32 *)n_APP_LATEST_CHECK_ADDR;
u32 app_check = *flash_ptr;
if (app_check == OTA_NOT_AVAL) { // 新的APP刷入后第一次启动
#if OTA_DEBUG
std::printf("APP enabled\r\n");
#endif
if (app_check == OTA_NOT_AVAL) { // 新的 APP 刷入后第一次启动
OTA_DEBUG_PRINT("APP enabled\r\n");
move_app_data();
}
@@ -248,7 +264,7 @@ void OTA_initial(void) {
fmc_lock();
u8 transmit_data[2] = {0x0A, 0xAC};
// 确认APP可用
// 确认 APP 可用
CAN0_transmiter.CANFD_AsyncSend(CANFD_OTA_ACK_ID, 2, transmit_data);
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;
u32 back_check = *flash_ptr;
if (back_aval == OTA_NOT_AVAL) { // 如果BACK不可用
#if OTA_DEBUG
std::printf("notaval\r\n");
#endif
if (back_aval == OTA_NOT_AVAL) { // 如果 BACK 不可用
OTA_DEBUG_PRINT("notaval\r\n");
move_app_data();
} else if (back_aval == OTA_AVAL &&
back_check == OTA_NOT_AVAL) { // BACK已刷写，但未检查
#if OTA_DEBUG
std::printf("aval\r\n");
#endif
back_check == OTA_NOT_AVAL) { // BACK 已刷写，但未检查
OTA_DEBUG_PRINT("aval\r\n");
move_app_data();
} else {
printf("check\r\n");
EEP_DEBUG_PRINT("check\r\n");
}
}
Robot_V2/sys/systick.cpp
+15 -14
View File
@@ -44,6 +44,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "motor.h"
#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;
extern CAN_transmiter CAN0_transmiter;
extern FlashEEPROM flashEEP;
@@ -131,7 +138,7 @@ void app_prepare_deep_sleep(bool save_data) {
if (save_data) {
flashEEP.save_system_config(true);
}
// 将SIT1044设置为低功耗待机模式
// 将 SIT1044 设置为低功耗待机模式
// CAN0_transmiter.CAN_Sleep();
motor_sleep();
// 在睡眠前调整看门狗超时时间为最大值，使其在唤醒前不会触发
@@ -140,7 +147,7 @@ void app_prepare_deep_sleep(bool save_data) {
fwdgt_write_disable();
__disable_irq();
// 遍历最后一个数字，后一个地址写+1
// 遍历最后一个数字，后一个地址写 +1
for (u32 address = SLEEP_CONFIG_END - SIZE_U32;
address >= SLEEP_CONFIG_START; address -= SIZE_U32) { // 遍历睡眠存储区
volatile u32 *flash_ptr = (volatile u32 *)address;
@@ -149,9 +156,7 @@ void app_prepare_deep_sleep(bool save_data) {
address > SLEEP_CONFIG_START) { // 空数据且未到头跳过
continue;
} else { // 有数据的话读取
#if SLEEP_DEBUG
printf("app sleep found %08x at %08x\r\n", sleep_enable, address);
#endif
SLEEP_DEBUG_PRINT("app sleep found %08x at %08x\r\n", sleep_enable, address);
if (address == SLEEP_CONFIG_END - SIZE_U32) {
fmc_unlock();
fmc_state_enum fmc_status =
@@ -164,27 +169,23 @@ void app_prepare_deep_sleep(bool save_data) {
address = SLEEP_CONFIG_START - SIZE_U32; // 重新开始写入
}
address += SIZE_U32;
#if SLEEP_DEBUG
printf("app sleep prepare write %08x at %08x\r\n", SLEEP_ENABLE,
SLEEP_DEBUG_PRINT("app sleep prepare write %08x at %08x\r\n", SLEEP_ENABLE,
address);
#endif
fmc_state_enum fmc_status =
write_ADDRESS(address, SLEEP_ENABLE); // 写入数据
#if SLEEP_DEBUG
volatile u32 *flash_ptr = (volatile u32 *)address;
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
if (fmc_status != FMC_READY) { // 写入失败报错
flashEEP.EEPROMStatus = FLASH_EEPROM_WRITE_ERROR;
#if SLEEP_DEBUG
printf("app wrote %08x at %08x ERROR\r\n", SLEEP_ENABLE,
SLEEP_DEBUG_PRINT("app wrote %08x at %08x ERROR\r\n", SLEEP_ENABLE,
address);
#endif
return;
}
break;
}
}
jumpToBOOT(); // 跳转到bootloader正式休眠，进入低功耗待机模式
}
jumpToBOOT(); // 跳转到 bootloader 正式休眠，进入低功耗待机模式
}