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

基础写读函数
; N5 e# R3 D' o  ]定义内部EEPROM的地址空间：
" g& q4 j! b# u: n

1. //STM32L031K6T6
   / v6 W9 U( V/ p; V. N: M' |; _6 C; D
2. #define EEPROM_BASE_ADDR        0x08080000
   
3. #define EEPROM_BYTE_SIZE        0x03FF

复制代码

基础字节写函数
- |8 X. U3 @- w# S

1. //Byte write
   * Y! D6 F* `  X/ z8 T/ H+ ~
2. void EEPROM_WRITE(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   
3. {
   
4.         uint16_t i;
   9 @0 J/ ]! U1 s3 T+ n
5.         HAL_StatusTypeDef status = HAL_OK;
   
6. 
   
7.         HAL_FLASHEx_DATAEEPROM_Unlock();
   
8.         for(i=0;i<len;i++)
   : \9 Q) P3 E+ l9 L4 m8 B0 ^
9.         {
   
10.                 status +=HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, EEPROM_BASE_ADDR+BiasAddress+i, *Data);
    9 L- e* ]+ q8 x# s
11.                 Data++;
    ! Q, F0 E( o- f' J
12.         }
    
13.         HAL_FLASHEx_DATAEEPROM_Lock();
    
14. }

复制代码

基础字节读函数
% O% E. D. a" ~9 S. }: K2 p

1. <span style="background-color: rgb(255, 255, 255);">/</span>/Byte read
   
2. void EEPROM_READ(uint16_t BiasAddress,uint8_t *Buffer,uint16_t Len)
   
3. {
   
4.         uint8_t *wAddr;
   
5.         wAddr=(uint8_t *)(EEPROM_BASE_ADDR+BiasAddress);
   $ l" H( A2 O! v7 v# O
6.         while(Len--)
   ) C% D7 |1 z- d2 I2 }5 a# u5 A- o, W
7.         {
   4 [# H/ W, x# `4 H5 ]' v
8.                 *Buffer++=*wAddr++;
   ; @5 S, Y# K( b1 e, F
9.         }
   
10. }

复制代码

带校验写读函数
如果考虑到写读过程中，可以出现错误的情况，为了保证操作的正确性，需要采用校验方式进行写读。
对于写过程，需要将写入的数据，读回做比较。
对于读过程，需要将两次读回的数据，进行比较。
如果比较正确，则操作完成。
如果错误，可重新进行写或读操作，并在设定的重新操作次数范围内，进行重新操作识别，如果正确，则报告正确，如果错误，则报告错误。

设定重复校验次数
8 _7 F$ H8 d1 o9 r: t

1. #include <string.h>
   2 K5 i/ _6 V' i& @( D+ g% w- q+ J
2. #define iEEPROM_CHECK_NUM 2

复制代码

# |4 {" i' O1 x; j3 V
带操作校验的写函数

1. HAL_StatusTypeDef EEPROM_WRITE_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   
2. {
     b& N5 ^+ c" |  @& B
3.         uint8_t buff[len];
   0 j% v6 P6 w# O) \2 Q# f& Q
4.         uint16_t i;
   " U% U! q: g) [! D$ j
5.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   
6.         {
   
7.                 EEPROM_WRITE(BiasAddress, Data, len);
   . l% L% ?8 T8 u: t- R
8.                 EEPROM_READ(BiasAddress, buff, len);
   6 `6 \! ?% x1 @& b. o
9.                 if (memcmp(Data, buff, len)==0)
   1 `! c( m8 _, N5 d& N3 H
10.                 {
    
11.                         return HAL_OK;
    
12.                 }
    
13.         }
    
14. 
    + @$ g: e, s7 w& e1 ]. u1 s+ u( P
15.         return HAL_ERROR;
    ! P( g: S3 N# I6 y8 Z1 S
16. }

复制代码

带操作校验的读函数
3 s; I0 C" R2 g- H* t

1. HAL_StatusTypeDef EEPROM_Read_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   * X% a5 M+ J, T6 D" p
2. {
   9 c& Q9 ~; s- v: N6 l
3.         uint8_t buff0[len];
   
4.         uint8_t buff1[len];
   7 K# ?$ }$ p3 e0 i
5.         uint16_t i;
   
6.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   
7.         {
   
8.                 EEPROM_READ(BiasAddress, buff0, len);
   4 I+ L1 K5 Y: g& o% x8 y: G
9.                 EEPROM_READ(BiasAddress, buff1, len);
   6 c3 y& {% h0 V6 o
10. 
    
11.                 if (memcmp(buff0, buff1, len)==0)
    # ?4 E2 \! r1 E5 p
12.                 {
    
13.                         memcpy(Data, buff0, len);
    
14.                         return HAL_OK;
    7 k& S% ~' Y% R7 N
15.                 }
    
16.         }
    % }7 I1 i. J3 K. i6 |2 y( I
17. 
    1 W3 ]' d# Z$ G2 {6 D
18.         return HAL_ERROR;
    
19. }

复制代码

其中BiasAddress为0对应内部EEPROM的0地址（EEPROM_BASE_ADDR定义了其基址），Data为数据字节指针，len为操作字节长度。

+ N9 _+ n8 w$ l+ i8 `, P4 j! w+ O需要注意的是，基于工艺制程和设计，EEPROM的使用也分为两种，其中一种和FRAM相似，可以直接进行写入而不需要提前擦除，STM32内部的EEPROM也是这一种；另外一种和FLASH相似，需要先进行基于Page的擦除后才能正确写入，对于有的EEPROM，支持基于Page最小为Byte单元的擦除。

1 s; e9 k( U0 k" Y+ b. uHAL提供的内部EEPROM擦除函数, 只是进行一个word的擦除，即在某个地址上将数据改写为0x00000000, 和直接调用写函数在该地址写入0x00000000效果一样。HAL的内部EEPROM擦除函数如下：
" U5 d7 v$ D' h7 c: }: J

1. /**
   
2.   * @brief  Erase a word in data memory.
   9 J/ O5 A* f# J! u% D! |+ W, D
3.   * @param  Address specifies the address to be erased.
   4 Z/ u9 R1 Z( R3 n" [
4.   * @note   To correctly run this function, the @ref HAL_FLASHEx_DATAEEPROM_Unlock() function
   
5.   *         must be called before.
   
6.   *         Call the @ref HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access
   4 ~8 w% ]2 a- A! F$ N
7.   *         and Flash program erase control register access(recommended to protect
   3 ]2 w- V# G/ T9 U
8.   *         the DATA_EEPROM against possible unwanted operation).
   7 L, K, T6 U9 k! V4 A* B: `% b1 d
9.   * @retval HAL_StatusTypeDef HAL Status
   , \* m6 N4 w. ^3 H* G  i
10.   */
    $ x$ Y; M1 k$ ~% h; C0 ~$ X, B2 B
11. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
    $ z; n3 g  q7 _2 \$ u2 Y
12. {
    7 l' v5 K  N& w8 s; V' @/ A
13.   HAL_StatusTypeDef status = HAL_OK;
    
14. 
    
15.   /* Check the parameters */
    / M: I$ @7 }* P) d( C
16.   assert_param(IS_FLASH_DATA_ADDRESS(Address));
    
17. 
      H) g" M3 [4 q: {7 p
18.   /* Wait for last operation to be completed */
    % b& h% o+ _5 x- p
19.   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
      g2 b( I# K* n3 n: r
20. 
    
21.   if(status == HAL_OK)
    ) k( r% v! [0 e$ c
22.   {
    ; h  @" e5 E4 C1 k& O6 u, d
23.     /* Clean the error context */
    $ X8 t# F! ?' e) h! I- ]# N
24.     pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
25. 
    
26.       /* Write 00000000h to valid address in the data memory */
    
27.       *(__IO uint32_t *) Address = 0x00000000U;
    ; E! @7 i1 R) K$ S5 [5 P& D
28. 
    0 ^, J+ n9 P  r* B1 k6 ]% G# V
29.     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    
30.   }
    $ Z* m, G0 I, \  j2 H
31. 
    
32.   /* Return the erase status */
    * Y2 d- F0 \) m" T+ M( r" V
33.   return status;
    
34. }  

复制代码

% s# C" ^4 _8 ^1 p: l; M: h9 L上述的代码，如果要用于STM32内部FLASH的操作，还需要增加页擦除操作。
2 x" J$ e0 Z) i, r4 f9 c$ x
/ @! @1 I& I  ~: L
8 T, Q  J8 Z7 C) w9 m" C