你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

基于STM32L051测试Flash和EEPROM的读写

[复制链接]
攻城狮Melo 发布时间:2023-6-12 17:30

本文测试 L051 flash的读写,用来处理以后应用中的掉电数据保存。

1、STM32L051内部存储模块地址范围

开始找到F103的FLASH图复习了一遍,然后L051C8T6,64KB的flash,  然后我惊奇的发现还有2KB的EEPROM。发现L051系列的地址与F103完全不同,F103的flash每页的长度有1KB(小容量<=64KB)和2KB(大容量128KB起)查看各种资料, 查了2个小时, 还是不知道L051的flash 每页长度是 128Byte 还是256Byte????????????????????????还是请教了一下大佬,发现直接在J-Flash中可以找到答案,先上个F103的图:

. g: k  f- i# R- E' ^1 g5 f7 ]2 v

微信图片_20230612172451.png

/ c$ Q7 D5 Q# S6 [

微信图片_20230612172454.png


& Y! E1 v6 u1 [; [/ z

然后来看个L051的图:图中64KB 的flash 和2KB的EEPROM都能都明显的看出地址,flash 512页,每页128bytes,EEPROM只有4页,每页512bytes.知道了基本的地址,就可以操作起来了。

最后还需要确定的一点事,最小擦除单元是128bytes,还是256bytes,按以前的认知,删除是按照一个Sector擦除的,也就是128bytes,但是我查看了一些网上的例子和资料,有的是说256bytes,所以后面需要自己确定一下

其实在HAL库的 stm32l0xx_hal_flash.h 文件中有过 FLASH_PAGE_SIZE    的定义,就是128bytes       :

# Z- K+ J4 X" ^  _) e' e

  1. #define FLASH_SIZE                (uint32_t)((*((uint32_t *)FLASHSIZE_BASE)&0xFFFF) * 1024U)3 E7 }6 d: @6 @# t8 J: D
  2. #define FLASH_PAGE_SIZE           ((uint32_t)128U)  /*!< FLASH Page Size in bytes */
复制代码
1 e4 P3 Q! H9 s" ~4 m& h

对于flash的操作,有一些基础知识补充一下:

Read interface organized by word, half-word or byte in every area • Programming in the Flash memory performed by word or half-page • Programming in the Option bytes area performed by word • Programming in the data EEPROM performed by word, half-word or byte • Erase operation performed by page (in Flash memory, data EEPROM and Option bytes)

STM32L051写Flash必须字,读 字节、半字、字都支持。(这句话也是错误的,这是以前哪里看到的,实际测试写可以根据字,半字,字节来写)

一些基本概念:定义字是根据处理器的特性决定的。首先ARM是32bit处理器,所以它的字是32bit的。半字自然就是16bit;字节不论在哪个CPU上都是8bit。1 Byte = 8 bits(即 1B=8b) 1 KB = 1024 Bytes Bit意为“位”或“比特”,是计算机运算的基础,属于二进制的范畴;Byte意为“字节”,是计算机文件大小的基本计算单位;

0 X7 y! N' n6 ~' C9 p! J4 \
2、读写函数的设计

HAL库中肯定是有对flash和EEPROM进行操作的函数,我们这里新建一个stml0_flash.c 和stml0_flash.h 函数分别放在对应位置,进行自己的函数设计。库中Flash与EEPROM的函数看样子是分别放在 stm32l0xx_hal_flash.c 和 stm32l0xx_hal_flash_ex.c 中的,我们先使用EEPROM,因为提供EEPROM,就是让用户可以保存一些掉电后的数据的嘛,测试完EEPROM,再去测试下flash,因为怕有时候数据不够放……


5 j& Y- a6 j# I* I* n2.1 读取函数
  1. //读取指定地址的半字(16位数据)4 B, G, p: i, [- G9 z6 t3 s
  2. uint16_t FLASH_ReadHalfWord(uint32_t address), U! R* b- h1 T
  3. {
    2 G) ?- k! L1 ~  w# v6 f
  4.   return *(__IO uint16_t*)address; 8 n8 @& Z$ N# Q! [5 x! O+ X7 K
  5. }
    $ S- H& l$ c& q3 u+ Z5 M
  6. # X) l! r2 v( v! N1 O; J
  7. //读取指定地址的全字(32位数据)# z# u1 g1 F; N
  8. uint32_t FLASH_ReadWord(uint32_t address)7 K' r$ W6 m) Z& J5 L
  9. {
    : l8 c% `9 Z0 b, ]2 f
  10.   return *(__IO uint32_t*)address;: I6 q" p# Q1 f6 D  Q, S
  11. }
复制代码
: a# n. w- Q5 ~5 E) g) M7 M
; E/ [$ r7 b9 B

简单测试一下:

  1. u32 read_data1=0XFFFFFFFF;
    ' A! W4 z: V% D9 w; [
  2. u32 read_data2=0XFFFFFFFF;
    2 i' m: a7 ]0 ]1 R6 W- k0 Z
  3. ...7 }- R6 j8 o$ h6 [) e, c# T" q
  4. read_data1 = FLASH_ReadWord(DATA_EEPROM_START_ADDR);
    * D+ {6 W" k# k$ p7 a
  5. printf("the DATA_EEPROM_START_ADDR is: 0x %x \r\n",read_data1);& P4 B% t( E& u! j/ m
  6. read_data2 = FLASH_ReadWord(DATA_EEPROM_START_ADDR + EEPROM_PAGE_SIZE);
    8 N- x. @. q8 a6 w: {/ I  c9 x9 l* n
  7. printf("the EEPROM sceond page test data is: 0x %x \r\n",read_data2);
复制代码

* p- z" s4 R, W" |7 ?. P

没有写入数据读取的值应该都是0。

1 p; P  d1 b. q$ B" S- s# P$ z* e7 D
2.2   EEPROM写函数

对EEPROM的写函数:stm32l0xx_hal_flash_ex.h中函数如下:

  1. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Unlock(void);3 f* K. q  x5 n. k+ l; O# ~. r
  2. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Lock(void);
    ; K/ b; l+ ^$ _" K! a* _
  3. / p" a" [6 t7 P$ l1 D
  4. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Erase(uint32_t Address);; m9 L; a6 @! |
  5. HAL_StatusTypeDef HAL_FLASHEx_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data);
复制代码
) `: G4 Q8 F' V2 D

通过函数看来,可以直接用,但是这里有一个问题

需要测试一下,擦除是否会擦除整个扇区,有待验证!!

答:EEPROM的擦除可以直接擦除某个地址的字,不会擦除整个片区

EEPROM的操作相对Flash,比较简单,直接使用HAL库中的函数即可完成

  1. HAL_FLASHEx_DATAEEPROM_Unlock();" y; x& Y: f) B6 Q$ n+ q
  2. HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, DATA_EEPROM_START_ADDR, write_data1);
    , g) J  e( a. R9 P+ |5 P' Y' K
  3. HAL_FLASHEx_DATAEEPROM_Lock();# ]- w0 l5 m6 p
  4. ...
    : X2 _, P: ?% Z. z) Q* `& e
  5. if(btn_getState(&K1_BUTTON_150mS) == BTN_EDGE2){  s1 R6 u* X! G: I
  6.         printf(" K1 150ms button!,EEPROM_Erase test\r\n");3 J. i) h9 u7 b6 p
  7.         HAL_FLASHEx_DATAEEPROM_Unlock();3 Q# x/ f+ [5 }. U% v$ _
  8.         HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_START_ADDR+4);9 Y5 P* v8 J+ ~9 `- v5 H( l
  9.         HAL_FLASHEx_DATAEEPROM_Lock();% y; z2 `2 s1 G  g+ X9 F7 }- A* _
  10.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);8 C' `# H1 t$ t! Q4 ^/ U8 s" m
  11.     }
    0 L9 A2 ?% k3 j5 x
  12. ...# W$ x5 [$ q# P
  13. if(btn_getState(&K2_BUTTON_150mS) == BTN_EDGE2){
    ) }5 i! l# @) ~" {. `/ r
  14.         printf(" K2 150ms button!EEPROM_read test\r\n");
    ) \6 j9 Z* b. M
  15.         read_data1 = FLASH_ReadWord(DATA_EEPROM_START_ADDR);
    9 p/ C0 B. z/ G. E2 i% n* I. ^
  16.         printf("the DATA_EEPROM_START_ADDR is: 0x %x \r\n",read_data1);
    9 j; B6 d2 _( j
  17.     }
复制代码
2 c. g6 e# i+ s& T6 S: C9 k

按照上面的例子,擦除DATA_EEPROM_START_ADDR+4的地址不会影响DATA_EEPROM_START_ADDR地址的开始写入的数据 写入一样,如果不在意以前的数据,直接写入就可以。 总结来说EEPROM的使用还是很好用而且简单的。而且EEPROM是可以按照字节,半字,全字写入的,测试了一下,是右对齐

右对齐什么意思呢,打个比方就是如果在地址 addr 中,本来写入全字 0x12345678 然后直接在EEPROM 的 addr 这个地址,写入半字 0xFFFF, 再读取全字的话,addr 地址的全字就变成了 0x1234FFFF  ,这个具体的为什么在地址写入半字,不会直接从地址开始占用2个字节,是因为地址的类型为 uint32_t ,所以该地址就是 4个字节类型的数。


1 ?4 g  K* t0 H2 [$ X' r写入问题说明修改

2021/11/23 修改说明 上面一段的解释有误,这里修改一下,不是因为地址类型为uint32_t,地址类型永远是这个,是因为定义的数据类型为uint32_t ,然后STM32又是小端模式,所以保存的方式是从地址的最后开始保存,4个字节的全字,第一个字节放在地址开始+4 的位置,第二个字节放在地址开始+3的位置,所以如果调用HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, DATA_EEPROM_START_ADDR, write_data1);关键在于FLASH_TYPEPROGRAMDATA_WORD以全字方式写入半字,那么内核会自动分配4个字节的宽度,半字的第一个字节放在写入地址+4 的位置,第二个字节放在写入地址+3的位置,所以导致了上面的结果

  1.   HAL_FLASHEx_DATAEEPROM_Unlock();) k; T6 d$ [) Z: s: L/ b
  2.   HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, DATA_EEPROM_START_ADDR, 0X88);4 P6 M# S. B# Z, d. y
  3.   HAL_FLASHEx_DATAEEPROM_Lock();
    + T: ^# L! s5 y; D; h
  4.   read_data1 = FLASH_ReadWord(DATA_EEPROM_START_ADDR);
    $ M0 j. R$ T, z
  5.   printf("the DATA_EEPROM_START_ADDR is: 0x %x \r\n",read_data1);
复制代码
% a4 L8 [- T) c, J: n; y- n0 o* b

最后在 stml0_flash.h 中把函数完善声明一下,使得主函数中的程序更加简洁。

  1. void MY_DATAEEPROM_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)   
    $ E3 b, p7 k5 c
  2. {8 g9 S9 _  N* c% j
  3. HAL_FLASHEx_DATAEEPROM_Unlock();        ( t7 j7 @) u" @+ z' i
  4.     HAL_FLASHEx_DATAEEPROM_Program(TypeProgram, Address, Data);
    / v9 U. O& a1 Z5 U- C
  5. HAL_FLASHEx_DATAEEPROM_Lock();
    4 G* [; L$ ?6 N& ]
  6. }
复制代码
  P! E7 T- |! ^: J0 u" ?0 a; X4 X9 o

那么L051 的EEPROM的测试就到这里,其实有EEPROM,在项目中的保存数据的功能就问题不大了,但是我们既然开始了,就把L051 Flash的读写也测试一下。


( E. |" l+ s( R2.3   Flash写函数

Flash的读取其实和EEPROM一样,主要是写函数,来看一下stm32l0xx_hal_flash.h 中有哪些函数

  1. /* IO operation functions *****************************************************/
    8 `5 F2 ?) n+ Q' d& X, f7 u' N
  2. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data);3 E# D1 N' m8 r4 s8 S, j  v' V
  3. HAL_StatusTypeDef HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint32_t Data);" c+ V, m0 o9 B' U1 W8 K+ q

  4. . V/ A2 F8 i+ b2 k5 W) Y2 g
  5. /* FLASH IRQ handler function */1 `: M& u# D5 |- ], N
  6. void       HAL_FLASH_IRQHandler(void);* N! \+ \& ^& X+ }) z" H# L) w0 h  A
  7. /* Callbacks in non blocking modes */
    " n  A0 ~8 y$ Q. J
  8. void       HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue);+ \% }) @6 Y. A% q1 }% S$ ^+ E. {
  9. void       HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue);
    0 f! F: s  {1 }  Z: r

  10. 3 i) m) {! }! j5 V# D7 \: c
  11. /**: B( T5 [! H8 x0 [1 Y8 G. \
  12.   * @}3 d8 V: r. N! ?- \! g0 N6 N9 }
  13.   */
    ! A  n' d# R7 D6 J, _

  14. 5 o% `1 R8 n( q( m( S6 ]1 c" }
  15. /** @addtogroup FLASH_Exported_Functions_Group2
    ( ]% t+ K& N  b3 ?* R9 K
  16.   * @{
    6 f; [9 H. p9 E
  17.   */
    : [7 K' q& p; M" u$ `( Y9 {: \
  18. /* Peripheral Control functions ***********************************************/
    7 j5 `9 A1 [" x8 k9 o6 L
  19. HAL_StatusTypeDef HAL_FLASH_Unlock(void);
    2 r! x" U2 s7 m* Q
  20. HAL_StatusTypeDef HAL_FLASH_Lock(void);  @# G2 ~6 W4 F
  21. HAL_StatusTypeDef HAL_FLASH_OB_Unlock(void);
    , j  G( N& w9 [) E7 ?. x' u* t
  22. HAL_StatusTypeDef HAL_FLASH_OB_Lock(void);
    3 p0 c9 a1 u3 A0 d* N  _
  23. HAL_StatusTypeDef HAL_FLASH_OB_Launch(void);
复制代码

& z; j- [. h% b* x

有点忙,Flash的后面再也,看了几个demo,只需要做几个测试就可以;


3 w' {1 q. E; _" K: a0 U

2021.8.5  今天有空来接着测试一下L051  Flash的读写,看了下HAL_FLASH_Program函数:

* G' N, V2 G, C
  1. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint32_t Data)0 F; A, y4 g: i( I6 _, X" E" o
  2. {4 ]5 R$ S; y5 Q7 _
  3.   HAL_StatusTypeDef status = HAL_ERROR;
    * a1 v; ?! {; M, p' \5 S
  4.   6 i) [9 b7 O' r% f- n& O  I
  5.   /* Process Locked */
    ! Z+ r: U/ j' H1 i6 W
  6.   __HAL_LOCK(&pFlash);+ @) c, Y  [9 W% P  x, d
  7. ( W9 j* e# @: V4 {0 y0 A
  8.   /* Check the parameters */- v- n5 j& x! N& Y
  9.   assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
    $ Q( Z1 I( J1 y, W' e4 M8 I! ^5 n
  10.   assert_param(IS_FLASH_PROGRAM_ADDRESS(Address));: ?; z9 @6 b* q& ~2 }
  11. $ M% q% P3 G6 f
  12.   /* Wait for last operation to be completed */
    . T( V1 }/ }3 `8 Z- o9 I3 o
  13.   status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    : o7 c! [( g( u4 }4 ^8 H
  14.   
    / z6 o. Y1 a0 Z7 I1 y' U% U
  15.   if(status == HAL_OK)) q: v2 L% ~( S8 K& {
  16.   {
    , U+ _1 W# Q4 P6 h; Z
  17.     /* Clean the error context */
    1 x' N+ c/ u9 L7 K4 N9 m, e
  18.     pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    ' q. N- U4 o; [# S4 X* _! o% L
  19. 6 c% T- W4 q  r
  20.     /*Program word (32-bit) at a specified address.*/, I9 N' C) o' w5 F/ _
  21.     *(__IO uint32_t *)Address = Data;) e4 q- Q% N# j" |( o8 e) U
  22. , E/ Y' p! Y0 ~7 p
  23.     /* Wait for last operation to be completed */
    0 Y+ Z1 B- `( j/ x$ {
  24.     status = FLASH_WaitForLastOperation(FLASH_TIMEOUT_VALUE);
    3 y0 x( }; C! w( g
  25.   }
    5 i, k. w2 h; a( E: m# w& c

  26. % a3 \1 r; \, L
  27.   /* Process Unlocked */2 _7 @6 I, G0 d. m0 d
  28.   __HAL_UNLOCK(&pFlash);
    $ N3 w, I+ ]# x9 n, I& w' q

  29. - e! P8 i3 I! V0 f+ o6 f
  30.   return status;
    " U& G) e5 l. f. ]( q6 C  y
  31. }4 Q' Z( F, N! ~0 [5 g/ q' D8 o
复制代码

" n4 B7 Z/ H* O. E

这里也再次说明了,L051的写必须以字的方式写入。

不管了,先测试一下,不擦除直接写入,这里先定义一下写入的地址,前面我们已经知道了L051 flash一共 512页,每页128bytes,所以我们直接拿最后面的几页来测试

  1. #define ADDR_FLASH_PAGE_505      0X08000000 + 128*504   //
    " o6 J# v3 U3 [7 D8 t' T
  2. #define ADDR_FLASH_PAGE_506      0X08000000 + 128*505   //( s$ ?6 g7 Q3 |2 `$ z/ o( A; r
  3. #define ADDR_FLASH_PAGE_507      0X08000000 + 128*506   //( M1 O7 w  o1 o# _9 Q- C( L, @
  4. #define ADDR_FLASH_PAGE_508      0X08000000 + 128*507   //7 F! o- u( ~, I( n- a, P
  5. #define ADDR_FLASH_PAGE_509      0X08000000 + 128*508   //) h. q) f  Z% y
  6. #define ADDR_FLASH_PAGE_510      0X08000000 + 128*509   //
    5 Y% s( E6 Q- B" k; m4 _  U) h
  7. #define ADDR_FLASH_PAGE_511      0X08000000 + 128*510   //  A, I9 T8 a  J& @
  8. #define ADDR_FLASH_PAGE_512      0X08000000 + 128*511   //最后一页
复制代码

开始先不擦除,直接在最后一页写入一个字读取一下试试,整理一下写入函数:

  1. void MY_DATAFLASH_Program(uint32_t Address, uint32_t Data)   
    5 D- L% x: K+ A) {; U9 K1 J
  2. {+ U! h0 i) C8 z( }7 d
  3. HAL_FLASH_Unlock();        $ m+ I8 R* q& K8 g% C/ k8 j2 @
  4.   if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, Data) == HAL_OK){
    * E2 |" i5 L; `9 a* d: F9 o# c
  5.     printf("write data 0x%x OK\n", Data);! ^+ d# q  s/ U$ ^; r6 X5 a
  6.   }
    + u1 I* Q) _. ]& g/ |
  7.   else{8 S7 z9 @8 V9 B$ G9 H+ I4 p0 d1 J
  8.     printf("failed!!!\n");
    $ j/ E3 \6 M5 c- O. g% f. b
  9.   }
    8 C& B! H5 B1 `/ e
  10. HAL_FLASH_Lock();5 s. @; i6 W7 D# L. ~& Y- O! A0 a
  11. }
复制代码

$ ?% w8 I0 M# @+ u" J5 H! k0 N8 N; N" {+ X

测试一下;

  1.   MY_DATAFLASH_Program(ADDR_FLASH_PAGE_512,write_data2);
    ; o# N( A3 I1 m- Z/ b
  2.   read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_512);
    3 H9 B! j. W8 n, E; q5 _
  3.   printf("the ADDR_FLASH_PAGE_512 is: 0x %x \r\n",read_data1);
复制代码
- f$ `& S% Y" R0 f

在没有写入flash之前,该地址读出来的数据为0,写入后读出来是正常写入的数据这里有个疑问,按理来说,flash存储器有个特点,就是只能写0,不能写1,所以flash的写入,比需先擦除,或者至少检查一下该数据区是否可以写入,但是L051 怎么初始的时候读出来是0? 难道L051的有区别,需要测试一下

先在一个地址写0XFFFFFFFF ,然后写完了再写一次别的数据看看能否直接写入,结果是写入了0XFFFFFFFF ,不能继续直接写数据,说明,估计L051是相反的,这里具体是不是我只看测试结果,结论的话我自己知道就可以应用,希望有权威大神指正。

这里我们得用到一个关键的函数 ,这个函数是在stm32l0xx_hal_flash_ex.c 这个文件中的,是flash的擦除函数:HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *PageError)

所以这里我们知道了以后,可以优化一下写入函数,我们项目中用到的是可以直接对某个地址的写入,然后也不需要保存,此页其他的数据,所以我们把函数改成如下:

  1. void MY_DATAFLASH_Program(uint32_t Address, uint32_t Data)   . A2 M4 n- ~, X/ S
  2. {
    $ Z5 F) x; x$ M4 g: t1 S
  3.   FLASH_EraseInitTypeDef EraseInitStruct;+ v1 |$ @! b. F) }' @4 ]: g) k
  4.   uint32_t checkdata;
    ( i! `2 Q. S! `/ L  a$ r
  5.   uint32_t PAGEError = 0;: w2 G( e. `) m: q
  6.   checkdata = FLASH_ReadWord(Address);. {" ]) S6 ?0 x: W) n/ ^0 A/ y
  7. HAL_FLASH_Unlock();
    5 z, t! J+ @. |. J  e4 {* v
  8.   /*如果是0,直接写*/2 E2 }# j, R  n4 e- w
  9.   if(checkdata == 0){       " n  Z$ r) c* p0 \# b' U
  10.     if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, Data) == HAL_OK){
    % ]6 A; m2 |) W8 p
  11.       printf("write data 0x%x OK\n", Data);# ^) m+ c, K$ Q
  12.     }
    ; B- P" E! {+ B9 b
  13.     else{
    2 n0 D8 B6 P6 t
  14.       printf("failed!!!\n");) @9 r/ H2 N* |; c! [' v
  15.     }* g1 \: x- z+ q+ L9 Z
  16.   }3 e/ j' f- A" R) T8 w
  17.   /*否则擦除再写*/5 o( I3 ?) H1 `/ h9 y. h5 s) z
  18.   else{$ V% W+ l- j) Q- l, N+ m! H1 ^3 B
  19.      __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR);
    , e2 \2 f( L% C4 @+ o

  20. : @4 G( a& \7 O) e# l
  21.       EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES; // 刷除方式
    7 x" }2 r( T- F0 J8 W
  22.    EraseInitStruct.PageAddress = Address; // 起始地址( L9 w: O. ~' k% z  R: [$ b5 X
  23.       EraseInitStruct.NbPages = 1;
    8 ~# {% t$ ^6 F9 a9 j; B" f
  24. 6 }$ E7 ^6 E) a; c8 a( e3 n  Q
  25.       if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
    0 v5 t3 m1 H# Y! G
  26.       {
    4 R  [  M/ P" Q
  27.         // 如果刷除错误" X9 l% g+ V2 S! I- N; Z
  28.         printf("\r\n FLASH Erase Fail\r\n");
    : W$ R* M# U1 s8 Y
  29.         printf("Fail Code:%d\r\n",HAL_FLASH_GetError());
    & L3 ?; h, C+ [4 e* L- f8 ]8 R
  30.         printf("Fail Page:%d\r\n",PAGEError);0 Q4 g' l: ?) G9 w$ k  x, U  C
  31.       }6 K# t, _: Q7 j0 Y
  32. ' w1 Z0 X5 [2 c6 |4 l5 `. g
  33.       if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, Data) == HAL_OK){
    + L3 {0 G) Z; I/ U8 y. d2 e
  34.       printf("write data 0x%x OK\n", Data);
    + w2 f0 a1 V6 I, R6 I
  35.       }
    # K2 L+ Y7 \/ `! a% h/ t
  36.       else{
      m) _, I9 _+ k2 r9 y  W% K
  37.         printf("failed!!!\n");
    - {! U% K' p0 W: S
  38.       }
    * ]& z* {) q2 S' P/ G

  39. 9 c6 V. e8 ^8 g' v) A
  40.   }/ }* z" Z% P9 {3 \
  41. HAL_FLASH_Lock();3 S( n# x1 L: \; J* i
  42. }
复制代码

4 z! Y4 k( b# Z  B1 z! v  b

自己修改了一个函数, 改成这样以后,就能直接在想写入的地方写入数据了,到这里,flash足够我项目中的使用了。但是还有最后一个疑问,就是擦除的一页到底是不是128bytes我来验证一下。

  1. u32 write_data1 = 0X12345678;  @& A! o$ u4 r
  2. u32 write_data2 = 0X87654321;
    ! {- H& ~% R, X
  3. u32 write_data3 = 0XFFFFFFFF;
    . E8 g8 B5 [" M9 i

  4. ! L. }2 L- k5 e* i: {
  5. MY_DATAFLASH_Program(ADDR_FLASH_PAGE_508 + 124,0X508508FF);& \3 W9 j* K- O2 D8 }
  6. MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509,write_data3);
    8 B2 U1 W, `- g
  7. MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509+4,write_data2);9 E% X0 o) }1 x/ ?4 D8 x* \4 r3 T
  8. MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509+8,write_data1);
    1 u- R! F: S* z% Q+ \" z4 |" h
  9. MY_DATAFLASH_Program(ADDR_FLASH_PAGE_510,0X510510FF); 1 _: ^  U1 o6 Z4 b$ \7 H
  10. & z0 q! {8 ]' {  K: |$ o5 E
  11. read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_508 + 124);) C+ v7 V6 S, {$ E1 V& \
  12. printf("the ADDR_FLASH_PAGE_508 last is: 0x %x \r\n",read_data1);0 X3 d% t# g% }0 k1 K
  13.   read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509);
    7 W' _' H' g" @% c5 x: R+ Y& [$ s
  14.   printf("the ADDR_FLASH_PAGE_509 1 is: 0x %x \r\n",read_data1);0 n- m! m) p* g3 h, |' n
  15.   read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 4);
    4 U" F" K% {3 ?6 C- O
  16.   printf("the ADDR_FLASH_PAGE_509 2 is: 0x %x \r\n",read_data1);
    % L9 c/ D( ~8 {( u; [9 e
  17.   read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 8);
    ) W- d/ N7 q+ {0 z/ t% u
  18.   printf("the ADDR_FLASH_PAGE_509 3 is: 0x %x \r\n",read_data1);9 X8 N' b3 ^6 ~) q! h3 F
  19.   read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_510);, O/ q' U4 L2 Y+ u
  20.   printf("the ADDR_FLASH_PAGE_510 first is: 0x %x \r\n",read_data1);
    " v& W8 G+ T3 E! \) H# z
  21. 6 H) T7 O2 I. Q. }* k' |6 h
  22. if(btn_getState(&K2_BUTTON_150mS) == BTN_EDGE2){  {# `' \% a- y
  23.         printf(" K2 150ms button!EEPROM_read test\r\n");3 i7 T2 s2 x& U' m
  24.         read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_508 + 124);* _! X2 {5 F  b
  25.         printf("the ADDR_FLASH_PAGE_508 last is: 0x %x \r\n",read_data1);. Y" Z. v. `1 U/ H) r
  26.         read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509);1 q% }1 Z8 Z  L5 C/ W4 a1 G$ p
  27.         printf("the ADDR_FLASH_PAGE_509 1 is: 0x %x \r\n",read_data1);
    $ f3 l2 H8 ?7 a. v, i
  28.         read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 4);/ Q  X  _) Y& \! w
  29.         printf("the ADDR_FLASH_PAGE_509 2 is: 0x %x \r\n",read_data1);# n5 s  C! M4 {  j& G
  30.         read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_509 + 8);7 c9 u3 M/ T4 c* @: z3 V; T# S2 {
  31.         printf("the ADDR_FLASH_PAGE_509 3 is: 0x %x \r\n",read_data1);
    % s' Q# `( U: Y  I
  32.         read_data1 = FLASH_ReadWord(ADDR_FLASH_PAGE_510);0 y- s! J' U$ R9 x/ C
  33.         printf("the ADDR_FLASH_PAGE_510 first is: 0x %x \r\n",read_data1);, X+ p# {' v& R& G
  34. : `( `5 v8 B- Y5 h$ c
  35.     }
    8 u  O, L+ ~% B' |' b
  36. if(btn_getState(&K1_BUTTON_150mS) == BTN_EDGE2){
    # }; S3 K1 u0 a; O
  37.         // printf(" K1 150ms button!,EEPROM_Erase test\r\n");3 {7 Y* L3 Y! O% w
  38.         // MY_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, DATA_EEPROM_START_ADDR, write_data1);
    6 d% n) E& K8 S" h; m: C
  39.         printf(" K1 150ms button!,flash write test\r\n");
    8 a' g8 t- I" w' o: t5 k8 \
  40.         MY_DATAFLASH_Program(ADDR_FLASH_PAGE_509,0X33333333);
    1 _( u+ b6 V7 K
  41.         HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
    6 t9 X, n3 a' y' d. g; M5 l
  42.     }
复制代码
& _0 h: A; X( h; \

因为地址位置如果有数据的话会擦除一页再写入,所以我们看了一下508页最后一个地址,和510页的第一个地址数据,对509页的数据进行了操作,结果发现不会改变508 和510的数据,509页的数据会全部清除!


. B+ C, B3 ?4 n- C3 K

微信图片_20230612172448.png


  W% y$ U9 H7 T( e: }* O

微信图片_20230612172355.png


/ m! Y# E6 |* A0 j1 v6 |( s; y% o

所以得出的结论显而易见,flash擦除按照一页一页擦除, 在L051上面一页为128bytes,而且擦除后数据全部为 0;


5 G4 ]  p1 I7 [5 e2.4 读写EEPROM的后续问题

最近有一个项目,因为缺货 STM32L051R系列缺货,买了 STM32L071RBT6 替代:


6 H) ~) m! y. d$ C6 p. `

微信图片_20230612172339.png

2 M1 d) [% s7 a) D

看了一下地址,其实我们上面所有的测试代码基本都是可以直接用的,代码直接用STM32L051的代码也是可以的,实际项目中,还是使用EEPROM比较方便,所以在使用EEPROM的时候,发现了一个问题(并不是换了芯片的问题),还是数据读取和写入的问题。

1 @( ^0 S/ [  u6 W' a5 I8 h
2.4.1 问题的出现和解决

下面程序的硬件平台是 STM32L071RBT6,首先在程序中,有一个写ID的函数:


2 U) |- t4 g  @2 s1 B4 d

微信图片_20230612172215.png

# _3 x. f! V# [/ J% e( V

写入IO是通过字节的方式 byte  写入的,写了6个字节(蓝牙设备的ID)。

然后最初读取的函数用的是:

5 l6 J& D+ K( H* W

微信图片_20230612172212.png


' G; L6 K% W  f- Y

使用这个读ID的函数,问题就出来了。上图代码中,我读取ID使用的是半字读取,处理方式是把读到的半字前面8位给ID1, 后面8位给ID2, 但是测试中发现 数据读出来与想要的相反,什么意思呢,看下面的测试说明:

上电打印出EEPROM中读取的一个地址的,每个ID(每个ID是uint8_t类型)的数据,在代码开始定义了测试数据:

  1. BlueID_STRUCT test;. f' }9 T7 }0 Y, g
  2. ...
    ; j4 J2 d* F) ?+ G8 j) o
  3. /*! Q; d1 p3 h" }+ G, V  a; W" N7 B
  4. CHBlueID_STRUCT Flash_PowerOn_BlueCheck(). [' ^: a1 d: K4 W0 ]
  5. {. y; u1 y9 j! D

  6. - ?6 E6 o% {" H, J- s7 p
  7. CHBlueID_STRUCT PowerOn_ID;3 q* _+ ^% x& n0 X7 ?+ \
  8. PowerOn_ID.CH1ID = FLASH_blueIDRead(CH1_ID_ADDR);7 b' C5 A0 r9 Q8 U: ?) S" V  G
  9. PowerOn_ID.CH2ID = FLASH_blueIDRead(CH2_ID_ADDR);
    , z* d% b! P" ^8 O2 _' {
  10. PowerOn_ID.CH3ID = FLASH_blueIDRead(CH3_ID_ADDR);6 K. t9 ~9 I- s# P3 [
  11. PowerOn_ID.CH4ID = FLASH_blueIDRead(CH4_ID_ADDR);
    # N# t0 A, m1 v1 N9 A: H; B% F
  12. PowerOn_ID.CH5ID = FLASH_blueIDRead(CH5_ID_ADDR);
    " ~7 W4 i3 P7 c) q  r5 z
  13. PowerOn_ID.CH6ID = FLASH_blueIDRead(CH6_ID_ADDR);8 P8 t1 H: ?, g; |. B0 s; B7 W( z4 T
  14. PowerOn_ID.CH7ID = FLASH_blueIDRead(CH7_ID_ADDR);
    , d, F  v5 Q' ~  L+ O" r8 D2 l0 O' Q
  15. PowerOn_ID.CH8ID = FLASH_blueIDRead(CH8_ID_ADDR);
    . m, {  w% E) H1 ]/ ^  V
  16. PowerOn_ID.CH9ID = FLASH_blueIDRead(CH9_ID_ADDR);
    4 a3 ~$ V7 V4 q2 J$ ^- c
  17. PowerOn_ID.CH10ID = FLASH_blueIDRead(CH10_ID_ADDR);
    + T8 P* ?8 [5 f
  18. * n* t# i, @$ s. |8 T0 r! e
  19. return PowerOn_ID;
    / l/ q7 t! h  c) E/ T3 S) T
  20. }
    ! G' F- a, Y0 a# h' ^' M7 E
  21. */
    / c7 j" s4 {6 ]2 ?  r
  22. BlueChipID = Flash_PowerOn_BlueCheck(); //上电先把ID读出来做比较3 {( g6 O+ Q8 g" C! I+ `# p
  23. //打印一个出来测试,看结果$ w/ b1 y1 d# v$ o! d" z
  24. printf("BlueChipID.CH1ID is 0x%x,0x%x,0x%x,0x%x,0x%x,0x%x\r\n",BlueChipID.CH1ID.ID1,BlueChipID.CH1ID.ID2,BlueChipID.CH1ID.ID3,BlueChipID.CH1ID.ID4,BlueChipID.CH1ID.ID5,BlueChipID.CH1ID.ID6);, i. F; I- P+ y. `7 |% S. ~; P; n4 a

  25. $ X' \  V% @" |  F8 ?, V; d
  26. test.ID1= 0XFF; //结构体每个元素是 uint8_t 类型: \2 R4 k# g& K+ a; Q
  27. test.ID2= 0XEE;3 r7 x/ w4 p, r+ H
  28. test.ID3= 0XDD;
    0 j6 c3 J" \- I( l) X- V
  29. test.ID4= 0XCC;
    , @1 @0 B! J# f: J# `6 w
  30. test.ID5= 0XBB;
    ) t  ]; m4 W  Y* m
  31. test.ID6= 0XAA;
    8 b' o. ]+ B6 b5 I1 P
  32. + t/ ^% l* j+ \& p9 c
  33. while (1){...}
复制代码
! v6 ^2 J! F. S2 O5 Z9 p

在程序中通过操作,写入测试数据,调用上面提到过的写ID的函数,写ID的函数是每个字节每个字节写的:


7 S$ W$ y2 n9 k4 d& ^

微信图片_20230612172209.png


5 o3 h3 z8 I. R, C

按我们希望的结果来说,读出来按照顺序打印,应该是:0xff,0xee,0xdd,0xcc,0xbb,0xaa 。测试实际上是:

  a! {2 D$ G& O+ c

微信图片_20230612172207.png


4 D. I  d7 t3 d9 L6 k8 M

为了确实是读的问题还是写的问题,添加了读字节的函数:

" S8 u4 V* Y$ J  \- B( w

微信图片_20230612172058.png


# ~" b3 H9 q, q# _* K

微信图片_20230612172050.png

0 f) X/ w* \0 F: K6 n$ j9 ]

打印的结果:

, x) K' I% t2 X

微信图片_20230612172039.png

" `0 v/ T8 [: R! h& u

说明确实是ID的读取函数出的问题,是因为使用的半字读取,问题处理不麻烦,我们把读取函数修改一下:

  1. BlueID_STRUCT FLASH_blueIDRead(uint32_t address)3 T  m( @8 X3 Q/ b; p6 r* k4 X
  2. {1 N* D. s9 N" ?: {. e
  3. BlueID_STRUCT u48id;
    ' n% f4 ?( {9 ?0 V# \: D- E( k9 M
  4.   // uint16_t temp1,temp2,temp3;  /**(__IO uint16_t*)address; */
    0 _7 Z: _( C4 U8 ]! j
  5.   // temp1=*(__IO uint16_t*)address;
    - G  I5 x" [1 G3 E( c1 o. s( R+ `' A
  6. // u48id.ID1 = (uint8_t)(temp1>>8);
    # T: v% U# W( R4 y/ T4 h
  7. // u48id.ID2 = (uint8_t)(temp1&0X00FF);
    : l2 U# q6 T+ c# [: }. {
  8.   // temp2=*(__IO uint16_t*)(address+2);
    , |3 D" a5 m& v) @5 G/ ^% s
  9. // u48id.ID3 = (uint8_t)(temp2>>8);
    : [5 \1 f5 T9 U% e& d5 O/ K" X
  10. // u48id.ID4 = (uint8_t)(temp2&0X00FF);
    7 u$ C8 r* v% |4 @# w7 S  \
  11. // temp3=*(__IO uint16_t*)(address+4);* j& A6 e- ?# t8 N
  12. // u48id.ID5 = (uint8_t)(temp3>>8);
    # `+ ~! `% y& ?
  13. // u48id.ID6 = (uint8_t)(temp3&0X00FF); : |5 i& b+ }2 X* S& a. s
  14. / j8 R3 j- ^, a9 }
  15.   u48id.ID1 =  FLASH_Readbyte(address);5 R0 b8 ^, H. p) C
  16.   u48id.ID2 =  FLASH_Readbyte(address+1);- U+ F/ Z0 K7 `6 A- U
  17.   u48id.ID3 =  FLASH_Readbyte(address+2);
    6 l- d+ V  O% j
  18.   u48id.ID4 =  FLASH_Readbyte(address+3);
    " D! J6 _' M9 @& _0 N3 j3 |2 O
  19.   u48id.ID5 =  FLASH_Readbyte(address+4);3 L5 I6 u. K# T4 C- i" V+ k
  20.   u48id.ID6 =  FLASH_Readbyte(address+5);; m( d) X# n* Y$ y# X, o

  21. ! d) y2 p9 s# e  O) J2 h
  22.   return u48id;
    + A$ }) C$ r! m
  23. }
复制代码

8 q$ v  z1 r( I& L0 k( [0 }0 k

测试结果才正常了,如下图:


6 K( C0 S8 h. Q6 ]* G" F

微信图片_20230612172035.png

0 E: ^0 d. T3 k
2.4.2 问题的分析(大小端模式数据格式)

出现上面的问题,其实是和我们经常说的大端模式和小端模式有关的。

STM32使用的是小端模式,简单介绍一下大端模式小端模式数据存放的方式,如下图:


* z( ~% C* N8 k4 H

微信图片_20230612172032.png


- [  D9 n! ^9 `8 ~& i

知道上面的知识,我们在开始的读取函数中是直接读取的半字(__IO uint16_t*)address; ,但是我们写入的时候是一个字节一个字节写入,上面的例子所以我们内存中的数据实际上如下图所示:


: u0 |; E5 d& w  p4 E6 j, R

微信图片_20230612172030.png


2 d+ \& \( F" P4 i

使用(__IO uint16_t*)address; 去读取,读取出来的数值一个uint16_t类型的数值:

假设是 a,a=*(__IO uint16_t*)addr; 会有 a = 0xEEFF; 所以高8位变成了 0xEE。OK!解释清楚!问题解决!

至此,我们基本上把STM32L051 的EEPROM 和Flash 功能都测试过了,把工程中需要用到的功能做了测试,也学到了一些新的知识,还是实践出结论啊,当初没有自己测试之前看了网上的有关类似的介绍,还是很多误解,这下全部清晰了。


# n5 ?% R8 c) v% K# j2.4.3 STM32L071RBT6 EEPROM读写全字问题
5 E6 X; V7 Y& A5 t5 u
读问题的出现

前面其实测试过,读取全字是可以的,直接使用return *(__IO uint32_t*)address;:便可以读到该地址的全字:

  1. uint32_t  FLASH_ReadWord(uint32_t address)
    ! y, I- A- G1 A7 a
  2. {
    7 o/ d9 M. t$ H5 |0 m$ F1 u4 Q
  3.   return *(__IO uint32_t*)address;2 i( R/ H$ S3 Q4 E2 M9 G
  4. }
复制代码

! x6 x9 p4 H& Y! `

所以在后面使用过程中,有这么一个函数:


! \/ C$ ^; l  M3 l4 G4 h

微信图片_20230612172026.png


( }( W3 D* T! p7 z; @

一开始还真的不知道哪里出了问题?折腾了好一阵才发现调用函数读取ID时就会卡死。

0 k. p6 i2 e1 w" H* {

问题的解决:

因为还有另外一个蓝牙版本的产品,如果是蓝牙设备的ID,因为蓝牙设备的ID是6位的,所以当时读取蓝牙的ID的时候使用的是(蓝牙版本是没问题的):


8 \. ?1 X) i: i* w

微信图片_20230612172019.png

/ T+ D  X& s( b1 c9 H& Y

其实折腾了好一会儿,后来想着蓝牙是读一个字节,要不要试着把 全字 分为 4个字节,单独读取试一试?

于是学蓝牙把程序分为4个字节读取:

1 \% u+ ~3 S; S# s5 v% @+ w

微信图片_20230612172012.png

/ e; [4 F# ^! R0 o4 l

代码也放一下,方便复制:

  1. u32 FLASH_ReadEnoceanID(uint32_t address)7 Y$ B- t) v7 E3 G2 q& r7 g
  2. {
    $ T1 p# l+ \+ k3 O/ i5 A
  3.   u32 keepid;( W# J1 F9 ^) x* o) `% s( L
  4.   u8 i;% V9 ^& g$ V5 t
  5.   keepid = FLASH_Readbyte(address);
    9 q4 {' E8 X$ C+ [3 C
  6.   i = FLASH_Readbyte(address + 1);0 I& O* @$ a/ {3 [' [; U2 D4 x
  7.   keepid = (i<<8)|keepid;( d0 t% ~/ L: C0 P
  8.   i = FLASH_Readbyte(address + 2);
    2 r/ p; r, ~$ i6 Q; [2 x! Q
  9.   keepid = (i<<16)|keepid;+ v1 ], K  H. q# p6 k5 b7 S
  10.   i = FLASH_Readbyte(address + 3);
    $ w  q3 D5 B+ D2 k# s/ h
  11.   keepid = (i<<24)|keepid;
    0 e8 Y3 i4 {* s/ S. U
  12.   return keepid;5 U& ?8 ]( T% m/ o4 x7 P
  13. }: |5 m5 P7 Y: z) r9 q& L* l$ b& t

  14. + H+ H; `5 T: z6 p: b" N- E
  15. CHID_STRUCT Flash_PowerOn_Check()$ U. j' h# [+ v
  16. {  [) W3 S3 a$ x* L! p3 ]

  17. 0 _% [7 h+ D: r" ~& C
  18. CHID_STRUCT PowerOn_ID;- |4 Q- K2 _/ y2 f8 |0 s
  19. PowerOn_ID.CH1ID = FLASH_ReadEnoceanID(CH1_ID_ADDR);, D4 s0 G# x8 q2 i( k( F3 f! O# K
  20. PowerOn_ID.CH2ID = FLASH_ReadEnoceanID(CH2_ID_ADDR);6 |9 q8 V# ~  |" l
  21. PowerOn_ID.CH3ID = FLASH_ReadEnoceanID(CH3_ID_ADDR);
    / F  I+ e( @% R
  22. PowerOn_ID.CH4ID = FLASH_ReadEnoceanID(CH4_ID_ADDR);
    & f' b  U/ ]3 d+ w! i
  23. PowerOn_ID.CH5ID = FLASH_ReadEnoceanID(CH5_ID_ADDR);
    ( p; R; {, H( _- w# Y6 M5 o
  24. PowerOn_ID.CH6ID = FLASH_ReadEnoceanID(CH6_ID_ADDR);: i. X' V% f* l' x& F
  25. PowerOn_ID.CH7ID = FLASH_ReadEnoceanID(CH7_ID_ADDR);; ~/ [- r( ]0 G, B7 r" J
  26. PowerOn_ID.CH8ID = FLASH_ReadEnoceanID(CH8_ID_ADDR);) V7 J$ }, f0 A# ?3 D
  27. PowerOn_ID.CH9ID = FLASH_ReadEnoceanID(CH9_ID_ADDR);7 K- B# f4 k: I; ^0 K
  28. PowerOn_ID.CH10ID = FLASH_ReadEnoceanID(CH10_ID_ADDR);
    . Y( K5 c6 O4 _+ U9 Z1 k0 C; D
  29. & a8 m( l; ?; r
  30. return PowerOn_ID;" s, p. R) p7 ^# l
  31. }
复制代码
, n1 v  ~" F" |1 ]# x6 k9 K( n

测试一下,发现就好了,至于原因,目前还不知道为什么……(最后问题解决有说明,内存字节对齐问题)


% B% Q& W6 Q8 k. t; V& A- O. t写问题的出现

本来以为解决了上面问题OK了,可是后面测试的时候发现写的时候也有问题:

一直用的写全字函数为:

  1. FLASH_Status  FLASH_WriteWord(uint32_t Address, uint32_t Data)
    : C4 K1 p4 w) A. V5 G/ P. I
  2. {
    9 N. C3 _1 F7 _$ |) \
  3. $ N2 ?  F0 i8 {
  4. FLASH_Status i = FLASH_COMPLETE;3 z& R! C: U5 \1 j6 D( g& Q6 Y
  5. " q& M! |) Y; ]) Z. Q# |: z
  6. HAL_FLASHEx_DATAEEPROM_Unlock();  9 J# e5 J5 `) ]5 D  v3 p' ?
  7.   while(HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_WORD, Address, Data) != HAL_OK);
    * C; c+ J- X1 i, }7 d  s
  8. HAL_FLASHEx_DATAEEPROM_Lock();% G0 T2 a& f/ n7 ~, a7 f
  9. . Q% G5 V$ ^6 Y* A  Z" J
  10. return i;3 j) p# ~/ r" j& }, ~* ]
  11. }
复制代码

5 ~1 q! h' C3 I

在程序中会调用此函数进行 ID 保存:

! H& p2 H5 n/ A2 J5 Y# x

微信图片_20230612172009.png


  \& ^0 d; X1 h% T, r

但是使用时候发现:

& B2 M# b, O1 ^

微信图片_20230612172006.png


. N3 f4 R) G, b% j% \0 m: |# u6 C

问题的解决:

其实这个问题也莫名其妙,真是说不出来为什么,估计是得详细的查看数据手册,但是还是 因为 在蓝牙的版本上面没有此类问题:

  t1 ~7 Y. b: t3 m: F

微信图片_20230612172003.png

7 Z- J. o. ]1 o( [9 d) I

所以这里还是尝试改成 以 字节 方式写入:

  1. FLASH_Status  FLASH_WriteWord(uint32_t Address, uint32_t Data)
    ! q6 X8 W2 `+ j/ ?$ @3 g
  2. {) w+ q. s: L3 a( R* g* @0 ?

  3. ' C& ^6 h: J1 B+ n% H. d& w
  4.   FLASH_Status state = FLASH_COMPLETE;, x! r$ V4 x# T) p- M: J
  5.   u8 i = 0;
    8 x$ |! X$ F. }$ s( v- M, g
  6.   u8 writedata[6]={0};
      i3 v  V% ~2 M: E# m. A% |
  7. : X7 `: f+ T. t
  8.   writedata[0] = (u8)Data;
    1 m/ g, l: h( V
  9.   writedata[1] = (u8)(Data>>8);2 |6 k7 e( C6 W4 y0 @
  10.   writedata[2] = (u8)(Data>>16);4 V% Y' r% {7 K( M4 M1 W
  11.   writedata[3] = (u8)(Data>>24);
    ; p+ \7 L  P/ U9 Y
  12. 3 _" c, D* U. P4 A6 {) q. x
  13. HAL_FLASHEx_DATAEEPROM_Unlock();  , K/ Q3 i+ A0 Y5 f: Z, e
  14.   for(i=0; i<4; i++){: K  Y' M) }) v5 k7 y" F& P
  15.     while(HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, Address + i, writedata[i]) != HAL_OK);( x6 k4 U# Q3 u5 o& t
  16.   }& e, T! [1 s/ y# m3 }  i# b
  17. HAL_FLASHEx_DATAEEPROM_Lock();
    % K# G/ q6 o( h: d$ z

  18. / E: ?9 n8 X0 J% t% h- p
  19. return state;1 ^* s6 [3 y6 O1 x. K* f
  20. }
复制代码

使用此种方式写入,就不会出现问题!

其实也可以尝试修改地址,使得成为 4 的倍数,可能也不会出问题,这里就不测试了(最后问题解决有还是测试了,内存字节对齐问题)

2.4.3小结使用的芯片为  STM32L071RBT6

1 z1 O  B8 Q# x( {4 k
最后问题的解决

先直接说结论,就是EEPROM地址定义的问题,应该是4字节对齐(4的整数倍),读取全字的操作才能正常!

上面 STM32L071RBT6 EEPROM 读写全字问题的关键在于,存储地址的定义上,如上面一张图所示:(我在EEPROM区域定义了10个地址,用来存放无线设备的ID数据,如果是蓝牙芯片,那么ID为6个字节,如果是Enocean芯片,那么ID为4个字节,为了保持代码的统一,我在使用保存4个字节的ID数据的地址定义时候沿用的是蓝牙的 EEPROM区域定义)

! k9 h7 [$ z2 s3 B2 p5 ^

微信图片_20230612172000.png

, K( W- X" J4 d- x% \3 y- Y

那么正如我图中猜想的一样,蓝牙的 ID 6个字节,我是都是通过一个字节一个字节操作,组合起来进行的,所以一切正常。但是对于 4个字节的 ID ,期初是用的 全字的方式,就出问题了,换成一个字节一个字节的操作,看上去是解决问题了。

但是实际上多了一些隐藏问题,暂时也说不清楚,在产品使用的时候,读写ID还是会有莫名其妙的问题,最终还是对当初的这个猜想,地址是不是也需要4字节对齐?进行了修改测试,于是乎,对于 4 个字节 ID的处理,地址改成:


$ h  H- T4 G  `; |9 k3 B. d6 j4 P1 R

微信图片_20230612171954.png


9 }* W, x% U0 X2 j4 W" K

把地址修改成 4  的倍数以后,上面的读取全字的两个函数便可以正常使用,而不会出上面莫名其妙的问题。


- K+ b+ O: t' t- u+ L  [7 g! g9 ~
赞 收藏 评论0 发布时间:2023-6-12 17:30

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版