Motor_v2/Robot_V2/sys/flash.cpp

#include "flash.h"
#include "DengFOC.h"
#include "ang_sensor.h"
#include "gd32c10x_crc.h"
#include "gd32c10x_fmc.h"
#include "math.h"
#include <Can.h>
#include <Filter.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <stdint.h>

FlashEEPROM flashEEP = FlashEEPROM();
extern angle_sensor KTH7823;
extern CAN_transmiter CAN0_transmiter;
extern FOC_Controlroller FOC; // FOC控制
constexpr u8 SIZE_U32 = sizeof(uint32_t);
constexpr u8 DEFAULT_VALUE = 0;
constexpr u8 NUM_SAVED = 5;

// FlashEEPROM类实现
FlashEEPROM::FlashEEPROM() {
	// 构造函数可以为空，或者做一些初始化工作
}

/**
 * @brief  初始化Flash EEPROM模拟
 * @param  None
 * @retval None
 */
u8 FlashEEPROM::init() {
	rcu_periph_clock_enable(RCU_CRC);
	// 使用硬件CRC计算校验值
	crc_deinit(); // 初始化CRC模块

	// 读取保存的参数
	u32 CRC_NUM = 0x0000;
	FlashEepromStatus status_read[NUM_SAVED] = {FLASH_EEPROM_OK};
	float angle = 0.0f;
	float data[NUM_SAVED - 1] = {0.0f, 0.0f, 0.0f, 0.0f};
	FlashEepromStatus status = FLASH_EEPROM_OK;
	if (readFloat(ADDR_ANGLE, &angle) != FLASH_EEPROM_OK) {
		angle = DEFAULT_VALUE; // 默认值
	}

	// 尝试从Flash读取参数，如果不存在则使用默认值
	status_read[1] = readFloat(ADDR_TARGET_ANGLE, &data[0]);
	status_read[2] = readFloat(ADDR_TARGET_VEL, &data[1]);
	status_read[3] = readFloat(ADDR_VOLTAGE_LIMIT, &data[2]);
	status_read[4] = readFloat(ADDR_CONTROL_MODE, &data[3]);

	// 读取失败则使用默认值
	for (u8 i = 1; i < NUM_SAVED; i++) {
		if (status_read[i] ==
			FLASH_EEPROM_DATA_NOT_FOUND) { // 首次读取，不保存报错
			data[i - 1] = DEFAULT_VALUE;
		} else if (status_read[i] != FLASH_EEPROM_OK) { // 其余错误，保存报错
			data[i - 1] = DEFAULT_VALUE;
			status_read[0] = status_read[i];
		}
	}

	if (status_read[0] == FLASH_EEPROM_OK) {
		u32 next_address = EEPROM_END_ADDRESS;
		// 遍历Flash页面寻找下一个可写入位置
		for (u32 address = EEPROM_START_ADDRESS - SIZE_U32;
			 address > FLASH_START_ADDRESS; address -= SIZE_U32) {

			// 安全读取Flash数据
			volatile u32 *flash_ptr = (volatile u32 *)address;
			u32 data_word = *flash_ptr;
			// 找到空位置
			if (data_word == 0xFFFFFFFF) {
				next_address = address + SIZE_U32;
				break;
			}
			// 更新下一个可能的写入位置（如果需要格式化）
			next_address = address - SIZE_U32;
		}

		crc_data_register_reset(); // 确保CRC计算从初始状态开始
		CRC_NUM = crc_block_data_calculate((uint32_t *)data, NUM_SAVED);
		// for (float &p : data) {
		// 	printf("%f\r\n", p);
		// }
		// printf("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 < NUM_SAVED; i++) {
				data[i] = DEFAULT_VALUE;
			}
			EEPROMStatus = FLASH_EEPROM_CRC_ERROR;
		} else { //  CRC正确
			EEPROMStatus = FLASH_EEPROM_OK;
		}
	} else {
		// 读取失败，报错
		EEPROMStatus = status_read[0];
	}

	KTH7823.angle_set(angle - KTH7823.update());
	FOC.target_angle = data[0];
	FOC.target_velocity = data[1];
	FOC.limit_voltage = data[2];
	FOC.control_mode = (u8)data[3];
	return 0;
}

/**
 * @brief  从Flash EEPROM读取数据
 * @param  virtualAddr: 虚拟地址
 * @param  data: 指向存储读取数据的指针
 * @retval FlashEepromStatus: 操作状态
 */
FlashEepromStatus FlashEEPROM::read(u8 virtualAddr, u16 *data) const {
	// 参数检查
	if (data == nullptr) {
		return FLASH_EEPROM_INVALID_ADDR;
	}

	// 从Flash末尾开始向前搜索，找到最新的数据
	for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
		 address >= EEPROM_START_ADDRESS; address -= SIZE_U32) {
		u32 data_word = *((u32 *)address);
		// 检查是否是有效数据（非擦除状态）
		if (data_word != 0xFFFFFFFF) {
			u8 addr = (u8)(data_word & 0xFF);
			// 找到匹配的虚拟地址
			if (addr == virtualAddr) {
				*data = (u16)((data_word >> 16) & 0xFFFF);
				return FLASH_EEPROM_OK;
			}
		}
	}
	return FLASH_EEPROM_DATA_NOT_FOUND;
}

/**
 * @brief  从Flash EEPROM读取float数据
 * @param  virtualAddr: 虚拟地址
 * @param  data: 指向存储读取数据的指针
 * @retval FlashEepromStatus: 操作状态
 */
FlashEepromStatus FlashEEPROM::readFloat(u8 virtualAddr, float *data) const {
	// 检查参数有效性
	if (data == nullptr) {
		return FLASH_EEPROM_INVALID_ADDR;
	}

	// 从Flash末尾开始向前搜索，找到最新的数据
	for (u32 address = EEPROM_END_ADDRESS - SIZE_U32;
		 address >= EEPROM_START_ADDRESS; address -= SIZE_U32) {
		u32 data_word = *((u32 *)address);
		// 检查是否是有效数据（非擦除状态）
		if (data_word != 0xFFFFFFFF) {
			u8 addr = (u8)(data_word & 0xFF);
			// 找到匹配的虚拟地址
			if (addr == virtualAddr) {
				u32 data_word_c = *((u32 *)address);
				// 清除最低的8位地址信息，保留高24位数据
				u32 float_data = data_word & 0xFFFFFF00;
				// 使用内存拷贝将处理后的数据解释为float
				memcpy(data, &float_data, sizeof(float));
				// printf("check:0x%x=%f\r\n", address, *data);
				return FLASH_EEPROM_OK;
			}
		}
	}
	// 未找到指定虚拟地址的数据
	return FLASH_EEPROM_DATA_NOT_FOUND;
}

/**
 * @brief  向Flash EEPROM写入数据
 * @param  virtualAddr: 虚拟地址
 * @param  data: 要写入的数据
 * @retval FlashEepromStatus: 操作状态
 */
FlashEepromStatus FlashEEPROM::write(u8 virtualAddr, u16 data) {
	// 查找下一个可写入的位置
	u32 next_address = EEPROM_START_ADDRESS;

	// 遍历Flash页面寻找下一个可写入位置
	for (u32 address = EEPROM_START_ADDRESS; address < EEPROM_END_ADDRESS;
		 address += SIZE_U32) {

		// 安全读取Flash数据
		volatile u32 *flash_ptr = (volatile u32 *)address;
		u32 data_word = *flash_ptr;
		// 找到空位置
		if (data_word == 0xFFFFFFFF) {
			next_address = address;
			break;
		}
		// 更新下一个可能的写入位置（如果需要格式化）
		next_address = address + SIZE_U32;
	}

	// 如果有足够空间，直接写入
	if (next_address < EEPROM_END_ADDRESS) {
		// 新格式: [addr:8bit][reserved:8bit][data:16bit]
		u32 data_word = ((u32)data << 16) | (u32)virtualAddr;

		// 使用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 {
		// 空间不足，需要格式化页面
		FlashEepromStatus status = format();
		if (status != FLASH_EEPROM_OK) {
			return status;
		}

		// 格式化后在页面开头写入数据
		// 新格式: [addr:8bit][reserved:8bit][data:16bit]
		u32 new_data_word = ((u32)data << 16) | (u32)virtualAddr;
		fmc_state_enum fmc_status =
			fmc_word_program(EEPROM_START_ADDRESS, new_data_word);

		if (fmc_status == FMC_READY)
			return FLASH_EEPROM_OK;
		if (fmc_status == FMC_PGAERR)
			return FLASH_EEPROM_ALIGNMENT_ERROR;
		else if (fmc_status != FMC_READY)
			return FLASH_EEPROM_WRITE_ERROR;
	}
	return FLASH_EEPROM_WRITE_ERROR;
}

/**
 * @brief  向Flash EEPROM写入float数据
 * @param  virtualAddr: 虚拟地址
 * @param  data: 要写入的数据
 * @retval FlashEepromStatus: 操作状态
 */
FlashEepromStatus FlashEEPROM::writeFloat(u8 virtualAddr, float data) {
	// 查找下一个可写入的位置
	u32 next_address = EEPROM_START_ADDRESS;

	// 遍历Flash页面寻找下一个可写入位置
	for (u32 address = EEPROM_START_ADDRESS; address < EEPROM_END_ADDRESS;
		 address += SIZE_U32) {

		// 安全读取Flash数据
		volatile u32 *flash_ptr = (volatile u32 *)address;
		u32 data_word = *flash_ptr;
		// 找到空位置
		if (data_word == 0xFFFFFFFF) {
			next_address = address;
			break;
		}
		// 更新下一个可能的写入位置（如果需要格式化）
		next_address = address + SIZE_U32;
	}

	// 如果有足够空间，直接写入
	if (next_address < EEPROM_END_ADDRESS) {
		u32 data_word;
		// 将完整的float数据复制到32位变量中
		memcpy(&data_word, &data, sizeof(float));
		// 插入虚拟地址到低8位
		data_word = (data_word & 0xFFFFFF00) | (u32)virtualAddr;

		// 使用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();

		// u32 data_word_c = *((u32 *)next_address);
		// float float_data = *((float *)&data_word_c);
		// printf("check:0x%x=%f\r\n", next_address, float_data);

		if (fmc_status != FMC_READY) {
			return FLASH_EEPROM_WRITE_ERROR;
		}
		return FLASH_EEPROM_OK;
	} else {
		// 空间不足，需要格式化页面
		FlashEepromStatus status = format();
		if (status != FLASH_EEPROM_OK) {
			return status;
		}

		// 格式化后在页面开头写入数据
		u32 data_word;
		// 将完整的float数据复制到32位变量中
		memcpy(&data_word, &data, sizeof(float));
		// 插入虚拟地址到低8位
		data_word = (data_word & 0xFFFFFF00) | (u32)virtualAddr;
		fmc_unlock();
		fmc_state_enum fmc_status =
			fmc_word_program(EEPROM_START_ADDRESS, data_word);
		fmc_lock();
		if (fmc_status == FMC_READY)
			return FLASH_EEPROM_OK;
		if (fmc_status == FMC_PGAERR)
			return FLASH_EEPROM_ALIGNMENT_ERROR;
		else if (fmc_status != FMC_READY)
			return FLASH_EEPROM_WRITE_ERROR;
	}
	return FLASH_EEPROM_WRITE_ERROR;
}

/**
 * @brief  格式化Flash EEPROM页面
 * @param  None
 * @retval FlashEepromStatus: 操作状态
 */
FlashEepromStatus FlashEEPROM::format() {
	fmc_state_enum fmc_status;

	// 创建临时缓冲区存储唯一地址的最新数据
	u32 valid_entries[EEPROM_MAX_SIZE / SIZE_U32];
	u16 valid_count = 0;

	// 收集有效的数据项（去重，保留最新的）
	for (u32 address = EEPROM_START_ADDRESS; address < EEPROM_END_ADDRESS;
		 address += SIZE_U32) {
		u32 data_word = *((u32 *)address);

		// 检查是否是有效数据项
		if (data_word != 0xFFFFFFFF) {
			u8 addr = (u8)(data_word & 0xFF);
			u32 value = (data_word & 0xFFFFFF00); // 保留高24位

			// 查找是否已经有相同虚拟地址的数据项
			uint8_t found = 0;
			for (u16 i = 0; i < valid_count; i++) {
				u8 existing_addr = (u8)(valid_entries[i] & 0xFF);
				if (existing_addr == addr) {
					// 更新为最新的数据
					valid_entries[i] = value | addr;
					found = 1;
					break;
				}
			}
			// 如果是新的虚拟地址/类型组合，添加到有效数据列表
			if (!found && valid_count < (EEPROM_MAX_SIZE / SIZE_U32)) {
				valid_entries[valid_count] =
					((u32)value << 16) | ((u32)value << 8) | addr;
				valid_count++;
			}
		}
	}
	fmc_unlock();
	// 擦除整个页面
	fmc_status = fmc_page_erase(EEPROM_START_ADDRESS);
	if (fmc_status != FMC_READY) {
		return FLASH_EEPROM_ERASE_ERROR;
	}
	// 重新写入有效的数据项
	for (u16 i = 0; i < valid_count; i++) {
		fmc_status = fmc_word_program(EEPROM_START_ADDRESS + i * SIZE_U32,
									  valid_entries[i]);
		if (fmc_status != FMC_READY) {
			return FLASH_EEPROM_WRITE_ERROR;
		}
	}
	fmc_lock();

	return FLASH_EEPROM_OK;
}

/**
 * @brief 更新系统配置并保存到Flash
 * @param config 新的系统配置值
 */
FlashEepromStatus FlashEEPROM::save_system_config(bool saved) {
	u32 CRC_NUM = 0x0000;
	static u32 next_address;
	FlashEepromStatus status_save[NUM_SAVED - 1] = {FLASH_EEPROM_OK};
	float data[NUM_SAVED - 1] = {FOC.target_angle, FOC.target_velocity,
								 FOC.limit_voltage, (float)FOC.control_mode};

	// 读取保存的参数
	if (!system_config_saved) {
		// 写入参数
		status_save[0] = writeFloat(ADDR_TARGET_ANGLE, data[0]);
		status_save[1] = writeFloat(ADDR_TARGET_VEL, data[1]);
		status_save[2] = writeFloat(ADDR_VOLTAGE_LIMIT, data[2]);
		status_save[3] = writeFloat(ADDR_CONTROL_MODE, data[3]);
		for (FlashEepromStatus &p : status_save) {
			if (p != FLASH_EEPROM_OK) {
				EEPROMStatus = p;
				return p;
			}
		}

		crc_data_register_reset(); // 确保CRC计算从初始状态开始
		CRC_NUM = crc_block_data_calculate((uint32_t *)data, NUM_SAVED);

		// 遍历Flash页面寻找下一个可写入位置
		for (u32 address = EEPROM_START_ADDRESS - SIZE_U32;
			 address > FLASH_START_ADDRESS; address -= SIZE_U32) {
			// 安全读取Flash数据
			volatile u32 *flash_ptr = (volatile u32 *)address;
			u32 data_word = *flash_ptr;
			// 找到空位置
			if (data_word == 0xFFFFFFFF) {
				next_address = address;
				break;
			}
			// 更新下一个可能的写入位置（如果需要格式化）
			next_address = address - SIZE_U32;
		}
		// 如果有足够空间，直接写入
		if (next_address > FLASH_START_ADDRESS) {
			fmc_unlock();
			fmc_flag_clear(FMC_FLAG_PGERR | FMC_FLAG_PGAERR | FMC_FLAG_WPERR);
			fmc_state_enum fmc_status = fmc_word_program(next_address, CRC_NUM);
			// printf("write address:0x%X,status:0x%x \r\n", next_address,
			// 	   fmc_status);
			fmc_lock();
			// for (float &p : data) {
			// 	printf("%f\r\n", p);
			// }
			// printf("CRC cmp1,0x%X_0x%x \r\n", CRC_NUM, *((u32
			// *)next_address));
		} else {
			printf("no enough space\r\n");
			// 空间不足，需要格式化页面
			FlashEepromStatus status = format();
			if (status != FLASH_EEPROM_OK) {
				return status;
			}
			// 格式化后在页面底部写入数据
			fmc_unlock();
			fmc_flag_clear(FMC_FLAG_PGERR | FMC_FLAG_PGAERR | FMC_FLAG_WPERR);
			fmc_state_enum fmc_status =
				fmc_word_program(EEPROM_END_ADDRESS - SIZE_U32, CRC_NUM);
			fmc_lock();
			if (fmc_status == FMC_READY)
				return FLASH_EEPROM_OK;
			if (fmc_status == FMC_PGAERR)
				return FLASH_EEPROM_ALIGNMENT_ERROR;
			else if (fmc_status != FMC_READY)
				return FLASH_EEPROM_WRITE_ERROR;
		}
		if (CRC_NUM == *((u32 *)next_address)) {
			system_config_saved = saved;	// 标记已保存过
			EEPROMStatus = FLASH_EEPROM_OK; // 设置EEPROM状态
		} else {
			EEPROMStatus = FLASH_EEPROM_CRC_ERROR; // 设置EEPROM错误状态
			return FLASH_EEPROM_CRC_ERROR;
		}
	}
	EEPROMStatus = FLASH_EEPROM_OK;
	return FLASH_EEPROM_OK;
}

/**
 * @brief 保存角度数据到Flash
 * @param angle 角度数据
 * @return FlashEepromStatus: 操作状态
 */
FlashEepromStatus FlashEEPROM::save_angle(bool saved) {
	float angle_read = DEFAULT_VALUE;
	float angle = FOC.rt_angle;
	FlashEepromStatus status = FLASH_EEPROM_OK;

	// 读取保存的参数
	if (!angle_saved) {
		// 写入参数
		status = writeFloat(ADDR_ANGLE, angle);
		if (status != FLASH_EEPROM_OK) {
			EEPROMStatus = status;
			return status;
		}

		if (readFloat(ADDR_ANGLE, &angle_read) != FLASH_EEPROM_OK)
			angle_read = DEFAULT_VALUE; // 读不到角度值，存储失败

		if (fabsf(angle_read - angle) > 0.01 * fabs(angle)) {
			EEPROMStatus = FLASH_EEPROM_WRITE_ERROR; // 设置EEPROM错误状态
			return FLASH_EEPROM_WRITE_ERROR;
		} else {
			angle_saved = saved;			// 标记已保存过
			EEPROMStatus = FLASH_EEPROM_OK; // 设置EEPROM状态
		}
	}
	return FLASH_EEPROM_OK;
}

/**
 * @brief 读取角度数据从Flash
 * @return float: 角度数据
 */
float FlashEEPROM::read_angle() {
	float angle = DEFAULT_VALUE;
	if (readFloat(ADDR_ANGLE, &angle) != FLASH_EEPROM_OK) {
		angle = DEFAULT_VALUE;
	}
	return angle;
}