1、什么是Flash
FLASH闪存是属于内存器件的一种，其存储特性相当于硬盘，下图就能看出Flash扇区就等于电脑硬盘分区，但是对Flash进行写数据时必须先进行扇区擦除，然后才能再写入，否则会写入失败，MCU的Flash大小可参考数据手册


" u/ L2 O% u& C& R% q0 C" y
* G( N( l. L) h& A, B* G4 Z  G9 ]" c2、闪存模块存储器组织
此为STM32F407ZGT6的FLASH大小为1024K

5 B8 R% ^7 b4 Z5 |& a4 J/ w) E

不同容量的STM32F4，拥有的扇区数不一样，比如我们的STM32F407ZGT6，则拥有全部12个扇区。从上图可以看出主存储器的起始地址就是0X08000000， B0、B1都接GND的时候，就是从0X08000000开始运行代码的。
9 R# e. c: {$ b4 e0 v
% S. k. Y6 u# D2 j. SSTM32F40x的闪存模块由：主存储器、系统存储器、OPT区域和选项字节等4部分组成：

5 [/ q3 M  d4 F  k. ]& |2.1、主存储器
" J1 ~* b& P* }! f该部分用来存放代码和数据常数（如const类型的数据）。分为12个扇区，前4个扇区为16KB大小，然后扇区4是64KB大小，扇区5~11是128K大小。
6 a# V: j8 C9 u4 l% y# d
# |) B) i4 f" d. v8 I% H2.2、系统存储器
: m4 O2 |, U- ~  U" X. K0 }主要用来存放STM32F4的bootloader代码，此代码是出厂的时候就固化在STM32F4里面了，专门来给主存储器下载代码的。当B0接V3.3，B1接GND的时候，从该存储器启动（即进入串口下载模式）。

2.3、OTP区域
  y; z  H( T3 H& r. w  ^  B4 G即一次性可编程区域，共528字节，被分成两个部分，前面512字节（32字节为1块，分成16块），可以用来存储一些用户数据（一次性的，写完一次，永远不可以擦除！！），后面16字节，用于锁定对应块。
0 q9 b, w( l' D
2.4、选项字节
- V8 W, B* F9 h+ E. ?/ R用于配置读保护、BOR级别、软件/硬件看门狗以及器件处于待机或停止模式下的复位。
4 @  [% a6 T1 L) M" [9 z9 z" U
3、STM32F4的闪存6个32位寄存器控制
6 j$ a% ^# w( U, Z, O①访问控制寄存器(FLASH_ACR)

& L, V! r( }8 }# a6 t8 k& S4 ~②密钥寄存器(FLASH_KEYR)
# X) t$ O/ M9 j- k0 x: Z
         其中FPEC 密钥总共有2个键值：

! A4 h, g. S" j
6 T: c) y7 I" V
1 ]! Z; j" [* {③选项秘钥寄存器(FLASH_OPTKEYR)

6 D8 U. V# Q9 R+ \$ @( H) `. f; Y& n④状态寄存器(FLASH_SR)
. L" _" ^) Q  Z( U  l
⑤控制寄存器(FLASH_CR)
( Z9 h' H" p/ a, Q  O
⑥选项控制寄存器(FLASH_OPTCR)
/ `6 S* C* E5 q0 k$ Q
: a. e3 O' ~9 M) v5 [! X; N: b, s相关寄存器的操作可参考《STM32F4xx中文参考手册》的第3.8小节
. T9 Y3 w( }2 O& Q9 t  B& \& l
4、Flash等待周期与CPU时钟频率间的关系
" ]1 U/ q( }* z. b为了准确读取 Flash 数据，必须根据 CPU 时钟 (HCLK) 频率和器件电源电压在 Flash 存取控制寄存器 (FLASH_ACR) 中正确地设置等待周期数 (LATENCY)。当电源电压低于2.1V 时，必须关闭预取缓冲器。

, T6 p' ^1 q" E4 b0 X

/ }) a. z6 z; z7 `$ t  {, @我们供电电压一般是3.3V，所以，在我们设置168Mhz频率作为CPU时钟之前，必须先设置LATENCY为5，否则FLASH读写可能出错，导致死机。
! P$ q4 t8 H. M: Z$ C$ ^, p
0 }. _' U2 q. O4 T! P5、FLASH的操作介绍
5.1、读
' }+ q8 z6 v( F. bSTM23F4的FLASH读取是很简单的。例如，我们要从地址addr，读取一个字（字节为8位，半字为16位，字为32位），可以通过如下的语句读取：

                                                                                        data=*(vu32*)addr;
6 s% b) r4 K6 v# ?9 e
7 C2 ]# Y4 a# U4 [将addr强制转换为vu32指针，然后取该指针所指向的地址的值，即得到了addr地址的值。类似的，将上面的vu32改vu16，即可读取指定地址的一个半字。

/ u8 O* ^3 _: ?+ ]# l" A- g  s5.2、写
  P& F4 j. L/ Z在对 STM32F4的Flash执行写入或擦除操作期间，任何读取Flash的尝试都会导致总线阻塞。只有在完成编程操作后，才能正确处理读操作。这意味着，写/擦除操作进行期间不能从Flash中执行代码或数据获取操作。

注意：

( s8 b1 X' z' n编程前，要确保要写如地址的FLASH已经擦除。
" a* A! C/ V' S) Q# h- l要先解锁（否则不能操作FLASH_CR）。
' l: @$ F+ o5 S4 y# ~1 G& | 编程操作对OPT区域也有效，方法一模一样。
5.3、闪存擦除
我们在STM32F4的FLASH编程的时候，先判断首地址是否被擦除了，STM32F4的闪存擦除分为两种：扇区擦除整片擦除。

5.3.1、扇区擦除步骤
$ ~! f! P2 ~9 d4 i& h①检查FLASH_CR的LOCK是否解锁，如果没有则先解锁

' h. j0 i/ Q* a1 i②检查FLASH_SR寄存器中的BSY 位，确保当前未执行任何FLASH操作
2 p/ T8 {' `' P& G. I4 b
( s5 J: ~- y# `: e③将FLASH_CR控制寄存器的SER位置1，并从主存储块的12个扇区中选择要擦除的扇区 (SNB)

④将FLASH_CR寄存器中的STRT位置1，触发擦除操作

7 F2 ?( O) P  v" _" S, ~6 i6 v⑤等待BSY位清零
: s  u0 H- C! u; v* K) {
经过以上五步，就可以擦除某个扇区。

5.3.2、批量/整片擦除步骤
/ u# t7 M( p5 J3 J! L& _% K2 S①检查FLASH_SR寄存器中的BSY 位，确保当前未执行任何FLASH操作

: W4 b  v, U/ }. R4 ?②在FLASH_CR寄存器中，将MER位置1 (STM32F407xx/405xx/43xxx)
7 f( X8 y! u* j5 ~: d2 J* f, c) `
③将FLASH_CR寄存器中的STRT位置1，触发擦除操作

④等待BSY位清零
0 k$ Z, C% d! Y! a  N
经过以上四步，就可以批量擦除扇区。扇区擦除功能可以看《STM32F4xx中文参考手册》第3.5小节。

6、STM32F4的标准编程步骤
( R, ^0 F/ y- y9 H( \/ Y①检查FLASH_SR中的BSY位，确保当前未执行任何FLASH操作。

" U+ b& [; S8 H9 C1 o②将FLASH_CR寄存器中的PG位置1，激活FLASH编程。
5 z% _* @0 n: }4 k2 m
) G  @, M6 k/ {# G9 @+ z6 R③针对所需存储器地址（主存储器块或OTP区域内）执行数据写入操作：

        —并行位数为x8时按字节写入（PSIZE=00）
, }* t# O' z1 N9 e
; [7 T1 i; B$ U, \3 C( g        —并行位数为x16时按半字写入（PSIZE=01）
7 |4 {* }: N4 L/ W2 T5 g: j, q9 ]' L
        —并行位数为x32时按字写入（PSIZE=02）
3 o, o1 u4 t! J/ {" [( u
$ U0 j; A- z- b9 `; l         —并行位数为x64时按双字写入（PSIZE=03）
$ ?& ^4 G2 D1 ]* c( J4 \
④等待BSY位清零，完成一次编程。
+ i; q5 D& L% @& I4 f' N6 L
按以上四步操作，就可以完成一次FLASH编程。不过有几点要注意：
7 d( \) O1 t  @3 h9 ~
1、编程前，要确保要写如地址的FLASH已经擦除

2、要先解锁（否则不能操作FLASH_CR）
' {. E9 ~  V& Y# T8 Z' v
0 T+ \( y# z8 u: s. f8 G  c( Y3、编程操作对OPT区域也有效，方法一模一样

4、Flash写数据时会把整个扇区擦除掉，所以原来的数据得不到保存，如果想要保存数据，需要分配一个扇区大小的内存去存储原来的数据，占用内存太大，不像SPI的W25Qxx那么方便
' t% t4 B" G. G' S0 S; T
8 }& @5 B2 F5 ?2 w* @6 t$ B: d: a7、代码的编写实现
/ m, Q# |4 p( H  y/ Cflash.c：
6 V# y" g$ t5 k6 j- `

1. #include "stmflash.h"
   ' G$ b7 I, E0 i: e
2. #include "delay.h"
   ! r6 {1 P- f8 p* B9 w& M& x
3. 
   
4. 
   8 s& z2 X3 M6 `. `9 ^+ j% Z/ D
5. //读取指定地址的半字(16位数据)
   
6. //faddr:读地址
   : p5 g# l# J: b/ l1 z0 m+ z* J& }: m
7. //返回值:对应数据.
   
8. u32 STMFLASH_ReadWord(u32 faddr)
   $ B. n+ X4 J" r1 S' s- r  X& a
9. {
   
10.         return *(vu32*)faddr;
    ; t/ q0 w5 V% o  A  w' n  Q* a7 N
11. }
    % A, r$ S! S4 z/ |: s1 d: F9 w
12. 
    " Z, |# ]  [  f; w  }+ H+ ^
13. //获取某个地址所在的flash扇区
    7 V5 p: X) ~" d
14. //addr:flash地址
    
15. //返回值:0~11,即addr所在的扇区
    # {# N6 l( Y- t+ F( ]: N
16. uint16_t STMFLASH_GetFlashSector(u32 addr)
    # h- a0 h6 z) b
17. {
    ) \9 @" O8 {/ `1 |. Y1 z$ l
18.         if(addr<ADDR_FLASH_SECTOR_1)return FLASH_Sector_0;
    
19.         else if(addr<ADDR_FLASH_SECTOR_2)return FLASH_Sector_1;
    . s1 q- j& P" T" |
20.         else if(addr<ADDR_FLASH_SECTOR_3)return FLASH_Sector_2;
    
21.         else if(addr<ADDR_FLASH_SECTOR_4)return FLASH_Sector_3;
    % m+ L% l( `3 o1 s* \6 _0 e
22.         else if(addr<ADDR_FLASH_SECTOR_5)return FLASH_Sector_4;
    
23.         else if(addr<ADDR_FLASH_SECTOR_6)return FLASH_Sector_5;
    
24.         else if(addr<ADDR_FLASH_SECTOR_7)return FLASH_Sector_6;
    * M$ x3 P9 l+ O: K
25.         else if(addr<ADDR_FLASH_SECTOR_8)return FLASH_Sector_7;
    
26.         else if(addr<ADDR_FLASH_SECTOR_9)return FLASH_Sector_8;
    8 _+ a) \" @4 D/ ~$ G& B# Q
27.         else if(addr<ADDR_FLASH_SECTOR_10)return FLASH_Sector_9;
    " w- d7 J; x0 i' _
28.         else if(addr<ADDR_FLASH_SECTOR_11)return FLASH_Sector_10;
    
29.         return FLASH_Sector_11;        
    ) C8 k* T. g1 u# b% D
30. }
    
31. 
    
32. //从指定地址开始写入指定长度的数据
    
33. //特别注意:因为STM32F4的扇区实在太大,没办法本地保存扇区数据,所以本函数
    " v0 e/ E8 d" q6 c' |$ D
34. //         写地址如果非0XFF,那么会先擦除整个扇区且不保存扇区数据.所以
    
35. //         写非0XFF的地址,将导致整个扇区数据丢失.建议写之前确保扇区里
    2 f9 M# l/ B8 {  e* u+ i8 X+ a5 N
36. //         没有重要数据,最好是整个扇区先擦除了,然后慢慢往后写.
    
37. //该函数对OTP区域也有效!可以用来写OTP区!
    
38. //OTP区域地址范围:0X1FFF7800~0X1FFF7A0F
    
39. //WriteAddr:起始地址(此地址必须为4的倍数!!)
    
40. //pBuffer:数据指针
    - F) f8 Q# z% P
41. //NumToWrite:字(32位)数(就是要写入的32位数据的个数.)
    ! \6 G9 C: e" ^& q+ s" _
42. void STMFLASH_Write(u32 WriteAddr,u32 *pBuffer,u32 NumToWrite)        
    
43. {
    ; V& Z, f4 z, P% x
44.   FLASH_Status status = FLASH_COMPLETE;
    
45.         u32 addrx=0;
    
46.         u32 endaddr=0;        
    
47.   if(WriteAddr<STM32_FLASH_BASE||WriteAddr%4)return;        //非法地址
    7 G: B6 ]( F* D- _* [2 Y
48.         FLASH_Unlock();                                                                        //解锁 ①
    
49.   FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存
    2 M" O  J, P+ i" h' s
50.                  
    8 M5 w# U! F' H0 V# k' K
51.         addrx=WriteAddr;                                //写入的起始地址
    9 ~( C* a* |. z, k
52.         endaddr=WriteAddr+NumToWrite*4;        //写入的结束地址
    $ u$ u! o/ e3 O- n
53.         if(addrx<0X1FFF0000)                        //只有主存储区,才需要执行擦除操作!!
    . Z6 `# s1 w, @' C; t& P4 p/ E; J) p1 b
54.         {
      l% U) r7 ?! i
55.                 while(addrx<endaddr)                //扫清一切障碍.(对非FFFFFFFF的地方,先擦除)
    3 X6 D* y. x, b% q' M% ~
56.                 {
    
57.                         if(STMFLASH_ReadWord(addrx)!=0XFFFFFFFF)//有非0XFFFFFFFF的地方,要擦除这个扇区 ③
    ) M5 _3 v5 P/ \, R
58.                         {   
    ! z6 b3 n9 k+ Y! F1 H. G: I$ @  q
59.                                 status=FLASH_EraseSector(STMFLASH_GetFlashSector(addrx),VoltageRange_3);//VCC=2.7~3.6V之间!!
    + ]7 P4 a0 {0 V5 J/ v
60.                                 if(status!=FLASH_COMPLETE)break;        //发生错误了
    0 w) x' i% c3 ]6 U( ?
61.                         }else addrx+=4;
    
62.                 }
    4 e5 K* q8 f$ k/ G
63.         }
    
64.         if(status==FLASH_COMPLETE)
    + _, N' p' p3 \( ~8 F: H1 ^
65.         {
    7 J2 F: p- c! s# g+ Q$ c$ B+ M
66.                 while(WriteAddr<endaddr)//写数据
    9 L% H  y# y6 \4 R( m
67.                 {
    # B: e: B- C) K9 J8 S2 R' f/ Q
68.                         if(FLASH_ProgramWord(WriteAddr,*pBuffer)!=FLASH_COMPLETE)//写入数据④
    1 f. u! z* w2 ~5 n
69.                         {
    
70.                                 break;        //写入异常
    + k4 A+ U/ R2 Z6 ?! j( W
71.                         }
    6 F  s' V8 e, \5 d% B1 g2 p
72.                         WriteAddr+=4;
    ! l" u) z( U% U
73.                         pBuffer++;
    % {3 V3 A( q. K0 a: ?
74.                 }
    ; m) q, i# U* i
75.         }
    
76.   FLASH_DataCacheCmd(ENABLE);        //FLASH擦除结束,开启数据缓存
    ; Q( l$ m# e; s5 |" A; Y. R6 m9 W
77.         FLASH_Lock();//上锁 ⑤
    
78. }
    
79. 
    % v2 B: a$ s3 J
80. //从指定地址开始读出指定长度的数据
    
81. //ReadAddr:起始地址
    
82. //pBuffer:数据指针
    
83. //NumToRead:字(4位)数
    $ c* r% C" y4 W, @* m
84. void STMFLASH_Read(u32 ReadAddr,u32 *pBuffer,u32 NumToRead)           
    2 c# [# k' p2 ?3 R4 F
85. {
    
86.         u32 i;
    6 `4 F: _8 l0 h) K$ F
87.         for(i=0;i<NumToRead;i++)
    
88.         {
    
89.                 pBuffer<i>=STMFLASH_ReadWord(ReadAddr);//读取4个字节.
    
90.                 ReadAddr+=4;//偏移4个字节.        
    # f: v' ?$ M4 c2 w
91.         }
    # k' `: R6 p) Z& b2 W
92. }</i>

复制代码

flash.h
% V! p9 S: g" {( ?* E2 N
+ z* [5 i6 `, e2 j

1. <i>#ifndef __STMFLASH_H__</i>
   
2. <i>#define __STMFLASH_H__</i>
   3 p$ }# ?3 A) [" c( o: s  }9 j
3. <i>#include "sys.h"   </i>
   
4. 
   9 h4 S: k& H! i- @3 z
5. <i>//FLASH起始地址</i>
   # f- F: E- c! O, v7 W& p6 ~
6. <i>#define STM32_FLASH_BASE 0x08000000         //STM32 FLASH的起始地址</i>
   7 v$ |3 v# v3 G6 t
7. 
   1 t$ ~& R- R" x' u
8. <i>//FLASH 扇区的起始地址</i>
   
9. <i>#define ADDR_FLASH_SECTOR_0     ((u32)0x08000000)         //扇区0起始地址, 16 Kbytes  </i>
   
10. <i>#define ADDR_FLASH_SECTOR_1     ((u32)0x08004000)         //扇区1起始地址, 16 Kbytes  </i>
    $ h/ ]: Y, ~! W' T4 Y
11. <i>#define ADDR_FLASH_SECTOR_2     ((u32)0x08008000)         //扇区2起始地址, 16 Kbytes  </i>
    
12. <i>#define ADDR_FLASH_SECTOR_3     ((u32)0x0800C000)         //扇区3起始地址, 16 Kbytes  </i>
    
13. <i>#define ADDR_FLASH_SECTOR_4     ((u32)0x08010000)         //扇区4起始地址, 64 Kbytes  </i>
    
14. <i>#define ADDR_FLASH_SECTOR_5     ((u32)0x08020000)         //扇区5起始地址, 128 Kbytes  </i>
    
15. <i>#define ADDR_FLASH_SECTOR_6     ((u32)0x08040000)         //扇区6起始地址, 128 Kbytes  </i>
    
16. <i>#define ADDR_FLASH_SECTOR_7     ((u32)0x08060000)         //扇区7起始地址, 128 Kbytes  </i>
    
17. <i>#define ADDR_FLASH_SECTOR_8     ((u32)0x08080000)         //扇区8起始地址, 128 Kbytes  </i>
    
18. <i>#define ADDR_FLASH_SECTOR_9     ((u32)0x080A0000)         //扇区9起始地址, 128 Kbytes  </i>
    + k* T8 n# Z: h5 V( Y0 ^# `9 \
19. <i>#define ADDR_FLASH_SECTOR_10    ((u32)0x080C0000)         //扇区10起始地址,128 Kbytes  </i>
    1 a* t1 Q& e" ^8 }$ i
20. <i>#define ADDR_FLASH_SECTOR_11    ((u32)0x080E0000)         //扇区11起始地址,128 Kbytes  </i>
    
21. 
    
22. <i>u32 STMFLASH_ReadWord(u32 faddr);                          //读出字  </i>
    
23. <i>void STMFLASH_Write(u32 WriteAddr,u32 *pBuffer,u32 NumToWrite);                //从指定地址开始写入指定长度的数据</i>
    
24. <i>void STMFLASH_Read(u32 ReadAddr,u32 *pBuffer,u32 NumToRead);                   //从指定地址开始读出指定长度的数据</i>
    
25. <i>                                                   </i>
    : A' v8 M: \+ t3 H: r5 e- ^
26. <i>#endif</i>
    
27. 
    ; I# m; P* P2 w, ?$ r+ g9 O
28. 
    , l( o/ K" v1 [0 `

复制代码

5 Q0 @& E7 A. b7 p; m