// 状态码
typedef enum
{
FLASH_OK = 0,
FLASH_ERR_INVALID_PARAM,
FLASH_ERR_ADDR_OUT_OF_RANGE,
FLASH_ERR_WRITE_FAILURE,
FLASH_ERR_MEM_ALLOC
} flash_status_t;
#define FLASH_PAGE_SIZE AM_HAL_FLASH_PAGE_SIZE //每页大小为8K字节，
#define FLASH_INSTANCE_SIZE AM_HAL_FLASH_INSTANCE_SIZE //每个实例512K，2个实例一共1M用作用户存储
#define FLASH_TOTAL_SIZE (2 * FLASH_INSTANCE_SIZE - 1) //2个实例一共1M用作用户存储
#define START_PAGE_ADDRESS (0x80000) //(AM_HAL_FLASH_INSTANCE_SIZE)
#define WEAR_LEVELING_PAGE_NUM 20 // 磨损均衡页数(20页)
#define WEAR_LEVELING_END_ADDR (START_PAGE_ADDRESS + WEAR_LEVELING_PAGE_NUM * FLASH_PAGE_SIZE - 1) // 结束地址
#define RECORD_BUF_SIZE 510
typedef struct
{
uint8_t frame_num; //
uint8_t temp[4];
uint8_t buffer[RECORD_BUF_SIZE]; //
uint8_t crc; //异哉较验
}__attribute__((aligned(4)))flash_record_t;
#include <stdlib.h>
#include <stdbool.h>
#include "am_mcu_apollo.h"
#include "am_bsp.h"
#include "am_util.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "dev_flash.h"
QueueHandle_t xFlashQueue = NULL;
flash_record_t flash_record;
static uint32_t ui32Source[512];
/******************************************************************************
* @brief 带自动对齐的Flash写入函数
* @param pDest 目标Flash地址（需在已擦除区域）
* @param pSrc 源数据指针
* @param ui32DataLen 数据实际长度（字节）
* @return flash_status_t 操作状态码
*****************************************************************************///
flash_status_t flash_flex_write(uint32_t ui32DestAddr, uint8_t *pData, uint32_t ui32DataLen)
{
uint16_t i, WordCount = 0;
// 参数基础校验
if ((ui32DataLen == 0) || (ui32DestAddr >= (FLASH_TOTAL_SIZE - 1)))
{
am_util_debug_printf("write option error...\n");
return FLASH_ERR_INVALID_PARAM;
}
// 计算需要填充的字节数（对齐到4字节）
uint32_t ui32Padding = (4 - (ui32DataLen % 4)) % 4; //和__attribute__((aligned(4)))定义功能一样，二者用其一即可
uint32_t ui32TotalLen = ui32DataLen + ui32Padding;
am_util_stdio_printf("TotalLen: %d Padding = %d\n", ui32TotalLen, ui32Padding);
// 检查地址范围
if ((ui32DestAddr + ui32TotalLen) > (FLASH_TOTAL_SIZE - 1))
{
am_util_debug_printf("write addr exceed...\n");
return FLASH_ERR_ADDR_OUT_OF_RANGE;
}
WordCount = ui32TotalLen / 4;
// 将每 4 个字节复制到 uint32_t 缓冲区
for (i = 0; i < WordCount; i++)
{
memcpy(&ui32Source[i], (pData + i * 4), 4);
}
// 执行Flash编程
int32_t i32Ret = am_hal_flash_program_main(
AM_HAL_FLASH_PROGRAM_KEY,
ui32Source,
(uint32_t*)ui32DestAddr,
WordCount);
am_util_stdio_printf("ui32WordCount: %d OK:%d \n", WordCount, i32Ret);
return (i32Ret == 0) ? FLASH_OK : FLASH_ERR_WRITE_FAILURE;
}
/*******************************************************************************
* @brief 灵活读取Flash数据
* @param pDest 目标缓冲区指针
* @param ui32SrcAddr Flash源地址
* @param ui32DataLen 需要读取的实际数据长度
* @return flash_status_t 操作状态码
*******************************************************************************/
flash_status_t flash_flex_read(uint8_t *pData, uint32_t ui32SrcAddr, uint32_t ui32DataLen)
{
uint32_t ix;
// 参数基础校验
if ((ui32DataLen == 0) || (ui32SrcAddr >= (FLASH_TOTAL_SIZE - 1)))
{
am_util_debug_printf("read option error...\n");
return FLASH_ERR_INVALID_PARAM;
}
// 计算实际需要读取的字节数（包含填充）
uint32_t ui32TotalLen = ui32DataLen + ((4 - (ui32DataLen % 4)) % 4); //和__attribute__((aligned(4)))定义功能一样，二者用其一即可
// 检查地址范围
if ((ui32SrcAddr + ui32TotalLen) > (FLASH_TOTAL_SIZE - 1))
{
am_util_debug_printf("read addr exceed...\n");
return FLASH_ERR_ADDR_OUT_OF_RANGE;
}
am_util_stdio_printf("TotalLen: %d len = %d\n", ui32TotalLen, ui32DataLen);
for ( ix = 0; ix < ui32DataLen; ix++ )
{
*pData = *(uint32_t*)(ui32SrcAddr + ix);
pData++;
}
return FLASH_OK;
}
/*******************************************************************************
//Flash 擦除操作以页（Page）为单位，每个页的大小为固定值（如 8KB = 0x2000 字节）。
页起始地址必须是页大小的整数倍，例如：
第 0 页起始地址：0x0000
第 1 页起始地址：0x2000
第 2 页起始地址：0x4000
*******************************************************************************/
void write_system_config(void)
{
uint16_t i,k,vlength;
uint8_t *vPointer;
uint8_t vValue;
vValue = 0;
k = 0;
vlength = sizeof(flash_record_t);
vPointer = (uint8_t*)(&flash_record);
for(i = 0;i < (vlength-1);i++)
{
vValue = (vValue^(*vPointer)) + k;
k++;
vPointer++;
}
flash_record.crc = vValue;
am_util_stdio_printf("write: %d crc= %d\n", vlength, flash_record.crc);
// 先擦除目标页
uint32_t ui32PageAddr = START_PAGE_ADDRESS & ~(FLASH_PAGE_SIZE - 1); //计算给定地址所在的 Flash 页起始地址
am_hal_flash_page_erase(AM_HAL_FLASH_PROGRAM_KEY,
AM_HAL_FLASH_ADDR2INST(ui32PageAddr),
AM_HAL_FLASH_ADDR2PAGE(ui32PageAddr));
// 写入数据（自动处理对齐）
vValue = flash_flex_write(START_PAGE_ADDRESS, (uint8_t*)&flash_record, sizeof(flash_record_t));
am_util_stdio_printf("status: %d\n", vValue);
}
void read_system_config(void)
{
uint16_t i,k,vlength;
uint8_t *vPointer;
uint8_t vValue;
// 读取数据
flash_flex_read((uint8_t*)&flash_record, START_PAGE_ADDRESS, sizeof(flash_record_t));
// 验证数据
vValue = 0;
k = 0;
vlength = sizeof(flash_record_t);
vPointer = (uint8_t*)(&flash_record);
for(i = 0; i < (vlength -1); i++)
{
vValue = (vValue^(*vPointer)) + k;
k++;
vPointer++;
}
am_util_stdio_printf("vlength:%d check: %d crc= %d\n", vlength,vValue, flash_record.crc);
am_util_debug_printf("read:%s\n", (uint8_t*)(&flash_record));
if(vValue == flash_record.crc)
{
am_util_debug_printf("read flash option ok\r\n");
}
else
{
memset(&flash_record, 0x0, vlength);
am_util_debug_printf("read flash init\r\n");
flash_record.frame_num = '1';
flash_record.temp[0] = '2';
flash_record.temp[1] = '3';
flash_record.temp[2] = '4';
flash_record.temp[3] = '5';
for(i = 0; i < RECORD_BUF_SIZE; i++)
{
flash_record.buffer[i] = '0' + i;
}
write_system_config();
}
}
void init_flash(void)
{
int32_t i32ReturnCode;
uint32_t ui32PrgmAddr;
uint32_t *pui32Src;
uint32_t *pui32Dst;
int32_t ix;
ui32PrgmAddr = START_PAGE_ADDRESS;
//
// Erase the whole block of FLASH instance 1.
//
//am_util_stdio_printf(" ... erasing all of flash instance %d.\n", AM_HAL_FLASH_ADDR2INST(ui32PrgmAddr) );
//i32ReturnCode = am_hal_flash_mass_erase(AM_HAL_FLASH_PROGRAM_KEY, 1);
//
// Check for an error from the HAL.
//
if (i32ReturnCode)
{
am_util_stdio_printf("FLASH_MASS_ERASE i32ReturnCode = 0x%x.\n",
i32ReturnCode);
}
am_util_stdio_printf(" ... programming flash instance %d, page %d.\n",
AM_HAL_FLASH_ADDR2INST(ui32PrgmAddr),
AM_HAL_FLASH_ADDR2PAGE(ui32PrgmAddr) );
pui32Src = ui32Source;
for (ix = 0x100; ix < (0x100 + (512 * 4)); ix += 4)
{
*pui32Src++ = ix;
}
memset(ui32Source, 0x0, sizeof(ui32Source));
pui32Dst = (uint32_t *) ui32PrgmAddr;
i32ReturnCode = am_hal_flash_program_main(AM_HAL_FLASH_PROGRAM_KEY,
ui32Source,
pui32Dst,
512);
//
// Check for an error from the HAL.
//
if (i32ReturnCode)
{
am_util_stdio_printf("FLASH program page at 0x%08x "
"i32ReturnCode = 0x%x.\n",
ui32PrgmAddr,
i32ReturnCode);
}
//
// Check the page just programmed.
//
am_util_stdio_printf(" ... verifying the page just programmed.\n");
for ( ix = 0; ix < 512; ix++ )
{
if ( *(uint32_t*)(ui32PrgmAddr + (ix*4)) != ui32Source[ix] )
{
am_util_stdio_printf("ERROR: flash address 0x%08x did not program properly:\n"
" Expected value = 0x%08x, programmed value = 0x%08x.\n",
ui32PrgmAddr + (ix * 4),
ui32Source[ix],
*(uint32_t*)(ui32PrgmAddr + (ix * 4)) );
}
}
}
/*******************************************************************************
// 磨损均衡处理
//均衡写入分布：通过动态跳转写入地址，避免集中写入某一页。
//跨页处理：通过 ui32PageRemain 判断是否触发擦除下一页的操作。
//页起始地址对齐：s_ui32CurrentWriteAddr 必须是页大小的整数倍（如 0x4000, 0x8000）
//取模运算：得到当前地址相对于页起始地址的偏移量。
//例如：若 s_ui32CurrentWriteAddr = 0x8400，则偏移量 = 0x8400 % 0x2000 = 0x400。
*******************************************************************************/
static uint32_t s_ui32CurrentWriteAddr = START_PAGE_ADDRESS;
void flash_wear_leveling_write(uint8_t *pSrc, uint32_t ui32DataLen)
{
// 1. 检查当前页剩余空间
uint32_t ui32CurrentPageOffset = s_ui32CurrentWriteAddr - START_PAGE_ADDRESS;
uint32_t ui32PageRemain = FLASH_PAGE_SIZE - (ui32CurrentPageOffset % FLASH_PAGE_SIZE);
// 2. 若剩余空间不足，跳转到下一页
if (ui32DataLen > ui32PageRemain)
{
// 计算目标页地址
uint32_t ui32NextPageAddr = s_ui32CurrentWriteAddr + ui32PageRemain;
// 地址超出循环窗口时，回到基地址
if (ui32NextPageAddr > WEAR_LEVELING_END_ADDR)
{
ui32NextPageAddr = START_PAGE_ADDRESS;
}
// 3. 擦除目标页（需确保地址对齐到页起始）
uint32_t ui32PageToErase = AM_HAL_FLASH_ADDR2PAGE(ui32NextPageAddr);
am_util_stdio_printf("erase: 0x%08x Remain= 0x%08x %d\n", ui32PageToErase,ui32PageRemain, ui32NextPageAddr);
am_hal_flash_page_erase(AM_HAL_FLASH_PROGRAM_KEY,
AM_HAL_FLASH_ADDR2INST(ui32NextPageAddr),
ui32PageToErase);
// 更新写入地址到目标页起始
s_ui32CurrentWriteAddr = ui32NextPageAddr;
}
flash_flex_write(s_ui32CurrentWriteAddr, pSrc, ui32DataLen);
am_util_stdio_printf("Current: 0x%08x len= %d\n", s_ui32CurrentWriteAddr, ui32DataLen);
// 5. 更新写入地址
s_ui32CurrentWriteAddr += ui32DataLen;
if (s_ui32CurrentWriteAddr > WEAR_LEVELING_END_ADDR)
{
s_ui32CurrentWriteAddr = START_PAGE_ADDRESS + (s_ui32CurrentWriteAddr - WEAR_LEVELING_END_ADDR - 1);
}
}
void flash_test(void)
{
uint16_t i,vlength;
vlength = sizeof(flash_record_t);
memset(&flash_record, 0x0, vlength);
flash_record.frame_num = '1';
flash_record.temp[0] = '2';
flash_record.temp[1] = '3';
flash_record.temp[2] = '4';
flash_record.temp[3] = '5';
for(i = 0; i < 100; i++)
{
flash_wear_leveling_write((uint8_t*)&flash_record, vlength);
vTaskDelay(100 / portTICK_PERIOD_MS);
}
}
//更新FLASH数据
void flash_send_to_updata(uint8_t Type)
{
uint8_t data = Type;
xQueueSend(xFlashQueue,&data,0);
}
//*****************************************************************************
//
//initial setup for the flash task.
//
//*****************************************************************************
void flash_task_function (void * pvParameter)
{
char file_type = 0;
//
// Print a debug message.
am_util_debug_printf("Running flash tasks...\r\n");
//read_system_config();
//flash_test();
vTaskDelay(1000 / portTICK_PERIOD_MS);
xFlashQueue = xQueueCreate(5,1);
while (1)
{
if(xQueueReceive(xFlashQueue, &file_type, portMAX_DELAY)== pdPASS)
{
//write_system_config();
}
vTaskDelay(100 / portTICK_PERIOD_MS);
}
}
