527 lines
18 KiB
C
527 lines
18 KiB
C
/**
|
||
* @file meter_calculate_flash_impl.c
|
||
* @brief 充电订单与临时订单的 EEPROM + 外部 SPI Flash 持久化实现
|
||
*
|
||
* 功能说明：
|
||
* - 订单管理块 `S_CHG_ORDER_MNG` 存于 EEPROM（`EEPROM_ADDR_CHGRCD_MNG`）：头标志、已存条数、
|
||
* 环形槽当前位置、单调递增的 `u32_lastIndex`（对外唯一订单号）。
|
||
* - 订单正文 `S_LOG_DATA` 存于 Flash 区 `DATAFLASH_HIS_RECORD_ADDR` 起；单条布局为
|
||
* 1 字节 `RECORD_HEADER` + 数据 + 1 字节 CRC（`u16_crc_checksum` 低 8 位），按扇区擦除后顺序写入。
|
||
* - `u32_chg_order_save_record`：分配新 `u32_lastIndex`，按 `(lastIndex-1)%CHG_ORDER_MAX_CNT` 映射槽位并写 Flash。
|
||
* - `v_read_chg_order_record(index)`：用 `(index-1)%CHG_ORDER_MAX_CNT` 定位槽，并校验记录内 `u32_index` 与请求一致，防止覆盖残留。
|
||
* - `v_read_chg_order_by_position`：在未满/已满环形缓冲下，按“第几条历史”语义换算槽位。
|
||
* - 双枪临时订单：标志字节 + `S_LOG_DATA` 存于 EEPROM（`EEPROM_ADDR_A_LOG_DATA` / `B`），用于断电续传；清除时仅写无效标志以省擦写。
|
||
*
|
||
* 注意：`v_chg_order_clear_all` 仅复位管理元数据，不整片擦除 Flash（由后续写入覆盖）。
|
||
*/
|
||
|
||
#include "meter_calculate_flash_impl.h"
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include "mylog/mylog.h"
|
||
|
||
/* 动态内存抽象：默认使用 FreeRTOS 堆接口，可按需覆盖 */
|
||
#ifndef FLASH_MGR_MALLOC
|
||
#define FLASH_MGR_MALLOC(sz) pvPortMalloc((sz))
|
||
#endif
|
||
#ifndef FLASH_MGR_FREE
|
||
#define FLASH_MGR_FREE(ptr) vPortFree((ptr))
|
||
#endif
|
||
|
||
/* 模块内部全局变量 */
|
||
S_CHG_ORDER_MNG s_chgOrderMng;
|
||
|
||
/* 内部函数声明 */
|
||
static void v_write_chg_order_record(S_LOG_DATA *order_data, U16_T position);
|
||
static U8_T v_read_chg_order_record_internal(S_LOG_DATA *order_data, U16_T position);
|
||
|
||
/***************************************************************
|
||
* EEPROM管理函数
|
||
***************************************************************/
|
||
|
||
/**
|
||
* @brief 写入充电订单管理信息到EEPROM
|
||
*/
|
||
void v_write_eeprom_chgOrderMng(S_CHG_ORDER_MNG *chgOrderMng)
|
||
{
|
||
S_CHG_ORDER_MNG tempMng;
|
||
|
||
// 设置头标志
|
||
tempMng.u16_head = 0x5AA5;
|
||
tempMng.u16_chgOrderCnt = chgOrderMng->u16_chgOrderCnt;
|
||
tempMng.u16_currIndex = chgOrderMng->u16_currIndex;
|
||
tempMng.u32_lastIndex = chgOrderMng->u32_lastIndex;
|
||
|
||
// 写入EEPROM
|
||
eeprom_write(EEPROM_ADDR_CHGRCD_MNG, (U8_T *)&tempMng, sizeof(S_CHG_ORDER_MNG));
|
||
}
|
||
|
||
/**
|
||
* @brief 从EEPROM读取充电订单管理信息
|
||
*/
|
||
void v_read_eeprom_chgOrderMng(S_CHG_ORDER_MNG *chgOrderMng)
|
||
{
|
||
S_CHG_ORDER_MNG tempMng;
|
||
int i;
|
||
|
||
for (i = 0; i < 3; i++) {
|
||
// eeprom_read返回HAL_OK(0)表示成功，非0表示失败
|
||
if (eeprom_read(EEPROM_ADDR_CHGRCD_MNG, (U8_T *)&tempMng, sizeof(S_CHG_ORDER_MNG)) == HAL_OK) {
|
||
// 验证头标志
|
||
if (tempMng.u16_head == 0x5AA5) {
|
||
chgOrderMng->u16_head = 0x5AA5;
|
||
chgOrderMng->u16_chgOrderCnt = tempMng.u16_chgOrderCnt;
|
||
chgOrderMng->u16_currIndex = tempMng.u16_currIndex;
|
||
chgOrderMng->u32_lastIndex = tempMng.u32_lastIndex;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 读取失败或数据无效，初始化默认值
|
||
chgOrderMng->u16_head = 0x5AA5;
|
||
chgOrderMng->u16_chgOrderCnt = 0;
|
||
chgOrderMng->u16_currIndex = RECORD_ZERO_SAVE;
|
||
chgOrderMng->u32_lastIndex = 0;
|
||
}
|
||
|
||
/***************************************************************
|
||
* Flash记录读写函数（内部）
|
||
***************************************************************/
|
||
|
||
/**
|
||
* @brief 向Flash写充电订单记录（内部函数）
|
||
*
|
||
* @param order_data 充电订单数据指针
|
||
* @param position 循环缓冲区中的位置（1-N范围）
|
||
*/
|
||
static void v_write_chg_order_record(S_LOG_DATA *order_data, U16_T position)
|
||
{
|
||
U16_T u16_oneRcdSize = CHG_ORDER_RECORD_SIZE; // 一条记录大小（可能大于255）
|
||
U32_T u32_addr; // 存储地址
|
||
U16_T SectorIndex = 0; // 扇区偏移索引
|
||
U16_T SectorRcdIndex = 0; // 扇区内记录索引号
|
||
U16_T OneSectorRcdCnt = CHG_ORDER_PER_SECTOR_CNT; // 一个扇区内最多存储记录数
|
||
U32_T SectorAddr = 0; // 扇区地址
|
||
U16_T CurSectorRcdCnt = 0; // 当前扇区内应存放最大数目
|
||
|
||
// position参数范围是1-N，转换为0-N范围用于内部计算
|
||
U16_T internal_position = position - 1;
|
||
|
||
U8_T *tmpbuf = (U8_T *)FLASH_MGR_MALLOC(CHG_ORDER_FULL_RECORD_SIZE);
|
||
if (tmpbuf == NULL) {
|
||
return;
|
||
}
|
||
|
||
// 填充待存储数据缓存
|
||
tmpbuf[0] = RECORD_HEADER;
|
||
memcpy(tmpbuf + 1, order_data, u16_oneRcdSize); // 充电订单记录
|
||
|
||
// 计算并存储CRC
|
||
U16_T calculated_crc = u16_crc_checksum((U8_T *)order_data, u16_oneRcdSize);
|
||
tmpbuf[u16_oneRcdSize + 1] = (U8_T)calculated_crc; // 存储CRC低字节
|
||
|
||
#ifdef DEBUG_FLASH_WRITE
|
||
MYLOG_MSG(TASK_ID_Meterfee, "[DEBUG] Write to addr 0x%08X (position %u, internal %u):", u32_addr, position, internal_position);
|
||
MYLOG_MSG(TASK_ID_Meterfee, " Header: 0x%02X", tmpbuf[0]);
|
||
MYLOG_MSG(TASK_ID_Meterfee, " Calculated CRC: 0x%04X -> stored low byte: 0x%02X", calculated_crc, tmpbuf[u16_oneRcdSize + 1]);
|
||
#endif
|
||
|
||
// 确定存储位置（使用internal_position，范围0-N）
|
||
SectorIndex = internal_position / OneSectorRcdCnt;
|
||
SectorRcdIndex = internal_position % OneSectorRcdCnt;
|
||
SectorAddr = DATAFLASH_HIS_RECORD_ADDR + SectorIndex * SPI_SECTOR_SIZE;
|
||
|
||
// 如果是扇区内第一条记录，需要擦除整个扇区
|
||
if (SectorRcdIndex == 0) {
|
||
s32_flash_dataflash_erase_sector(SectorAddr);
|
||
|
||
// 如果记录数超过最大限制，需要调整计数
|
||
if (s_chgOrderMng.u16_chgOrderCnt > CHG_ORDER_MAX_CNT) {
|
||
// 如果待存储扇区为最后一个扇区
|
||
U16_T totalSectors = (CHG_ORDER_MAX_CNT + OneSectorRcdCnt - 1) / OneSectorRcdCnt;
|
||
if ((SectorIndex + 1) == totalSectors) {
|
||
CurSectorRcdCnt = CHG_ORDER_MAX_CNT % OneSectorRcdCnt;
|
||
if (CurSectorRcdCnt == 0) {
|
||
CurSectorRcdCnt = OneSectorRcdCnt;
|
||
}
|
||
} else {
|
||
CurSectorRcdCnt = OneSectorRcdCnt;
|
||
}
|
||
|
||
s_chgOrderMng.u16_chgOrderCnt = CHG_ORDER_MAX_CNT - CurSectorRcdCnt + 1;
|
||
}
|
||
}
|
||
|
||
// 计算具体地址并写入
|
||
u32_addr = SectorAddr + SectorRcdIndex * CHG_ORDER_FULL_RECORD_SIZE;
|
||
s32_flash_dataflash_write(u32_addr, tmpbuf, CHG_ORDER_FULL_RECORD_SIZE);
|
||
|
||
FLASH_MGR_FREE(tmpbuf);
|
||
}
|
||
|
||
/**
|
||
* @brief 从Flash读充电订单记录（内部函数）
|
||
*
|
||
* @param order_data 充电订单数据指针（用于存储读取到的数据）
|
||
* @param position 循环缓冲区中的位置（1-N范围）
|
||
* @return U8_T 读取结果：0-成功，1-失败
|
||
*/
|
||
static U8_T v_read_chg_order_record_internal(S_LOG_DATA *order_data, U16_T position)
|
||
{
|
||
U16_T u16_oneRcdSize = CHG_ORDER_RECORD_SIZE; // 一条记录大小（可能大于255）
|
||
U32_T u32_addr; // 读取地址
|
||
U16_T SectorIndex = 0; // 扇区偏移索引
|
||
U16_T SectorRcdIndex = 0; // 扇区内记录索引号
|
||
U16_T OneSectorRcdCnt = CHG_ORDER_PER_SECTOR_CNT; // 一个扇区内最多存储记录数
|
||
|
||
// position参数范围是1-N，转换为0-N范围用于内部计算
|
||
U16_T internal_position = position - 1;
|
||
|
||
U8_T *tmpbuf = (U8_T *)FLASH_MGR_MALLOC(CHG_ORDER_FULL_RECORD_SIZE);
|
||
if (tmpbuf == NULL) {
|
||
return 1;
|
||
}
|
||
|
||
// 确定读取位置（使用internal_position，范围0-N）
|
||
SectorIndex = internal_position / OneSectorRcdCnt;
|
||
SectorRcdIndex = internal_position % OneSectorRcdCnt;
|
||
u32_addr = DATAFLASH_HIS_RECORD_ADDR + SectorIndex * SPI_SECTOR_SIZE +
|
||
SectorRcdIndex * CHG_ORDER_FULL_RECORD_SIZE;
|
||
|
||
// 读取数据
|
||
s32_flash_dataflash_read(u32_addr, tmpbuf, CHG_ORDER_FULL_RECORD_SIZE);
|
||
|
||
// 调试信息：打印读取到的数据
|
||
#ifdef DEBUG_FLASH_READ
|
||
MYLOG_MSG(TASK_ID_Meterfee, "[DEBUG] Read from addr 0x%08X (position %u, internal %u):", u32_addr, position, internal_position);
|
||
MYLOG_MSG(TASK_ID_Meterfee, " Header: 0x%02X (expected: 0x%02X)", tmpbuf[0], RECORD_HEADER);
|
||
|
||
// 计算CRC
|
||
U16_T calculated_crc = u16_crc_checksum(tmpbuf + 1, u16_oneRcdSize);
|
||
U8_T stored_crc = tmpbuf[u16_oneRcdSize + 1];
|
||
MYLOG_MSG(TASK_ID_Meterfee, " Stored CRC: 0x%02X", stored_crc);
|
||
MYLOG_MSG(TASK_ID_Meterfee, " Calculated CRC: 0x%04X -> low byte: 0x%02X", calculated_crc, (U8_T)calculated_crc);
|
||
#endif
|
||
|
||
// 验证数据完整性
|
||
if ((tmpbuf[0] == RECORD_HEADER) &&
|
||
(tmpbuf[u16_oneRcdSize + 1] == (U8_T)u16_crc_checksum(tmpbuf + 1, u16_oneRcdSize))) {
|
||
#ifdef DEBUG_FLASH_READ
|
||
MYLOG_MSG(TASK_ID_Meterfee, "[DEBUG] v_read_chg_order_record_internal: data ok, memcpy dst=0x%08X, size=%u",
|
||
(U32_T)order_data, u16_oneRcdSize);
|
||
#endif
|
||
memcpy(order_data, tmpbuf + 1, u16_oneRcdSize);
|
||
FLASH_MGR_FREE(tmpbuf);
|
||
return 0;
|
||
}
|
||
|
||
#ifdef DEBUG_FLASH_READ
|
||
MYLOG_MSG(TASK_ID_Meterfee, "[DEBUG] CRC check failed!");
|
||
MYLOG_MSG(TASK_ID_Meterfee, " Header match: %s", (tmpbuf[0] == RECORD_HEADER) ? "YES" : "NO");
|
||
MYLOG_MSG(TASK_ID_Meterfee, " CRC match: %s", (tmpbuf[u16_oneRcdSize + 1] == (U8_T)u16_crc_checksum(tmpbuf + 1, u16_oneRcdSize)) ? "YES" : "NO");
|
||
#endif
|
||
|
||
FLASH_MGR_FREE(tmpbuf);
|
||
return 1;
|
||
}
|
||
|
||
/***************************************************************
|
||
* 公共接口函数实现
|
||
***************************************************************/
|
||
|
||
/**
|
||
* @brief 初始化充电订单Flash存储模块
|
||
*/
|
||
void v_chg_order_flash_init(void)
|
||
{
|
||
// 从EEPROM读取管理信息
|
||
v_read_eeprom_chgOrderMng(&s_chgOrderMng);
|
||
|
||
// 如果头标志无效，初始化默认值
|
||
if (s_chgOrderMng.u16_head != 0x5AA5)
|
||
{
|
||
s_chgOrderMng.u16_head = 0x5AA5;
|
||
s_chgOrderMng.u16_chgOrderCnt = 0;
|
||
s_chgOrderMng.u16_currIndex = RECORD_ZERO_SAVE;
|
||
s_chgOrderMng.u32_lastIndex = 0;
|
||
|
||
// 写入EEPROM
|
||
v_write_eeprom_chgOrderMng(&s_chgOrderMng);
|
||
}
|
||
|
||
// MYLOG_MSG(TASK_ID_Meterfee, "OrderMng: init ok, cnt=%u",
|
||
// s_chgOrderMng.u16_chgOrderCnt);
|
||
}
|
||
|
||
/**
|
||
* @brief 清除所有充电订单记录
|
||
*/
|
||
void v_chg_order_clear_all(void)
|
||
{
|
||
// 重置管理信息
|
||
s_chgOrderMng.u16_head = 0x5AA5;
|
||
s_chgOrderMng.u16_chgOrderCnt = 0;
|
||
s_chgOrderMng.u16_currIndex = RECORD_ZERO_SAVE;
|
||
s_chgOrderMng.u32_lastIndex = 0;
|
||
|
||
// 写入EEPROM
|
||
v_write_eeprom_chgOrderMng(&s_chgOrderMng);
|
||
|
||
// 注意：这里不清除Flash中的实际数据，因为Flash擦除成本高
|
||
// 实际数据会在后续写入时被覆盖
|
||
}
|
||
|
||
/**
|
||
* @brief 保存充电订单记录到Flash
|
||
*
|
||
* 新设计：索引号直接对应Flash物理位置
|
||
* 索引号 = u32_lastIndex + 1
|
||
* 存储位置 = (u32_lastIndex % CHG_ORDER_MAX_CNT)
|
||
* 注意：此函数会修改order_data中的u32_index字段
|
||
*/
|
||
U32_T u32_chg_order_save_record(S_LOG_DATA *order_data)
|
||
{
|
||
U32_T assignedIndex;
|
||
|
||
// 分配唯一递增索引
|
||
s_chgOrderMng.u32_lastIndex++;
|
||
assignedIndex = s_chgOrderMng.u32_lastIndex;
|
||
|
||
// 计算存储位置（基于索引号的循环缓冲区）
|
||
U16_T storagePosition = (s_chgOrderMng.u32_lastIndex - 1) % CHG_ORDER_MAX_CNT;
|
||
|
||
// 更新当前索引位置（存储0-N范围）
|
||
s_chgOrderMng.u16_currIndex = storagePosition;
|
||
|
||
// 记录条数递增（不超过最大限制）
|
||
if (s_chgOrderMng.u16_chgOrderCnt < CHG_ORDER_MAX_CNT) {
|
||
s_chgOrderMng.u16_chgOrderCnt++;
|
||
}
|
||
|
||
// 直接修改传入的订单数据，设置索引
|
||
order_data->u32_index = assignedIndex;
|
||
|
||
// 写入Flash记录，传递1-N范围的position
|
||
v_write_chg_order_record(order_data, storagePosition + 1);
|
||
|
||
// 更新管理信息到EEPROM
|
||
v_write_eeprom_chgOrderMng(&s_chgOrderMng);
|
||
|
||
return assignedIndex;
|
||
}
|
||
|
||
/**
|
||
* @brief 从Flash读取指定索引的充电订单记录
|
||
*
|
||
* 新设计：根据索引号直接计算存储位置，无需遍历查找
|
||
* 存储位置 = (index - 1) % CHG_ORDER_MAX_CNT
|
||
*/
|
||
U8_T v_read_chg_order_record(S_LOG_DATA *order_data, U32_T index)
|
||
{
|
||
// 检查索引号有效性
|
||
if (index == 0 || index > s_chgOrderMng.u32_lastIndex) {
|
||
return 1; // 索引号无效
|
||
}
|
||
|
||
// 如果没有记录，直接返回失败
|
||
if (s_chgOrderMng.u16_chgOrderCnt == 0) {
|
||
return 1;
|
||
}
|
||
|
||
|
||
// 计算存储位置（基于索引号的循环缓冲区）
|
||
U16_T storagePosition = (index - 1) % CHG_ORDER_MAX_CNT;
|
||
|
||
// 直接读取到传入的缓冲区，传递1-N范围的position
|
||
if (v_read_chg_order_record_internal(order_data, storagePosition + 1) == 0) {
|
||
// 检查索引是否匹配（防止数据被覆盖）
|
||
if (order_data->u32_index == index) {
|
||
return 0; // 成功
|
||
}
|
||
}
|
||
|
||
return 1; // 读取失败或索引不匹配
|
||
}
|
||
|
||
/**
|
||
* @brief 读取指定位置的充电订单记录（基于循环缓冲区位置）
|
||
*/
|
||
U8_T v_read_chg_order_by_position(S_LOG_DATA *order_data, U16_T position)
|
||
{
|
||
// 检查位置是否有效
|
||
if (position >= s_chgOrderMng.u16_chgOrderCnt) {
|
||
return 1;
|
||
}
|
||
|
||
// 计算实际Flash位置（考虑循环缓冲区）
|
||
U16_T actual_position;
|
||
if (s_chgOrderMng.u16_chgOrderCnt < CHG_ORDER_MAX_CNT) {
|
||
// 缓冲区未满，直接按顺序读取
|
||
actual_position = position;
|
||
} else {
|
||
// 缓冲区已满，需要计算循环位置
|
||
actual_position = (s_chgOrderMng.u16_currIndex + 1 + position) % CHG_ORDER_MAX_CNT;
|
||
}
|
||
|
||
// 传递1-N范围的position给内部函数
|
||
return v_read_chg_order_record_internal(order_data, actual_position + 1);
|
||
}
|
||
|
||
/**
|
||
* @brief 获取充电订单记录总数
|
||
*/
|
||
U16_T v_get_chg_order_count(void)
|
||
{
|
||
return s_chgOrderMng.u16_chgOrderCnt;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取当前索引位置
|
||
*/
|
||
U16_T v_get_chg_order_curr_index(void)
|
||
{
|
||
return s_chgOrderMng.u16_currIndex;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取最后分配的索引值
|
||
*/
|
||
U32_T v_get_chg_order_last_index(void)
|
||
{
|
||
return s_chgOrderMng.u32_lastIndex;
|
||
}
|
||
|
||
/***************************************************************
|
||
* EEPROM临时充电记录存储函数
|
||
***************************************************************/
|
||
|
||
/**
|
||
* @brief 获取指定枪号的EEPROM地址
|
||
*/
|
||
static U32_T v_get_eeprom_addr_for_gun(U8_T gunNo)
|
||
{
|
||
if (gunNo == 0) {
|
||
return EEPROM_ADDR_A_LOG_DATA;
|
||
} else {
|
||
return EEPROM_ADDR_B_LOG_DATA;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 保存临时充电记录到EEPROM（用于断电续传）
|
||
*/
|
||
U8_T v_save_temp_chg_record_to_eeprom(U8_T gunNo, const S_LOG_DATA *order_data, E_TEMP_CHG_FLAG flag)
|
||
{
|
||
U32_T eeprom_addr = v_get_eeprom_addr_for_gun(gunNo);
|
||
U8_T *buffer = NULL;
|
||
U8_T ret = 1;
|
||
|
||
// 检查参数有效性
|
||
if (order_data == NULL || flag >= TEMP_CHG_FLAG_INVALID) {
|
||
return 1;
|
||
}
|
||
|
||
// 动态分配内存
|
||
buffer = (U8_T *)FLASH_MGR_MALLOC(TEMP_CHG_RECORD_SIZE + 1);
|
||
if (buffer == NULL) {
|
||
return 1; // 内存分配失败
|
||
}
|
||
|
||
// 构建缓冲区：标志位 + 订单数据
|
||
buffer[0] = (U8_T)flag;
|
||
memcpy(buffer + 1, order_data, TEMP_CHG_RECORD_SIZE);
|
||
|
||
// 写入EEPROM，eeprom_write返回HAL_OK(0)表示成功
|
||
if (eeprom_write(eeprom_addr, buffer, TEMP_CHG_RECORD_SIZE + 1) == HAL_OK) {
|
||
ret = 0; // 成功
|
||
}
|
||
|
||
// 释放内存
|
||
FLASH_MGR_FREE(buffer);
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief 从EEPROM读取临时充电记录（用于断电续传恢复）
|
||
*/
|
||
U8_T v_read_temp_chg_record_from_eeprom(U8_T gunNo, S_LOG_DATA *order_data, E_TEMP_CHG_FLAG *flag)
|
||
{
|
||
U32_T eeprom_addr = v_get_eeprom_addr_for_gun(gunNo);
|
||
U8_T *buffer = NULL;
|
||
|
||
// 检查参数有效性
|
||
if (order_data == NULL) {
|
||
return 1;
|
||
}
|
||
|
||
// 动态分配内存
|
||
buffer = (U8_T *)FLASH_MGR_MALLOC(TEMP_CHG_RECORD_SIZE + 1);
|
||
if (buffer == NULL) {
|
||
return 1; // 内存分配失败
|
||
}
|
||
|
||
// 从EEPROM读取，eeprom_read返回HAL_OK(0)表示成功
|
||
if (eeprom_read(eeprom_addr, buffer, TEMP_CHG_RECORD_SIZE + 1) != HAL_OK) {
|
||
FLASH_MGR_FREE(buffer);
|
||
return 1; // 读取失败
|
||
}
|
||
|
||
// 检查标志位有效性
|
||
U8_T read_flag = buffer[0];
|
||
if (read_flag >= TEMP_CHG_FLAG_INVALID) {
|
||
FLASH_MGR_FREE(buffer);
|
||
return 1; // 无效标志位
|
||
}
|
||
|
||
// 返回标志位（如果提供了指针）
|
||
if (flag != NULL) {
|
||
*flag = (E_TEMP_CHG_FLAG)read_flag;
|
||
}
|
||
|
||
// 复制订单数据
|
||
memcpy(order_data, buffer + 1, TEMP_CHG_RECORD_SIZE);
|
||
|
||
// 释放内存
|
||
FLASH_MGR_FREE(buffer);
|
||
return 0; // 成功
|
||
}
|
||
|
||
/**
|
||
* @brief 清除EEPROM中的临时充电记录
|
||
*/
|
||
U8_T v_clear_temp_chg_record_in_eeprom(U8_T gunNo)
|
||
{
|
||
U32_T eeprom_addr = v_get_eeprom_addr_for_gun(gunNo);
|
||
U8_T invalid_flag = TEMP_CHG_FLAG_INVALID;
|
||
|
||
// 只写入无效标志位，不清除整个区域（节省EEPROM写寿命）
|
||
// eeprom_write返回HAL_OK(0)表示成功
|
||
if (eeprom_write(eeprom_addr, &invalid_flag, 1) == HAL_OK) {
|
||
return 0; // 成功
|
||
}
|
||
|
||
return 1; // 失败
|
||
}
|
||
|
||
/**
|
||
* @brief 检查EEPROM中是否有有效的临时充电记录
|
||
*/
|
||
U8_T v_check_temp_chg_record_valid(U8_T gunNo)
|
||
{
|
||
U32_T eeprom_addr = v_get_eeprom_addr_for_gun(gunNo);
|
||
U8_T flag_byte;
|
||
|
||
// 读取标志位，eeprom_read返回HAL_OK(0)表示成功
|
||
if (eeprom_read(eeprom_addr, &flag_byte, 1) != HAL_OK) {
|
||
return 0; // 读取失败，视为无效
|
||
}
|
||
|
||
// 检查标志位是否有效
|
||
if (flag_byte == TEMP_CHG_FLAG_UNSETTLED || flag_byte == TEMP_CHG_FLAG_SETTLED) {
|
||
return 1; // 有有效记录
|
||
}
|
||
|
||
return 0; // 无效记录
|
||
}
|