devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【FLASH】STM32内部Flash模拟EEPROM磨损均衡算法--存储设备擦写均衡自带掉电保护接口-如何在同等存储空间下增加FLASH寿命呢？往下看-STM32F334实现FLASH擦写均衡_flash的均衡磨损和掉电保护算法

作者：小蓝xlanll | 2024-06-05 11:16:36

赞

踩

flash的均衡磨损和掉电保护算法

        STM32内部Flash的写寿命大约是1万次，假如我们在其Flash中存储数据，每天100次写操作，100天后Flash就无法继续可靠使用了；外部FLASH，比如说W25Q32，擦写次数也只有十万次，在高频率读写下也支撑不了多久， 本文采取了一种非常简单的方法，将Flash的使用寿命无限延长，取决于你为它分配的存储区大小。

主要思想就是将FLASH 分配一块区域给我们的管理机，然后用索引的方式累积写FLASH，中途不进行擦写，在存满整个分区时进行统一擦写，读取根据ID进行读取，并且加上了数据校验，异常回调。主要用于存储系统配置，运行记录等。支持多个存储管理机管理不同的区域。

FLASH存储模型如下：

 管理者内存结构如下：

  1. typedef struct{
  2. 	unsigned int PageSize;		//页大小 
  3. 	unsigned int Pages;         //写的总页数      
  4. 	unsigned int StartAddr;  	//起始地址 
  5. 	unsigned int DriftAddr;		//偏移地址需要大于四字节 
  6. 	unsigned int Number;        //总共有效条数
  7. 	unsigned char * Buffer;     //数据缓冲区地址
  8.     unsigned int ReadAddr;      //读地址，用于节省查找时间提高效率 
  9.     unsigned int WriteAddr;     //写地址，用于节省时间提高查找空区效率          
  10.     void (* Error_Handle)(FERROR err, unsigned char * src, unsigned int len);
  11. }FlashConfig;


 

PageSize：用户为该管理机提供的存储分区业大小。同时也最小擦除单位。

Pages:存储分区页大小。

StartAddr：存储分区起始地址。

DriftAddr：需要存储数据的数据宽度
Number:需要存储的数据条数，也就是最大ID，这里如果你相同类型的数据有多条有效数据，就通过ID来进行区分。打个比方：周一到周五的菜单，每天固定三个菜，要进行存储的话，就需要提供五组数据，那么日期就是ID，用来区分周几。

Buffer：这个是你数据的内存首地址，这个在后面不同的接口会有介绍

ReadAddr：读地址，由于查找最后一块有效数据地址随着分区的大小，查找时间会相应的变长，所以在系统上电初始化的时候将最后一块有效数据块首地址记录，之后就不用再从子分区0查找了，提高系统执行效率，这个保留在这，暂未实现，后面的版本会加入。

WriteAddr:写地址，与上面一样。

Error_Handle：错误回调，如未实现，请赋值为NULL

存储器接口：

  1. void open_service()
  2. {
  3. 	//这里可提供线程安全防止中断flash操作，由close_service释放安全锁 
  4. 	eeplog("%s", "open service\n");
  5. }
  6.  
  7. void close_service()
  8. {
  9. 	eeplog("%s", "close service\n");
  10. }
  11.  
  12.  
  13. /**
  14.   * @brief  写储存器接口。
  15.   * @param  addr:写首地址
  16.   			sd：写入的数据首地址 
  17. 			len：写入的长度 
  18.   * @retval None
  19.   */
  20. void write_flash(unsigned int addr, const unsigned char * sd, unsigned int len){
  21.     unsigned short * pt = (unsigned short *)sd;
  22. 	HAL_FLASH_Unlock();
  23. 	for(int i = 0; i < len/2; i++)
  24. 	{
  25. 		HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, addr+i*2, *(pt+i));
  26. 	}
  27. 	HAL_FLASH_Lock();
  28. } 
  29.  
  30. /**
  31.   * @brief  擦除储存器接口 
  32.   * @param  addr:擦除地址 
  33.   * @param  擦写长度，暂时未用到，保留，接口默认擦除一页，
  34.   * @retval None
  35.   */
  36. void erase_flash(unsigned int addr, unsigned int len){
  37.     uint32_t PageError = 0;
  38. 	FLASH_EraseInitTypeDef pEraseInit;
  39. 	pEraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
  40. 	pEraseInit.PageAddress = addr;
  41. 	pEraseInit.NbPages = 1;
  42. 	HAL_FLASH_Unlock();
  43. 	HAL_StatusTypeDef s =  HAL_FLASHEx_Erase(&pEraseInit, &PageError);
  44. 	HAL_FLASH_Lock();
  45. } 
  46.  
  47. /**
  48.   * @brief  读储存器接口.
  49.   * @param  addr:读起始地址
  50.   			sd：读数据缓存区首地址
  51. 			len：读的长度
  52.   * @retval None
  53.   */
  54. void read_flash(unsigned int addr, unsigned char * sd, unsigned int len){
  55.     unsigned short * pt = (unsigned short *)sd;
  56. 	for(int i = 0; i < len / 2; i++){
  57. 		pt[i] = *((__IO uint16_t*)(addr+i*2));
  58. 	}
  59. }

erase_flash:这里的长度其实无效，这里需要提供的是擦除一页的接口，这里也许会有人说NAND Flash，最小擦除单位为1块，也就是64页，怎么办呢？这里你就需要在配置管理类的时候，将页数量配置为1，然后页大小不超过一块的大小就可以。

下面是全部代码：
eeprom.c

  1. /*********************************************************************************
  2.   *Copyright(C) -
  3.   *FileName: eeprom.c
  4.   *Author: 我不是阿沸
  5.   *Version: 6.1.0
  6.   *Date: 2023.08.20
  7.   *Description:  用于嵌入式系统保存数据至存储器，兼容大多数存储器，经内部算法优化，擦写寿命可达：正常寿命*100倍，这个取决于你分配的空间大小，空间越大寿命越长。  
  8.   *Others:  互斥需自己实现
  9.   			
  10.   *History:  
  11.   	 1.Date:2023/04/03
  12.        Author:我不是阿沸 
  13.        Modification:增加自定义互斥接口，由用户实现 
  14.      2.Date:2023/05/16
  15.        Author:我不是阿沸 
  16.        Modification:修改相关接口实现方式 
  17.      3.Date:2023/07/18
  18.        Author:我不是阿沸 
  19.        Modification:修改读写数据实现方式
  20.      4.Date:2023/08/20
  21.        Author:我不是阿沸 
  22.        Modification:删除冗余成分 
  23. 	 4.Date:2023/010/24
  24. 	   Author:我不是阿沸 
  25. 	   Modification:增加查找分区地址记录，只需上电查找一次，提高效率 
  26. 	 5.其他修改 
  27. **********************************************************************************/
  28.  
  29. #include "eeprom.h"
  30.  
  31. void open_service()
  32. {
  33. 	//HAL_FLASH_Unlock();
  34. 	//这里可提供线程安全防止中断flash操作，由close_service释放安全锁 
  35. 	eeplog("%s", "open service\n");
  36. }
  37.  
  38.  
  39. void close_service()
  40. {
  41. 	eeplog("%s", "close service\n");
  42. 	//HAL_FLASH_Lock();
  43. }
  44.  
  45.  
  46. //ProgramGroup programGroups[10];
  47. /**
  48.   * @brief  写储存器接口。
  49.   * @param  addr:写首地址
  50.   			sd：写入的数据首地址 
  51. 			len：写入的长度 
  52.   * @retval None
  53.   */
  54. void write_flash(epmu32 addr, const epmu8 * sd, epmu32 len){
  55. 	//注意，这里传入的sd必须是偶数地址，不然在转换为16位时会出现字节对齐的情况
  56. 	uint64_t * pt = (uint64_t *)sd;
  57. 	HAL_FLASH_Unlock();
  58. 	//rt_kprintf("\nlen:%d\n", len);
  59. 	Flash_If_Write((uint8_t*)sd, addr, len);
  60. //	for(int i = 0; i < len/8; i++)
  61. //	{
  62. //		HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, addr+i*8, *(pt+i));
  63. //	}
  64. 	HAL_FLASH_Lock();
  65. } 
  66.  
  67.  
  68. /**
  69.   * @brief  擦除储存器接口 
  70.   * @param  addr:擦除地址 
  71.   * @retval None
  72.   */
  73. void erase_flash(epmu32 addr, epmu32 len){
  74. 	
  75. 	epmu32 PageError = 0;
  76. 	//FLASH_EraseInitTypeDef pEraseInit;
  77. 	HAL_FLASH_Unlock();
  78. 	
  79. 	
  80. 	Flash_If_Erase(addr);
  81.  
  82. 	HAL_FLASH_Lock();
  83. } 
  84.  
  85.  
  86. /**
  87.   * @brief  读储存器接口.
  88.   * @param  addr:读起始地址
  89.   	@param	sd：读数据缓存区首地址
  90. 	@param	len：读的长度
  91.   * @retval None
  92.   */
  93. void read_flash(epmu32 addr, epmu8 * sd, epmu32 len){
  94.  
  95. 	uint64_t * pt = (uint64_t *)sd;
  96. //	for(int i = 0; i < len / 8; i++){
  97. //		pt[i] = *((__IO uint64_t*)(addr+i*8));
  98. //	}
  99. 	Flash_If_Read(sd, addr, len);
  100. }
  101.  
  102.  
  103. /**
  104.   * @brief  校验数据接口 
  105.   * @param  src:需要校验的数据首地址 
  106. 			len：要校验的长度 
  107.   * @retval epmbool：返回校验成功或者失败 
  108.   */
  109. epmbool check_flash(epmu8 *src, epmu32 len){
  110. 	eeplog("start check data\n");
  111.     epmu32 src_ckeck = epm_crc32(src, len -4);
  112.     epmu32 dec_ckeck = epmu32_buffer_max((src+ len - 4));
  113.     if(src_ckeck  != dec_ckeck) {
  114.     	eeplog("data check error!\n");
  115.     	return EPMFALSE;
  116. 	}
  117. 	eeplog("data check success!\n");
  118. 	return EPMTRUE;
  119. }
  120.  
  121. /**
  122.   * @brief  判断第一块存储区是否进行初始化
  123.   * @param  flg:分区信息  
  124.   * @retval epmbool：true:存储区已初始化 false：未初始化 
  125.   */
  126. epmbool isinit_first_block(FlashConfig flg){
  127. 	epmu8 ch[10];
  128. 	read_flash(flg.start_addr, ch, 8);
  129.     int i = 0;
  130.     for(; i < 8; i++){
  131.     	if(ch[i] != 0xA5) break;
  132. 	}
  133. 	if(i !=  8) return EPMFALSE;
  134. 	return EPMTRUE;
  135. 	
  136. }
  137.  
  138. /**
  139.   * @brief  第一块存储区初始化，写入初始化信息 
  140.   * @param  flg:分区信息  
  141.   * @retval epmbool：true:存储区初始化成功 false：分区损坏 
  142.   */
  143. epmbool first_block_init(FlashConfig flg){
  144. 	eeplog("Is check epm init?\n");
  145. 	epmu8 ch[10];
  146. 	memset(ch, 0xA5, 8);
  147. 	
  148. 	eeplog("Sector not initialized, about to initialize...\n");
  149. 	for(int m = 0; m < flg.pages; m++){
  150.         erase_flash(flg.start_addr+m*flg.page_size, flg.page_size);
  151. 	}
  152. 	write_flash(flg.start_addr, ch, 8);
  153. 	read_flash(flg.start_addr, ch, 8);
  154. 	for(int i = 0; i < 8; i++){
  155. 		if(ch[i] != 0xA5) {
  156. 			eeplog("Sector initialization default!!!!!!!!!!!!!!!\n");
  157. 			return EPMFALSE;	
  158. 		}
  159. 	}
  160. 	eeplog("Sector initialization successful\n");	
  161.     return EPMTRUE;
  162. }
  163.  
  164.  
  165. /**
  166.   * @brief  校验flash读出的数据是否为空 
  167.   * @param  data:需要校验的数据首地址  
  168. 			len：数据的长度 
  169.   * @retval epmbool：未被写入过数据返回true 
  170.   */
  171. epmbool is_eeprom_null(FlashConfig flg, epmu8 * data, int len){
  172. 	int n = 0;
  173. 	eeplog("Is flash empty?\n");
  174. 	for(n = 0; n < len; n++){
  175. 		if(data[n] != 0xff){
  176. 			eeplog("flash isn`t empty\n");
  177. 			return EPMFALSE;
  178. 		}
  179. 	}
  180. 	eeplog("flash is empty\n");
  181. 	return EPMTRUE;
  182. }
  183.  
  184.  
  185.  
  186. /**
  187.   * @brief  CRC32校验 
  188.   * @param  data:需要校验的数据首地址  
  189. 			len：数据的长度 
  190.   * @retval CRC32校验值 
  191.   */
  192. #define POLY 0xEDB88320UL
  193. epmu32 epm_crc32(epmu8 * data, epmu32 datalen)
  194. {
  195. 	const uint8_t *bytes = data;
  196.     uint32_t crc = 0xFFFFFFFFUL;
  197.  
  198.     // 循环处理每个字节
  199.     for (size_t i = 0; i < datalen; i++) {
  200.         crc ^= bytes[i];        // 把当前字节与 crc 的低 8 位进行异或操作
  201.  
  202.         // 处理当前字节的 8 位，每次处理一位
  203.         for (int j = 0; j < 8; j++) {
  204.             if (crc & 1) {      // 如果 crc 的最低位为 1，则右移并与多项式除数进行异或操作
  205.                 crc = (crc >> 1) ^ POLY;
  206.             } else {            // 否则，只右移一个比特位
  207.                 crc >>= 1;
  208.             }
  209.         }
  210.     }
  211.  
  212.     return ~crc;                // 取反操作得到最终结果
  213. }
  214.  
  215. /**
  216.   * @brief  初始化分区信息 
  217.   * @param  分区信息指针
  218.   * @param  起始地址
  219.   * @param  偏移地址，子存储区大小
  220.   * @param  有效数据条数
  221.   * @param  分区占用存储器页数
  222.   * @param  存储器叶大小
  223.   * @param  数据缓存区指针
  224.   * @param  错误回调接口
  225.   * @retval none 
  226.   */
  227. void eeprom_init(FlashConfig * flg, epmu32 start_addr, epmu8 drift_addr, epmu16 number, epmu16 pages, epmu32 page_size, epmu8 * buffer, error_handle error)
  228. {
  229. 	flg->find_flag = EPMFALSE;
  230. 	flg->find_addr = start_addr;
  231. 	flg->start_addr = start_addr;
  232. 	flg->drift_addr = drift_addr;
  233. 	flg->number = number;
  234. 	flg->pages = pages;
  235. 	flg->page_size = page_size;
  236. 	flg->buffer = buffer;
  237. 	flg->error = error;
  238. }
  239.  
  240.  
  241. /**
  242.   * @brief  顺序查找flash空区 
  243.   * @param  flg:分区信息  
  244.   * @retval int：返回空区首地址 
  245.   */
  246. epmu32 epm_seq_search_addr(FlashConfig * flg){
  247. 	int findCount = flg->page_size * flg->pages / (flg->drift_addr+4);
  248. 	
  249. 	epmu32 start_addr = flg->start_addr;
  250. 	epmu32 find_addr = start_addr;
  251. 	epmu8 data[200];
  252. 	int i;
  253. 	
  254.     open_service();
  255.     eeplog("epy find start!\n");
  256.     //这里注意，首地址为初始化校验区，无有效数据
  257.     
  258. 	if(flg->find_flag == EPMFALSE)
  259. 	{
  260. 		epmbool bl = isinit_first_block(*flg);
  261. 		if(bl == EPMFALSE) {
  262. 			close_service();
  263. 			flg->find_flag = EPMTRUE;
  264. 			flg->find_addr = start_addr;
  265. 			return start_addr;	
  266. 		}
  267. 		
  268. 		for(i = 1; i < findCount; i++){
  269. 			read_flash(start_addr + i*(flg->drift_addr+4), data, flg->drift_addr+4);
  270. 			
  271. 			if(is_eeprom_null(*flg, data, flg->drift_addr+4) == EPMTRUE){
  272. 				find_addr = start_addr + i*(flg->drift_addr+4);
  273. 				eeplog("epy find end, return emp addr!\n");
  274. 				break;
  275. 			}
  276. 		}
  277. 		if(i == findCount)
  278. 		{
  279. 			find_addr = start_addr + findCount*(flg->drift_addr+4);
  280. 		}
  281. 		else
  282. 		{
  283. 			
  284. 		}
  285. 		flg->find_addr = find_addr;
  286. 		flg->find_flag = EPMTRUE;
  287. 		
  288. 	}
  289.     close_service();
  290. 	return flg->find_addr; 
  291. }
  292.  
  293. /**
  294.   * @brief  写入数据
  295.   * @param  flg:分区信息  
  296.   			data:需要写入的数据 
  297.   * @retval int：返回对应的空区首地址 
  298.   */
  299. FERROR epm_write_data(FlashConfig * flg, const epmu8 * data){
  300. 	epmu8 ch[200] = {0};
  301.     epmu8 chb[200] = {0};
  302.     epmu32 addr = flg->start_addr;
  303. 	int findCount = flg->page_size * flg->pages / (flg->drift_addr+4);
  304.     addr = epm_seq_search_addr(flg);
  305. 	
  306.     if(flg->find_addr >= flg->start_addr + findCount* (flg->drift_addr+4))
  307. 	{
  308. 		flg->find_addr = flg->start_addr;
  309. 		addr = flg->start_addr;
  310. 	}
  311. 	
  312.     open_service();
  313. 	if(addr == flg->start_addr){
  314. 		epmbool b = first_block_init(*flg);
  315. 		
  316. 		if(b == EPMFALSE){
  317. 			flg->error(InitError, NULL, 0);
  318. 			
  319. 			close_service();
  320. 			return InitError;
  321. 		}
  322. 		
  323.         for(int i = 0; i < flg->number; i++){
  324.         	memcpy(ch, flg->buffer+i*flg->drift_addr, flg->drift_addr);
  325.         	
  326.         	epmu32 src_ckeck = epm_crc32(ch, flg->drift_addr);
  327.         	
  328. 			buffer_epmu32_max(src_ckeck, (ch+flg->drift_addr));
  329. 		    
  330.             write_flash(addr +(i+1)*(flg->drift_addr+4), ch, flg->drift_addr+4);
  331. 			
  332.             //这里可适当加入回读错误处理 
  333. 		}
  334. 		flg->find_addr = addr + (flg->drift_addr+4)*(flg->number+1);
  335. 		eeplog("addr:%08X\n", addr);	
  336. 		close_service();
  337. 		return Success;
  338. 	}
  339. 	
  340. 	memcpy(ch, data, flg->drift_addr);
  341.    	epmu32 src_ckeck = epm_crc32(ch, flg->drift_addr);
  342.     buffer_epmu32_max(src_ckeck, (ch+flg->drift_addr));
  343.     
  344.  
  345. 	
  346. 	write_flash(addr, ch, flg->drift_addr+4);
  347. 	read_flash(addr, chb, flg->drift_addr+4);
  348. 	flg->find_addr += (flg->drift_addr+4);
  349. 	
  350. 	if(flg->find_addr >= flg->start_addr + findCount* (flg->drift_addr+4))
  351. 	{
  352. 		flg->find_addr = flg->start_addr;
  353. 	}
  354. 	
  355. 	int m = 0;
  356.     for( ; m < flg->drift_addr+4; m++){
  357.         if(chb[m] != ch[m]){
  358.             break;
  359.         }
  360.     }
  361. 	
  362. 	if(flg->drift_addr+4 == m) 
  363.     {
  364.     	
  365.         close_service();
  366.         eeplog("%s", "data write succse");
  367.         return Success;
  368.     }
  369. 	else
  370. 	{
  371. 		eeplog("%s", "data write error, sd have bad block");
  372. 	}
  373.     close_service();
  374.     eeplog("%s", "data write error, sd have bad block");
  375. 	return WriteError;	
  376. } 
  377.  
  378.  
  379.  
  380. /**
  381.   * @brief  读出数据 
  382.   * @param  flg:分区信息  
  383.   			data:需要写入的数据 
  384.   * @retval NONE 
  385.   */
  386. FERROR epm_read_data(FlashConfig *flg,  epmu8 * data){
  387. 	
  388. 	epmu32 addr = epm_seq_search_addr(flg);
  389.     epmu8 ch[200];
  390.     
  391.     if(flg->drift_addr+4 >= 200) return IndexError;
  392.     
  393. 	if(addr == flg->start_addr){
  394. 		flg->error(Empty, NULL, 0);
  395. 		return Empty;
  396. 	}
  397. 	else{
  398. 		addr -= (flg->drift_addr+4);
  399. 		open_service();
  400. 		
  401. 		read_flash(addr, ch, flg->drift_addr+4);
  402. 		close_service();
  403. 		if(check_flash(ch, flg->drift_addr+4) == EPMFALSE){
  404. 			flg->error(ReadError, NULL, 0);
  405.        		return ReadError;
  406. 		}
  407. 		memcpy(data, ch, flg->drift_addr);
  408. 	}
  409.  
  410.    
  411.     return Success;
  412. }
  413.  
  414.  
  415. /**
  416.   * @brief  查询全部数据 ，并且通过ID写入对应的缓冲区 
  417.   * @param  flg:分区信息
  418.   * @retval void
  419.   */
  420. void epm_select_all_data(FlashConfig * flg)
  421. {
  422.     int findCount = (flg->page_size * flg->pages) / (flg->drift_addr+4);
  423. 	epmu32 start_addr = flg->start_addr;
  424. 	int i, n;
  425.     epmu8 ch[200] = {0};
  426.     
  427.     if(flg->drift_addr+4 >= 200) return;
  428.     
  429.     open_service();
  430.     
  431.     epmbool b = isinit_first_block(*flg);
  432. 		
  433. 	if(b == EPMFALSE){
  434. 		flg->error(InitError, NULL, 0);
  435. 		close_service();
  436. 		return;
  437. 	}
  438. 	for(i = 1; i < findCount; i++){
  439. 		read_flash(start_addr + i*(flg->drift_addr+4), ch, flg->drift_addr+4);
  440.         if(is_eeprom_null(*flg, ch, flg->drift_addr+4) == EPMTRUE) 
  441.         {
  442.             break;
  443.         }
  444.         
  445. 		if(check_flash(ch, flg->drift_addr+4) == EPMFALSE){
  446.             if(flg->error != NULL)
  447.             {
  448.             	flg->error(CheckError, ch, flg->drift_addr);
  449. 			}
  450.             continue;
  451.         }
  452.         
  453. 		int id = *((epmu16*)ch);
  454.         if(id >= flg->number) id = flg->number - 1;
  455.         for(n = 0; n < flg->drift_addr; n++){
  456.             flg->buffer[id*flg->drift_addr+n] = ch[n];
  457.         }
  458. 	}
  459.     close_service();
  460. 	return;
  461. }
  462.  
  463.  
  464. /**
  465.   * @brief  通过索引查询多条数据数据 
  466.   * @param  flg:分区信息  
  467.   			start:开始条数，这里换算成地址为：flg->drift_addr* start
  468.   			num：查寻条数 
  469.   * @retval int：返回对应的空区首地址 
  470.   */
  471. void epm_select_data(FlashConfig * flg, epmu32 start, epmu32 num)
  472. {
  473. 	epmu32 start_addr = flg->start_addr;
  474.  
  475.     epmu8 ch[200] = {0};
  476.     if(flg->drift_addr+ 4 >= 200) return;
  477.     
  478.     open_service();
  479.     for(int i = 1; i < num && i < flg->number; i++){
  480.         read_flash(start_addr + (i+start)*(flg->drift_addr+4), ch, flg->drift_addr+4);
  481. 		if(check_flash(ch, flg->drift_addr+4) == EPMFALSE){
  482.             flg->error(CheckError, ch, flg->drift_addr);
  483.             continue;
  484.         }
  485.         for(int n = 0; n < flg->drift_addr; n++){
  486.             flg->buffer[(i-1)*flg->drift_addr+n] = ch[n];
  487.         }
  488.     }
  489. 	close_service();
  490. 	return;
  491. }
  492.  
  493.

eeprom.h:

  1. /*********************************************************************************
  2.   *Copyright(C) -
  3.   *FileName: eeprom.h
  4.   *Author: 我不是阿沸
  5.   *Version: 6.1.0
  6.   *Date: 2023.08.20
  7.   *Description:  用于嵌入式系统保存数据至存储器，兼容大多数存储器，经内部算法优化，擦写寿命可达：正常寿命*100倍，这个取决于你分配的空间大小，空间越大寿命越长。  
  8.   *Others:  互斥需自己实现
  9.   			
  10.   *History:  
  11.   	 1.Date:2023/04/03
  12.        Author:我不是阿沸 
  13.        Modification:增加自定义互斥接口，由用户实现 
  14.      2.Date:2023/05/16
  15.        Author:我不是阿沸 
  16.        Modification:修改相关接口实现方式 
  17.      3.Date:2023/07/18
  18.        Author:我不是阿沸 
  19.        Modification:修改读写数据实现方式
  20.      4.Date:2023/08/20
  21.        Author:我不是阿沸 
  22.        Modification:删除冗余成分 
  23. 	 4.Date:2023/010/24
  24. 	   Author:我不是阿沸 
  25. 	   Modification:增加查找分区地址记录，只需上电查找一次，提高效率 
  26. 	 5.其他修改 
  27. **********************************************************************************/
  28.  
  29. #ifndef __EEPROMS_H
  30. #define __EEPROMS_H
  31.  
  32. #include <stdio.h>
  33. #include "if_flash.h"
  34. #include <stdio.h>
  35. #include <string.h>
  36.  
  37.  
  38.  
  39. //#define __EEPDEBUG
  40. #ifdef __EEPDEBUG
  41.  	#define eeplog(format, ...) \
  42.       	rt_kprintf("[%s:%d->%s]:"format, __FILE__, __LINE__, __func__, ##__VA_ARGS__)
  43. #else
  44.  	#define eeplog(format, ...)
  45. #endif
  46.  
  47. #define FLASH_PAGE_STEP  FLASH_PAGE_SIZE       
  48. #define START_ADDRESS    (uint32_t)0x08000000
  49.  
  50. #define epmu32_buffer_min(x) (epmu32)(*((x+3))<<24 | *((x)+2)<<16 | *((x)+1)<<8 | *(x))
  51. #define epmu32_buffer_max(x) (epmu32)(*(x)<<24 | *((x)+1)<<16 | *((x)+2)<<8 | *((x)+3))
  52.  
  53. #define epmu16_buffer_min(x) (epmu16)(*((x)+1)<<8 | *(x))
  54. #define epmu16_buffer_max(x) (epmu16)(*(x)<<8 | *(x+1))
  55.  
  56. #define buffer_epmu32_min(x, buf) {(buf)[0] = (x); (buf)[1] = (x)>>8; (buf)[2] = (x)>>16; (buf)[3] = (x)>>24;}
  57. #define buffer_epmu32_max(x, buf) {(buf)[3] = (x); (buf)[2] = (x)>>8; (buf)[1] = (x)>>16; (buf)[0] = (x)>>24;}
  58.  
  59. #define buffer_epmu16_min(x, buf) {(buf)[0] = (x); (buf)[1] = (x)>>8;}
  60. #define buffer_epmu16_max(x, buf) {(buf)[1] = (x); (buf)[0] = (x)>>8;}
  61.  
  62.  
  63. typedef unsigned int epmu32;
  64. typedef unsigned short epmu16;
  65. typedef unsigned char epmu8;
  66.  
  67.  
  68.  
  69. typedef enum flash_error{
  70.     Success,
  71. 	WriteError,
  72. 	ReadError,
  73.     IndexError,
  74.     CheckError,
  75.     InitError,
  76.     Empty
  77. }FERROR;
  78.  
  79.  
  80. typedef enum{
  81.     EPMFALSE,
  82. 	EPMTRUE
  83. }epmbool;
  84.  
  85.  
  86. typedef void (* error_handle)(FERROR err, epmu8 * src, epmu32 len);
  87.  
  88.  
  89.  
  90. typedef struct{
  91. 	epmu32 page_size;		//页大小 
  92. 	epmu16 pages;         //写的总页数      
  93. 	epmu32 start_addr;  	//起始地址 
  94. 	epmu8 drift_addr;		//偏移地址需要大于四字节 
  95. 	epmu32 number;        //总共有效条数
  96. 	epmu8 * buffer;        //数据缓冲区地址
  97.     epmu32 find_addr; 
  98. 	epmbool find_flag;
  99.     error_handle error;
  100. }FlashConfig;
  101.  
  102. void eeprom_init(FlashConfig * flg, epmu32 start_addr, epmu8 drift_addr, epmu16 number, epmu16 pages, epmu32 page_size, epmu8 * buffer, error_handle error);
  103. epmu32 epm_seq_search_addr(FlashConfig * flg);
  104. void epm_select_data(FlashConfig * flg, epmu32 start, epmu32 num);
  105. epmu32 epm_crc32(epmu8 * data, epmu32 datalen);
  106. epmbool check_flash(epmu8 *src, epmu32 len);
  107. void erase_flash(epmu32 addr, epmu32 len);
  108. void write_flash(epmu32 addr, const epmu8 * sd, epmu32 len);
  109. void read_flash(epmu32 addr, epmu8 * sd, epmu32 len);
  110. FERROR epm_read_data(FlashConfig *flg,  epmu8 * data);
  111. FERROR epm_write_data(FlashConfig * flg, const epmu8 * data);
  112. void epm_select_all_data(FlashConfig * flg);
  113.  
  114. #endif 
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.

main.c

  1. #include "stdio.h"
  2. #include "eeprom.h"
  3.  
  4.  
  5. typedef struct
  6. {
  7. 	char id;
  8. 	char depth; //宽度
  9. 	short cmp;
  10. 	short angle;
  11. 	
  12. 	short temp;  //温度
  13. 	short count; //执行次数
  14. 	short width; //间隔时间
  15. 	short lc ;   //lc开关值
  16. 	unsigned int freq;
  17. 	int expand;
  18. 	int outi;
  19. 	int kp1;
  20. 	int ki1;
  21. 	int kd1;
  22. 	int power;
  23. 	int kp2;
  24. 	int ki2;
  25. 	int kd2;
  26. 	int outv;
  27. 	int kp3;
  28. 	int ki3;
  29. 	int kd3;
  30. 	int y1;
  31. 	int y2;
  32. 	int y3;
  33. 	int ts;
  34. 	int xx;
  35. }Preset;
  36.  
  37. Preset preset;
  38.  
  39. FlashConfig PresetCfg; 
  40.  
  41.  
  42. void preset_config_ehandle(FERROR err, unsigned char * src, unsigned int len)
  43. {
  44. 	eeplog("preset_config_ehandle error:%d\n", err);
  45. }
  46.  
  47.  
  48. void printf_preset(Preset p)
  49. {
  50. 	eeplog("freq:%d,cmp:%d,angle:%d,expand:%d,temp:%d,count:%d,width:%d,depth:%d", p.freq, p.cmp, p.angle, p.expand, p.temp, p.count, p.width, p.depth);
  51. }
  52.  
  53. epmbool write_preset(void)
  54. {
  55. 	//printf_preset(preset);
  56.     epm_write_data(&PresetCfg, (unsigned char *)&preset);
  57.     return EPMTRUE;
  58. }
  59.  
  60.  
  61. /**
  62.   * @brief  read_preset 读取预设组
  63.   * @param  
  64.   * @retval bool：读取是否成功
  65.   */
  66. epmbool read_preset(void)
  67. {
  68. 	epm_read_data(&PresetCfg, (unsigned char * )&preset);
  69.     return EPMTRUE;
  70. }
  71.  
  72.  
  73.  
  74.  
  75. epmbool preset_config_init(void){
  76. 	eeplog("size:%d\n", sizeof(Preset));
  77. 	eeprom_init(&PresetCfg, 59*FLASH_PAGE_STEP + START_ADDRESS, sizeof(Preset), 1, 4,                 
  78.     FLASH_PAGE_STEP, (unsigned char * )&preset, preset_config_ehandle);
  79.     read_preset();
  80. 	printf_preset(preset);
  81.     return EPMTRUE;
  82. }
  83.  
  84.  
  85.  
  86.  
  87.  
  88.

如有疑问可以评论区留言，或者联系QQ：2227273007，另外附上eeprom的源文件：

(7条消息) STM32存储设备磨损均衡算法与数据结构资源-CSDN文库

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/676288
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号