STM32L的EEPROM支持字、半字和字节的读写操作。写操作之前自动擦除，如果写的数据为0，则只执行擦除操作。

& k0 V) H& J, j  _, `5 Q       使用STM32Cube库对自带的EEPROM进行操作，代码如下：
3 ~; F) }3 v3 \* j1 M

1. 
   2 R- ?3 k9 @* E9 L* H
2. #define                EPROM_WR_TYPE_BYTE                                ((UNS8)0x00)
   ; N: X. v- b7 a1 H% h
3. #define                EPROM_WR_TYPE_HALF_WORD                ((UNS8)0x01)
   2 v4 y/ g4 s. j# l) `/ e  \
4. #define                EPROM_WR_TYPE_WORD                                ((UNS8)0x02)
   # i) x# K- e2 _% Z; B& D& s
5. 
   2 ^* ^) U3 G8 d3 t& ~3 o0 ~
6. #define                EPROM_TEST_ADDR                                (STM_EPROM_ADDR_BASE + 12)
     e: R; p& M  g9 H" u" u
7. #define                EPROM_TESTE_ADDR                                (STM_EPROM_ADDR_BASE + 32)
   2 @0 c) i$ Y5 v& d  T2 `
8. #define                EPROM_TESTEE_ADDR                                (STM_EPROM_ADDR_BASE + 61)
   
9. 
   * B4 O) U) Q+ L0 e  j, V9 [2 S
10. //// Unlocks the data memory and FLASH_PECR register access
    
11. //// ret :
    
12. ////   OK       = 0x00U,
      a  S: J3 u7 w, E/ S/ M
13. ////   ERROR    = 0x01U,
    
14. ////   BUSY     = 0x02U,
    
15. ////   TIMEOUT  = 0x03U
    2 u8 p8 e) O2 L
16. UNS8 StmL0xxEpromUnlock(void)
    
17. {
    4 h  P1 t+ G' F: u4 g% o4 |
18.         UNS8                ret=0;
    
19.         
    
20.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Unlock();
    0 S# m4 f0 y! L# @
21.         
    # C- P3 v5 I3 l% }/ @
22.         return ret;
    
23. }
    
24. 
    
25. //// Locks the Data memory and FLASH_PECR register access
    
26. //// ret :
    
27. ////   OK       = 0x00U,
    
28. ////   ERROR    = 0x01U,
    # a: X& @4 J& G( M5 s' e
29. ////   BUSY     = 0x02U,
    
30. ////   TIMEOUT  = 0x03U
    
31. UNS8 StmL0xxEpromLock(void)
    
32. {
    % h1 c) u; X7 Q9 t, q) U
33.         UNS8                ret=0;
    " g8 h, s/ N) N" h" f  o
34.         
    
35.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Lock();
    , [- k# |+ b/ |2 T; Q+ }
36.         
    7 b2 e' D) [' t
37.         return ret;
    
38. }
    5 a  Y1 b* K) U1 T% J) x3 Y/ K
39. 
    
40. //// Erase a word in data memory.
    2 c& u/ J+ R9 H+ F; r: ~; w
41. //// To correctly run this function, the @ref StmL0xxEpromUnlock() function
    
42. //// must be called before.
    
43. //// addr -- specifies the address to be erased.
    ( l6 U( H3 M& {
44. //// ret :
    , \" N, [. U* l" |" O5 ^
45. ////   OK       = 0x00U,
    
46. ////   ERROR    = 0x01U,
    & u2 u  h: o  q$ ]( X; O/ F7 o
47. ////   BUSY     = 0x02U,
    1 {( p$ L" ~7 N0 F- P
48. ////   TIMEOUT  = 0x03U
    
49. UNS8 StmL0xxEpromWordErase(UNS32 addr)
    
50. {
    . z( e) O2 I) E
51.         UNS8                ret=0;
    
52.         
    
53.         if ( (STM_EPROM_ADDR_BASE>addr) || (STM_EPROM_ADDR_END<addr) )
    + f/ l1 Y: f; a% U
54.         {
    
55.                 return ret;
    
56.         }
    
57.         
    2 a& N  ^6 @# l# p# G9 r9 I( l6 G
58.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Erase(addr);
    
59.         
    
60.         return ret;
    7 ?) A5 i9 u& Q7 m7 D
61. }
    
62. 
    
63. //// Program data at a specified address
    
64. //// type :
    
65. ////   Byte -- 0x00
    
66. ////   HalfWord -- 0x01
    
67. ////   Word -- 0x02
    
68. //// addr -- specifies the address to be erased.
    
69. //// ret :
    " O4 N' |' Q. P  I& G3 j
70. ////   OK       = 0x00U,
    
71. ////   ERROR    = 0x01U,
    
72. ////   BUSY     = 0x02U,
    
73. ////   TIMEOUT  = 0x03U
    3 k( U# k1 Q9 r  Z% X
74. UNS8 StmL0xxEpromSingleWrite(UNS8 type, UNS32 addr, UNS32 data)
    
75. {
    
76.         UNS8                ret=0;
    
77.         
    
78.         if ( (STM_EPROM_ADDR_BASE>addr) || (STM_EPROM_ADDR_END<addr) )
    
79.         {
    
80.                 return ret;
    5 Z+ q# u# U; ?: f) o7 P+ d4 @
81.         }
    . e5 b9 C3 [" @% k
82.         
    
83.         StmL0xxEpromUnlock();
    3 Z5 i" B5 w' m  a2 T6 W6 x+ V7 v9 b) q
84.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Program((UNS32)type, addr, data); //// 库函数
    ) [4 d2 j4 O! L6 H  b5 a' G" }2 ?
85.         StmL0xxEpromLock();
    
86.         
    
87.         return ret;
    
88. }
    / U7 M5 ^! e* z1 Z3 T
89. 
    4 H  P2 m" I( e) A) x
90. //// read a byte at a specified address
    
91. //// addr -- specifies the address to be erased.
    # ]4 f; J, z/ O) Q" P% C
92. //// ret :
    8 T# h6 F& p% ]$ m5 [1 ]% n
93. ////   OK       = 0x00U,
    
94. ////   ERROR    = 0x01U,
    
95. ////   BUSY     = 0x02U,
      X$ @5 A/ \4 Z3 d
96. ////   TIMEOUT  = 0x03U
    ) Q6 D3 H" w0 K1 [' V* q
97. void StmL0xxEpromSingleByteRead(UNS32 addr, UNS8 *data)
    3 N  e; O* J. M& q/ K
98. {
    
99.         
    
100.         if ( (STM_EPROM_ADDR_BASE>addr) || (STM_EPROM_ADDR_END<addr) )
     8 R: g+ M# Z; l8 j
101.         {
     
102.                 return ;
     
103.         }
     
104.         
     8 J% A  t, b5 z
105.         StmL0xxEpromUnlock();
     ) |* \) Y7 \% c- A! a9 t. S( Z
106.         *data = *(volatile uint8_t *)(addr);
     
107.         StmL0xxEpromLock();
     ' j1 t4 [$ K8 G/ h/ G; }
108. }

复制代码

    测试代码如下：

1. void EpromTest(void)
   
2. {
   ; K4 E# h6 W% _' y# c9 X8 J  E
3.         UNS8        tmp[8] = {1, 2, 3, 4, 5, 6, 7, 8};
   ! q$ h' E; d6 ]# I/ r
4.         UNS8        read[8] = {0}, num=0, time=1;
   
5.         
   
6.         while(5>time)
   
7.         {
   ( \8 C4 C! y2 W
8.                 for (num=0; num<8; num++)
   : {( P4 h1 T& C  \0 o
9.                 {
   ' Z5 x" w. f; K
10.                         tmp[num] *= time;
    8 s1 K2 g9 S5 V8 n1 b
11.                         StmL0xxEpromSingleWrite(EPROM_WR_TYPE_BYTE, EPROM_TEST_ADDR+num, (uint32_t)tmp[num]);
    
12.                 }
    
13.                
    ; ]( g1 p& ^( x
14.                 for (num=0; num<8; num++)
    
15.                 {
    
16.                         StmL0xxEpromSingleByteRead(EPROM_TEST_ADDR+num, &read[num]);
    2 o, D7 I4 Z/ @9 S' \# j) b
17.                         if (tmp[num]!=read[num])
    0 P2 ~( |7 H3 a' l* b
18.                         {
    
19.                                 time = 10;
    ( C( A1 e+ V/ e6 Q
20.                         }
    
21.                 }
    
22.         
    7 r7 {  [$ [/ |# q# h
23. ////                StmL0xxEpromSingleWrite(EPROM_WR_TYPE_HALF_WORD, EPROM_TESTEE_ADDR, *(uint16_t *)(&tmp[0])); //// 进入异常中断
    8 h7 B* T! K1 ]- n" Y- O7 t" a
24. ////                StmL0xxEpromSingleWrite(EPROM_WR_TYPE_WORD, EPROM_TESTEE_ADDR, *(uint32_t *)(&tmp[0]));//// 进入异常中断
    7 J( T( }) x  k% `0 a4 ~
25.                 StmL0xxEpromSingleWrite(EPROM_WR_TYPE_WORD, EPROM_TESTE_ADDR, *(uint32_t *)(&tmp[0]));
      P* G8 k) y6 x
26.                 StmL0xxEpromSingleWrite(EPROM_WR_TYPE_WORD, EPROM_TESTE_ADDR+4, *(uint32_t *)(&tmp[4]));
    
27.                 StmL0xxEpromSingleByteRead(EPROM_TESTE_ADDR+0, (UNS32*)(&read[0]));
    0 H0 |) o$ m  a. S6 `" v; E, K; V
28.                 StmL0xxEpromSingleByteRead(EPROM_TESTE_ADDR+4, (UNS32*)(&read[4]));
    
29.                
    
30.                 time ++;
    . ~+ {+ l% o- u# S- `$ g1 |- X6 K* C
31.         }
    
32. }

复制代码

	/ P' b4 k$ T0 K+ W9 m/ k

总结：
     1. 字节操作时，传入任何地址参数都可以，读写操作正常；
     2. 但是当半字操作时，如果地址不是2对齐的，则调用函数StmL0xxEpromSingleWrite时进入HardFault中断；
     3. 但是当字操作时，如果地址不是4对齐的，则调用函数StmL0xxEpromSingleWrite时进入HardFault中断；
                 
; g; y1 K( x$ K9 S" C6 p     调试发现调用HAL_FLASHEx_DATAEEPROM_Program函数时进入异常中断。
     原因是EEPROM在内存结构上实际是以字为单位的：

9 }' ^- \# X2 \( B6 P( v- W' H           虽然可以进行字节、半字的参数，但是必须保证地址的对其方式——半字操作以2对齐，字操作以4对齐，否则会出错。
! F5 r3 [' H/ f* t# R
! Q0 V. x5 f% \' ^' ?9 {     ！！！！这个代码的对其方式怎么跟贴代码之前不一样呢，完全左对齐了！！！
3 Y  {+ J; U7 j; [1 W' Y

# f' v, K/ B6 s/ ]% s: f

来晚了，感谢支持，已汇总到1月技术原创
4 Q; i7 ~7 I$ l6 o$ t" N. Thttps://www.stmcu.org.cn/module/forum/thread-614550-1-1.html