赞
踩
#FLASH平衡擦写#
简易示意图如下:
写参数前要擦除对应的扇区 全为0XFFFFFFFF操作的最小单位为32位 uint32_t; 当一块扇区写完时,将所有有用参数复制到第二块扇区,开始写新的参数,如果所有参数写完,又重第一块参数开始写,这样就能实现平衡写的目的,所以要实现这个功能,至少需要分配2个扇区实现均衡擦写。
- /* 储存扇区信息的结构体 */
- struct SSCT_HDR
- {
-
- uint32_t st; // 状态
- uint32_t cnt; // 标号
- uint32_t version; // 版本
- }; // 扇区HEAD结构
-
-
- typedef struct
- {
- uint16_t len:16;
- uint16_t alen:16;
- /* data */
- }VARLEN;
- struct VAR_ST //Flash数据存储结构
- {
- uint32_t status; //数据当前状态
- uint32_t key; //数据key
- union
- {
- uint32_t len; //数据长度 len +alen 数据实际长度+所在内存长度 内存长度必须是4的整数倍
- VARLEN len_b;
- /* data */
- };
-
- };
扇区1 |
|
-
- #include <stdbool.h>
- #include <stdint.h> //引用框架配置文件
-
- #define MAX_CVAR_NUM (200) //数据存储最大个数
-
-
-
- typedef struct
- {
- uint16_t len:16;
- uint16_t alen:16;
- /* data */
- }VARLEN;
- struct VAR_ST //Flash数据存储结构
- {
- uint32_t status; //数据当前状态
- uint32_t key; //数据key
- union
- {
- uint32_t len; //数据长度 len +alen 数据实际长度+所在内存长度 内存长度必须是4的整数倍
- VARLEN len_b;
- /* data */
- };
-
- };
-
-
-
- struct SFVAR_POINT
- {
- uint32_t key; //数据key
- uint8_t* flashAddr; //数据地址
- };
-
- typedef struct
- {
- uint8_t* sectorBaseAdr;
- uint32_t sectorSize;
- uint8_t sectorNum;
-
- void (*FlashInit_Cbk)(void); // Flash初始化函数
- bool (*FlashErase_Cbk)(uint8_t* addr, uint32_t size); // Flash擦除函数
- uint32_t (*FlashWrite_Cbk)(void* addr, const void* buf, uint32_t size); // Flash写入函数
- uint32_t (*FlashRead_Cbk)(void* addr, void* buf, uint32_t size); /// flash读函数
-
-
- // private
- struct
- {
- uint32_t makeTime;
- uint8_t* sectorUseBaseAdr; // flash 参数存储区基地址
- uint8_t sectorUseCnt; // Flash 所有的序号
- uint32_t varNum; // Flash存储数据个数
- uint32_t tail; // Flash当前地址
- uint32_t head; // 有效头部位置
- uint8_t swSctFlag; //扇区切换flag
- uint8_t* rmAdr; //需要删除的 地址
-
- struct VAR_ST pCVar; //单个参数的头部结构
-
- struct SFVAR_POINT varList[MAX_CVAR_NUM]; //数据Z指针数组
-
- } pri;
-
-
- }FlashPar_Prop;
-
- typedef struct
- {
- void (* const Create)(FlashPar_Prop* self); // FlashVar
-
- void (*Init)(FlashPar_Prop* self,
- uint32_t makeTime,
- uint8_t* sectorBaseAdr, // FLASH基地址
- uint32_t sectorSize, // flash大小
- uint32_t sectorNum, // flash块的个数
- void (*FlashInit_Cbk)(void), // flash初始化函数
- bool (*FlashErase_Cbk)(uint8_t* addr, uint32_t size), // flash擦除函数
- uint32_t (*FlashWrite_Cbk)(void* addr, const void* buf, uint32_t size), // flash写入函数
- uint32_t (*FlashRead_Cbk)(void* addr, void* buf, uint32_t size) // flash读函数
- );
-
- // API
- uint32_t (*RdPar)(FlashPar_Prop* self, uint32_t key, uint8_t* pRdBuf, uint32_t bufLen); ///数据读取函数
- MOBJ_BOOL (*WtPar)(FlashPar_Prop* self, uint32_t key, uint8_t* pWtDat, uint32_t datLen); //数据写入函数
- MOBJ_BOOL (*DelPar)(FlashPar_Prop* self, uint32_t key); //数据删除函数
-
-
- }FlashPar_Func;
-
- extern const FlashPar_Func FlashPar;
-
-
- #include "MFlashVar.h"
- #include "string.h"
- #include "MTime.h"
- /* 扇区使用情况 表示各个扇区状态*/
-
- #define SSCT_UNUSE (0xFFFFFFFF) // 未使用
- #define SSCT_USE (0xBBBBBBBB) // 使用中
- #define SSCT_DEL (0x00000000) // 删除状状态
-
-
- /* 某区域保存参数的状态 */
-
- #define SCVAR_UNUSE (0xFFFFFFFF) // 未使用
- #define SCVAR_USE (0xAAAAAAAA) // 使用中
- #define SCVAR_DEL (0x00000000) // 删除状状态
- // 表示各个数据状态
-
- /* 储存扇区信息的结构体 */
- struct SSCT_HDR
- {
-
- uint32_t st; // 状态
- uint32_t cnt; // 标号
- uint32_t version; // 版本
-
- }; // 扇区HEAD结构
-
- static int32_t FindVarAddr(FlashPar_Prop *self, uint32_t key);
- static uint32_t AllocVar(FlashPar_Prop *self, uint32_t len, uint32_t key);
- static void DelVar(FlashPar_Prop *self, uint8_t *addr);
- static void PrgVar(FlashPar_Prop *self, void *flashAddr, uint32_t key, uint8_t *pWtDat, uint32_t dataLen);
- static void LoadSector(FlashPar_Prop *self);
- static void LoadFVar(FlashPar_Prop *self);
- static void SwitchSct(FlashPar_Prop *self);
-
- /**
- * @brief FlashPar
- *
- */
- static void FlashPar_Init(FlashPar_Prop *self,
- uint32_t makeTime,
- uint8_t *sectorBaseAdr,
- uint32_t sectorSize,
- uint32_t sectorNum,
- void (*FlashInit_Cbk)(void),
- bool (*FlashErase_Cbk)(uint8_t *addr, uint32_t size),
- uint32_t (*FlashWrite_Cbk)(void *addr, const void *buf, uint32_t size),
- uint32_t (*FlashRead_Cbk)(void *addr, void *buf, uint32_t size) // flash读函数
- )
- {
- self->pri.varNum = 0;
- self->sectorBaseAdr = sectorBaseAdr;
- self->sectorSize = sectorSize;
- self->sectorNum = sectorNum;
- self->pri.makeTime = makeTime;
- self->FlashInit_Cbk = FlashInit_Cbk;
- self->FlashErase_Cbk = FlashErase_Cbk;
- self->FlashWrite_Cbk = FlashWrite_Cbk;
- self->FlashRead_Cbk = FlashRead_Cbk;
-
- // step1: load useing sector
- LoadSector(self);
-
- // step2 : load flash variable
- LoadFVar(self);
-
- }
-
- /**
- * @brief 申请地址并检查剩余地址是否足够
- *
- */
- static uint32_t AllocVar(FlashPar_Prop *self, uint32_t len, uint32_t key)
- {
- uint32_t pFVarAddress;
- uint8_t tmp, actLen;
- uint16_t index;
-
- /******step1 :Caculate the actual space***/
- tmp = len % 4;
- if (tmp != 0)
- actLen = sizeof(struct VAR_ST) + len + (4 - tmp);
- else
- actLen = sizeof(struct VAR_ST) + len;
-
- /*step2: check current sector has enough sapace*/
- if (self->pri.tail + actLen >= self->sectorSize)
- {
- SwitchSct(self);
- index = FindVarAddr(self, key);
- self->pri.rmAdr = self->pri.varList[index].flashAddr;
- }
- else {}
-
- /*step3: current sector has enough sapace*/
- if (self->pri.tail + actLen < self->sectorSize)
- {
- pFVarAddress = (uint32_t)(self->pri.sectorUseBaseAdr + self->pri.tail);
- self->pri.tail += actLen;
- }
- else
- {
- pFVarAddress = 0;
- }
-
- return pFVarAddress;
- }
- /**
- * @brief 删除原有变量函数
- *
- */
- static void DelVar(FlashPar_Prop *self, uint8_t *addr)
- {
- uint32_t st;
- st = SCVAR_DEL;
- self->FlashWrite_Cbk(addr, &st, sizeof(st));
- }
- /**
- * @brief 写入参数
- *
- */
- static void PrgVar(FlashPar_Prop *self, void *flashAddr, uint32_t key, uint8_t *pWtDat, uint32_t dataLen)
- {
- struct VAR_ST tmpVar;
- uint32_t tmp;
- uint32_t dtActLen;
-
- uint8_t *pHead = (uint8_t *)flashAddr;
- uint8_t *pData = (uint8_t *)flashAddr + sizeof(struct VAR_ST);
- tmp = dataLen % 4;
-
- if (tmp != 0)
- dtActLen = dataLen + (4 - tmp);
- else
- dtActLen = dataLen;
-
- tmpVar.status = SCVAR_USE;
- tmpVar.key = key;
- tmpVar.len_b.len = dataLen;
- tmpVar.len_b.alen = dtActLen;
-
- self->FlashWrite_Cbk(pHead, (uint8_t *)&tmpVar, sizeof(struct VAR_ST));
- self->FlashWrite_Cbk(pData, pWtDat, dtActLen);
-
- }
-
-
- /**
- * @brief 根据关键字查询变量
- *
- */
- static uint32_t FlashPar_RdPar(FlashPar_Prop *self, uint32_t key, uint8_t *pRdBuf, uint32_t bufLen)
- {
- struct VAR_ST pFVar;
- uint32_t ret = 0;
- uint8_t *pData;
- uint32_t len;
- int32_t index;
- // find var in ram
- index = FindVarAddr(self, key);
- if (index < 0)
- {
- return ret;
- }
- self->FlashRead_Cbk(self->pri.varList[index].flashAddr, &pFVar, sizeof(struct VAR_ST));
-
- len = pFVar.len_b.len;
- if (bufLen < len)
- {
- len = bufLen;
- }
-
- pData = self->pri.varList[index].flashAddr + sizeof(struct VAR_ST);
- self->FlashRead_Cbk(pData, pRdBuf, len);
- ret = len;
- return ret;
- }
- /* 根据KEY 删除一个参数 */
- static MOBJ_BOOL FlashPar_DelPar(FlashPar_Prop *self, uint32_t key)
- {
- uint8_t *pFVar;
- int32_t index;
- uint32_t MvDataNum;
-
- // find var in ram
- index = FindVarAddr(self, key);
-
- if (index < 0)
- {
- return NOT;
- }
-
- pFVar = self->pri.varList[index].flashAddr;
-
- MvDataNum = self->pri.varNum - (index + 1);
- while (MvDataNum--)
- {
- self->pri.varList[index].flashAddr = self->pri.varList[index + 1].flashAddr;
- self->pri.varList[index].key = self->pri.varList[index + 1].key;
- index++;
- }
- self->pri.varList[index].flashAddr = 0;
- self->pri.varList[index].key = 0;
- self->pri.varNum--;
- DelVar(self, pFVar);
-
- return YES;
- }
-
- /**
- * @brief 根据key保存一个参数
- *
- */
- static MOBJ_BOOL FlashPar_WtPar(FlashPar_Prop *self, uint32_t key, uint8_t *pWtDat, uint32_t datLen)
- {
- uint8_t *pNewVar;
-
- uint8_t tempdata[258] = {0};
- struct VAR_ST pOldVar;
- int32_t index;
-
- MOBJ_BOOL ret;
- if (datLen > 256)
- {
- }
- /******step1 :find old var ***/
- index = FindVarAddr(self, key);
-
- /******step2 :wite new var*/
- if (index < 0) // step2.1 old var not exist
- {
- if (self->pri.varNum >= MAX_CVAR_NUM) // check number
- {
- ret = NOT;
- }
- else if (0 == (pNewVar = (uint8_t *)AllocVar(self, datLen, key))) // alloc space
- {
- ret = NOT;
- }
- else
- {
- PrgVar(self, pNewVar, key, pWtDat, datLen);
-
- self->pri.varList[self->pri.varNum].key = key;
-
- self->pri.varList[self->pri.varNum].flashAddr = pNewVar;
-
- self->pri.varNum++;
-
- ret = YES;
- }
- }
- else // step2.2 old var exist
- {
- self->pri.rmAdr = self->pri.varList[index].flashAddr;
- self->FlashRead_Cbk(self->pri.rmAdr, &pOldVar, sizeof(struct VAR_ST));
- if (pOldVar.key == key)
- {
- self->FlashRead_Cbk(self->pri.rmAdr + sizeof(struct VAR_ST), tempdata, pOldVar.len_b.len);
- if ((pOldVar.len_b.len== datLen) && (0 == memcmp(tempdata, pWtDat, datLen)))
- {
- ret = YES;
- }
- else
- {
- pNewVar = (uint8_t *)AllocVar(self, datLen, key);
- if (0 == pNewVar) // alloc space
- {
- // EINT;
- ret = NOT;
- }
- else
- {
- PrgVar(self, pNewVar, key, pWtDat, datLen); // write new var
- DelVar(self, self->pri.rmAdr); // 完全删除
-
- ret = YES;
- }
- self->pri.varList[index].flashAddr = pNewVar;
- }
- }
- }
-
- return ret;
- }
- static int32_t FindVarAddr(FlashPar_Prop *self, uint32_t key)
- {
- int32_t i;
- for (i = 0; i < self->pri.varNum; i++)
- {
- if (self->pri.varList[i].key == key)
- return i;
- }
-
- return -1;
- }
-
- /**
- * @brief 加载各个扇区的状态信息
- *
- */
- static void LoadSector(FlashPar_Prop *self)
- {
- int32_t i;
- int32_t maxSctCnt = 0;
- uint8_t *useadd = 0;
- struct SSCT_HDR pSctHdr, newSctHdr;
-
- // step1 : find using sector
- for (i = 0; i < self->sectorNum; i++)
- {
- useadd = self->sectorBaseAdr + i * self->sectorSize;
- self->FlashRead_Cbk(useadd, &pSctHdr, sizeof(struct SSCT_HDR));
-
- // check the version,
- if ((pSctHdr.version != 0xFFFFFFFF) && (pSctHdr.version != self->pri.makeTime))
- {
- self->FlashErase_Cbk(useadd, self->sectorSize);
- }
- else
- {
- switch (pSctHdr.st)
- {
- case SSCT_UNUSE: {
- break;
- }
- case SSCT_USE: {
- if (pSctHdr.cnt >= maxSctCnt)
- {
- self->pri.sectorUseBaseAdr = useadd;
- self->pri.sectorUseCnt = i;
- maxSctCnt = pSctHdr.cnt;
- }
- break;
- }
- case SSCT_DEL: {
- break;
- }
- }
- }
- }
-
- // step2 : if don't find using sector them set sector0 is used
- if (maxSctCnt == 0)
- {
- self->pri.sectorUseBaseAdr = self->sectorBaseAdr;
- self->pri.sectorUseCnt = 0;
- self->FlashErase_Cbk(self->pri.sectorUseBaseAdr, self->sectorSize); // 擦除 实际地址需
- newSctHdr.st = SSCT_USE;
- newSctHdr.cnt = 1;
- newSctHdr.version = self->pri.makeTime;
- self->FlashWrite_Cbk(self->pri.sectorUseBaseAdr, (uint8_t *)&newSctHdr, sizeof(struct SSCT_HDR));
- }
- self->pri.tail = sizeof(struct SSCT_HDR);
- }
- /**
- * @brief 加载flash 区的参数信息
- *
- */
- static void LoadFVar(FlashPar_Prop *self)
- {
- uint8_t rFlag = 1;
- struct VAR_ST *pErrVar = 0;
- struct VAR_ST nowVar;
- uint32_t errNo = 0;
- uint8_t *pFVarAddress = 0;
- // uint8_t* pFVarAddress = 0;
- while ((self->pri.tail < self->sectorSize) && rFlag)
- {
- pFVarAddress = self->pri.sectorUseBaseAdr + self->pri.tail;
- self->FlashRead_Cbk(pFVarAddress, &nowVar, sizeof(struct VAR_ST));
- switch (nowVar.status)
- {
- // if the data was unused than over build process
- case SCVAR_UNUSE: {
- rFlag = 0; // stop research
- break;
- }
- case SCVAR_USE: {
- if ((pErrVar != 0) && (nowVar.key == pErrVar->key))
- {
- self->pri.tail += sizeof(struct VAR_ST) + nowVar.len_b.alen;
- DelVar(self, self->pri.varList[errNo].flashAddr); // 删除原有错误数据
- self->pri.varList[errNo].flashAddr = pFVarAddress;
- }
- else // nomal
- {
- self->pri.tail += sizeof(struct VAR_ST) + nowVar.len_b.alen;
- self->pri.varList[self->pri.varNum].key = nowVar.key;
- self->pri.varList[self->pri.varNum].flashAddr = pFVarAddress;
- self->pri.varNum++;
- }
- break;
- }
- // if deleted than jump
- case SCVAR_DEL: {
- self->pri.tail += sizeof(struct VAR_ST) + nowVar.len_b.alen;
- }
- default: // 参数报错
- {
- // self->pri.tail += sizeof(struct VAR_ST) + dtActLen;
- }
- }
- } // end while
- }
- /**
- * @brief Flash扇区切换 (暂时未确认是否ok)
- *
- */
- static void SwitchSct(FlashPar_Prop *self)
- {
- uint8_t data[256];
- struct VAR_ST pOldVar;
- struct SSCT_HDR pOldSctHD;
- uint8_t *oldSct = self->pri.sectorUseBaseAdr;
- self->FlashRead_Cbk(oldSct, &pOldSctHD, sizeof(struct SSCT_HDR));
- /********step1: find next sector******/
- self->pri.sectorUseCnt++;
- if (self->pri.sectorUseCnt >= self->sectorNum)
- {
- self->pri.sectorUseCnt = 0;
- }
- uint8_t *newSct = self->sectorBaseAdr + self->pri.sectorUseCnt * self->sectorSize;
- self->FlashErase_Cbk(newSct, self->sectorSize); // 擦除即将切换到的扇区 擦除地址开始后的1个扇区
- /********step2 : produce sector header*******/
- struct SSCT_HDR newSctHD = {
- .st = SSCT_USE,
- .cnt = pOldSctHD.cnt + 1,
- .version = self->pri.makeTime,
- };
- self->pri.sectorUseBaseAdr = (uint8_t *)newSct;
- self->pri.tail = sizeof(struct SSCT_HDR);
- // sector write pre
- self->FlashWrite_Cbk(newSct, (uint8_t *)&newSctHD, sizeof(struct SSCT_HDR));
- /********step3 :将原有参数移动到新区*************/
- int32_t i;
- uint8_t *newvaraddr;
- for (i = 0; i < self->pri.varNum; i++)
- {
- self->FlashRead_Cbk(self->pri.varList[i].flashAddr, &pOldVar, sizeof(struct VAR_ST));
- newvaraddr = (uint8_t *)((uint32_t)self->pri.sectorUseBaseAdr + self->pri.tail);
- self->FlashRead_Cbk(self->pri.varList[i].flashAddr + sizeof(struct VAR_ST), data, pOldVar.len_b.len); // 读数据
- PrgVar(self, newvaraddr, pOldVar.key, data, pOldVar.len_b.len); // 保存数据
- self->pri.varList[i].flashAddr = newvaraddr;
- self->pri.tail += sizeof(struct VAR_ST) + pOldVar.len_b.alen;
- if (self->pri.tail > self->sectorSize)
- {
- //扇区溢出
- return;
- }
- }
- pOldSctHD.st = SSCT_DEL;
- // sector write pre
- self->FlashWrite_Cbk(oldSct, (uint8_t *)&pOldSctHD, sizeof(struct SSCT_HDR));
- }
- /**
- * @brief FlashPar
- *
- */
- void FlashPar_Create(FlashPar_Prop *self) { memset(self, 0, sizeof(FlashPar_Prop)); }
- const FlashPar_Func FlashPar = {.Create = FlashPar_Create,
- .Init = FlashPar_Init,
- .RdPar = FlashPar_RdPar,
- .WtPar = FlashPar_WtPar,
- .DelPar = FlashPar_DelPar};
平衡擦写的流程主要涉及到扇区的选择和切换,以及变量的写入和删除。
1. 首先,在`FlashPar_Init`函数中,通过调用`LoadSector`函数加载扇区的状态信息。该函数会遍历所有扇区,检查状态并选择使用中的扇区作为当前扇区。
2. 接下来,在`LoadFVar`函数中,会加载当前扇区中的flash变量。函数会遍历当前扇区中的每个flash变量,将其存储到`pri.varList`数组中。同时,将当前扇区中的`tail`指针指向下一个可用的地址。
3. 当需要写入一个新的flash变量时,首先通过`AllocVar`函数申请一个地址,并检查当前扇区是否有足够的空间。如果空间不足,则需要切换到下一个扇区,并重新分配地址。然后,通过`PrgVar`函数将变量写入到flash中,并更新`pri.varList`数组和`pri.varNum`变量。如果找到了相同关键字的旧变量,则会先删除旧变量。
4. 当需要删除一个flash变量时,通过`FlashPar_DelPar`函数根据关键字找到变量的地址,并调用`DelVar`函数删除变量。
5. 当需要读取一个flash变量时,通过`FlashPar_RdPar`函数根据关键字找到变量的地址,并将变量的数据读取出来。
在上述流程中,如果当前扇区的空间不足以容纳新的flash变量,就会触发扇区切换。在`SwitchSct`函数中,先找到下一个可用的扇区,并将其标记为使用状态。然后,将当前扇区中的变量逐个移动到新的扇区,并更新变量的地址。同时,将当前扇区的状态设置为删除状态,并将新的扇区的状态设置为使用状态。
通过这样的流程,可以实现对flash的平衡擦写,避免频繁的擦写操作,延长flash的使用寿命。同时,可以方便地存储和读取变量,提供了一种简单有效的持久化存储解决方案。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。