说明
在工业应用中经常使用 EEPROM（电可擦除可编程只读存储器）来存储可更新的数据。EEPROM 是用在复杂系统（例如计算机）和其它电子器件中的一种永久（非易失）存储器存储系统，它可以在电源故障时存储和保留少量数据。

由于STM32的单片机支持IAP功能，因此可以通过读写Flash的某个特定区域来实现对EEPROM的模拟。STM32F103与F407的EEPROM仿真主要参考了意法半导体公司官方应用笔记：

STM32F101xx和STM32F103xx微控制器中的EEPROM仿真（AN2594）
STM32F40x/STM32F41x微控制器中的EEPROM仿真（AN3969）
笔者在EEPROM仿真库的基础上，进一步封装了应用层的扩展库。利用此扩展库，可以直接声明和定义一个StorableData类型的变量。该变量可以利用扩展库提供的接口方便的实现掉电存储、上电加载、重置默认等功能。

需要特别说明的是：
笔者提供的EEPROM仿真库源码与官方提供的源码相比，稍作了修改以使其能更好的配合应用层扩展库使用。
由于STM32F103与STM32F407的标准外设库函数中对flash的操作API不同，因此EEPROM仿真库针对不同单片机平台的函数实现（源文件）是有所不同的。
应用层扩展是基于EEPROM仿真库实现的，利用了EEPROM仿真库统一的接口，因此可以兼容不同的单片机平台。

EEPROM仿真
框架介绍
EEPROM 是许多需要非易失性数据存储的嵌入式应用的关键组件，它在运行期间以字节或字为粒度。这些系统中使用的微控制器通常是基于嵌入式 Flash 存储器的。为了避免使用这些组件、节约 PCB 空间并降低系统成本，可使用 STM32的Flash代替外部 EEPOM，模拟代码和数据的存储。但是与 Flash 不同的是，外部 EEPROM 在重写数据之前并不需要执行擦除操作来释放空间。要将数据存储到嵌入式 Flash 中，需要执行特殊的软件管理。

官方提供的应用笔记介绍了使用 STM32F103/STM32F407 器件的片上 Flash 通过仿真 EEPROM 机制来取代独立 EEPROM 的软件解决方案。由于Flash的可采写次数较少（1万次），因此EEPROM仿真库采用了耗损均衡算法以增加Flash可擦写次数。

源码
容量设置
根据项目需要可以修改头文件与源文件中的相关内容，设置一个合适的16位数据可存储的数量。

在头文件中指定了16位数据可存储的数量为128个，如果都以32位的浮点数类型来保存数据的话，保存的浮点数数量为64个。
头文件中相关内容：

1. /* Variables' number */
   
2. #define EEPROM_NumbOfVar                128
   
3. extern uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar];

复制代码

源文件中相关内容：

1. /* Virtual address defined by the user: 0xFFFF value is prohibited */
   
2. uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar] =
   
3. {
   
4.         0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
   
5.         0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010,
   
6.         0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018,
   
7.         0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020,
   
8.         0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028,
   
9.         0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030,
   
10.         0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038,
    
11.         0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,
    
12.         0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048,
    
13.         0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
    
14.         0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058,
    
15.         0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060,
    
16.         0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068,
    
17.         0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070,
    
18.         0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078,
    
19.         0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, 0x0080,
    
20. };

复制代码

在头文件中指定了16位数据可存储的数量为256个，如果都以32位的浮点数类型来保存数据的话，保存的浮点数数量为128个。
头文件中相关内容：

1. /* Variables' number */
   
2. #define EEPROM_NumbOfVar                256
   
3. extern uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar];

复制代码

源文件中相关内容：

1. /* Virtual address defined by the user: 0xFFFF value is prohibited */
   
2. uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar] =
   
3. {
   
4.         0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
   
5.         0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010,
   
6.         0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018,
   
7.         0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020,
   
8.         0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028,
   
9.         0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030,
   
10.         0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038,
    
11.         0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,
    
12.         0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048,
    
13.         0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
    
14.         0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058,
    
15.         0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060,
    
16.         0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068,
    
17.         0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070,
    
18.         0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078,
    
19.         0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, 0x0080,
    
20. 
    
21.         0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088,
    
22.         0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F, 0x0090,
    
23.         0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098,
    
24.         0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F, 0x00A0,
    
25.         0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8,
    
26.         0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00B0,
    
27.         0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8,
    
28.         0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, 0x00C0,
    
29.         0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8,
    
30.         0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D0,
    
31.         0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8,
    
32.         0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00E0,
    
33.         0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8,
    
34.         0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0,
    
35.         0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8,
    
36.         0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF, 0x0100,
    
37. };

复制代码

STM32F103
头文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    EEPROM_Emulation/inc/eeprom.h
   
4.   * @author  MCD Application Team
   
5.   * @version V3.1.0
   
6.   * @date    07/27/2009
   
7.   * @brief   This file contains all the functions prototypes for the EEPROM
   
8.   *          emulation firmware library.
   
9.   ******************************************************************************
   
10.   * @copy
    
11.   *
    
12.   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    
13.   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    
14.   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
    
15.   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    
16.   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    
17.   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    
18.   *
    
19.   * <h2><center>© COPYRIGHT 2009 STMicroelectronics</center></h2>
    
20.   */
    
21. 
    
22. /* Define to prevent recursive inclusion -------------------------------------*/
    
23. #ifndef __EEPROM_H
    
24. #define __EEPROM_H
    
25. 
    
26. /* Includes ------------------------------------------------------------------*/
    
27. #include "stm32f10x.h"
    
28. #include "stm32f10x_conf.h"
    
29. 
    
30. /* Exported constants --------------------------------------------------------*/
    
31. /* Define the STM32F10Xxx Flash page size depending on the used STM32 device */
    
32. #if defined (STM32F10X_LD) || defined (STM32F10X_MD)
    
33.   #define PAGE_SIZE  (uint16_t)0x400  /* Page size = 1KByte */
    
34.   #define FLASH_END_ADDRESS 0x08010000
    
35. 
    
36. #elif defined (STM32F10X_HD) || defined (STM32F10X_CL)
    
37.   #define PAGE_SIZE  (uint16_t)0x800  /* Page size = 2KByte */
    
38.   #define FLASH_END_ADDRESS 0x08040000
    
39. 
    
40. #endif
    
41. 
    
42. /* EEPROM start address in Flash */
    
43. #define EEPROM_START_ADDRESS    ((uint32_t)(FLASH_END_ADDRESS - 2 * PAGE_SIZE))
    
44. 
    
45. 
    
46. /* Pages 0 and 1 base and end addresses */
    
47. #define PAGE0_BASE_ADDRESS      ((uint32_t)(EEPROM_START_ADDRESS + 0x000))
    
48. #define PAGE0_END_ADDRESS       ((uint32_t)(EEPROM_START_ADDRESS + (PAGE_SIZE - 1)))
    
49. 
    
50. #define PAGE1_BASE_ADDRESS      ((uint32_t)(EEPROM_START_ADDRESS + PAGE_SIZE))
    
51. #define PAGE1_END_ADDRESS       ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))
    
52. 
    
53. /* Used Flash pages for EEPROM emulation */
    
54. #define PAGE0                   ((uint16_t)0x0000)
    
55. #define PAGE1                   ((uint16_t)0x0001)
    
56. 
    
57. /* No valid page define */
    
58. #define NO_VALID_PAGE           ((uint16_t)0x00AB)
    
59. 
    
60. /* Page status definitions */
    
61. #define ERASED                  ((uint16_t)0xFFFF)     /* PAGE is empty */
    
62. #define RECEIVE_DATA            ((uint16_t)0xEEEE)     /* PAGE is marked to receive data */
    
63. #define VALID_PAGE              ((uint16_t)0x0000)     /* PAGE containing valid data */
    
64. 
    
65. /* Valid pages in read and write defines */
    
66. #define READ_FROM_VALID_PAGE    ((uint8_t)0x00)
    
67. #define WRITE_IN_VALID_PAGE     ((uint8_t)0x01)
    
68. 
    
69. /* Page full define */
    
70. #define PAGE_FULL               ((uint8_t)0x80)
    
71. 
    
72. /* Variables' number */
    
73. //#define EEPROM_NumbOfVar               ((uint8_t)STORABLE_DATA_COUNT * 2)
    
74. #define EEPROM_NumbOfVar                128
    
75. 
    
76. extern uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar];
    
77. 
    
78. /* Exported types ------------------------------------------------------------*/
    
79. /* Exported macro ------------------------------------------------------------*/
    
80. /* Exported functions ------------------------------------------------------- */
    
81. uint16_t EE_Init(void);
    
82. uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
    
83. uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
    
84. 
    
85. #endif /* __EEPROM_H */
    
86. 
    
87. /******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/

复制代码

源文件

1. /**
   
2. ******************************************************************************
   
3. * @file    EEPROM_Emulation/src/eeprom.c
   
4. * @author  MCD Application Team
   
5. * @version V3.1.0
   
6. * @date    07/27/2009
   
7. * @brief   This file provides all the EEPROM emulation firmware functions.
   
8. ******************************************************************************
   
9. * @copy
   
10. *
    
11. * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    
12. * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    
13. * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
    
14. * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    
15. * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    
16. * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    
17. *
    
18. * <h2><center>© COPYRIGHT 2009 STMicroelectronics</center></h2>
    
19. */
    
20. /** @addtogroup EEPROM_Emulation
    
21. * @{
    
22. */
    
23. 
    
24. /* Includes ------------------------------------------------------------------*/
    
25. #include "eeprom.h"
    
26. 
    
27. /* Private typedef -----------------------------------------------------------*/
    
28. /* Private define ------------------------------------------------------------*/
    
29. /* Private macro -------------------------------------------------------------*/
    
30. /* Private variables ---------------------------------------------------------*/
    
31. 
    
32. /* Global variable used to store variable value in read sequence */
    
33. static uint16_t DataVar = 0;
    
34. 
    
35. /* Virtual address defined by the user: 0xFFFF value is prohibited */
    
36. uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar] =
    
37. {
    
38.         0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
    
39.         0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010,
    
40.         0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018,
    
41.         0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020,
    
42.         0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028,
    
43.         0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030,
    
44.         0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038,
    
45.         0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,
    
46.         0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048,
    
47.         0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
    
48.         0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058,
    
49.         0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060,
    
50.         0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068,
    
51.         0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070,
    
52.         0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078,
    
53.         0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, 0x0080,
    
54. };
    
55. 
    
56. /* Private function prototypes -----------------------------------------------*/
    
57. /* Private functions ---------------------------------------------------------*/
    
58. static FLASH_Status EE_Format(void);
    
59. static uint16_t EE_FindValidPage(uint8_t Operation);
    
60. static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data);
    
61. static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data);
    
62. 
    
63. /**
    
64. * @brief  Restore the pages to a known good state in case of page's status
    
65. *   corruption after a power loss.
    
66. * @param  None.
    
67. * @retval - Flash error code: on write Flash error
    
68. *         - FLASH_COMPLETE: on success
    
69. */
    
70. uint16_t EE_Init(void)
    
71. {
    
72.         uint16_t PageStatus0 = 6, PageStatus1 = 6;
    
73.         uint16_t VarIdx = 0;
    
74.         uint16_t EepromStatus = 0, ReadStatus = 0;
    
75.         int16_t x = -1;
    
76.         uint16_t FlashStatus;
    
77. 
    
78.         /* Get Page0 status */
    
79.         PageStatus0 = (*(__IO uint16_t*) PAGE0_BASE_ADDRESS);
    
80.         /* Get Page1 status */
    
81.         PageStatus1 = (*(__IO uint16_t*) PAGE1_BASE_ADDRESS);
    
82. 
    
83.         /* Check for invalid header states and repair if necessary */
    
84.         switch (PageStatus0)
    
85.         {
    
86.         case ERASED:
    
87.                 if (PageStatus1 == VALID_PAGE) /* Page0 erased, Page1 valid */
    
88.                 {
    
89.                         /* Erase Page0 */
    
90.                         FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
    
91.                         /* If erase operation was failed, a Flash error code is returned */
    
92.                         if (FlashStatus != FLASH_COMPLETE)
    
93.                         {
    
94.                                 return FlashStatus;
    
95.                         }
    
96.                 }
    
97.                 else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */
    
98.                 {
    
99.                         /* Erase Page0 */
    
100.                         FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
     
101.                         /* If erase operation was failed, a Flash error code is returned */
     
102.                         if (FlashStatus != FLASH_COMPLETE)
     
103.                         {
     
104.                                 return FlashStatus;
     
105.                         }
     
106.                         /* Mark Page1 as valid */
     
107.                         FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
     
108.                         /* If program operation was failed, a Flash error code is returned */
     
109.                         if (FlashStatus != FLASH_COMPLETE)
     
110.                         {
     
111.                                 return FlashStatus;
     
112.                         }
     
113.                 }
     
114.                 else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
     
115.                 {
     
116.                         /* Erase both Page0 and Page1 and set Page0 as valid page */
     
117.                         FlashStatus = EE_Format();
     
118.                         /* If erase/program operation was failed, a Flash error code is returned */
     
119.                         if (FlashStatus != FLASH_COMPLETE)
     
120.                         {
     
121.                                 return FlashStatus;
     
122.                         }
     
123.                 }
     
124.                 break;
     
125. 
     
126.         case RECEIVE_DATA:
     
127.                 if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */
     
128.                 {
     
129.                         /* Transfer data from Page1 to Page0 */
     
130.                         for (VarIdx = 0; VarIdx < EEPROM_NumbOfVar; VarIdx++)
     
131.                         {
     
132.                                 if ((*(__IO uint16_t*) (PAGE0_BASE_ADDRESS + 6))
     
133.                                                 == EEPROM_VirtAddVarTab[VarIdx])
     
134.                                 {
     
135.                                         x = VarIdx;
     
136.                                 }
     
137.                                 if (VarIdx != x)
     
138.                                 {
     
139.                                         /* Read the last variables' updates */
     
140.                                         ReadStatus = EE_ReadVariable(EEPROM_VirtAddVarTab[VarIdx],
     
141.                                                         &DataVar);
     
142.                                         /* In case variable corresponding to the virtual address was found */
     
143.                                         if (ReadStatus != 0x1)
     
144.                                         {
     
145.                                                 /* Transfer the variable to the Page0 */
     
146.                                                 EepromStatus = EE_VerifyPageFullWriteVariable(
     
147.                                                                 EEPROM_VirtAddVarTab[VarIdx], DataVar);
     
148.                                                 /* If program operation was failed, a Flash error code is returned */
     
149.                                                 if (EepromStatus != FLASH_COMPLETE)
     
150.                                                 {
     
151.                                                         return EepromStatus;
     
152.                                                 }
     
153.                                         }
     
154.                                 }
     
155.                         }
     
156.                         /* Mark Page0 as valid */
     
157.                         FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
     
158.                         /* If program operation was failed, a Flash error code is returned */
     
159.                         if (FlashStatus != FLASH_COMPLETE)
     
160.                         {
     
161.                                 return FlashStatus;
     
162.                         }
     
163.                         /* Erase Page1 */
     
164.                         FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
     
165.                         /* If erase operation was failed, a Flash error code is returned */
     
166.                         if (FlashStatus != FLASH_COMPLETE)
     
167.                         {
     
168.                                 return FlashStatus;
     
169.                         }
     
170.                 }
     
171.                 else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */
     
172.                 {
     
173.                         /* Erase Page1 */
     
174.                         FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
     
175.                         /* If erase operation was failed, a Flash error code is returned */
     
176.                         if (FlashStatus != FLASH_COMPLETE)
     
177.                         {
     
178.                                 return FlashStatus;
     
179.                         }
     
180.                         /* Mark Page0 as valid */
     
181.                         FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
     
182.                         /* If program operation was failed, a Flash error code is returned */
     
183.                         if (FlashStatus != FLASH_COMPLETE)
     
184.                         {
     
185.                                 return FlashStatus;
     
186.                         }
     
187.                 }
     
188.                 else /* Invalid state -> format eeprom */
     
189.                 {
     
190.                         /* Erase both Page0 and Page1 and set Page0 as valid page */
     
191.                         FlashStatus = EE_Format();
     
192.                         /* If erase/program operation was failed, a Flash error code is returned */
     
193.                         if (FlashStatus != FLASH_COMPLETE)
     
194.                         {
     
195.                                 return FlashStatus;
     
196.                         }
     
197.                 }
     
198.                 break;
     
199. 
     
200.         case VALID_PAGE:
     
201.                 if (PageStatus1 == VALID_PAGE) /* Invalid state -> format eeprom */
     
202.                 {
     
203.                         /* Erase both Page0 and Page1 and set Page0 as valid page */
     
204.                         FlashStatus = EE_Format();
     
205.                         /* If erase/program operation was failed, a Flash error code is returned */
     
206.                         if (FlashStatus != FLASH_COMPLETE)
     
207.                         {
     
208.                                 return FlashStatus;
     
209.                         }
     
210.                 }
     
211.                 else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */
     
212.                 {
     
213.                         /* Erase Page1 */
     
214.                         FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
     
215.                         /* If erase operation was failed, a Flash error code is returned */
     
216.                         if (FlashStatus != FLASH_COMPLETE)
     
217.                         {
     
218.                                 return FlashStatus;
     
219.                         }
     
220.                 }
     
221.                 else /* Page0 valid, Page1 receive */
     
222.                 {
     
223.                         /* Transfer data from Page0 to Page1 */
     
224.                         for (VarIdx = 0; VarIdx < EEPROM_NumbOfVar; VarIdx++)
     
225.                         {
     
226.                                 if ((*(__IO uint16_t*) (PAGE1_BASE_ADDRESS + 6))
     
227.                                                 == EEPROM_VirtAddVarTab[VarIdx])
     
228.                                 {
     
229.                                         x = VarIdx;
     
230.                                 }
     
231.                                 if (VarIdx != x)
     
232.                                 {
     
233.                                         /* Read the last variables' updates */
     
234.                                         ReadStatus = EE_ReadVariable(EEPROM_VirtAddVarTab[VarIdx],
     
235.                                                         &DataVar);
     
236.                                         /* In case variable corresponding to the virtual address was found */
     
237.                                         if (ReadStatus != 0x1)
     
238.                                         {
     
239.                                                 /* Transfer the variable to the Page1 */
     
240.                                                 EepromStatus = EE_VerifyPageFullWriteVariable(
     
241.                                                                 EEPROM_VirtAddVarTab[VarIdx], DataVar);
     
242.                                                 /* If program operation was failed, a Flash error code is returned */
     
243.                                                 if (EepromStatus != FLASH_COMPLETE)
     
244.                                                 {
     
245.                                                         return EepromStatus;
     
246.                                                 }
     
247.                                         }
     
248.                                 }
     
249.                         }
     
250.                         /* Mark Page1 as valid */
     
251.                         FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
     
252.                         /* If program operation was failed, a Flash error code is returned */
     
253.                         if (FlashStatus != FLASH_COMPLETE)
     
254.                         {
     
255.                                 return FlashStatus;
     
256.                         }
     
257.                         /* Erase Page0 */
     
258.                         FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
     
259.                         /* If erase operation was failed, a Flash error code is returned */
     
260.                         if (FlashStatus != FLASH_COMPLETE)
     
261.                         {
     
262.                                 return FlashStatus;
     
263.                         }
     
264.                 }
     
265.                 break;
     
266. 
     
267.         default: /* Any other state -> format eeprom */
     
268.                 /* Erase both Page0 and Page1 and set Page0 as valid page */
     
269.                 FlashStatus = EE_Format();
     
270.                 /* If erase/program operation was failed, a Flash error code is returned */
     
271.                 if (FlashStatus != FLASH_COMPLETE)
     
272.                 {
     
273.                         return FlashStatus;
     
274.                 }
     
275.                 break;
     
276.         }
     
277. 
     
278.         return FLASH_COMPLETE;
     
279. }
     
280. 
     
281. /**
     
282. * @brief  Returns the last stored variable data, if found, which correspond to
     
283. *   the passed virtual address
     
284. * @param  VirtAddress: Variable virtual address
     
285. * @param  Data: Global variable contains the read variable value
     
286. * @retval Success or error status:
     
287. *           - 0: if variable was found
     
288. *           - 1: if the variable was not found
     
289. *           - NO_VALID_PAGE: if no valid page was found.
     
290. */
     
291. uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
     
292. {
     
293.         uint16_t ValidPage = PAGE0;
     
294.         uint16_t AddressValue = 0x5555, ReadStatus = 1;
     
295.         uint32_t Address = 0x08010000, PageStartAddress = 0x08010000;
     
296. 
     
297.         /* Get active Page for read operation */
     
298.         ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
     
299. 
     
300.         /* Check if there is no valid page */
     
301.         if (ValidPage == NO_VALID_PAGE)
     
302.         {
     
303.                 return NO_VALID_PAGE;
     
304.         }
     
305. 
     
306.         /* Get the valid Page start Address */
     
307.         PageStartAddress = (uint32_t) (EEPROM_START_ADDRESS
     
308.                         + (uint32_t) (ValidPage * PAGE_SIZE ));
     
309. 
     
310.         /* Get the valid Page end Address */
     
311.         Address = (uint32_t) ((EEPROM_START_ADDRESS - 2)
     
312.                         + (uint32_t) ((1 + ValidPage) * PAGE_SIZE ));
     
313. 
     
314.         /* Check each active page address starting from end */
     
315.         while (Address > (PageStartAddress + 2))
     
316.         {
     
317.                 /* Get the current location content to be compared with virtual address */
     
318.                 AddressValue = (*(__IO uint16_t*) Address);
     
319. 
     
320.                 /* Compare the read address with the virtual address */
     
321.                 if (AddressValue == VirtAddress)
     
322.                 {
     
323.                         /* Get content of Address-2 which is variable value */
     
324.                         *Data = (*(__IO uint16_t*) (Address - 2));
     
325. 
     
326.                         /* In case variable value is read, reset ReadStatus flag */
     
327.                         ReadStatus = 0;
     
328. 
     
329.                         break;
     
330.                 }
     
331.                 else
     
332.                 {
     
333.                         /* Next address location */
     
334.                         Address = Address - 4;
     
335.                 }
     
336.         }
     
337. 
     
338.         /* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
     
339.         return ReadStatus;
     
340. }
     
341. 
     
342. /**
     
343. * @brief  Writes/upadtes variable data in EEPROM.
     
344. * @param  VirtAddress: Variable virtual address
     
345. * @param  Data: 16 bit data to be written
     
346. * @retval Success or error status:
     
347. *           - FLASH_COMPLETE: on success
     
348. *           - PAGE_FULL: if valid page is full
     
349. *           - NO_VALID_PAGE: if no valid page was found
     
350. *           - Flash error code: on write Flash error
     
351. */
     
352. uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
     
353. {
     
354.         uint16_t Status = 0;
     
355. 
     
356.         /* Write the variable virtual address and value in the EEPROM */
     
357.         Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
     
358. 
     
359.         /* In case the EEPROM active page is full */
     
360.         if (Status == PAGE_FULL)
     
361.         {
     
362.                 /* Perform Page transfer */
     
363.                 Status = EE_PageTransfer(VirtAddress, Data);
     
364.         }
     
365. 
     
366.         /* Return last operation status */
     
367.         return Status;
     
368. }
     
369. 
     
370. /**
     
371. * @brief  Erases PAGE0 and PAGE1 and writes VALID_PAGE header to PAGE0
     
372. * @param  None
     
373. * @retval Status of the last operation (Flash write or erase) done during
     
374. *         EEPROM formating
     
375. */
     
376. static FLASH_Status EE_Format(void)
     
377. {
     
378.         FLASH_Status FlashStatus = FLASH_COMPLETE;
     
379. 
     
380.         /* Erase Page0 */
     
381.         FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
     
382. 
     
383.         /* If erase operation was failed, a Flash error code is returned */
     
384.         if (FlashStatus != FLASH_COMPLETE)
     
385.         {
     
386.                 return FlashStatus;
     
387.         }
     
388. 
     
389.         /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
     
390.         FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
     
391. 
     
392.         /* If program operation was failed, a Flash error code is returned */
     
393.         if (FlashStatus != FLASH_COMPLETE)
     
394.         {
     
395.                 return FlashStatus;
     
396.         }
     
397. 
     
398.         /* Erase Page1 */
     
399.         FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
     
400. 
     
401.         /* Return Page1 erase operation status */
     
402.         return FlashStatus;
     
403. }
     
404. 
     
405. /**
     
406. * @brief  Find valid Page for write or read operation
     
407. * @param  Operation: operation to achieve on the valid page.
     
408. *   This parameter can be one of the following values:
     
409. *     @arg READ_FROM_VALID_PAGE: read operation from valid page
     
410. *     @arg WRITE_IN_VALID_PAGE: write operation from valid page
     
411. * @retval Valid page number (PAGE0 or PAGE1) or NO_VALID_PAGE in case
     
412. *   of no valid page was found
     
413. */
     
414. static uint16_t EE_FindValidPage(uint8_t Operation)
     
415. {
     
416.         uint16_t PageStatus0 = 6, PageStatus1 = 6;
     
417. 
     
418.         /* Get Page0 actual status */
     
419.         PageStatus0 = (*(__IO uint16_t*) PAGE0_BASE_ADDRESS);
     
420. 
     
421.         /* Get Page1 actual status */
     
422.         PageStatus1 = (*(__IO uint16_t*) PAGE1_BASE_ADDRESS);
     
423. 
     
424.         /* Write or read operation */
     
425.         switch (Operation)
     
426.         {
     
427.         case WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */
     
428.                 if (PageStatus1 == VALID_PAGE)
     
429.                 {
     
430.                         /* Page0 receiving data */
     
431.                         if (PageStatus0 == RECEIVE_DATA)
     
432.                         {
     
433.                                 return PAGE0; /* Page0 valid */
     
434.                         }
     
435.                         else
     
436.                         {
     
437.                                 return PAGE1; /* Page1 valid */
     
438.                         }
     
439.                 }
     
440.                 else if (PageStatus0 == VALID_PAGE)
     
441.                 {
     
442.                         /* Page1 receiving data */
     
443.                         if (PageStatus1 == RECEIVE_DATA)
     
444.                         {
     
445.                                 return PAGE1; /* Page1 valid */
     
446.                         }
     
447.                         else
     
448.                         {
     
449.                                 return PAGE0; /* Page0 valid */
     
450.                         }
     
451.                 }
     
452.                 else
     
453.                 {
     
454.                         return NO_VALID_PAGE; /* No valid Page */
     
455.                 }
     
456. 
     
457.         case READ_FROM_VALID_PAGE: /* ---- Read operation ---- */
     
458.                 if (PageStatus0 == VALID_PAGE)
     
459.                 {
     
460.                         return PAGE0; /* Page0 valid */
     
461.                 }
     
462.                 else if (PageStatus1 == VALID_PAGE)
     
463.                 {
     
464.                         return PAGE1; /* Page1 valid */
     
465.                 }
     
466.                 else
     
467.                 {
     
468.                         return NO_VALID_PAGE; /* No valid Page */
     
469.                 }
     
470. 
     
471.         default:
     
472.                 return PAGE0; /* Page0 valid */
     
473.         }
     
474. }
     
475. 
     
476. /**
     
477. * @brief  Verify if active page is full and Writes variable in EEPROM.
     
478. * @param  VirtAddress: 16 bit virtual address of the variable
     
479. * @param  Data: 16 bit data to be written as variable value
     
480. * @retval Success or error status:
     
481. *           - FLASH_COMPLETE: on success
     
482. *           - PAGE_FULL: if valid page is full
     
483. *           - NO_VALID_PAGE: if no valid page was found
     
484. *           - Flash error code: on write Flash error
     
485. */
     
486. static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress,
     
487.                 uint16_t Data)
     
488. {
     
489.         FLASH_Status FlashStatus = FLASH_COMPLETE;
     
490.         uint16_t ValidPage = PAGE0;
     
491.         uint32_t Address = 0x08010000, PageEndAddress = 0x080107FF;
     
492. 
     
493.         /* Get valid Page for write operation */
     
494.         ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
     
495. 
     
496.         /* Check if there is no valid page */
     
497.         if (ValidPage == NO_VALID_PAGE)
     
498.         {
     
499.                 return NO_VALID_PAGE;
     
500.         }
     
501. 
     
502.         /* Get the valid Page start Address */
     
503.         Address = (uint32_t) (EEPROM_START_ADDRESS
     
504.                         + (uint32_t) (ValidPage * PAGE_SIZE ));
     
505. 
     
506.         /* Get the valid Page end Address */
     
507.         PageEndAddress = (uint32_t) ((EEPROM_START_ADDRESS - 2)
     
508.                         + (uint32_t) ((1 + ValidPage) * PAGE_SIZE ));
     
509. 
     
510.         /* Check each active page address starting from begining */
     
511.         while (Address < PageEndAddress)
     
512.         {
     
513.                 /* Verify if Address and Address+2 contents are 0xFFFFFFFF */
     
514.                 if ((*(__IO uint32_t*) Address) == 0xFFFFFFFF)
     
515.                 {
     
516.                         /* Set variable data */
     
517.                         FlashStatus = FLASH_ProgramHalfWord(Address, Data);
     
518.                         /* If program operation was failed, a Flash error code is returned */
     
519.                         if (FlashStatus != FLASH_COMPLETE)
     
520.                         {
     
521.                                 return FlashStatus;
     
522.                         }
     
523.                         /* Set variable virtual address */
     
524.                         FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);
     
525.                         /* Return program operation status */
     
526.                         return FlashStatus;
     
527.                 }
     
528.                 else
     
529.                 {
     
530.                         /* Next address location */
     
531.                         Address = Address + 4;
     
532.                 }
     
533.         }
     
534. 
     
535.         /* Return PAGE_FULL in case the valid page is full */
     
536.         return PAGE_FULL;
     
537. }
     
538. 
     
539. /**
     
540. * @brief  Transfers last updated variables data from the full Page to
     
541. *   an empty one.
     
542. * @param  VirtAddress: 16 bit virtual address of the variable
     
543. * @param  Data: 16 bit data to be written as variable value
     
544. * @retval Success or error status:
     
545. *           - FLASH_COMPLETE: on success
     
546. *           - PAGE_FULL: if valid page is full
     
547. *           - NO_VALID_PAGE: if no valid page was found
     
548. *           - Flash error code: on write Flash error
     
549. */
     
550. static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
     
551. {
     
552.         FLASH_Status FlashStatus = FLASH_COMPLETE;
     
553.         uint32_t NewPageAddress = 0x080103FF, OldPageAddress = 0x08010000;
     
554.         uint16_t ValidPage = PAGE0, VarIdx = 0;
     
555.         uint16_t EepromStatus = 0, ReadStatus = 0;
     
556. 
     
557.         /* Get active Page for read operation */
     
558.         ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
     
559. 
     
560.         if (ValidPage == PAGE1) /* Page1 valid */
     
561.         {
     
562.                 /* New page address where variable will be moved to */
     
563.                 NewPageAddress = PAGE0_BASE_ADDRESS;
     
564. 
     
565.                 /* Old page address where variable will be taken from */
     
566.                 OldPageAddress = PAGE1_BASE_ADDRESS;
     
567.         }
     
568.         else if (ValidPage == PAGE0) /* Page0 valid */
     
569.         {
     
570.                 /* New page address where variable will be moved to */
     
571.                 NewPageAddress = PAGE1_BASE_ADDRESS;
     
572. 
     
573.                 /* Old page address where variable will be taken from */
     
574.                 OldPageAddress = PAGE0_BASE_ADDRESS;
     
575.         }
     
576.         else
     
577.         {
     
578.                 return NO_VALID_PAGE; /* No valid Page */
     
579.         }
     
580. 
     
581.         /* Set the new Page status to RECEIVE_DATA status */
     
582.         FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, RECEIVE_DATA);
     
583.         /* If program operation was failed, a Flash error code is returned */
     
584.         if (FlashStatus != FLASH_COMPLETE)
     
585.         {
     
586.                 return FlashStatus;
     
587.         }
     
588. 
     
589.         /* Write the variable passed as parameter in the new active page */
     
590.         EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
     
591.         /* If program operation was failed, a Flash error code is returned */
     
592.         if (EepromStatus != FLASH_COMPLETE)
     
593.         {
     
594.                 return EepromStatus;
     
595.         }
     
596. 
     
597.         /* Transfer process: transfer variables from old to the new active page */
     
598.         for (VarIdx = 0; VarIdx < EEPROM_NumbOfVar; VarIdx++)
     
599.         {
     
600.                 if (EEPROM_VirtAddVarTab[VarIdx] != VirtAddress) /* Check each variable except the one passed as parameter */
     
601.                 {
     
602.                         /* Read the other last variable updates */
     
603.                         ReadStatus = EE_ReadVariable(EEPROM_VirtAddVarTab[VarIdx], &DataVar);
     
604.                         /* In case variable corresponding to the virtual address was found */
     
605.                         if (ReadStatus != 0x1)
     
606.                         {
     
607.                                 /* Transfer the variable to the new active page */
     
608.                                 EepromStatus = EE_VerifyPageFullWriteVariable(
     
609.                                                 EEPROM_VirtAddVarTab[VarIdx], DataVar);
     
610.                                 /* If program operation was failed, a Flash error code is returned */
     
611.                                 if (EepromStatus != FLASH_COMPLETE)
     
612.                                 {
     
613.                                         return EepromStatus;
     
614.                                 }
     
615.                         }
     
616.                 }
     
617.         }
     
618. 
     
619.         /* Erase the old Page: Set old Page status to ERASED status */
     
620.         FlashStatus = FLASH_ErasePage(OldPageAddress);
     
621.         /* If erase operation was failed, a Flash error code is returned */
     
622.         if (FlashStatus != FLASH_COMPLETE)
     
623.         {
     
624.                 return FlashStatus;
     
625.         }
     
626. 
     
627.         /* Set new Page status to VALID_PAGE status */
     
628.         FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, VALID_PAGE);
     
629.         /* If program operation was failed, a Flash error code is returned */
     
630.         if (FlashStatus != FLASH_COMPLETE)
     
631.         {
     
632.                 return FlashStatus;
     
633.         }
     
634. 
     
635.         /* Return last operation flash status */
     
636.         return FlashStatus;
     
637. }
     
638. 
     
639. /**
     
640. * @}
     
641. */
     
642. 
     
643. /******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/
     

复制代码

STM32F407
头文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    EEPROM_Emulation/inc/eeprom.h
   
4.   * @author  MCD Application Team
   
5.    * @version V1.0.0
   
6.   * @date    10-October-2011
   
7.   * @brief   This file contains all the functions prototypes for the EEPROM
   
8.   *          emulation firmware library.
   
9.   ******************************************************************************
   
10.   * @attention
    
11.   *
    
12.   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    
13.   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    
14.   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
    
15.   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    
16.   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    
17.   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    
18.   *
    
19.   * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
    
20.   ******************************************************************************
    
21.   */
    
22. 
    
23. /* Define to prevent recursive inclusion -------------------------------------*/
    
24. #ifndef __EEPROM_H
    
25. #define __EEPROM_H
    
26. 
    
27. /* Includes ------------------------------------------------------------------*/
    
28. #include "stm32f4xx.h"
    
29. 
    
30. /* Exported constants --------------------------------------------------------*/
    
31. 
    
32. #define ADDR_FLASH_SECTOR_0                        ((uint32_t) 0x08000000)
    
33. #define ADDR_FLASH_SECTOR_1                        ((uint32_t) 0x08004000)
    
34. #define ADDR_FLASH_SECTOR_2                        ((uint32_t) 0x08008000)
    
35. #define ADDR_FLASH_SECTOR_3                        ((uint32_t) 0x0800C000)
    
36. #define ADDR_FLASH_SECTOR_4                        ((uint32_t) 0x08010000)
    
37. #define ADDR_FLASH_SECTOR_5                        ((uint32_t) 0x08020000)
    
38. #define ADDR_FLASH_SECTOR_6                        ((uint32_t) 0x08040000)
    
39. #define ADDR_FLASH_SECTOR_7                        ((uint32_t) 0x08060000)
    
40. #define ADDR_FLASH_SECTOR_8                        ((uint32_t) 0x08080000)
    
41. #define ADDR_FLASH_SECTOR_9                        ((uint32_t) 0x080A0000)
    
42. #define ADDR_FLASH_SECTOR_10                        ((uint32_t) 0x080C0000)
    
43. #define ADDR_FLASH_SECTOR_11                        ((uint32_t) 0x080E0000)
    
44. 
    
45. #define ADDR_FLASH_SECTOR_12                        ((uint32_t) 0x08100000)
    
46. #define ADDR_FLASH_SECTOR_13                        ((uint32_t) 0x08104000)
    
47. #define ADDR_FLASH_SECTOR_14                        ((uint32_t) 0x08108000)
    
48. #define ADDR_FLASH_SECTOR_15                        ((uint32_t) 0x0810C000)
    
49. #define ADDR_FLASH_SECTOR_16                        ((uint32_t) 0x08110000)
    
50. #define ADDR_FLASH_SECTOR_17                        ((uint32_t) 0x08120000)
    
51. #define ADDR_FLASH_SECTOR_18                        ((uint32_t) 0x08140000)
    
52. #define ADDR_FLASH_SECTOR_19                        ((uint32_t) 0x08160000)
    
53. #define ADDR_FLASH_SECTOR_20                ((uint32_t) 0x08180000)
    
54. #define ADDR_FLASH_SECTOR_21                        ((uint32_t) 0x081A0000)
    
55. #define ADDR_FLASH_SECTOR_22                ((uint32_t) 0x081C0000)
    
56. #define ADDR_FLASH_SECTOR_23                ((uint32_t) 0x081E0000)
    
57. 
    
58. /*Bootload占用了Flash的0~1扇区，模拟EEPROM占用2~3扇区，用户APP从4扇区开始启动*/
    
59. 
    
60. /* Define the size of the sectors to be used */
    
61. #define PAGE_SIZE               (uint32_t)0x4000  /* Page size = 16KByte */
    
62. 
    
63. /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
    
64.    be done by word  */
    
65. #define VOLTAGE_RANGE           (uint8_t)VoltageRange_3
    
66. 
    
67. /* EEPROM start address in Flash */
    
68. /* EEPROM emulation start address: from sector2 : after 16KByte of usedFlash memory */
    
69. #define EEPROM_START_ADDRESS  ADDR_FLASH_SECTOR_2
    
70. 
    
71. /* Pages 0 and 1 base and end addresses */
    
72. #define PAGE0_BASE_ADDRESS    ((uint32_t)(EEPROM_START_ADDRESS + 0x0000))
    
73. #define PAGE0_END_ADDRESS     ((uint32_t)(EEPROM_START_ADDRESS + (PAGE_SIZE - 1)))
    
74. #define PAGE0_ID               FLASH_Sector_2
    
75. 
    
76. #define PAGE1_BASE_ADDRESS    ((uint32_t)(EEPROM_START_ADDRESS + 0x4000))
    
77. #define PAGE1_END_ADDRESS     ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))
    
78. #define PAGE1_ID               FLASH_Sector_3
    
79. 
    
80. /* Used Flash pages for EEPROM emulation */
    
81. #define PAGE0                 ((uint16_t)0x0000)
    
82. #define PAGE1                 ((uint16_t)0x0001)
    
83. 
    
84. /* No valid page define */
    
85. #define NO_VALID_PAGE         ((uint16_t)0x00AB)
    
86. 
    
87. /* Page status definitions */
    
88. #define ERASED                ((uint16_t)0xFFFF)     /* Page is empty */
    
89. #define RECEIVE_DATA          ((uint16_t)0xEEEE)     /* Page is marked to receive data */
    
90. #define VALID_PAGE            ((uint16_t)0x0000)     /* Page containing valid data */
    
91. 
    
92. /* Valid pages in read and write defines */
    
93. #define READ_FROM_VALID_PAGE  ((uint8_t)0x00)
    
94. #define WRITE_IN_VALID_PAGE   ((uint8_t)0x01)
    
95. 
    
96. /* Page full define */
    
97. #define PAGE_FULL             ((uint8_t)0x80)
    
98. 
    
99. /* Variables' number */
    
100. #define EEPROM_NumbOfVar                128
     
101. extern uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar];
     
102. 
     
103. /* Exported types ------------------------------------------------------------*/
     
104. /* Exported macro ------------------------------------------------------------*/
     
105. /* Exported functions ------------------------------------------------------- */
     
106. uint16_t EE_Init(void);
     
107. uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
     
108. uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
     
109. 
     
110. #endif /* __EEPROM_H */
     
111. 
     
112. /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
     

复制代码

源文件

1. /**
   
2.   ******************************************************************************
   
3.   * @file    EEPROM_Emulation/src/eeprom.c
   
4.   * @author  MCD Application Team
   
5.   * @version V1.0.0
   
6.   * @date    10-October-2011
   
7.   * @brief   This file provides all the EEPROM emulation firmware functions.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    
12.   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    
13.   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
    
14.   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    
15.   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    
16.   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    
17.   *
    
18.   * <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
    
19.   ******************************************************************************
    
20.   */
    
21. 
    
22. /** @addtogroup EEPROM_Emulation
    
23.   * @{
    
24.   */
    
25. 
    
26. /* Includes ------------------------------------------------------------------*/
    
27. #include "eeprom.h"
    
28. 
    
29. /* Private typedef -----------------------------------------------------------*/
    
30. /* Private define ------------------------------------------------------------*/
    
31. /* Private macro -------------------------------------------------------------*/
    
32. /* Private variables ---------------------------------------------------------*/
    
33. 
    
34. /* Global variable used to store variable value in read sequence */
    
35. uint16_t DataVar = 0;
    
36. 
    
37. /* Virtual address defined by the user: 0xFFFF value is prohibited */
    
38. uint16_t EEPROM_VirtAddVarTab[EEPROM_NumbOfVar] =
    
39. {
    
40.         0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
    
41.         0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010,
    
42.         0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018,
    
43.         0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020,
    
44.         0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028,
    
45.         0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030,
    
46.         0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038,
    
47.         0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,
    
48.         0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048,
    
49.         0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
    
50.         0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058,
    
51.         0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060,
    
52.         0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068,
    
53.         0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070,
    
54.         0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078,
    
55.         0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, 0x0080,
    
56. };
    
57. 
    
58. /* Private function prototypes -----------------------------------------------*/
    
59. /* Private functions ---------------------------------------------------------*/
    
60. static FLASH_Status EE_Format(void);
    
61. static uint16_t EE_FindValidPage(uint8_t Operation);
    
62. static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data);
    
63. static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data);
    
64. 
    
65. /**
    
66.   * @brief  Restore the pages to a known good state in case of page's status
    
67.   *   corruption after a power loss.
    
68.   * @param  None.
    
69.   * @retval - Flash error code: on write Flash error
    
70.   *         - FLASH_COMPLETE: on success
    
71.   */
    
72. uint16_t EE_Init(void)
    
73. {
    
74.   uint16_t PageStatus0 = 6, PageStatus1 = 6;
    
75.   uint16_t VarIdx = 0;
    
76.   uint16_t EepromStatus = 0, ReadStatus = 0;
    
77.   int16_t x = -1;
    
78.   uint16_t  FlashStatus;
    
79. 
    
80.   /* Get Page0 status */
    
81.   PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
    
82.   /* Get Page1 status */
    
83.   PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);
    
84. 
    
85.   /* Check for invalid header states and repair if necessary */
    
86.   switch (PageStatus0)
    
87.   {
    
88.     case ERASED:
    
89.       if (PageStatus1 == VALID_PAGE) /* Page0 erased, Page1 valid */
    
90.       {
    
91.         /* Erase Page0 */
    
92.         FlashStatus = FLASH_EraseSector(PAGE0_ID,VOLTAGE_RANGE);
    
93.         /* If erase operation was failed, a Flash error code is returned */
    
94.         if (FlashStatus != FLASH_COMPLETE)
    
95.         {
    
96.           return FlashStatus;
    
97.         }
    
98.       }
    
99.       else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */
    
100.       {
     
101.         /* Erase Page0 */
     
102.         FlashStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
     
103.         /* If erase operation was failed, a Flash error code is returned */
     
104.         if (FlashStatus != FLASH_COMPLETE)
     
105.         {
     
106.           return FlashStatus;
     
107.         }
     
108.         /* Mark Page1 as valid */
     
109.         FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
     
110.         /* If program operation was failed, a Flash error code is returned */
     
111.         if (FlashStatus != FLASH_COMPLETE)
     
112.         {
     
113.           return FlashStatus;
     
114.         }
     
115.       }
     
116.       else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
     
117.       {
     
118.         /* Erase both Page0 and Page1 and set Page0 as valid page */
     
119.         FlashStatus = EE_Format();
     
120.         /* If erase/program operation was failed, a Flash error code is returned */
     
121.         if (FlashStatus != FLASH_COMPLETE)
     
122.         {
     
123.           return FlashStatus;
     
124.         }
     
125.       }
     
126.       break;
     
127. 
     
128.     case RECEIVE_DATA:
     
129.       if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */
     
130.       {
     
131.         /* Transfer data from Page1 to Page0 */
     
132.         for (VarIdx = 0; VarIdx < EEPROM_NumbOfVar; VarIdx++)
     
133.         {
     
134.           if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == EEPROM_VirtAddVarTab[VarIdx])
     
135.           {
     
136.             x = VarIdx;
     
137.           }
     
138.           if (VarIdx != x)
     
139.           {
     
140.             /* Read the last variables' updates */
     
141.             ReadStatus = EE_ReadVariable(EEPROM_VirtAddVarTab[VarIdx], &DataVar);
     
142.             /* In case variable corresponding to the virtual address was found */
     
143.             if (ReadStatus != 0x1)
     
144.             {
     
145.               /* Transfer the variable to the Page0 */
     
146.               EepromStatus = EE_VerifyPageFullWriteVariable(EEPROM_VirtAddVarTab[VarIdx], DataVar);
     
147.               /* If program operation was failed, a Flash error code is returned */
     
148.               if (EepromStatus != FLASH_COMPLETE)
     
149.               {
     
150.                 return EepromStatus;
     
151.               }
     
152.             }
     
153.           }
     
154.         }
     
155.         /* Mark Page0 as valid */
     
156.         FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
     
157.         /* If program operation was failed, a Flash error code is returned */
     
158.         if (FlashStatus != FLASH_COMPLETE)
     
159.         {
     
160.           return FlashStatus;
     
161.         }
     
162.         /* Erase Page1 */
     
163.         FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
     
164.         /* If erase operation was failed, a Flash error code is returned */
     
165.         if (FlashStatus != FLASH_COMPLETE)
     
166.         {
     
167.           return FlashStatus;
     
168.         }
     
169.       }
     
170.       else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */
     
171.       {
     
172.         /* Erase Page1 */
     
173.         FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
     
174.         /* If erase operation was failed, a Flash error code is returned */
     
175.         if (FlashStatus != FLASH_COMPLETE)
     
176.         {
     
177.           return FlashStatus;
     
178.         }
     
179.         /* Mark Page0 as valid */
     
180.         FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
     
181.         /* If program operation was failed, a Flash error code is returned */
     
182.         if (FlashStatus != FLASH_COMPLETE)
     
183.         {
     
184.           return FlashStatus;
     
185.         }
     
186.       }
     
187.       else /* Invalid state -> format eeprom */
     
188.       {
     
189.         /* Erase both Page0 and Page1 and set Page0 as valid page */
     
190.         FlashStatus = EE_Format();
     
191.         /* If erase/program operation was failed, a Flash error code is returned */
     
192.         if (FlashStatus != FLASH_COMPLETE)
     
193.         {
     
194.           return FlashStatus;
     
195.         }
     
196.       }
     
197.       break;
     
198. 
     
199.     case VALID_PAGE:
     
200.       if (PageStatus1 == VALID_PAGE) /* Invalid state -> format eeprom */
     
201.       {
     
202.         /* Erase both Page0 and Page1 and set Page0 as valid page */
     
203.         FlashStatus = EE_Format();
     
204.         /* If erase/program operation was failed, a Flash error code is returned */
     
205.         if (FlashStatus != FLASH_COMPLETE)
     
206.         {
     
207.           return FlashStatus;
     
208.         }
     
209.       }
     
210.       else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */
     
211.       {
     
212.         /* Erase Page1 */
     
213.         FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
     
214.         /* If erase operation was failed, a Flash error code is returned */
     
215.         if (FlashStatus != FLASH_COMPLETE)
     
216.         {
     
217.           return FlashStatus;
     
218.         }
     
219.       }
     
220.       else /* Page0 valid, Page1 receive */
     
221.       {
     
222.         /* Transfer data from Page0 to Page1 */
     
223.         for (VarIdx = 0; VarIdx < EEPROM_NumbOfVar; VarIdx++)
     
224.         {
     
225.           if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == EEPROM_VirtAddVarTab[VarIdx])
     
226.           {
     
227.             x = VarIdx;
     
228.           }
     
229.           if (VarIdx != x)
     
230.           {
     
231.             /* Read the last variables' updates */
     
232.             ReadStatus = EE_ReadVariable(EEPROM_VirtAddVarTab[VarIdx], &DataVar);
     
233.             /* In case variable corresponding to the virtual address was found */
     
234.             if (ReadStatus != 0x1)
     
235.             {
     
236.               /* Transfer the variable to the Page1 */
     
237.               EepromStatus = EE_VerifyPageFullWriteVariable(EEPROM_VirtAddVarTab[VarIdx], DataVar);
     
238.               /* If program operation was failed, a Flash error code is returned */
     
239.               if (EepromStatus != FLASH_COMPLETE)
     
240.               {
     
241.                 return EepromStatus;
     
242.               }
     
243.             }
     
244.           }
     
245.         }
     
246.         /* Mark Page1 as valid */
     
247.         FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
     
248.         /* If program operation was failed, a Flash error code is returned */
     
249.         if (FlashStatus != FLASH_COMPLETE)
     
250.         {
     
251.           return FlashStatus;
     
252.         }
     
253.         /* Erase Page0 */
     
254.         FlashStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
     
255.         /* If erase operation was failed, a Flash error code is returned */
     
256.         if (FlashStatus != FLASH_COMPLETE)
     
257.         {
     
258.           return FlashStatus;
     
259.         }
     
260.       }
     
261.       break;
     
262. 
     
263.     default:  /* Any other state -> format eeprom */
     
264.       /* Erase both Page0 and Page1 and set Page0 as valid page */
     
265.       FlashStatus = EE_Format();
     
266.       /* If erase/program operation was failed, a Flash error code is returned */
     
267.       if (FlashStatus != FLASH_COMPLETE)
     
268.       {
     
269.         return FlashStatus;
     
270.       }
     
271.       break;
     
272.   }
     
273. 
     
274.   return FLASH_COMPLETE;
     
275. }
     
276. 
     
277. /**
     
278.   * @brief  Returns the last stored variable data, if found, which correspond to
     
279.   *   the passed virtual address
     
280.   * @param  VirtAddress: Variable virtual address
     
281.   * @param  Data: Global variable contains the read variable value
     
282.   * @retval Success or error status:
     
283.   *           - 0: if variable was found
     
284.   *           - 1: if the variable was not found
     
285.   *           - NO_VALID_PAGE: if no valid page was found.
     
286.   */
     
287. uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
     
288. {
     
289.   uint16_t ValidPage = PAGE0;
     
290.   uint16_t AddressValue = 0x5555, ReadStatus = 1;
     
291.   uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS;
     
292. 
     
293.   /* Get active Page for read operation */
     
294.   ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
     
295. 
     
296.   /* Check if there is no valid page */
     
297.   if (ValidPage == NO_VALID_PAGE)
     
298.   {
     
299.     return  NO_VALID_PAGE;
     
300.   }
     
301. 
     
302.   /* Get the valid Page start Address */
     
303.   PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
     
304. 
     
305.   /* Get the valid Page end Address */
     
306.   Address = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
     
307. 
     
308.   /* Check each active page address starting from end */
     
309.   while (Address > (PageStartAddress + 2))
     
310.   {
     
311.     /* Get the current location content to be compared with virtual address */
     
312.     AddressValue = (*(__IO uint16_t*)Address);
     
313. 
     
314.     /* Compare the read address with the virtual address */
     
315.     if (AddressValue == VirtAddress)
     
316.     {
     
317.       /* Get content of Address-2 which is variable value */
     
318.       *Data = (*(__IO uint16_t*)(Address - 2));
     
319. 
     
320.       /* In case variable value is read, reset ReadStatus flag */
     
321.       ReadStatus = 0;
     
322. 
     
323.       break;
     
324.     }
     
325.     else
     
326.     {
     
327.       /* Next address location */
     
328.       Address = Address - 4;
     
329.     }
     
330.   }
     
331. 
     
332.   /* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
     
333.   return ReadStatus;
     
334. }
     
335. 
     
336. /**
     
337.   * @brief  Writes/upadtes variable data in EEPROM.
     
338.   * @param  VirtAddress: Variable virtual address
     
339.   * @param  Data: 16 bit data to be written
     
340.   * @retval Success or error status:
     
341.   *           - FLASH_COMPLETE: on success
     
342.   *           - PAGE_FULL: if valid page is full
     
343.   *           - NO_VALID_PAGE: if no valid page was found
     
344.   *           - Flash error code: on write Flash error
     
345.   */
     
346. uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
     
347. {
     
348.   uint16_t Status = 0;
     
349. 
     
350.   /* Write the variable virtual address and value in the EEPROM */
     
351.   Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
     
352. 
     
353.   /* In case the EEPROM active page is full */
     
354.   if (Status == PAGE_FULL)
     
355.   {
     
356.     /* Perform Page transfer */
     
357.     Status = EE_PageTransfer(VirtAddress, Data);
     
358.   }
     
359. 
     
360.   /* Return last operation status */
     
361.   return Status;
     
362. }
     
363. 
     
364. /**
     
365.   * @brief  Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE
     
366.   * @param  None
     
367.   * @retval Status of the last operation (Flash write or erase) done during
     
368.   *         EEPROM formating
     
369.   */
     
370. static FLASH_Status EE_Format(void)
     
371. {
     
372.   FLASH_Status FlashStatus = FLASH_COMPLETE;
     
373. 
     
374.   /* Erase Page0 */
     
375.   FlashStatus = FLASH_EraseSector(PAGE0_ID, VOLTAGE_RANGE);
     
376. 
     
377.   /* If erase operation was failed, a Flash error code is returned */
     
378.   if (FlashStatus != FLASH_COMPLETE)
     
379.   {
     
380.     return FlashStatus;
     
381.   }
     
382. 
     
383.   /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
     
384.   FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
     
385. 
     
386.   /* If program operation was failed, a Flash error code is returned */
     
387.   if (FlashStatus != FLASH_COMPLETE)
     
388.   {
     
389.     return FlashStatus;
     
390.   }
     
391. 
     
392.   /* Erase Page1 */
     
393.   FlashStatus = FLASH_EraseSector(PAGE1_ID, VOLTAGE_RANGE);
     
394. 
     
395.   /* Return Page1 erase operation status */
     
396.   return FlashStatus;
     
397. }
     
398. 
     
399. /**
     
400.   * @brief  Find valid Page for write or read operation
     
401.   * @param  Operation: operation to achieve on the valid page.
     
402.   *   This parameter can be one of the following values:
     
403.   *     @arg READ_FROM_VALID_PAGE: read operation from valid page
     
404.   *     @arg WRITE_IN_VALID_PAGE: write operation from valid page
     
405.   * @retval Valid page number (PAGE or PAGE1) or NO_VALID_PAGE in case
     
406.   *   of no valid page was found
     
407.   */
     
408. static uint16_t EE_FindValidPage(uint8_t Operation)
     
409. {
     
410.   uint16_t PageStatus0 = 6, PageStatus1 = 6;
     
411. 
     
412.   /* Get Page0 actual status */
     
413.   PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
     
414. 
     
415.   /* Get Page1 actual status */
     
416.   PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);
     
417. 
     
418.   /* Write or read operation */
     
419.   switch (Operation)
     
420.   {
     
421.     case WRITE_IN_VALID_PAGE:   /* ---- Write operation ---- */
     
422.       if (PageStatus1 == VALID_PAGE)
     
423.       {
     
424.         /* Page0 receiving data */
     
425.         if (PageStatus0 == RECEIVE_DATA)
     
426.         {
     
427.           return PAGE0;         /* Page0 valid */
     
428.         }
     
429.         else
     
430.         {
     
431.           return PAGE1;         /* Page1 valid */
     
432.         }
     
433.       }
     
434.       else if (PageStatus0 == VALID_PAGE)
     
435.       {
     
436.         /* Page1 receiving data */
     
437.         if (PageStatus1 == RECEIVE_DATA)
     
438.         {
     
439.           return PAGE1;         /* Page1 valid */
     
440.         }
     
441.         else
     
442.         {
     
443.           return PAGE0;         /* Page0 valid */
     
444.         }
     
445.       }
     
446.       else
     
447.       {
     
448.         return NO_VALID_PAGE;   /* No valid Page */
     
449.       }
     
450. 
     
451.     case READ_FROM_VALID_PAGE:  /* ---- Read operation ---- */
     
452.       if (PageStatus0 == VALID_PAGE)
     
453.       {
     
454.         return PAGE0;           /* Page0 valid */
     
455.       }
     
456.       else if (PageStatus1 == VALID_PAGE)
     
457.       {
     
458.         return PAGE1;           /* Page1 valid */
     
459.       }
     
460.       else
     
461.       {
     
462.         return NO_VALID_PAGE ;  /* No valid Page */
     
463.       }
     
464. 
     
465.     default:
     
466.       return PAGE0;             /* Page0 valid */
     
467.   }
     
468. }
     
469. 
     
470. /**
     
471.   * @brief  Verify if active page is full and Writes variable in EEPROM.
     
472.   * @param  VirtAddress: 16 bit virtual address of the variable
     
473.   * @param  Data: 16 bit data to be written as variable value
     
474.   * @retval Success or error status:
     
475.   *           - FLASH_COMPLETE: on success
     
476.   *           - PAGE_FULL: if valid page is full
     
477.   *           - NO_VALID_PAGE: if no valid page was found
     
478.   *           - Flash error code: on write Flash error
     
479.   */
     
480. static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data)
     
481. {
     
482.   FLASH_Status FlashStatus = FLASH_COMPLETE;
     
483.   uint16_t ValidPage = PAGE0;
     
484.   uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE;
     
485. 
     
486.   /* Get valid Page for write operation */
     
487.   ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
     
488. 
     
489.   /* Check if there is no valid page */
     
490.   if (ValidPage == NO_VALID_PAGE)
     
491.   {
     
492.     return  NO_VALID_PAGE;
     
493.   }
     
494. 
     
495.   /* Get the valid Page start Address */
     
496.   Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
     
497. 
     
498.   /* Get the valid Page end Address */
     
499.   PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
     
500. 
     
501.   /* Check each active page address starting from begining */
     
502.   while (Address < PageEndAddress)
     
503.   {
     
504.     /* Verify if Address and Address+2 contents are 0xFFFFFFFF */
     
505.     if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF)
     
506.     {
     
507.       /* Set variable data */
     
508.       FlashStatus = FLASH_ProgramHalfWord(Address, Data);
     
509.       /* If program operation was failed, a Flash error code is returned */
     
510.       if (FlashStatus != FLASH_COMPLETE)
     
511.       {
     
512.         return FlashStatus;
     
513.       }
     
514.       /* Set variable virtual address */
     
515.       FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);
     
516.       /* Return program operation status */
     
517.       return FlashStatus;
     
518.     }
     
519.     else
     
520.     {
     
521.       /* Next address location */
     
522.       Address = Address + 4;
     
523.     }
     
524.   }
     
525. 
     
526.   /* Return PAGE_FULL in case the valid page is full */
     
527.   return PAGE_FULL;
     
528. }
     
529. 
     
530. /**
     
531.   * @brief  Transfers last updated variables data from the full Page to
     
532.   *   an empty one.
     
533.   * @param  VirtAddress: 16 bit virtual address of the variable
     
534.   * @param  Data: 16 bit data to be written as variable value
     
535.   * @retval Success or error status:
     
536.   *           - FLASH_COMPLETE: on success
     
537.   *           - PAGE_FULL: if valid page is full
     
538.   *           - NO_VALID_PAGE: if no valid page was found
     
539.   *           - Flash error code: on write Flash error
     
540.   */
     
541. static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
     
542. {
     
543.   FLASH_Status FlashStatus = FLASH_COMPLETE;
     
544.   uint32_t NewPageAddress = EEPROM_START_ADDRESS;
     
545.   uint16_t OldPageId=0;
     
546.   uint16_t ValidPage = PAGE0, VarIdx = 0;
     
547.   uint16_t EepromStatus = 0, ReadStatus = 0;
     
548. 
     
549.   /* Get active Page for read operation */
     
550.   ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
     
551. 
     
552.   if (ValidPage == PAGE1)       /* Page1 valid */
     
553.   {
     
554.     /* New page address where variable will be moved to */
     
555.     NewPageAddress = PAGE0_BASE_ADDRESS;
     
556. 
     
557.     /* Old page ID where variable will be taken from */
     
558.     OldPageId = PAGE1_ID;
     
559.   }
     
560.   else if (ValidPage == PAGE0)  /* Page0 valid */
     
561.   {
     
562.     /* New page address  where variable will be moved to */
     
563.     NewPageAddress = PAGE1_BASE_ADDRESS;
     
564. 
     
565.     /* Old page ID where variable will be taken from */
     
566.     OldPageId = PAGE0_ID;
     
567.   }
     
568.   else
     
569.   {
     
570.     return NO_VALID_PAGE;       /* No valid Page */
     
571.   }
     
572. 
     
573.   /* Set the new Page status to RECEIVE_DATA status */
     
574.   FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, RECEIVE_DATA);
     
575.   /* If program operation was failed, a Flash error code is returned */
     
576.   if (FlashStatus != FLASH_COMPLETE)
     
577.   {
     
578.     return FlashStatus;
     
579.   }
     
580. 
     
581.   /* Write the variable passed as parameter in the new active page */
     
582.   EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
     
583.   /* If program operation was failed, a Flash error code is returned */
     
584.   if (EepromStatus != FLASH_COMPLETE)
     
585.   {
     
586.     return EepromStatus;
     
587.   }
     
588. 
     
589.   /* Transfer process: transfer variables from old to the new active page */
     
590.   for (VarIdx = 0; VarIdx < EEPROM_NumbOfVar; VarIdx++)
     
591.   {
     
592.     if (EEPROM_VirtAddVarTab[VarIdx] != VirtAddress)  /* Check each variable except the one passed as parameter */
     
593.     {
     
594.       /* Read the other last variable updates */
     
595.       ReadStatus = EE_ReadVariable(EEPROM_VirtAddVarTab[VarIdx], &DataVar);
     
596.       /* In case variable corresponding to the virtual address was found */
     
597.       if (ReadStatus != 0x1)
     
598.       {
     
599.         /* Transfer the variable to the new active page */
     
600.         EepromStatus = EE_VerifyPageFullWriteVariable(EEPROM_VirtAddVarTab[VarIdx], DataVar);
     
601.         /* If program operation was failed, a Flash error code is returned */
     
602.         if (EepromStatus != FLASH_COMPLETE)
     
603.         {
     
604.           return EepromStatus;
     
605.         }
     
606.       }
     
607.     }
     
608.   }
     
609. 
     
610.   /* Erase the old Page: Set old Page status to ERASED status */
     
611.   FlashStatus = FLASH_EraseSector(OldPageId, VOLTAGE_RANGE);
     
612.   /* If erase operation was failed, a Flash error code is returned */
     
613.   if (FlashStatus != FLASH_COMPLETE)
     
614.   {
     
615.     return FlashStatus;
     
616.   }
     
617. 
     
618.   /* Set new Page status to VALID_PAGE status */
     
619.   FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, VALID_PAGE);
     
620.   /* If program operation was failed, a Flash error code is returned */
     
621.   if (FlashStatus != FLASH_COMPLETE)
     
622.   {
     
623.     return FlashStatus;
     
624.   }
     
625. 
     
626.   /* Return last operation flash status */
     
627.   return FlashStatus;
     
628. }
     
629. 
     
630. /**
     
631.   * @}
     
632.   */
     
633. 
     
634. /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

复制代码

使用指南
EEPROM 仿真应用所需的扇区大小和扇区数量可根据系统使用寿命内写入的数据量进行选择。需要特别注意的是STM32F103与STM32F407的Flash扇区大小、扇区数量、扇区地址是不一样的，因此为仿真EEPROM分配扇区时，针对不同的单片机应当有不同的分配扇区策略。

以STM32F103VE为例，它的主存储器分为256页，每页大小为2KB，共512KB。由于每页的大小相同的，因此可以直接选取最后两个扇区作为EEPROM仿真应用的扇区。

以STM32F407ZG为例，它的主存储器分为12个扇区，其中包含4个16KB扇区、1个64KB扇区和7个128KB 的扇区，共1MB。由于最后的7个扇区容量过大，因此直接选取最后两个扇区是不合适的。如果选取两个16KB扇区作为EEPROM仿真应用的扇区，将破坏正常程序烧录在Flash中的结构（从第一个扇区的首地址开始烧写）。因此最好设置一个BootLoader程序（占用前两个扇区，共32K空间），然后通过此程序跳转到用户程序。用户程序从第五个扇区开始烧录。这样可以将第三与第四扇区作为EEPROM仿真应用的扇区。

应用层扩展
源码
应用层的StorableData数组以float类型的数据保存变量的值，因此需要两个16位的空间在仿真EEPROM中储存。通过定义一个联合体类型，可以方便的实现float类型的数据与16位字节数组的相互转换。

1. typedef union
   
2. {
   
3.         float toFloat;
   
4.         uint16_t toUint16Array[2];
   
5. } EepDataUnion;

复制代码

要使用一个完善的“可存储类型”的变量，还需要指定在EEPROM中的存储位置、默认值、索引值等其他信息。通过定义一个结构体类型来封装可存储类型的变量：

1. typedef struct
   
2. {
   
3.         char name[6];
   
4.         EepDataUnion value;
   
5.         const EepDataUnion defaultValue;
   
6.         const uint16_t EEP_Index;
   
7.         const uint16_t GLO_Index;
   
8. } EepromData_typedef;

复制代码

EepromData_typedef结构体类型的各成员简介如下：
name为变量的名称，不影响存储与读写的功能，可以根据需要调整字符串存储空间大小
value为变量的值，这是一个联合体变量，可以通过.toFloat获取浮点数表示的值，通过.toUint16Array获取16位数组表示的值
defaultValue为变量的默认值，数据类型与value相同，它记录了这个变量的默认值。
EEP_Index为此变量在EEPROM中存储的位置，在连续存储的情况下，它一般设置为GLO_Index的两倍
GLO_Index为此变量的全局序列号，如果是在一个数组中，它应当设置为在数组中的索引号
为了增加数据存储安全性能，将全局数组变量StorableData[]的第一个成员设置为校验数据，它主要有以下几个作用：

检测是否首次烧录（启用仿真EEPROM）程序，如果是首次烧录程序（EEPROM中没有保存StorableData成员的值）则执行初始化，将StorableData成员的默认值保存在EEPROM中的对应位置。
记录MCU的启动次数。完成StorableData成员在EEPROM中的初始化之后，每次启动MCU都会将此值加1。因此通过读取此值可以判断MCU的开机次数，进而推断电路板的工作时长、使用寿命等信息。

头文件

1. #ifndef __GLOBALVARIATE_H__
   
2. #define __GLOBALVARIATE_H__
   
3. 
   
4. #include "stm32f4xx_conf.h"
   
5. #include "stm32f4xx.h"
   
6. 
   
7. typedef union
   
8. {
   
9.         float toFloat;
   
10.         uint16_t toUint16Array[2];
    
11. } EepDataUnion;
    
12. 
    
13. typedef struct
    
14. {
    
15.         char name[6];
    
16.         EepDataUnion value;
    
17.         EepDataUnion defaultValue;
    
18.         uint16_t EEP_Index;
    
19.         uint16_t GLO_Index;
    
20. } EepromData_typedef;
    
21. 
    
22. #define EEPROM_CKECKCODE_COUNT                 100000.0f
    
23. 
    
24. extern uint16_t STORABLE_DATA_COUNT;
    
25. 
    
26. extern volatile EepromData_typedef StorableData[];
    
27. 
    
28. void StorableData_InitAll();
    
29. 
    
30. void StorableData_SaveDefaultValue(const EepromData_typedef *EEPROM_Data_Struct);
    
31. void StorableData_SaveAllDefaultValue();
    
32. 
    
33. void StorableData_SaveValue(const EepromData_typedef *EEPROM_Data_Struct);
    
34. void StorableData_SaveAllValue();
    
35. 
    
36. void StorableData_LoadValueFromEEPROM(EepromData_typedef *EEPROM_Data_Struct);
    
37. void StorableData_LoadAllValueFromEEPROM();
    
38. 
    
39. void StorableData_ResetValue(EepromData_typedef *EEPROM_Data_Struct);
    
40. void StorableData_ResetAllValue();
    
41. 
    
42. void StorableData_SetValue_Float(uint16_t index, float value);
    
43. void StorableData_SetValue_16BitArray(uint16_t index, uint16_t *array);
    
44. 
    
45. float StorableData_GetValue(uint16_t index);
    
46. 
    
47. #endif

复制代码

源文件

1. #include "globalVariate.h"
   
2. #include "eeprom.h"
   
3. 
   
4. /**
   
5. * STORABLE_DATA_COUNT的值必须等于EepromData_typedef数组数量，
   
6. * 因此它将在void StorableData_InitAll()中被计算出来，以确保数值准确
   
7. */
   
8. 
   
9. uint16_t STORABLE_DATA_COUNT = 0;
   
10. 
    
11. volatile EepromData_typedef StorableData[] =
    
12. {
    
13.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = EEPROM_CKECKCODE_COUNT }, 0, 0 },
    
14. 
    
15.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 2, 1 },                //通道1：Iout1-4mA 电压
    
16.         { {""}, .value = { .toFloat = 500 }, .defaultValue = { .toFloat = 0 }, 4, 2 },                //通道1：Iout1-20mA对应电压
    
17.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 6, 3 },                //通道1：传感器类型
    
18.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 8, 4 },                //通道1：输出信号类型
    
19. 
    
20.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 10, 5 },                //通道2：Iout2-4mA对应电压
    
21.         { {""}, .value = { .toFloat = 500 }, .defaultValue = { .toFloat = 0 }, 12, 6 },                //通道2：Iout2-20mA对应电压
    
22.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 14, 7 },                //通道2：传感器类型
    
23.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 16, 8 },                //通道2：输出信号类型
    
24. };
    
25. 
    
26. 
    
27. /**
    
28. * @brief 初始化StorableData_Struct数组（应当在程序运行进入主循环之前调用）
    
29. *         主要通过第一个StorableData_Struct[0]是否等于默认值(100,000)来判断当前MCU是否为首次烧录。
    
30. *         如果当前MCU为首次烧录，则将默认值先保存进EEPROM，再加载到StorableData_Struct数组。
    
31. *         每次开机运行调用本函数时，都会将StorableData_Struct[0].value.toFloat的值加一。
    
32. *         通过读取StorableData_Struct[0].value.toFloat的值(减去100,000)，亦可以判断MCU的累计开机次数。
    
33. */
    
34. void StorableData_InitAll()
    
35. {
    
36. 
    
37.         STORABLE_DATA_COUNT = sizeof(StorableData) / sizeof(*StorableData);
    
38. 
    
39.         StorableData_LoadAllValueFromEEPROM();
    
40. 
    
41.         ///首次烧录
    
42.         if(StorableData[0].value.toFloat < EEPROM_CKECKCODE_COUNT)
    
43.         {
    
44.                 StorableData_SaveAllDefaultValue();
    
45.                 StorableData_LoadAllValueFromEEPROM();
    
46.         }
    
47.         else
    
48.         {
    
49.                 StorableData[0].value.toFloat += 1.0;
    
50.                 StorableData_SaveValue((const EepromData_typedef*) &StorableData[0]);
    
51.         }
    
52. }
    
53. 
    
54. 
    
55. /**
    
56. * @brief 将指定的StorableData默认值存储在EEPROM中
    
57. */
    
58. void StorableData_SaveDefaultValue(const EepromData_typedef *EEPROM_Data_Struct) {
    
59.         FLASH_Unlock();
    
60.         EE_Init();
    
61. 
    
62.         EE_WriteVariable(EEPROM_VirtAddVarTab[EEPROM_Data_Struct->EEP_Index],EEPROM_Data_Struct->defaultValue.toUint16Array[0]);
    
63.         EE_WriteVariable(EEPROM_VirtAddVarTab[EEPROM_Data_Struct->EEP_Index+1],EEPROM_Data_Struct->defaultValue.toUint16Array[1]);
    
64. 
    
65.         FLASH_Lock();
    
66. }
    
67. 
    
68. /**
    
69. * @brief 将全部的StorableData默认值存储在EEPROM中
    
70. */
    
71. void StorableData_SaveAllDefaultValue()
    
72. {
    
73.         FLASH_Unlock();
    
74.         EE_Init();
    
75. 
    
76.         for (uint16_t i = 0; i < STORABLE_DATA_COUNT; i++)
    
77.         {
    
78.                 EE_WriteVariable(EEPROM_VirtAddVarTab[StorableData<i>.EEP_Index],StorableData<i>.defaultValue.toUint16Array[0]);
    
79.                 EE_WriteVariable(EEPROM_VirtAddVarTab[StorableData<i>.EEP_Index+1],StorableData<i>.defaultValue.toUint16Array[1]);
    
80.         }
    
81. 
    
82.         FLASH_Lock();
    
83. }
    
84. 
    
85. 
    
86. /**
    
87. * @brief 将指定的StorableData实时值存储在EEPROM中
    
88. */
    
89. void StorableData_SaveValue(const EepromData_typedef *EEPROM_Data_Struct)
    
90. {
    
91.         FLASH_Unlock();
    
92.         EE_Init();
    
93. 
    
94.         EE_WriteVariable(EEPROM_VirtAddVarTab[EEPROM_Data_Struct->EEP_Index],EEPROM_Data_Struct->value.toUint16Array[0]);
    
95.         EE_WriteVariable(EEPROM_VirtAddVarTab[EEPROM_Data_Struct->EEP_Index+1],EEPROM_Data_Struct->value.toUint16Array[1]);
    
96. 
    
97.         FLASH_Lock();
    
98. }
    
99. 
    
100. /**
     
101. * @brief 将全部的StorableData实时值存储在EEPROM中
     
102. */
     
103. void StorableData_SaveAllValue()
     
104. {
     
105.         FLASH_Unlock();
     
106.         EE_Init();
     
107.         uint16_t count = sizeof(StorableData) / sizeof(*StorableData);
     
108.         for (uint16_t i = 0; i < count; i++)
     
109.         {
     
110.                 EE_WriteVariable(EEPROM_VirtAddVarTab[StorableData<i>.EEP_Index],StorableData<i>.value.toUint16Array[0]);
     
111.                 EE_WriteVariable(EEPROM_VirtAddVarTab[StorableData<i>.EEP_Index+1],StorableData<i>.value.toUint16Array[1]);
     
112.         }
     
113.         FLASH_Lock();
     
114. }
     
115. 
     
116. /**
     
117. * @brief 将EEPROM中对应的值赋予指定的StorableData实时值
     
118. */
     
119. void StorableData_LoadValueFromEEPROM(EepromData_typedef *EEPROM_Data_Struct)
     
120. {
     
121.         FLASH_Unlock();
     
122.         EE_Init();
     
123.         EE_ReadVariable(EEPROM_VirtAddVarTab[EEPROM_Data_Struct->EEP_Index],&EEPROM_Data_Struct->value.toUint16Array[0]);
     
124.         EE_ReadVariable(EEPROM_VirtAddVarTab[EEPROM_Data_Struct->EEP_Index+1],&EEPROM_Data_Struct->value.toUint16Array[1]);
     
125.         FLASH_Lock();
     
126. }
     
127. 
     
128. /**
     
129. * @brief 将EEPROM中全部的值赋予全部的StorableData实时值
     
130. */
     
131. void StorableData_LoadAllValueFromEEPROM()
     
132. {
     
133.         FLASH_Unlock();
     
134.         EE_Init();
     
135. 
     
136.         uint16_t count = sizeof(StorableData) / sizeof(*StorableData);
     
137.         for (uint16_t i = 0; i < count; i++)
     
138.         {
     
139.                 EE_ReadVariable(EEPROM_VirtAddVarTab[StorableData<i>.EEP_Index],(uint16_t *) &StorableData<i>.value.toUint16Array[0]);
     
140.                 EE_ReadVariable(EEPROM_VirtAddVarTab[StorableData<i>.EEP_Index+1],(uint16_t *) &StorableData<i>.value.toUint16Array[1]);
     
141.         }
     
142. 
     
143.         FLASH_Lock();
     
144. }
     
145. 
     
146. /**
     
147. * @brief 将指定的StorableData实时值重置为默认值
     
148. */
     
149. void StorableData_ResetValue(EepromData_typedef *EEPROM_Data_Struct)
     
150. {
     
151.         EEPROM_Data_Struct->value.toUint16Array[0] = EEPROM_Data_Struct->defaultValue.toUint16Array[0];
     
152.         EEPROM_Data_Struct->value.toUint16Array[1] = EEPROM_Data_Struct->defaultValue.toUint16Array[1];
     
153. }
     
154. 
     
155. /**
     
156. * @brief 将全部的StorableData实时值重置为默认值
     
157. */
     
158. void StorableData_ResetAllValue()
     
159. {
     
160.         uint16_t count = sizeof(StorableData) / sizeof(*StorableData);
     
161.         for (uint16_t i = 0; i < count; i++) {
     
162.                 StorableData<i>.value.toUint16Array[0] = StorableData<i>.defaultValue.toUint16Array[0];
     
163.                 StorableData<i>.value.toUint16Array[1] = StorableData<i>.defaultValue.toUint16Array[1];
     
164.         }
     
165. }
     
166. 
     
167. 
     
168. void StorableData_SetValue_Float(uint16_t index, float value)
     
169. {
     
170.         StorableData[index].value.toFloat = value;
     
171. }
     
172. 
     
173. 
     
174. void StorableData_SetValue_16BitArray(uint16_t index, uint16_t *array)
     
175. {
     
176.         StorableData[index].value.toUint16Array[0] = array[0];
     
177.         StorableData[index].value.toUint16Array[1] = array[1];
     
178. }
     
179. 
     
180. 
     
181. float StorableData_GetValue(uint16_t index)
     
182. {
     
183.         return StorableData[index].value.toFloat;
     
184. }</i></i></i></i></i></i></i></i></i></i></i></i></i></i></i></i>

复制代码

使用指南
定义StorableData[]数组，正确设置数组成员的值（注意最大数组成员数量不能超过64，否则需要修改EEPROM库中的虚拟地址分配表）。示例如下：

1. volatile EepromData_typedef StorableData[] =
   
2. {
   
3.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = EEPROM_CKECKCODE_COUNT }, 0, 0 },
   
4. 
   
5.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 2, 1 },                //通道1：Iout1-4mA 电压
   
6.         { {""}, .value = { .toFloat = 500 }, .defaultValue = { .toFloat = 0 }, 4, 2 },                //通道1：Iout1-20mA对应电压
   
7.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 6, 3 },                //通道1：传感器类型
   
8.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 8, 4 },                //通道1：输出信号类型
   
9. 
   
10.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 10, 5 },                //通道2：Iout2-4mA对应电压
    
11.         { {""}, .value = { .toFloat = 500 }, .defaultValue = { .toFloat = 0 }, 12, 6 },                //通道2：Iout2-20mA对应电压
    
12.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 14, 7 },                //通道2：传感器类型
    
13.         { {""}, .value = { .toFloat = 0 }, .defaultValue = { .toFloat = 0 }, 16, 8 },                //通道2：输出信号类型
    
14. };

复制代码

在程序启动的时候（一般在外设配置完成后）初始化应用层扩展库。应用层扩展库初始化的时候会自动先初始化EEPROM仿真库，并判断是否需要重置StorableData成员为默认值（一般在首次烧录程序的时候需要重置数据）。同时，用以表示数组长度的变量STORABLE_DATA_COUNT将被自动计算与更新。

1.         StorableData_InitAll();

复制代码

根据项目的需要对StorableData成员进行读取、写入、保存、重置等操作。
读取：StorableData_GetValue(1)。
写入：StorableData_SetValue_Float(1, 919.0)。
保存：StorableData_SaveValue((const EepromData_typedef *)&StorableData[1])。
重置：StorableData_ResetValue(&StorableData[1])。