STM32L的EEPROM支持字、半字和字节的读写操作。写操作之前自动擦除，如果写的数据为0，则只执行擦除操作。
6 z& ^( Y# |6 {$ O. p- i: [) B
, \0 P- e, H8 c7 V! n, f4 C6 p       使用STM32Cube库对自带的EEPROM进行操作，代码如下：
5 x3 D' a2 C1 a; _9 l2 C

1. 
   
2. #define                EPROM_WR_TYPE_BYTE                                ((UNS8)0x00)
   2 s" `; }% |2 Z5 B
3. #define                EPROM_WR_TYPE_HALF_WORD                ((UNS8)0x01)
   
4. #define                EPROM_WR_TYPE_WORD                                ((UNS8)0x02)
   
5. 
   % t' F" O1 x4 E) f1 m. ~) W  V
6. #define                EPROM_TEST_ADDR                                (STM_EPROM_ADDR_BASE + 12)
   
7. #define                EPROM_TESTE_ADDR                                (STM_EPROM_ADDR_BASE + 32)
   
8. #define                EPROM_TESTEE_ADDR                                (STM_EPROM_ADDR_BASE + 61)
   
9. 
   
10. //// Unlocks the data memory and FLASH_PECR register access
    $ X2 {! q0 Y) _, h3 T/ {+ v# B0 G
11. //// ret :
    & A6 V/ m( q& Q0 b8 L) h
12. ////   OK       = 0x00U,
    
13. ////   ERROR    = 0x01U,
    
14. ////   BUSY     = 0x02U,
    ; m4 _! ^5 t; q) w/ G* a
15. ////   TIMEOUT  = 0x03U
    
16. UNS8 StmL0xxEpromUnlock(void)
    
17. {
    
18.         UNS8                ret=0;
    9 v# k5 L, Y3 r4 r
19.         
    4 F; |+ _( T6 b* o& y% p  ~: I
20.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Unlock();
    
21.         
    
22.         return ret;
    . l9 a1 H/ q2 e3 g9 {
23. }
    9 ^/ N9 n" o3 {5 h: w
24. 
    
25. //// Locks the Data memory and FLASH_PECR register access
    $ i$ y1 l& t6 e3 i
26. //// ret :
    . O5 q% _' o- Z3 o8 ~
27. ////   OK       = 0x00U,
    
28. ////   ERROR    = 0x01U,
    , G8 c. D2 Z3 c  N1 ?' K. \$ R0 \' E
29. ////   BUSY     = 0x02U,
    # a% h/ i: k5 c/ A; r4 @- d
30. ////   TIMEOUT  = 0x03U
    ) D9 C( B: h1 W# P
31. UNS8 StmL0xxEpromLock(void)
    8 g3 B" P5 t# ]
32. {
    
33.         UNS8                ret=0;
    - _+ ~4 S3 r! j* H; j
34.         
    3 p. z  \% m1 H
35.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Lock();
    
36.         
    8 n; D( F7 v* c  m
37.         return ret;
    
38. }
    
39. 
    
40. //// Erase a word in data memory.
    
41. //// To correctly run this function, the @ref StmL0xxEpromUnlock() function
    2 B: P+ j' ?5 f/ E. F6 l
42. //// must be called before.
    & e$ ]9 n! r7 u: T8 e% Q! @4 r! `
43. //// addr -- specifies the address to be erased.
    . x# X# c$ K0 z) g
44. //// ret :
    ' ]8 a. u' Q/ J- ?3 m- v
45. ////   OK       = 0x00U,
    + h! r$ B( D$ \% v7 q' R
46. ////   ERROR    = 0x01U,
    
47. ////   BUSY     = 0x02U,
    . ^. o; B5 D5 `' p& w( ?+ }7 h; k
48. ////   TIMEOUT  = 0x03U
    ; [8 m+ G0 q" G- I7 ^0 c% x
49. UNS8 StmL0xxEpromWordErase(UNS32 addr)
    5 m8 S2 s; K( |+ U
50. {
    / n: O) |) F; I6 _
51.         UNS8                ret=0;
    
52.         
    
53.         if ( (STM_EPROM_ADDR_BASE>addr) || (STM_EPROM_ADDR_END<addr) )
    7 F$ [# h, G5 A. o' c
54.         {
    $ ?. q" H1 L! G7 ?* n5 f. b$ s
55.                 return ret;
    " O" U8 C" C! B) ]  [/ ]
56.         }
    
57.         
    
58.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Erase(addr);
    - m- q, q; [9 o4 X6 l
59.         
    
60.         return ret;
    
61. }
    1 Q  ?  ~/ X1 i. ^! N9 h
62. 
    
63. //// Program data at a specified address
    
64. //// type :
    + X' T8 g& B8 @
65. ////   Byte -- 0x00
    5 Z2 e; i; q& N
66. ////   HalfWord -- 0x01
    ! e  S* I: \" Q, |9 z
67. ////   Word -- 0x02
    
68. //// addr -- specifies the address to be erased.
    3 j$ b4 a  {; ], X
69. //// ret :
    
70. ////   OK       = 0x00U,
    7 N) M9 z5 k8 b! u/ W
71. ////   ERROR    = 0x01U,
    
72. ////   BUSY     = 0x02U,
      _3 k# ]2 F9 r6 ^- o
73. ////   TIMEOUT  = 0x03U
    , r2 N  S2 G+ v3 n5 ^9 w
74. UNS8 StmL0xxEpromSingleWrite(UNS8 type, UNS32 addr, UNS32 data)
    
75. {
    
76.         UNS8                ret=0;
    . C3 @3 N& b+ K9 t( T) e' ]$ o) @7 y
77.         
    
78.         if ( (STM_EPROM_ADDR_BASE>addr) || (STM_EPROM_ADDR_END<addr) )
    6 W& X9 r7 p& H5 X. w2 ?
79.         {
    
80.                 return ret;
    - Y% E# v3 x, q$ ?1 a* w. a, J
81.         }
    
82.         
      j* A; H6 z; q6 U+ Y
83.         StmL0xxEpromUnlock();
    
84.         ret = (UNS8)HAL_FLASHEx_DATAEEPROM_Program((UNS32)type, addr, data); //// 库函数
    
85.         StmL0xxEpromLock();
    0 m  r- n* C1 R. n& N) F
86.         
    3 k/ u. F3 E4 V- b
87.         return ret;
    
88. }
    
89. 
    # C  }6 k! F' ], E
90. //// read a byte at a specified address
    
91. //// addr -- specifies the address to be erased.
    . Y; @4 [0 u: d1 K/ d0 R& K
92. //// ret :
    
93. ////   OK       = 0x00U,
    2 {/ P3 O* a% `! ~
94. ////   ERROR    = 0x01U,
    ! L0 }3 B& E6 T: k( C# x& ^
95. ////   BUSY     = 0x02U,
    
96. ////   TIMEOUT  = 0x03U
    ) A  j- C; ?( ~; w' d) H% e
97. void StmL0xxEpromSingleByteRead(UNS32 addr, UNS8 *data)
    
98. {
    5 _1 j- J* k  ^
99.         
    5 ~% h) L; t% }- J# N
100.         if ( (STM_EPROM_ADDR_BASE>addr) || (STM_EPROM_ADDR_END<addr) )
     9 n" H: k: \1 K- P
101.         {
     
102.                 return ;
     
103.         }
     
104.         
     & i' G3 y& u1 [* a
105.         StmL0xxEpromUnlock();
     
106.         *data = *(volatile uint8_t *)(addr);
     
107.         StmL0xxEpromLock();
     * l& P+ N/ n9 U* e
108. }

复制代码

    测试代码如下：
0 k% j3 W7 h  @6 O. L, h  Z

1. void EpromTest(void)
   
2. {
   , g* l3 @; L, |7 h
3.         UNS8        tmp[8] = {1, 2, 3, 4, 5, 6, 7, 8};
   
4.         UNS8        read[8] = {0}, num=0, time=1;
   2 u2 v: A8 {3 {( v
5.         
   
6.         while(5>time)
   
7.         {
   7 v2 u4 e. V% y# [
8.                 for (num=0; num<8; num++)
   
9.                 {
   5 P; k& \$ o! z! [
10.                         tmp[num] *= time;
    . v+ B( O  d5 L
11.                         StmL0xxEpromSingleWrite(EPROM_WR_TYPE_BYTE, EPROM_TEST_ADDR+num, (uint32_t)tmp[num]);
    
12.                 }
    
13.                
    
14.                 for (num=0; num<8; num++)
    
15.                 {
    
16.                         StmL0xxEpromSingleByteRead(EPROM_TEST_ADDR+num, &read[num]);
    3 V% D( T+ D5 ~. y8 X& `& F- X
17.                         if (tmp[num]!=read[num])
    
18.                         {
    $ T1 j5 p$ Q( U; ]' i& E. K
19.                                 time = 10;
    * R* e$ W" V8 V" E0 r0 K3 s1 h' `
20.                         }
    
21.                 }
    * H& c" j: c! G  j
22.         
    5 c! c7 \& T  B9 J+ g
23. ////                StmL0xxEpromSingleWrite(EPROM_WR_TYPE_HALF_WORD, EPROM_TESTEE_ADDR, *(uint16_t *)(&tmp[0])); //// 进入异常中断
    % }9 k3 U2 S2 q9 V* n- ?5 U
24. ////                StmL0xxEpromSingleWrite(EPROM_WR_TYPE_WORD, EPROM_TESTEE_ADDR, *(uint32_t *)(&tmp[0]));//// 进入异常中断
    
25.                 StmL0xxEpromSingleWrite(EPROM_WR_TYPE_WORD, EPROM_TESTE_ADDR, *(uint32_t *)(&tmp[0]));
    : ?2 a7 B# ~7 t% h8 P8 ^2 I/ v- V
26.                 StmL0xxEpromSingleWrite(EPROM_WR_TYPE_WORD, EPROM_TESTE_ADDR+4, *(uint32_t *)(&tmp[4]));
    
27.                 StmL0xxEpromSingleByteRead(EPROM_TESTE_ADDR+0, (UNS32*)(&read[0]));
    
28.                 StmL0xxEpromSingleByteRead(EPROM_TESTE_ADDR+4, (UNS32*)(&read[4]));
    8 v2 m. d: O7 L+ A# A
29.                
    
30.                 time ++;
    , \. G6 z5 A; [0 s1 [
31.         }
    7 V6 v% H! x$ X
32. }

复制代码

	$ J2 A  d: p; W* {4 t 2 f! l( U* G: R3 d2 U 2 ^3 F2 g  H8 C* i

总结：
     1. 字节操作时，传入任何地址参数都可以，读写操作正常；
     2. 但是当半字操作时，如果地址不是2对齐的，则调用函数StmL0xxEpromSingleWrite时进入HardFault中断；
" n- X+ L: B* l7 x, s     3. 但是当字操作时，如果地址不是4对齐的，则调用函数StmL0xxEpromSingleWrite时进入HardFault中断；
                 
8 j* W: X3 s0 d1 z% ^7 ~3 k- ?     调试发现调用HAL_FLASHEx_DATAEEPROM_Program函数时进入异常中断。
5 g$ M' c6 s& A0 V2 e/ ~     原因是EEPROM在内存结构上实际是以字为单位的：

, I' w* F" i; w: z. _           虽然可以进行字节、半字的参数，但是必须保证地址的对其方式——半字操作以2对齐，字操作以4对齐，否则会出错。

     ！！！！这个代码的对其方式怎么跟贴代码之前不一样呢，完全左对齐了！！！


6 L2 h5 ]! P9 [  N, m

来晚了，感谢支持，已汇总到1月技术原创
& \2 h1 N. Q6 D0 ihttps://www.stmcu.org.cn/module/forum/thread-614550-1-1.html