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

基础写读函数
定义内部EEPROM的地址空间：

1. //STM32L031K6T6
   - ^# e4 W2 w3 |0 P4 M$ O
2. #define EEPROM_BASE_ADDR        0x08080000
   
3. #define EEPROM_BYTE_SIZE        0x03FF

复制代码

基础字节写函数

1. //Byte write
   
2. void EEPROM_WRITE(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   6 U1 E/ Y% _( ~/ p5 T
3. {
   
4.         uint16_t i;
   
5.         HAL_StatusTypeDef status = HAL_OK;
   8 Y7 {3 k- O6 v: t' L6 S
6. 
   5 g: p; r& x4 h3 {
7.         HAL_FLASHEx_DATAEEPROM_Unlock();
   
8.         for(i=0;i<len;i++)
   6 \2 A+ y6 W0 G" g
9.         {
   6 R/ L/ Z. S) J# c
10.                 status +=HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, EEPROM_BASE_ADDR+BiasAddress+i, *Data);
      D9 c$ B( G, n4 G/ D& @
11.                 Data++;
    
12.         }
    ' S7 g( L8 L0 Q
13.         HAL_FLASHEx_DATAEEPROM_Lock();
    
14. }

复制代码

基础字节读函数
9 b: Q! u. |. Y) k" }, T

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. {
   " p  |2 k' o2 _; B# u
4.         uint8_t *wAddr;
   $ Y6 V  K) i. Z# o$ E* D
5.         wAddr=(uint8_t *)(EEPROM_BASE_ADDR+BiasAddress);
   
6.         while(Len--)
   * w( c. B) H( k& Z
7.         {
   7 }& v5 T5 e  O- |2 E% |
8.                 *Buffer++=*wAddr++;
   3 m7 N' n% J3 [+ d3 d* |2 U8 h
9.         }
   
10. }

复制代码

- K' e4 Y% X0 D' j+ P4 |7 }2 z带校验写读函数
6 y/ ?) q- Y! N如果考虑到写读过程中，可以出现错误的情况，为了保证操作的正确性，需要采用校验方式进行写读。
对于写过程，需要将写入的数据，读回做比较。
对于读过程，需要将两次读回的数据，进行比较。
- Y( i7 c- K% ?+ _" c3 K如果比较正确，则操作完成。
0 V5 ~2 k2 m1 D8 o& l1 l4 x如果错误，可重新进行写或读操作，并在设定的重新操作次数范围内，进行重新操作识别，如果正确，则报告正确，如果错误，则报告错误。
$ P5 N; L1 f6 H" F0 u7 g
设定重复校验次数
) {- N" y0 u0 e( m

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

复制代码

- \; Z& [5 M) e6 P7 e8 @带操作校验的写函数
) k% T7 [$ n- v: R. k

1. HAL_StatusTypeDef EEPROM_WRITE_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   
2. {
   6 M9 j. t4 r9 j" J  }  G  @
3.         uint8_t buff[len];
   
4.         uint16_t i;
   
5.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   8 w) V/ K, I$ d3 _
6.         {
   $ i. z( f8 t& E! Z. s0 b( a0 e
7.                 EEPROM_WRITE(BiasAddress, Data, len);
   
8.                 EEPROM_READ(BiasAddress, buff, len);
   % t- x  g" d7 f& s0 E$ e; p
9.                 if (memcmp(Data, buff, len)==0)
   
10.                 {
    : _9 w$ ?# x  R1 W( e9 C) U3 ~
11.                         return HAL_OK;
    
12.                 }
    2 w- D3 r& j; N5 `3 v
13.         }
    & ]9 z7 n; V2 e
14. 
    
15.         return HAL_ERROR;
    + w4 T8 W8 n% R' ?0 g; H+ n
16. }

复制代码

带操作校验的读函数
+ r  Y; I# W( p. ~  l* C

1. HAL_StatusTypeDef EEPROM_Read_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   # k# ]7 a* P! U; l: U" Z+ a, ^
2. {
   
3.         uint8_t buff0[len];
   
4.         uint8_t buff1[len];
   - d% p7 I, _* A: W9 P$ f
5.         uint16_t i;
   # b- ~6 r5 }& ?( t% q# X
6.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   3 t, l5 }5 I5 R$ P
7.         {
   
8.                 EEPROM_READ(BiasAddress, buff0, len);
   $ N+ x8 M7 a5 v& D. J( N
9.                 EEPROM_READ(BiasAddress, buff1, len);
   + W) c8 ]9 S% }8 f$ _4 h
10. 
    
11.                 if (memcmp(buff0, buff1, len)==0)
    
12.                 {
    & k& g5 F1 N& P4 |
13.                         memcpy(Data, buff0, len);
    , s5 i3 |% u1 V8 U- V" H) @
14.                         return HAL_OK;
    
15.                 }
    
16.         }
    
17. 
    3 z$ i- _7 j5 y" {" u
18.         return HAL_ERROR;
    
19. }

复制代码

4 W9 k: I6 i& h0 n3 l其中BiasAddress为0对应内部EEPROM的0地址（EEPROM_BASE_ADDR定义了其基址），Data为数据字节指针，len为操作字节长度。

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

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

1. /**
   
2.   * @brief  Erase a word in data memory.
   & c8 q6 V9 o' s' \3 \
3.   * @param  Address specifies the address to be erased.
   2 n, ]& f: f. F8 V4 K( s, r
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
   
7.   *         and Flash program erase control register access(recommended to protect
   
8.   *         the DATA_EEPROM against possible unwanted operation).
   % c$ l- P; ?0 O: U/ u, t$ U
9.   * @retval HAL_StatusTypeDef HAL Status
   
10.   */
    
11. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
    # j0 l# Q' L. D. h& s7 @8 m
12. {
    
13.   HAL_StatusTypeDef status = HAL_OK;
    & O- o' w1 U5 j8 e
14. 
    ; z: E0 j9 `" s
15.   /* Check the parameters */
    
16.   assert_param(IS_FLASH_DATA_ADDRESS(Address));
    
17. 
    
18.   /* Wait for last operation to be completed */
    6 I& C$ K' a# s& m% {9 S/ \+ N
19.   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    ( g3 g( N5 i$ u, L8 S7 Z6 X0 B, j
20. 
    2 ?. a, C8 G8 I( B
21.   if(status == HAL_OK)
    
22.   {
    
23.     /* Clean the error context */
    
24.     pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    $ q; E, X) t) o( p8 n4 O% ]
25. 
    
26.       /* Write 00000000h to valid address in the data memory */
    & E1 h' Z. |, Q# [) a1 Z
27.       *(__IO uint32_t *) Address = 0x00000000U;
    
28. 
    9 U/ e# Z" b. l$ y/ p# Y8 F% i5 J% n
29.     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    
30.   }
    
31. 
    4 ~# w$ p+ A9 n; l9 i+ Y3 F% S2 {6 p& |
32.   /* Return the erase status */
    / y, l0 Z6 W8 y- h( k3 k: |+ ^
33.   return status;
    " e  q! @1 ^9 m; k; r, u) n! L
34. }  

复制代码

上述的代码，如果要用于STM32内部FLASH的操作，还需要增加页擦除操作。

& j( ?' \( W; z( `. o' ?$ i
8 ]: ]+ K/ Y& c" r/ E& n3 c( r