STM32L0 内部EEPROM写读
说明
STM32L0内部的EEPROM写操作由解锁，写入，加锁过程组成，读过程则无需解锁。至于STM32L0内部的非易失空间区分为FLASH和EEPROM，主要体现在用ST-LINK等工具进行整片擦除时，只擦除FLASH的空间，EEPROM的部分不会被擦除，如同外部EEPROM芯片，MPU的代码升级不影响EEPROM的内容。后面以内部EEPROM的写读作为范例。

( ^% t+ u9 }& q3 A% g# g基础写读函数
0 |4 _# E4 \5 c' Q/ X定义内部EEPROM的地址空间：
7 W% b8 e* S% W, m

1. //STM32L031K6T6
   / Z. ?' G" R$ j* \1 F1 P( X
2. #define EEPROM_BASE_ADDR        0x08080000
   
3. #define EEPROM_BYTE_SIZE        0x03FF

复制代码

6 G8 i8 D6 m9 J8 a6 l# x基础字节写函数

1. //Byte write
   2 ^6 w7 r3 A. H9 R+ I
2. void EEPROM_WRITE(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   % y0 f* \, M+ X. K/ O0 x4 F
3. {
   
4.         uint16_t i;
   5 y+ s' y8 c1 d% g
5.         HAL_StatusTypeDef status = HAL_OK;
   
6. 
   
7.         HAL_FLASHEx_DATAEEPROM_Unlock();
   
8.         for(i=0;i<len;i++)
   
9.         {
   1 r# }( ]) B: ^! W5 b
10.                 status +=HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, EEPROM_BASE_ADDR+BiasAddress+i, *Data);
    
11.                 Data++;
    
12.         }
    
13.         HAL_FLASHEx_DATAEEPROM_Lock();
    
14. }

复制代码

基础字节读函数

1. <span style="background-color: rgb(255, 255, 255);">/</span>/Byte read
   . |; I6 {- q* V8 G- e( T- j
2. void EEPROM_READ(uint16_t BiasAddress,uint8_t *Buffer,uint16_t Len)
   5 g+ X+ l3 z' M* z9 V/ R
3. {
   7 f- {8 {7 K" d$ c! C" A2 X
4.         uint8_t *wAddr;
   
5.         wAddr=(uint8_t *)(EEPROM_BASE_ADDR+BiasAddress);
   5 W7 x" ?# v* o. O' u$ \
6.         while(Len--)
   
7.         {
   
8.                 *Buffer++=*wAddr++;
   : H4 q. R; D- x! P1 N1 k. Z
9.         }
   
10. }

复制代码

带校验写读函数
; e( L+ o; y0 B' \如果考虑到写读过程中，可以出现错误的情况，为了保证操作的正确性，需要采用校验方式进行写读。
对于写过程，需要将写入的数据，读回做比较。
1 N8 K' Y& ]  ~3 U对于读过程，需要将两次读回的数据，进行比较。
如果比较正确，则操作完成。
如果错误，可重新进行写或读操作，并在设定的重新操作次数范围内，进行重新操作识别，如果正确，则报告正确，如果错误，则报告错误。
' |2 K0 O! n. O0 q8 K3 D! R
6 E1 ]$ l) t$ O. {* @设定重复校验次数

1. #include <string.h>
   
2. #define iEEPROM_CHECK_NUM 2

复制代码

带操作校验的写函数
7 L& m* }" G# ?

1. HAL_StatusTypeDef EEPROM_WRITE_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   
2. {
   : F+ ~- t- R6 G) J% w
3.         uint8_t buff[len];
   % y( \: X, t3 c& n9 n* `( U
4.         uint16_t i;
   
5.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   
6.         {
   
7.                 EEPROM_WRITE(BiasAddress, Data, len);
   ) n- L4 I, f4 O* ~  R5 U, K2 F
8.                 EEPROM_READ(BiasAddress, buff, len);
   3 q( ~% |  J! X  [: v
9.                 if (memcmp(Data, buff, len)==0)
   
10.                 {
    
11.                         return HAL_OK;
    5 Q' h  A2 `: s/ L
12.                 }
    
13.         }
    
14. 
    
15.         return HAL_ERROR;
    
16. }

复制代码

带操作校验的读函数
- a$ @' o, Z5 b% [) J

1. HAL_StatusTypeDef EEPROM_Read_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   2 w1 ?  O9 b% |; d! p8 P
2. {
   
3.         uint8_t buff0[len];
   * Y3 a, `4 z+ R' ^1 ?' U! i; g* U
4.         uint8_t buff1[len];
   " r8 a. U" a" D5 G! U% H7 Y, E
5.         uint16_t i;
   7 x+ B- _7 {4 k  X: I) S
6.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   
7.         {
   6 t0 _6 [8 F3 L5 o' X. f, I1 O
8.                 EEPROM_READ(BiasAddress, buff0, len);
   3 l6 j* z* y8 g% E) ~7 c
9.                 EEPROM_READ(BiasAddress, buff1, len);
   8 a2 F: V$ ^- F8 f" r
10. 
    1 B9 s  o: C8 c1 G, H
11.                 if (memcmp(buff0, buff1, len)==0)
    
12.                 {
    
13.                         memcpy(Data, buff0, len);
    . o6 F$ I: s% A- ^1 T' g1 {
14.                         return HAL_OK;
    ' [# e: T9 M/ A, P
15.                 }
    9 I. ]0 f8 ^7 S$ T: _5 q, K, J. J
16.         }
    
17. 
    5 q2 c7 M, g3 q* t$ x
18.         return HAL_ERROR;
    
19. }

复制代码

1 s+ _. y8 t0 }/ L" w其中BiasAddress为0对应内部EEPROM的0地址（EEPROM_BASE_ADDR定义了其基址），Data为数据字节指针，len为操作字节长度。

0 V5 H2 C, x4 D6 F4 R; V" ^需要注意的是，基于工艺制程和设计，EEPROM的使用也分为两种，其中一种和FRAM相似，可以直接进行写入而不需要提前擦除，STM32内部的EEPROM也是这一种；另外一种和FLASH相似，需要先进行基于Page的擦除后才能正确写入，对于有的EEPROM，支持基于Page最小为Byte单元的擦除。

HAL提供的内部EEPROM擦除函数, 只是进行一个word的擦除，即在某个地址上将数据改写为0x00000000, 和直接调用写函数在该地址写入0x00000000效果一样。HAL的内部EEPROM擦除函数如下：

1. /**
   2 g5 {" a2 n' E( h' L
2.   * @brief  Erase a word in data memory.
   & A. \" M: N/ W7 o" `! m  i& K
3.   * @param  Address specifies the address to be erased.
   
4.   * @note   To correctly run this function, the @ref HAL_FLASHEx_DATAEEPROM_Unlock() function
   ; u8 c* _- h+ b, T* ^
5.   *         must be called before.
   
6.   *         Call the @ref HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access
   
7.   *         and Flash program erase control register access(recommended to protect
   ( v: v3 G6 o/ M# s
8.   *         the DATA_EEPROM against possible unwanted operation).
   
9.   * @retval HAL_StatusTypeDef HAL Status
   , A/ a  h2 F8 U. ?* ]  [3 P
10.   */
    
11. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
    
12. {
    . Y+ L6 ~, U' }
13.   HAL_StatusTypeDef status = HAL_OK;
    / j4 E3 Q2 `: R9 G
14. 
    $ v7 ?% L' X  @$ t
15.   /* Check the parameters */
    5 i+ ~( b5 P" s( Z
16.   assert_param(IS_FLASH_DATA_ADDRESS(Address));
    
17. 
    1 l6 V% v5 A7 p, X" t, Y
18.   /* Wait for last operation to be completed */
    
19.   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    
20. 
    ! g. G4 r2 K  A
21.   if(status == HAL_OK)
    ; Z! ?% _* T6 W3 U
22.   {
    ( d: ?% k  D( @4 W; C
23.     /* Clean the error context */
    
24.     pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
25. 
    
26.       /* Write 00000000h to valid address in the data memory */
    ( w  N% @  c3 {. A6 d5 l& X6 L
27.       *(__IO uint32_t *) Address = 0x00000000U;
    
28. 
    
29.     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    $ {$ L$ K2 M$ k9 H, u: E2 b2 T8 P
30.   }
    5 ]5 e- Q0 w8 c& r$ c
31. 
    4 e. D' K3 C+ l( D: E
32.   /* Return the erase status */
    
33.   return status;
    
34. }  

复制代码

. H9 G) T8 R# h7 G, C上述的代码，如果要用于STM32内部FLASH的操作，还需要增加页擦除操作。