This subsystem demonstrates how to implement Electrically Erasable Programmable Read-Only Memory (EEPROM) emulation (Type A) in the application. EEPROM emulation allows a device to emulate EEPROM in Flash memory, and make an equivalent durability similar to EEPROM. The following features are available using Flash memory:

• Data retention after unexpected power loss
• Flexible structure for different applications
• User-configured erase operation

Download the code for this example.

There are two types of EEPROM emulation libraries for MSPM0. Type A is to store one large block of data (64 bytes, 128 bytes or 256 bytes) with a Static Random Access Memory (SRAM) buffer. See the EEPROM Emulation Type A Design application note for details of the library. Type B is to store many small data items (16bit or 32bit) with item identifiers. See also the EEPROM Emulation Type B Design application note for details of the library.

This subsystem shows the usage of Type A. For the Type B subsystem, see the Emulate EEPROM With Flash (Type B) subsystem design.

Figure 1-1 shows a functional diagram of this subsystem.

Figure 1-1 Subsystem Functional Block Diagram

This application requires Flash.

1. Add the EEPROM emulation library. The MSPM0 software development kit (SDK) includes the EEPROM emulation library.
   Note: The EEPROM emulation library is based on the Flash API so the drivelib from SDK is also required.
   For Type A, the following files are needed:
   1. eeprom_emulation_type_a.c
   2. eeprom_emulation_type_a.h
   Figure 3-1 EEPROM Emulation Files
2. Add the include path in the code for eeprom_emulation_type_a.h.

   Users can modify the start address, the number of sectors to use, and the record size in eeprom_emulation_type_a.h. The default Flash address used for EEPROM emulation is 0x00001000, and 2 sectors are used by default, so 0x00001000-0x000017ff is occupied. Additionally, the default size of the emulated EEPROM is 128 bytes.

   1. #define EEPROM_EMULATION_ADDRESS (0x00001000)
   2. #define EEPROM_EMULATION_SECTOR_ACCOUNT (2)
   3. #define EEPROM_EMULATION_RECORD_SIZE (128)
3. Define a global array as a buffer in random-access memory (RAM). Every time the system powers on, the data of the emulated EEPROM is loaded from Flash to this buffer using the initialize function. The size of array ought to be equal to the record size in step 2.
   • uint32_t EEPROMEmulationBuffer[EEPROM_EMULATION_DATA_SIZE / sizeof(uint32_t)];
4. Add the initialize function at the beginning of main(), typically after SYSCFG_DL_init(). This action allows the relevant Flash areas to be formatted correctly and global variables to be allocated correctly. The initialize function EEPROM_TypeA_init() also searches the active record and loads the data from Flash to the buffer in step 3.
   • EEPROM_TypeA_init(&EEPROMEmulationBuffer[0]);
   Figure 3-2 EEPROM Initialization
5. Users can read or modify the buffer in RAM, as needed, after initialization. When the data from the buffer to Flash need to be stored, call EEPROM_TypeA_writeData() to create a new record in Flash.
   Note: After power down, the data in RAM is lost. To implement data storage after power loss, execute this function at least once.
   • EEPROM_TypeA_writeData(&EEPROMEmulationBuffer[0]);
   Figure 3-3 EEPROM Write
6. Add the erase function according to the gEEPROMTypeAEraseFlag. Flash needs to be erased before writing data again and the smallest unit of erasure is sector. For EEPROM emulation, after one sector is full, gEEPROMTypeAEraseFlag is set. Users can call EEPROM_TypeA_eraseLastSector() according to the flag. For example, add the following code after EEPROM_TypeA_writeData() from step 5. Users can also choose an appropriate timepoint to erase the full sector, as needed.
   • EEPROM_TypeA_eraseLastSector();
   Figure 3-4 EEPROM Erase

After steps 1 through 6, the EEPROM emulation Type A is implemented in the application. See Section 5 for the flow.