最开始用stm32的flash保存数据的方法都是用原子的例程，STM32F1的话，原子的方法大概是创建一个1K或者2K的缓存，修改数据的时候，先把该扇区的所有数据写到该缓存，然后查看是否需要擦除整个扇区，一般在一个地方写的话，必须要擦除，要想不擦除，就需要一个变量记录下一次要写的地址，和数据一块保存。STM32F4的话，因为其最小扇区为16K，最大128K，写个稍大点的程序，就得用大扇区，原子的做法干脆不缓存了，直接擦了扇区，重写！（吐个槽，原子的一些程序可以再优化一下，感觉有些源码就是应付事儿，可以向更实用的更有效的方向发展发展嘛！！）回归正题，有一天，有一个项目用的屏幕不是静态显示的，需要不停的扫，每次保存数据的时候屏都会闪一次，原来是保存数据的时候，要擦除扇区，1K的扇区大概要15ms的时间才能擦除完成，而且这段时间单片机什么都不能干。为了解决这个问题，发现了网上有stm32flash模拟EEPROM的程序，学习后发现，比原子的例程更实用，更有效，既提高了存取速度，又能平均磨损flash，延长flash改写寿命。大家可百度stm32flash模拟EEPROM，还有人优化了官方给的demo。优化过后，加入了CurWrAddress，意在提高读写速度，但是正是这个CurWrAddress，引起了一些bug。

1. 1 /* Global variable used to store variable value in read sequence */
   5 V1 K  D7 a! \; K
2. 2 uint16_t DataVar = 0;
   8 D7 w; x; G7 B8 |; t3 G8 c0 F
3. 3 uint32_t CurWrAddress;
   7 U. X, ^! o9 Z2 o8 r
4. 4 /* Virtual address defined by the user: 0xFFFF value is prohibited */
   
5. 5 extern uint16_t VirtAddVarTab[NumbOfVar];

复制代码

第3行 把CurWrAddress初始化为0，就是一个bug。修改后的代码， 把InitCurrWrAddress()函数放在了__EE_Init()之后，也就是说只要__EE_Init()函数用到了CurWrAddress，那么CurWrAddress = 0，有某种情况下，这是个灾难。

1. uint16_t EE_Init(void)
   
2. {
   7 r: \* k; s8 n$ B6 G+ u
3. uint16_t FlashStatus;
   
4.    
   $ ~$ l5 U5 h5 s+ W
5.    FlashStatus=__EE_Init();
   
6.    
   " e5 ?( M7 y5 U$ E4 n: q
7.    InitCurrWrAddress();
   
8.    
   ( s% ?9 K+ X, u+ s5 F( b9 a6 m
9.    return(FlashStatus);
   
10. }

复制代码

9 c& M& T$ `: o3 H- H# P- V

接下来，看__EE_Init()函数

1. 1   uint16_t __EE_Init(void)
   ( B1 @$ R- p$ g: K5 p$ s1 F
2.   2    {　　　　　　... 13   
   
3. 14    /* Check for invalid header states and repair if necessary */
   
4. 15     switch (PageStatus0)
   7 j5 P4 E1 V7 j( D6 E7 E& }4 t; y
5. 16     {
   
6. 17       case ERASED:             ...
   . N: Z. \" q/ p
7. 33       case RECEIVE_DATA:
   
8. 34         if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */
   * [5 f& R  t% B
9. 35         {
   9 F. o) q2 Y  X- I* b1 Z8 M+ A- s
10. 　　　　　　　　　　... 43             if (VarIdx != x)
    - V5 B+ e* y+ O9 N6 h
11. 44             {
    
12. 45               /* Read the last variables' updates */
    0 I) i- g6 h2 t8 O, ~9 h( [' N: u
13. 46               ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
    2 [7 ~: ?0 a& d! k! o# e
14.                     .... 57               } 59           }
    
15.              ...   
    + J' Y9 t' M$ I6 l" s3 ?) s, [
16. 85       case VALID_PAGE:
    
17. 95         {103            if (VarIdx != x)
    + N! s' }& E5 @7 b4 j; ]4 o
18. 104            {
    
19. 105              /* Read the last variables' updates */
    
20. 106              ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
    # c  L% `6 t* P( e/ j) n8 W
21. 　　　　　　　　　　...118            }
    
22. 119          }
    3 I# p2 \1 I+ \4 h) L$ z* u% \
23. 120         ....140    }
    * W) [- f0 S2 ~- O" z
24. 141  
    0 {( L. t: Y" h+ J
25. 142    return FLASH_COMPLETE;
    
26. 143  }

复制代码

* z* L9 I  Z0 v# o

我保留的出灾难的两种情况，第一PAGE0=VALID_PAGE,PAGE0 = RECEIVE_DATA,另一种反过来，其实就是在换页的时候，没有完成就掉电了，上电后初始化时,就会有bug了。为什么会有bug？因为这两种情况都用到了EE_ReadVariable函数，而优化后的EE_ReadVariable函数在读取保存变量的时候，是从CurWrAddress-2开始往后读，直到这一页的开始，问题来了，一开始CurWrAddress=0啊，uint32_t类型的0，减去2后等于多少？关键是还要用这个数，作为地址去读flash。。。所以一旦出现这种情况，GG。解决办法就是在碰到这两种情况的时候在读取变量之前，先调用InitCurrWrAddress()，并声明CurWrAddress的时候初始化为第二页的结尾（最起码不会GG了），调用InitCurrWrAddress()之后，会把CurrWrAddress更改为有效页或者RECEIVE页（如果状态为RECEIVE_DATA），然后再去读取数据，进行换页。这种办法并不能解决全部已知bug。

到这里还没完，还有一个bug，就是PAGE1要满了，换到PAGE0的时候。

1. 1 static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
   : j/ f% d3 w2 z5 l( r, X; @
2. 2 {
   
3. 　　　　　　　　...
   
4. 8   /* Get active Page for read operation */
   
5. 9   ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
   % u. z5 h1 n6 h( z& n4 q- C& o
6. 10
   
7. 11      ...19   if (ValidPage == PAGE1)  /* Page0 valid */
   1 W" c* }$ [' Q$ S
8. 20   {
   
9. 21     /* New page address where variable will be moved to */
   1 E! C3 l. y) r+ e- ]4 V
10. 22     NewPageAddress = PAGE0_BASE_ADDRESS;
    2 w( r* n& h# h! D! B- B
11. 23
    " _: U+ m3 a3 ~. U% k0 r) l$ |3 F: ?
12. 24     /* Old page address where variable will be taken from */
    6 G( {( g& i9 s+ T4 v
13. 25     OldPageAddress = PAGE1_BASE_ADDRESS;
    - s& Z! y+ K; k
14. 26   }
    
15. 　　　　...
    # H7 q  l& z# I5 X$ S8 ^
16. 32   /* Set the new Page status to RECEIVE_DATA status */
    7 Y9 v. p% i, k0 f
17. 33   FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, RECEIVE_DATA);
    
18. 　　　　...
    
19. 40   InitCurrWrAddress();//aft 重新初始化写地址
    * M% b1 i& }- _- G, h5 m: z
20. 41   /* Write the variable passed as parameter in the new active page */
    
21. 42   EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
    $ h- q: I8 Y; }3 B
22. 　　　　....
    
23. 49   /* Transfer process: transfer variables from old to the new active page */
    
24. 50   for (VarIdx = 0; VarIdx < NumbOfVar; VarIdx++)
    
25. 51   {
    ( @5 H0 z8 T) x5 u5 d: B
26. 52     if (VirtAddVarTab[VarIdx] != VirtAddress)  /* Check each variable except the one passed as parameter */
    + ^1 T) |8 ~6 V% v: \
27. 53     {
    
28. 54       /* Read the other last variable updates */
    ( u  ?8 }+ N/ P( H9 A
29. 55       ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
    
30. 　　　　　　...67     }
    ) X7 p$ {( s. q
31. 68   }
    
32. 69
    ! i3 R0 `* M8 J; v. l. v+ U
33. 70   /* Erase the old Page: Set old Page status to ERASED status */
    
34. 71   FlashStatus = FLASH_ErasePage(OldPageAddress);
    
35. 72   /* If erase operation was failed, a Flash error code is returned */
    
36. 73   if (FlashStatus != FLASH_COMPLETE)
    + y0 J- l" M7 B  o
37. 74   {
    + w$ H3 S6 `* w  r6 f2 P5 f
38. 75     return FlashStatus;
    
39. 76   }
    
40. 77
    
41. 78   /* Set new Page status to VALID_PAGE status */
    " d4 t  d( `7 [9 `! c) j
42. 79   FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, VALID_PAGE);
    1 r# c3 c* |0 Z; u/ }# E
43. 80   /* If program operation was failed, a Flash error code is returned */
    9 J: m6 j( U3 R9 J; e" D" m
44. 81   if (FlashStatus != FLASH_COMPLETE)
    
45. 82   {
    
46. 83     return FlashStatus;
    & e8 D+ f* O6 K% |, x' A, F. ^
47. 84   }
    
48. 85
    " _4 o, x) h5 l4 |; C: b
49. 86   /* Return last operation flash status */
    7 e9 }! H' R$ u( C
50. 87   return FlashStatus;
    
51. 88 }

复制代码

% `) I1 w; t* F# q. T

33行执行完后，要更改CurrAddress了，这时如果是PAGE0要接收，那么CurrAddress = PAGE0_StarAdress+4了，那么在后边的读取数据，用于转换的时候，有个判断

Address=CurWrAddress-2;

while (Address > (PageStartAddress + 2)) 这个地方PageStartAddress = Page1_StarAddress ，而PAGE0_StarAdress+2肯定小于Page1_StarAddress啊，直接跳过了，导致不能转存其他数据

1. EE_ReadVariable函数    /* Get active Page for read operation */    ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);//而READ的规则是谁有效 就是谁 不关系是否RECIVE 和写有效区分　　PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
   ; t6 M; o; l5 f8 T3 c+ \
2. 
   # M/ T. b0 C: J
3.   /* Get the valid Page end Address */
   
4.   //Address = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
   # F+ L1 w1 I. `" Y( _/ v$ L
5.   Address=CurWrAddress-2;
   8 o- J3 m. V5 q3 ?
6. 
   
7.   /* Check each active page address starting from end */
   
8.   while (Address > (PageStartAddress + 2))
   ) U  u) Q+ i* b% l# s
9.   {
   ( J( D% j3 r  j( Q" c
10.     /* Get the current location content to be compared with virtual address */
    
11.     AddressValue = (*(__IO uint16_t*)Address);
    
12. 
    
13.     /* Compare the read address with the virtual address */
    
14.     if (AddressValue == VirtAddress)
    
15.     {
    1 ?, Y2 G/ b$ V4 t/ t- ~
16.       /* Get content of Address-2 which is variable value */
    ! l1 j# R; E/ Q
17.       *Data = (*(__IO uint16_t*)(Address - 2));
    # B. X  a9 W7 q1 w
18. 
    
19.       /* In case variable value is read, reset ReadStatus flag */
    
20.       ReadStatus = 0;
    
21. 
    # I& `# W5 U  L: ^6 z; e
22.       break;
    3 g% a% r* u. ~3 u
23.     }
    
24.     else
    
25.     {
    0 G4 U8 d4 Z( U; ?$ w" Q
26.       /* Next address location */
    / ^& w0 h; y+ D* [! F0 M
27.       Address = Address - 4;
    
28.     }
    # b% r+ D, G3 B6 V, p  x; Q. {7 t
29.   }

复制代码

我的做法是，修改 EE_ReadVariable函数，在读取数据的时候，如果PAGE0或者PAGE1有一个状态为正在接受，那么Address就用官方Demo给的语句赋值。这时解决全部这篇所说bug的方法。

1. //之前加上读取PageStatus0和1的语句
   
2. 1     /* Get the valid Page end Address */
   
3. 2     if((PageStatus0 == RECEIVE_DATA)||(PageStatus1 == RECEIVE_DATA))//当在页传输时，地址放在有效页的末尾来搜索所有的存储信息
   ; h' x/ S2 _6 r/ O- c4 f6 c
4. 3     {
   1 T5 [- `: U( _0 I' |
5. 4         Address = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
   
6. 5     }
   2 K7 F6 d( G: I$ ~: m9 _( d
7. 6     else
   
8. 7     {
     d/ n$ y- u6 W& e$ [; l0 l& P( Q
9. 8         Address=CurWrAddress-2;
   9 K) I) W% }" z! d
10. 9     }

复制代码

2 a2 B1 v& j5 ]1 h
; n, d3 F, s* M+ ]) B/ b

目前遇到的bug就这些。

综上所述，都是CurWrAddress闹得，

第一种：因为初始化CurWrAddress为0，在刚上电时候，恰巧碰到有一页状态为RECEIVE_DATA（概率不大），则在执行EE_ReadVariable函数的时候，Address=CurWrAddress-2;导致得到一个非法地址。

第二种：PAGE1满 要转给PAGE0，还是出在EE_ReadVariable函数里，Address=CurWrAddress-2;因为EE_PageTransfer中在转移数据之前，重新调整了CurWrAddress写地址到PAGE0了，而在读取未转移的地址需要从PAGE1底部开始查询，这就导致转移不全。

解决办法就是修改EE_ReadVariable函数，加入读取PAGE0和PAGE1的状态语句，并判断，如果有一个状态为RECEIVE_DATA，则按官方的调整Address。

6 W- g  M; A5 O  F2 l+ U8 [% E

加上stm32的掉电检测保存数据，上电后，检测扇区剩余空间，不够下一次保存的话，提前换页，因为stm32f4擦除一个扇区要1s多，掉电那些时间根本不够，另外掉电后，阈值2.7v的话，测试发现，保守估计可保存1000个字，和外围器件，电容有关。

最后上张stm32flash保存数据的图，0x8040000是扇区6的首地址，用于保存这一页的状态00 00为有效页标志，0x8040004和05保存的是数据，06和07的01 A1保存的是变量虚拟地址，实际上是0XA101，因为STM32是小端模式，低位字节位排放在低地址端，高位字节排放在高位地址端。