fix(flash): 优化Flash EEPROM读写逻辑并修复角度保存问题

移除调试打印语句，改进Flash读写稳定性。
使用类型别名统一数据访问，增强代码可读性。
修正CAN通信中角度保存逻辑，确保正确写入实时角度值。
完善错误处理机制，增加对齐检查和状态反馈。
调整EEPROM起始地址以避免潜在冲突。

Robot_V2/RTE/Device/GD32C103CB/gd32c10x_fmc.c

@@ -330,7 +330,6 @@ fmc_state_enum fmc_doubleword_program(uint32_t address, uint64_t data)
 fmc_state_enum fmc_word_program(uint32_t address, uint32_t data)
 {
     fmc_state_enum fmc_state = fmc_ready_wait(FMC_TIMEOUT_COUNT); 
-	printf("fmc_status: 0x%x\r\n", fmc_state);
 
     if(FMC_READY == fmc_state){
         /* set the PG bit to start program */

Robot_V2/device/Can.cpp

@@ -696,7 +696,7 @@ void CAN_transmiter::communication_check() {
 			FOC.target_velocity = target_velocity_union.f;
 		} else if (receive_message.rx_efid == 0x00010301) {
 			motor_reset();
-			flashEEP.save_angle(666, false);
+			flashEEP.save_angle((u16)FOC.rt_angle, false);
 		} else {
 			printf("Unknown CAN ID: %X\n", receive_message.rx_efid);
 		}

Robot_V2/sys/flash.cpp

@@ -9,6 +9,7 @@
 FlashEEPROM flashEEP = FlashEEPROM();
 extern angle_sensor KTH7823;
 extern CAN_transmiter CAN0_transmiter;
+constexpr u8 SIZE_U32 = sizeof(uint32_t);
 
 // FlashEEPROM类实现
 FlashEEPROM::FlashEEPROM() {
@@ -21,12 +22,8 @@ FlashEEPROM::FlashEEPROM() {
  * @retval None
  */
 u8 FlashEEPROM::init() {
-	// 解锁Flash
-	fmc_unlock();
-
 	// 读取保存的参数
 	u16 angle;
-
 	// 尝试从Flash读取参数，如果不存在则使用默认值
 	if (read(ADDR_ANGLE_DATA, &angle) != FLASH_EEPROM_OK) {
 		angle = 0; // 默认值
@@ -34,9 +31,7 @@ u8 FlashEEPROM::init() {
 	} else {
 		std::printf("从Flash读取到角度数: %d\r\n", angle);
 	}
-
 	KTH7823.angle_set((float)angle);
-	// save_angle(200, false); // 重置保存标志以允许再次保存
 	return 0;
 }
 
@@ -46,31 +41,26 @@ u8 FlashEEPROM::init() {
  * @param  data: 指向存储读取数据的指针
  * @retval FlashEepromStatus: 操作状态
  */
-FlashEepromStatus FlashEEPROM::read(uint16_t virtualAddr,
+FlashEepromStatus FlashEEPROM::read(u16 virtualAddr, u16 *data) const {
-									uint16_t *data) const {
 	// 检查参数有效性
-	if (data == nullptr || virtualAddr == 0xFFFF) {
+	if (data == nullptr || virtualAddr > 0xFFFE) {
-		return FLASH_EEPROM_ERROR;
+		return FLASH_EEPROM_INVALID_ADDR;
 	}
 
 	// 从Flash末尾开始向前搜索，找到最新的数据
-	for (uint32_t address = EEPROM_END_ADDRESS - sizeof(uint32_t);
+	for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
-		 address >= EEPROM_START_ADDRESS; address -= sizeof(uint32_t)) {
+		 address >= EEPROM_START_ADDRESS; address -= SIZE_U32) {
-
+		u32 data_word = *((u32 *)address);
-		uint32_t data_word = *((uint32_t *)address);
-
 		// 检查是否是有效数据（非擦除状态）
 		if (data_word != 0xFFFFFFFF) {
-			uint16_t addr = (uint16_t)(data_word & 0xFFFF);
+			u16 addr = (u16)(data_word & 0xFFFF);
-
 			// 找到匹配的虚拟地址
 			if (addr == virtualAddr) {
-				*data = (uint16_t)((data_word >> 16) & 0xFFFF);
+				*data = (u16)((data_word >> 16) & 0xFFFF);
 				return FLASH_EEPROM_OK;
 			}
 		}
 	}
-
 	// 未找到指定虚拟地址的数据
 	return FLASH_EEPROM_NOT_FOUND;
 }
@@ -81,47 +71,45 @@ FlashEepromStatus FlashEEPROM::read(uint16_t virtualAddr,
  * @param  data: 要写入的数据
  * @retval FlashEepromStatus: 操作状态
  */
-FlashEepromStatus FlashEEPROM::write(uint16_t virtualAddr, uint16_t data) {
+FlashEepromStatus FlashEEPROM::write(u16 virtualAddr, u16 data) {
 	// 参数检查
-	if (virtualAddr == 0xFFFF) {
+	if (virtualAddr > 0xFFFE) {
 		return FLASH_EEPROM_INVALID_ADDR;
 	}
-
 	// 查找下一个可写入的位置
-	uint32_t next_address = EEPROM_START_ADDRESS;
+	u32 next_address = EEPROM_START_ADDRESS;
 
 	// 遍历Flash页面寻找下一个可写入位置
-	for (uint32_t address = EEPROM_START_ADDRESS; address < EEPROM_END_ADDRESS;
+	for (u32 address = EEPROM_START_ADDRESS; address < EEPROM_END_ADDRESS;
-		 address += sizeof(uint32_t)) {
+		 address += SIZE_U32) {
 
-		uint32_t data_word = *((uint32_t *)address);
+		// 安全读取Flash数据
-
+		volatile u32 *flash_ptr = (volatile u32 *)address;
-		// 如果找到已使用的地址且与要写入的地址相同，检查数据是否需要更新
+		u32 data_word = *flash_ptr;
-		if ((data_word & 0xFFFF) == virtualAddr) {
-			uint16_t old_data = (uint16_t)((data_word >> 16) & 0xFFFF);
-			if (old_data == data) {
-				// 数据相同，无需更新
-				return FLASH_EEPROM_OK;
-			}
-		}
 		// 找到空位置
 		if (data_word == 0xFFFFFFFF) {
 			next_address = address;
 			break;
 		}
 		// 更新下一个可能的写入位置（如果需要格式化）
-		next_address = address + sizeof(uint32_t);
+		next_address = address + SIZE_U32;
 	}
 
 	// 如果有足够空间，直接写入
 	if (next_address < EEPROM_END_ADDRESS) {
-		u32 new_data_word = ((u32)data << 16) | (virtualAddr & 0xFFFF);
+		u32 data_word = ((u32)data << 16) | (u32)virtualAddr;
-		fmc_state_enum fmc_status =
+
-			fmc_word_program(next_address, new_data_word);
+		// 使用GD32库函数进行安全编程
+		fmc_unlock();
+		fmc_flag_clear(FMC_FLAG_PGERR | FMC_FLAG_PGAERR | FMC_FLAG_WPERR);
+
+		// 确保使用对齐地址
+		fmc_state_enum fmc_status = fmc_word_program(next_address, data_word);
+
+		fmc_lock();
 		if (fmc_status != FMC_READY) {
 			return FLASH_EEPROM_WRITE_ERROR;
 		}
-
 		return FLASH_EEPROM_OK;
 	} else {
 		// 空间不足，需要格式化页面
@@ -131,8 +119,7 @@ FlashEepromStatus FlashEEPROM::write(uint16_t virtualAddr, uint16_t data) {
 		}
 
 		// 格式化后在页面开头写入数据
-		uint32_t new_data_word =
+		u32 new_data_word = ((u32)data << 16) | (virtualAddr & 0xFFFF);
-			((uint32_t)data << 16) | (virtualAddr & 0xFFFF);
 		fmc_state_enum fmc_status =
 			fmc_word_program(EEPROM_START_ADDRESS, new_data_word);
 
@@ -153,35 +140,34 @@ FlashEepromStatus FlashEEPROM::format() {
 	fmc_state_enum fmc_status;
 
 	// 创建临时缓冲区存储唯一地址的最新数据
-	uint32_t valid_entries[EEPROM_MAX_SIZE / sizeof(uint32_t)];
+	u32 valid_entries[EEPROM_MAX_SIZE / SIZE_U32];
-	uint16_t valid_count = 0;
+	u16 valid_count = 0;
 
 	// 收集有效的数据项（去重，保留最新的）
-	for (uint32_t address = EEPROM_START_ADDRESS; address < EEPROM_END_ADDRESS;
+	for (u32 address = EEPROM_START_ADDRESS; address < EEPROM_END_ADDRESS;
-		 address += sizeof(uint32_t)) {
+		 address += SIZE_U32) {
-
+		u32 data_word = *((u32 *)address);
-		uint32_t data_word = *((uint32_t *)address);
 
 		// 检查是否是有效数据项
 		if (data_word != 0xFFFFFFFF) {
-			uint16_t addr = (uint16_t)(data_word & 0xFFFF);
+			u16 addr = (u16)(data_word & 0xFFFF);
-			uint16_t value = (uint16_t)((data_word >> 16) & 0xFFFF);
+			u16 value = (u16)((data_word >> 16) & 0xFFFF);
 
 			// 查找是否已经有相同虚拟地址的数据项
 			uint8_t found = 0;
-			for (uint16_t i = 0; i < valid_count; i++) {
+			for (u16 i = 0; i < valid_count; i++) {
-				uint16_t existing_addr = (uint16_t)(valid_entries[i] & 0xFFFF);
+				u16 existing_addr = (u16)(valid_entries[i] & 0xFFFF);
 				if (existing_addr == addr) {
 					// 更新为最新的数据
-					valid_entries[i] = ((uint32_t)value << 16) | addr;
+					valid_entries[i] = ((u32)value << 16) | addr;
 					found = 1;
 					break;
 				}
 			}
 
 			// 如果是新的虚拟地址，添加到有效数据列表
-			if (!found && valid_count < (EEPROM_MAX_SIZE / sizeof(uint32_t))) {
+			if (!found && valid_count < (EEPROM_MAX_SIZE / SIZE_U32)) {
-				valid_entries[valid_count] = ((uint32_t)value << 16) | addr;
+				valid_entries[valid_count] = ((u32)value << 16) | addr;
 				valid_count++;
 			}
 		}
@@ -194,9 +180,9 @@ FlashEepromStatus FlashEEPROM::format() {
 	}
 
 	// 重新写入有效的数据项
-	for (uint16_t i = 0; i < valid_count; i++) {
+	for (u16 i = 0; i < valid_count; i++) {
-		fmc_status = fmc_word_program(
+		fmc_status = fmc_word_program(EEPROM_START_ADDRESS + i * SIZE_U32,
-			EEPROM_START_ADDRESS + i * sizeof(uint32_t), valid_entries[i]);
+									  valid_entries[i]);
 		if (fmc_status != FMC_READY) {
 			return FLASH_EEPROM_WRITE_ERROR;
 		}
@@ -211,7 +197,7 @@ FlashEepromStatus FlashEEPROM::format() {
  * @param ki 新的KI值
  * @param kd 新的KD值
  */
-void FlashEEPROM::update_pid_parameters(uint16_t kp, uint16_t ki, uint16_t kd) {
+void FlashEEPROM::update_pid_parameters(u16 kp, u16 ki, u16 kd) {
 	write(ADDR_MOTOR_KP, kp);
 	write(ADDR_MOTOR_KI, ki);
 	write(ADDR_MOTOR_KD, kd);
@@ -221,7 +207,7 @@ void FlashEEPROM::update_pid_parameters(uint16_t kp, uint16_t ki, uint16_t kd) {
  * @brief 更新系统配置并保存到Flash
  * @param config 新的系统配置值
  */
-void FlashEEPROM::update_system_config(uint16_t config) {
+void FlashEEPROM::update_system_config(u16 config) {
 	write(ADDR_SYSTEM_CONFIG, config);
 }
 
@@ -230,36 +216,27 @@ void FlashEEPROM::update_system_config(uint16_t config) {
  * @param angle 角度数据
  * @return FlashEepromStatus: 操作状态
  */
-FlashEepromStatus FlashEEPROM::save_angle(float angle,
+FlashEepromStatus FlashEEPROM::save_angle(u16 angle, bool saved) {
-										  bool saved) { // 解锁Flash
+	u16 angle_read = 0;
-	// 解锁Flash
+	FlashEepromStatus status = FLASH_EEPROM_ERROR;
-	fmc_unlock();
-
-	// 读取保存的参数
-	u16 angle2;
-
-	// 尝试从Flash读取参数，如果不存在则使用默认值
-	if (read(ADDR_ANGLE_DATA, &angle2) != FLASH_EEPROM_OK) {
-		angle = 0; // 默认值
-		std::printf("角度初始化为: %d\r\n", angle2);
-	} else {
-		std::printf("从Flash读取到角度数: %d\r\n", angle2);
-	}
 
 	// 读取保存的参数
 	if (!angle_saved) {
-		printf("saved_angle: %u\r\n", (u16)angle);
+		// 写入参数
-		FlashEepromStatus status = write(ADDR_ANGLE_DATA, (u16)angle);
+		status = write(ADDR_ANGLE_DATA, angle);
-		if (status == FLASH_EEPROM_OK) {
+
+		if (read(ADDR_ANGLE_DATA, &angle_read) != FLASH_EEPROM_OK)
+			angle_read = 0; // 读不到角度值，存储失败
+
+		if (angle_read != angle) {
+			status = FLASH_EEPROM_WRITE_ERROR;
+			CAN0_transmiter.EEPROMStatus = 1; // 设置EEPROM错误状态
+		} else {
 			angle_saved = saved;			  // 标记已保存过
 			CAN0_transmiter.EEPROMStatus = 0; // 设置EEPROM状态
-		} else {
-			CAN0_transmiter.EEPROMStatus = 1; // 设置EEPROM错误状态
 		}
-		CAN0_transmiter.testfloat_union.f = status; // CAN发送测试
-		return status;
 	}
-	return FLASH_EEPROM_OK; // 已保存过，直接返回
+	return status;
 }
 
 /**
@@ -268,17 +245,17 @@ FlashEepromStatus FlashEEPROM::save_angle(float angle,
  */
 float FlashEEPROM::read_angle() {
 	u16 angle = 0;
-	if (read(ADDR_ANGLE_DATA, &angle) == FLASH_EEPROM_OK) {
+	if (read(ADDR_ANGLE_DATA, &angle) != FLASH_EEPROM_OK) {
-		return (float)angle;
+		angle = 0;
 	}
-	return 0.0f; // 默认返回0度
+	return (float)angle; // 默认返回0度
 }
 
 /**
  * @brief 增加错误计数并保存到Flash
  */
 void FlashEEPROM::increment_error_count(void) {
-	uint16_t error_count = 0;
+	u16 error_count = 0;
 
 	// 读取当前错误计数
 	FlashEepromStatus read_status = read(ADDR_ERROR_COUNT, &error_count);
@@ -316,9 +293,9 @@ void flash_eeprom_example_main(void) {
 
 	// 再次读取参数验证保存是否成功
 	std::printf("\r\n--- 验证保存的数据 ---\r\n");
-	uint16_t kp_value, ki_value, kd_value;
+	u16 kp_value, ki_value, kd_value;
-	uint16_t system_config;
+	u16 system_config;
-	uint16_t error_count;
+	u16 error_count;
 
 	// if (flashEEP.read(ADDR_MOTOR_KP, &kp_value) == FLASH_EEPROM_OK) {
 	// 	std::printf("当前KP值: %d\r\n", kp_value);

Robot_V2/sys/flash.h

@@ -3,6 +3,9 @@
 
 #include "gd32c10x.h"
 #include <cstdint>
+#include <stdint.h>
+// 修改后 - 强制4字节对齐
+#define ALIGN_4BYTE(addr) ((addr) & 0xFFFFFFFC)  // 4字节对齐
 
 // EEPROM操作状态
 typedef enum {
@@ -11,13 +14,14 @@ typedef enum {
 	FLASH_EEPROM_NOT_FOUND,	   // 未找到指定数据
 	FLASH_EEPROM_INVALID_ADDR, // 无效地址
 	FLASH_EEPROM_WRITE_ERROR,  // 写入错误
-	FLASH_EEPROM_ERASE_ERROR   // 擦除错误
+	FLASH_EEPROM_ERASE_ERROR,   // 擦除错误
+	FLASH_EEPROM_ALIGNMENT_ERROR,// 对齐错误
 } FlashEepromStatus;
 
 // Flash EEPROM类
 class FlashEEPROM {
   public:
-  	// EEPROM emulation constants
+	// EEPROM emulation constants
 	static constexpr uint32_t EEPROM_START_ADDRESS =
 		0x0801F800; // Flash最后一页(2KB)
 	static constexpr uint32_t EEPROM_END_ADDRESS = 0x08020000; // Flash结束地址
@@ -32,7 +36,7 @@ class FlashEEPROM {
 	static constexpr uint16_t ADDR_ERROR_COUNT = 0x0030;   // 错误计数地址
 
 	// 角度数据存储地址
-	static constexpr u16 ADDR_ANGLE_DATA = 0x0021;
+	static constexpr u16 ADDR_ANGLE_DATA = 0x0013;
 	bool angle_saved = false;
 	// 构造函数
 	FlashEEPROM();
@@ -53,11 +57,10 @@ class FlashEEPROM {
 	void update_pid_parameters(uint16_t kp, uint16_t ki, uint16_t kd);
 	void update_system_config(uint16_t config);
 	void increment_error_count(void);
-	FlashEepromStatus save_angle(float angle,bool saved);
+	FlashEepromStatus save_angle(u16 angle, bool saved);
 	float read_angle();
 
   private:
-
 };
 
 void flash_eeprom_example_main(void);