STM32L0 内部EEPROM写读
说明
STM32L0内部的EEPROM写操作由解锁，写入，加锁过程组成，读过程则无需解锁。至于STM32L0内部的非易失空间区分为FLASH和EEPROM，主要体现在用ST-LINK等工具进行整片擦除时，只擦除FLASH的空间，EEPROM的部分不会被擦除，如同外部EEPROM芯片，MPU的代码升级不影响EEPROM的内容。后面以内部EEPROM的写读作为范例。
2 j, E3 X& _& j/ v/ S. Y0 v! w
基础写读函数
( t7 \1 {: D# a3 ^9 X定义内部EEPROM的地址空间：
. O; W- A7 F) E/ n

1. //STM32L031K6T6
   
2. #define EEPROM_BASE_ADDR        0x08080000
   - ]5 j$ W7 c5 x& S& X3 c1 K- h  u
3. #define EEPROM_BYTE_SIZE        0x03FF

复制代码

+ J% m, h1 i3 u1 k5 D" _( \基础字节写函数
& `7 f5 p3 M4 d+ l- v

1. //Byte write
   
2. void EEPROM_WRITE(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   
3. {
   
4.         uint16_t i;
   
5.         HAL_StatusTypeDef status = HAL_OK;
   - w4 a# Q) r# o! K( s2 p
6. 
   . A2 `3 ?% t" |; u
7.         HAL_FLASHEx_DATAEEPROM_Unlock();
   
8.         for(i=0;i<len;i++)
   
9.         {
   
10.                 status +=HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, EEPROM_BASE_ADDR+BiasAddress+i, *Data);
    , Q' h) }  k2 z* Y: `" v  h7 f
11.                 Data++;
    
12.         }
    
13.         HAL_FLASHEx_DATAEEPROM_Lock();
    & b/ X% b# \! L, n3 B" ]; j% W& z
14. }

复制代码

基础字节读函数

1. <span style="background-color: rgb(255, 255, 255);">/</span>/Byte read
   9 `: t7 I3 z2 F& [7 }
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);
   0 t/ i( h0 A( a2 M& W
6.         while(Len--)
   
7.         {
   5 R! z1 _2 j) W& H8 a7 ~4 F
8.                 *Buffer++=*wAddr++;
   ) ]/ I7 R) G" g; M+ P: t$ n. k& _
9.         }
   
10. }

复制代码

带校验写读函数
/ i+ q, U/ I. j. K7 Y, x如果考虑到写读过程中，可以出现错误的情况，为了保证操作的正确性，需要采用校验方式进行写读。
- S7 i- {1 T4 w" }  t: E2 E  J! n对于写过程，需要将写入的数据，读回做比较。
对于读过程，需要将两次读回的数据，进行比较。
如果比较正确，则操作完成。
如果错误，可重新进行写或读操作，并在设定的重新操作次数范围内，进行重新操作识别，如果正确，则报告正确，如果错误，则报告错误。
! n; H( T  M6 R
4 X$ C4 C. L6 _6 X设定重复校验次数
6 v6 M6 \9 b- W7 N0 a

1. #include <string.h>
   ( F- W$ y9 b2 ~0 m6 S3 p9 ]
2. #define iEEPROM_CHECK_NUM 2

复制代码

+ L9 V2 A  b( Z5 `/ W带操作校验的写函数
' }0 d( e3 S9 a2 C* _

1. HAL_StatusTypeDef EEPROM_WRITE_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   ( e5 {- i' f& Q4 M/ E' P; S- k! X
2. {
   ( T8 L% U1 W( h3 Q% O2 y
3.         uint8_t buff[len];
   5 m1 F) m# o( t: i. |; I
4.         uint16_t i;
     q6 p; ^  r7 X; t3 u
5.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   
6.         {
   
7.                 EEPROM_WRITE(BiasAddress, Data, len);
   
8.                 EEPROM_READ(BiasAddress, buff, len);
   
9.                 if (memcmp(Data, buff, len)==0)
   " u5 C5 p" I- n8 \: ~  O& _
10.                 {
    
11.                         return HAL_OK;
    9 M; N' t- ?0 A2 O) Z
12.                 }
    
13.         }
    ; G0 |: ^+ A- }
14. 
    3 h/ p6 g) i% Q& Z1 P# [3 i
15.         return HAL_ERROR;
    
16. }

复制代码

带操作校验的读函数

1. HAL_StatusTypeDef EEPROM_Read_W_CHECK(uint16_t BiasAddress, uint8_t *Data, uint16_t len)
   , d9 P6 ?, Q6 w8 ]
2. {
   0 o7 e9 [: }. {* J" o/ V
3.         uint8_t buff0[len];
   9 O3 M' X' F: H8 V2 ^+ _  e  c
4.         uint8_t buff1[len];
   
5.         uint16_t i;
   " Q0 g$ I5 i1 ?9 W
6.         for (i=0;i<iEEPROM_CHECK_NUM;i++)
   / [: Y6 G  N/ _) H
7.         {
   
8.                 EEPROM_READ(BiasAddress, buff0, len);
   
9.                 EEPROM_READ(BiasAddress, buff1, len);
   
10. 
    
11.                 if (memcmp(buff0, buff1, len)==0)
    
12.                 {
    
13.                         memcpy(Data, buff0, len);
    
14.                         return HAL_OK;
    8 q* T5 w* Y" h( }0 }% d
15.                 }
    9 Z/ X; `5 d1 U" h7 A/ l( E8 h/ j. z$ P
16.         }
    , T/ F; z) f2 @! j( v
17. 
    $ ~! [* ~5 E/ W+ I$ y; {
18.         return HAL_ERROR;
      D& V- l& [5 W/ C2 u" B+ }
19. }

复制代码

其中BiasAddress为0对应内部EEPROM的0地址（EEPROM_BASE_ADDR定义了其基址），Data为数据字节指针，len为操作字节长度。
0 A+ c  F. i' }  l0 _
需要注意的是，基于工艺制程和设计，EEPROM的使用也分为两种，其中一种和FRAM相似，可以直接进行写入而不需要提前擦除，STM32内部的EEPROM也是这一种；另外一种和FLASH相似，需要先进行基于Page的擦除后才能正确写入，对于有的EEPROM，支持基于Page最小为Byte单元的擦除。

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

' a% i& i* V1 G  j1 c

1. /**
   
2.   * @brief  Erase a word in data memory.
   9 i: l2 j) k' l) q4 ?
3.   * @param  Address specifies the address to be erased.
   
4.   * @note   To correctly run this function, the @ref HAL_FLASHEx_DATAEEPROM_Unlock() function
   
5.   *         must be called before.
   9 E! e1 K5 X7 _4 [
6.   *         Call the @ref HAL_FLASHEx_DATAEEPROM_Lock() to the data EEPROM access
   9 j4 U2 c% i2 h. u! S
7.   *         and Flash program erase control register access(recommended to protect
   
8.   *         the DATA_EEPROM against possible unwanted operation).
   / G/ D4 N/ m4 V: o' V" {* E- s$ t1 [
9.   * @retval HAL_StatusTypeDef HAL Status
   
10.   */
    8 i4 a/ o' _2 z( R: j* i
11. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address)
    
12. {
    
13.   HAL_StatusTypeDef status = HAL_OK;
    
14. 
    5 D7 ^& q0 S8 s3 o
15.   /* Check the parameters */
    
16.   assert_param(IS_FLASH_DATA_ADDRESS(Address));
    7 A* \3 L3 I4 ~4 ~5 z/ ~5 c
17. 
    3 x' `) A" H( m
18.   /* Wait for last operation to be completed */
    
19.   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    4 u! s9 z( N$ p! {+ y& ^. ]
20. 
    # @$ x/ \' M  ?* T2 O
21.   if(status == HAL_OK)
    
22.   {
    
23.     /* Clean the error context */
    
24.     pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
25. 
    
26.       /* Write 00000000h to valid address in the data memory */
    ) G' j+ ^2 b+ r) P, F
27.       *(__IO uint32_t *) Address = 0x00000000U;
    ' Z# [$ C( ?9 b4 d$ c; u
28. 
    
29.     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    / `. Q( r; H& {. p$ f- P0 C; q
30.   }
    # y+ |- A5 c: D3 N. w; w) O# r" Z8 g
31. 
    
32.   /* Return the erase status */
    
33.   return status;
    , d" ]1 t9 Q% M: Y& y7 [' s( T
34. }  

复制代码

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

5 X# H3 I, P8 W! A, V