一、Flash简介
快闪存储器（flash memory），是一种电子式可清除程序化只读存储器的形式，允许在操作中被多次擦或写的存储器。它是一种非易失性存储器，即断电数据也不会丢失。

" `) e, p: k; E# ~* X5 m, e$ w" C4 U二、STM32F1的Flash
: k( {0 c& t% Z- W5 mSTM32F103ZET6的Flash大小为512KB，属于大容量产品。在中文参考手册中给出了大容量产品的Flash模块组织结构图

3 {8 C( N: f% o+ u' p/ w- u0 A1 N
大容量产品Flsh模块组织结构图
0 ?/ G+ A, `! E: L7 p. H. [# ?• 主存储器 主存储器用来存储我们的代码和定义的一些常量数据。当Boot0和Boot1都接GND时，芯片从主存储器的起始地址0x0800 0000开始运行代码。
3 L5 Y3 R" T$ [' H
9 w1 m& E) ~4 o4 x6 P+ _7 _7 J• 信息块
系统存储器中存储的是启动程序代码。启动程序就是串口下载的代码。当Boot0接VCC，Boot1接GND时，运行的就是系统存储器中的代码。系统存储器中存储的启动代码，是ST公司在芯片出厂时就已经下载好的，用户无法修改。选择字节是用来配置写保护和杜保护功能。
  X# `8 G3 ?9 q: e) B5 S8 l9 K
• 闪存存储器接口寄存器 闪存存储器接口寄存器，是整个闪存的控制机构，里面包含了很多的闪存的控制寄存器和状态寄存器。
3 q) y% }+ X: Y! |" `
在执行闪存写操作时，任何对闪存的读操作都会被锁住。只有对闪存的写操作结束后，读操作才能够正常执行。也就是说，在对闪存进行写操作或者擦除操作时，无法对闪存进行读操作。

2 ~$ s9 m3 N. F! L2 Z5 J4 I6 Q
三、Flash操作步骤
* x  X/ J. n  {3 f& Q' r, k• 解锁和锁定
& q2 K& }9 B* u) D• 写/擦除操作
/ G1 [# |9 ]# b$ [, a' j  y0 `• 获取Flash状态
7 I7 `6 N8 K: X• 等待操作完成
• 读取Flash指定地址数据

, ]' Z% |5 [6 k7 b3 _) F
: P# j% _) v" D7 ^7 Q四、程序设计
7 v! f; ~* n4 m* L# v操作内部Flash时，最小单位是半字（16位）。

. {  Q2 Z' t9 Z- |. Y- \44.1 读取数据
读取数据用的是指针的方式，在之前博主的文章中有关于如何利用指针在指定地址读写数据的操作。 ```c /*
5 R! T9 ]  |  x6 W- l2 k5 I
" ^0 J( H# ^- R* z/ o$ n*============================================================================== *函数名称：Med_Flash_ReadHalfWord *函数功能：读取指定地址的半字(16位数据) *输入参数：faddr：读取地址 *返回值：对应读取地址数据 *备 注：对内部Flash的操作是以半字为单位，所以读写地址必须是2的倍数 *============================================================================== */ vu16 Med_Flash_ReadHalfWord (u32 faddr) { return (vu16)faddr; }

1. 
   2 x" ?* o" r/ ~# S. f# e
2. ```c
   
3. /*
   . L/ S3 ?% q# t" `
4. *==============================================================================
   
5. *函数名称：Med_Flash_Read
   ; B% v6 \$ j5 g: O
6. *函数功能：从指定地址开始读出指定长度的数据
   8 K1 R- m: V+ s( S# `, G: |; C
7. *输入参数：ReadAddr：读取起始地址；pBuffer：数据指针；
   
8.                         NumToRead：读取（半字）数
   
9. *返回值：无
   
10. *备  注：对内部Flash的操作是以半字为单位，所以读写地址必须是2的倍数
    
11. *==============================================================================
    6 d$ h) w" D% C6 H+ I1 G% Z
12. */
    / X9 `: T" i7 t: y% h" I
13. void Med_Flash_Read (u32 ReadAddr,u16 *pBuffer,u16 NumToRead)
    
14. {
    
15.     u16 i;
    
16.     for(i = 0;i < NumToRead;i ++)
    
17.     {
    $ K# l1 K! b# X7 i; z2 n. t
18.         pBuffer[i] = Med_Flash_ReadHalfWord(ReadAddr);   // 读取2个字节.
    ' L! t$ g. }: d: \  V: |  B
19.         ReadAddr += 2;   // 偏移2个字节.
    % b- N+ `$ O" R5 `8 p
20.     }
    ! [, k; x- N$ ~9 S4 H' F
21. }

复制代码

4.2 写入数据（不检查）
8 P+ |0 Z0 P) `* O: N- k; D这里的不检查，是指在写入之前，不检查写入地址是否可写。

1. /*
   ; P! u# Q% {  j, k
2. *==============================================================================
   7 @! ?9 m% \* S( C" ?% W: i% ?% h
3. *函数名称：Med_Flash_Write_NoCheck
   
4. *函数功能：不检查的写入
   7 K+ e( V5 E) c( P6 X& _
5. *输入参数：WriteAddr：写入起始地址；pBuffer：数据指针；
   - B* `' D% h. m4 i3 c6 w: X( B4 n
6.                         NumToWrite：写入（半字）数
   
7. *返回值：无
   
8. *备  注：对内部Flash的操作是以半字为单位，所以读写地址必须是2的倍数
   1 k% @; B' j) [4 o; L
9. *==============================================================================
   
10. */
    & t% n7 k1 d9 ~! i/ f
11. void Med_Flash_Write_NoCheck (u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)
    
12. {      
    
13.     u16 i;
    
14.     for(i = 0;i < NumToWrite;i ++)
    
15.     {
    0 m" S0 B, q! \0 y
16.         FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);
    8 ^9 \8 C4 G0 s/ Y6 O
17.         WriteAddr += 2;   // 地址增加2.
    8 u8 ]" y+ ]! N
18.     }  
    
19. }

复制代码

4.3 写入数据（检查）
0 h# v0 @2 |$ L- G( y+ R

1. /*
   
2. *==============================================================================
   
3. *函数名称：Med_Flash_Read
   
4. *函数功能：从指定地址开始写入指定长度的数据
   
5. *输入参数：WriteAddr：写入起始地址；pBuffer：数据指针；
   
6.                         NumToRead：写入（半字）数
   : g" h$ J9 }$ Z: z$ H
7. *返回值：无
   
8. *备  注：对内部Flash的操作是以半字为单位，所以读写地址必须是2的倍数
   ! b) s& `6 M3 u: n7 U6 {4 s4 j3 {2 N
9. *==============================================================================
   9 W: N% `5 A* s: p) w) T% T: U
10. */
    
11. 
    * p- e; @" s2 @& ]  ]
12. // 根据中文参考手册，大容量产品的每一页是2K字节
    
13. #if STM32_FLASH_SIZE < 256
    , }( D# f! m  L, F0 u
14.     #define STM32_SECTOR_SIZE   1024   // 字节
    
15. #else
    
16.     #define STM32_SECTOR_SIZE   2048
    , [0 F7 m$ ~7 L' R5 c. f
17. #endif
    
18. 
    
19. // 一个扇区的内存
    
20. u16 STM32_FLASH_BUF[STM32_SECTOR_SIZE / 2];
    
21. 
    
22. void Med_Flash_Write (u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)
    1 k4 O$ e) E( H8 r/ d# u, y/ v) t
23. {
    ) y( Y, `; D1 X# I# C  A) D2 f
24.     u32 secpos;   // 扇区地址
    
25.     u16 secoff;   // 扇区内偏移地址(16位字计算)
    + |' {4 m& t. O1 }4 P1 z7 s/ a
26.     u16 secremain;   // 扇区内剩余地址(16位计算)   
    
27.      u16 i;   
    5 g, d. P! p' D. f7 k9 y
28.     u32 offaddr;   // 去掉0X08000000后的地址
    " N; _  M7 |* J4 ]: D% D7 V
29.    
    
30.     // 判断写入地址是否在合法范围内
    4 r/ K2 j: t3 I3 @- ^
31.     if (WriteAddr < STM32_FLASH_BASE || (WriteAddr >= (STM32_FLASH_BASE + 1024 * STM32_FLASH_SIZE)))
    9 `2 R: x/ M3 d/ @
32.     {
    
33.         return;   // 非法地址
    
34.     }
    % r+ Y: r8 e) q- |
35.    
    . ?# S' L0 X- i
36.     FLASH_Unlock();   // 解锁
    : u& W' |) S$ Z- `( g  O$ e* q
37.     offaddr = WriteAddr - STM32_FLASH_BASE;   // 实际偏移地址
    $ D9 ]4 E3 X' _% S
38.     secpos = offaddr / STM32_SECTOR_SIZE;   // 扇区地址
    9 I1 v3 W) w8 [8 ^- ^: ~" M1 O& o
39.     secoff = (offaddr % STM32_SECTOR_SIZE) / 2;   // 在扇区内的偏移(2个字节为基本单位)
    
40.     secremain = STM32_SECTOR_SIZE / 2 - secoff;   // 扇区剩余空间大小
    / O' N. M% ?; f8 S( b
41.    
    
42.     if (NumToWrite <= secremain)
    : d, z/ R6 \0 H) s$ ]2 n- u
43.     {
    . ?4 `( D7 ~% m( _7 Q
44.         secremain = NumToWrite;   // 不大于该扇区范围
    ) @2 c0 M( K7 c4 m0 v' J( K1 y
45.     }
    : X9 a$ g4 A) K  U$ R
46.     while (1)
    
47.     {
    
48.         // 读出整个扇区的内容
    , u4 v4 F) D$ ^2 O% \
49.         Med_Flash_Read(secpos * STM32_SECTOR_SIZE + STM32_FLASH_BASE,STM32_FLASH_BUF,STM32_SECTOR_SIZE / 2);
    
50.         
    8 V! W) U4 l& n5 N0 S% D
51.         // 校验数据
    & k* ?+ I7 N# w+ L# a
52.         for (i = 0;i < secremain;i ++)
    
53.         {
    
54.             // 需要擦除
    $ d3 ]- V9 V0 e( ?! T, y
55.             if (STM32_FLASH_BUF[secoff + i] != 0XFFFF)
    
56.             {
    
57.                 break;
    . U- o4 L0 l) F, c
58.             }   
    
59.         }
    
60.         // 需要擦除
    5 L0 t0 Y# e* w: I
61.         if (i < secremain)
    8 D8 h% ?" S3 P5 M5 d
62.         {
    . Z$ p+ U5 X4 l% i
63.             FLASH_ErasePage(secpos * STM32_SECTOR_SIZE + STM32_FLASH_BASE);   // 擦除这个扇区
    
64.             
    
65.             // 复制
    % L2 x* r& v! k# d9 z5 Y* j. p$ J
66.             for (i = 0;i < secremain;i ++)
    
67.             {
    * t& x( z' L! ]
68.                 STM32_FLASH_BUF[i + secoff] = pBuffer[i];   
    ) _9 d4 }7 C; A- u
69.             }
    
70.             // 写入整个扇区
    
71.             Med_Flash_Write_NoCheck(secpos * STM32_SECTOR_SIZE + STM32_FLASH_BASE,STM32_FLASH_BUF,STM32_SECTOR_SIZE / 2);
    , l  G6 @. o8 c4 A. X7 j! X0 }  W1 W
72.         }
      e. j1 C. q' C5 J# f
73.         else
    
74.         {
    
75.             // 写已经擦除了的,直接写入扇区剩余区间
    . [/ L5 `& q+ U0 M& S( X
76.             Med_Flash_Write_NoCheck(WriteAddr,pBuffer,secremain);
    : y' g+ v5 n* h$ D
77.         }
    5 g( H3 l6 R: P! E" z. {
78.         
    
79.         if (NumToWrite == secremain)
    9 V" W. J' \7 o6 o9 |" |
80.         {
    
81.             break;   // 写入结束了
    , K9 S1 f7 x/ R' h+ a' P9 [0 J1 u
82.         }
    
83.         // 写入未结束
      t  i* E- L/ t* C$ f6 R" J9 W. P# ]
84.         else
    
85.         {
    
86.             secpos ++;   // 扇区地址增1
    
87.             secoff=0;   // 偏移位置为0   
    + _. o& c6 t' p2 [8 U( ~
88.             pBuffer+=secremain;   // 指针偏移
    , s+ P; q& M" F& ^
89.             WriteAddr+=secremain;   // 写地址偏移   
    
90.             NumToWrite-=secremain;   // 字节(16位)数递减
    " f# Q7 q$ ?) }6 f
91.             if (NumToWrite>(STM32_SECTOR_SIZE/2))
    
92.             {
    " U5 j( {* a* k' O8 a( k2 R& K" w2 n
93.                 secremain=STM32_SECTOR_SIZE/2;   // 下一个扇区还是写不完
    $ h) \1 N( M( L7 p0 C: j, e# e
94.             }
    4 k# L2 _+ |  o
95.             else
    
96.             {
    7 R: Z5 Q8 p! t: z+ y3 @/ p1 v7 C
97.                 secremain=NumToWrite;   // 下一个扇区可以写完了
    
98.             }
    
99.         }  
    
100.     }
     
101.     FLASH_Lock();   // 上锁
     2 {' j. D" J: B
102. }

复制代码

: B: c# d1 M/ z3 ]: X/ ?2 j宏定义如下

1. // STM32的Flash容量，单位为KB
   
2. #define STM32_FLASH_SIZE   512
   
3. 
   ! K# b0 I" {' W
4. // FLASH主存储块起始地址
   
5. #define STM32_FLASH_BASE   0x08000000

复制代码

上面的读取数据和不检查的写入都比较简单，因此并没有再做分析。这里分析一下带检查的写入的程序设计思路。

• 首先用一小段条件编译来区分一下大容量产品和其他产品。因为大容量产品的一页（一个扇区）是2K字节，中小容量产品的一页是1K字节。定一个了一个数组，数组大小是一个扇区的大小。
+ e' x' I5 a3 e. `' f2 Q7 }; G. [/ Q: u
* {) e; H! N$ G" i

1. // 根据中文参考手册，大容量产品的每一页是2K字节
   
2. #if STM32_FLASH_SIZE < 256
   ' f" D6 o4 u5 b5 z) M
3.     #define STM32_SECTOR_SIZE   1024   // 字节
     `7 b/ x9 ]2 O4 W& A# Q
4. #else
   
5.     #define STM32_SECTOR_SIZE   2048
   
6. #endif
   
7. 
   
8. // 一个扇区的内存
   2 L9 q* ~. U: V: U8 i* d( d* |
9. u16 STM32_FLASH_BUF[STM32_SECTOR_SIZE / 2];

复制代码

大容量产品，一个扇区2K字节，除以2是因为在对内部Flash操作时，最小单位是半字。
/ a% ^/ Q# O% R; U8 X8 l
- i5 @+ j' H0 e; \• 接下来，判断要写入的地址是否合法，也就是是否在主存储块地址范围内。
) }( m$ C- U, u9 r0 y# K( X; J( \

1. // 判断写入地址是否在合法范围内
   
2.     if (WriteAddr < STM32_FLASH_BASE || (WriteAddr >= (STM32_FLASH_BASE + 1024 * STM32_FLASH_SIZE)))
   
3.     {
   
4.         return;   // 非法地址
   
5.     }

复制代码

• 如果要写入的地址合法，那么解锁后计算一些参数值。

1.     offaddr = WriteAddr - STM32_FLASH_BASE;   // 实际偏移地址

复制代码

实际偏移地址，指的是要写入的地址与主存储块基地址（0x0800 0000）的差值。
1 P! B# J1 l6 u8 k* j- r

1.     secpos = offaddr / STM32_SECTOR_SIZE;   // 扇区地址

复制代码

6 S  _6 N* W! \9 Y! @9 c& z扇区地址指的是要写入的地址所在扇区前面的扇区数。由于所有的参数都不是浮点型，因此在做除法时，小数位都是0。最终除出来的结果就是当前扇区前面的扇区数。
* `* n* p- ]. f5 X; R

1.     secoff = (offaddr % STM32_SECTOR_SIZE) / 2;   // 在扇区内的偏移(2个字节为基本单位)

复制代码

, L+ B1 ]; Q5 r6 }& q4 k在扇区内的偏移指的是要写入的地址与其所在扇区首地址的差值。用要写入的地址取余每一个扇区的字节数，余数就是偏移地址。但是由于操作内部Flash时的最小单位是半字，因此要除以2。
/ E2 F9 j: Z9 E3 U

1.     secremain = STM32_SECTOR_SIZE / 2 - secoff;   // 扇区剩余空间大小

复制代码

扇区内剩余空间大小只需要用扇区总的空间大小减去偏移地址即可得到。但是需要注意的是，单位都是半字。这里的剩余空间大小，并不是真正的剩余空间大小。而是指写入地址后面的扇区大小。这里不太好理解，画一个图表示一下。

3 R9 C2 ?# n2 i# m2 j" J4 Y  S

2 ?; W; Y. H7 T6 D

扇区内剩余空间大小示意图

$ q. d& R, R. ^9 [$ ^5 w% t
正是因为这里的扇区剩余空间大小并不是指真正的剩余空间大小。在剩余空间内，也可能存在已经写入数据的地址。所以后面需要进行判断，来确定是否需要擦除。

, W. h" ^& S7 O• 判断在写入地址所在扇区能否将写入内容全部写入完成
" Y- ]* E; o/ T! G/ b

1. if (NumToWrite <= secremain)
   9 G5 k7 [$ O# D/ J8 g
2.     {
   
3.         secremain = NumToWrite;   // 不大于该扇区范围
   
4.     }

复制代码

: _7 Y1 @: ~9 {' L% d5 Q如果可以，直接将要写入的半字数赋值给当前扇区剩余空间大小。如果当前扇区剩余空间大小可以容纳要写入的半字数，那么只需要写入一次即可，在后续判断是否写完时，直接通过，while循环只执行一次。
/ [, n/ c% _3 H
• 读出整个扇区内容，判断是否需要擦除
6 H# Z. a* e- b% G, |5 q

1. // 读出整个扇区的内容
   
2.         Med_Flash_Read(secpos * STM32_SECTOR_SIZE + STM32_FLASH_BASE,STM32_FLASH_BUF,STM32_SECTOR_SIZE / 2);
   - S- b, x; k0 t1 e$ M6 g2 E, U/ M
3.         
   2 e. f8 y; U" \  F0 e( z' A
4.         // 校验数据
   
5.         for (i = 0;i < secremain;i ++)
   
6.         {
   
7.             // 需要擦除
   & }( d, b0 j! Q1 D
8.             if (STM32_FLASH_BUF[secoff + i] != 0XFFFF)
   
9.             {
   , K- Z5 u3 X9 ~  a+ o# g* ]
10.                 break;
    + |+ q+ u5 N% ^4 R  E1 ^1 b( h& E/ u7 d
11.             }   
    + V8 U& Y. h& G, ~/ z  G' U- P
12.         }

复制代码

8 [# ]/ O9 r$ y, |; v. E* d要对内部Flash某个地址写入数据时，需要确保该地址数值为0xFFFF。判断方法就是从扇区内的偏移开始，利用for循环判断读出地扇区剩余空间内，是否存在已经被写入内容的地址。for循环找到i的值，i加上在扇区内的偏移加1之后的空间，才是真正的扇区剩余空间大小。

for循环结束后，判断是否需要进行擦除
" D" `% L9 H. Q( F( E; ^

1. // 需要擦除
   
2.         if (i < secremain)
   
3.         {
   
4.             FLASH_ErasePage(secpos * STM32_SECTOR_SIZE + STM32_FLASH_BASE);   // 擦除这个扇区
   . t6 i% [7 n; }* A
5.             
   
6.             // 复制
   
7.             for (i = 0;i < secremain;i ++)
   * G! W+ `8 [: i# S4 V. a8 H
8.             {
   5 y7 d- p+ W& ]- N1 }+ i3 v
9.                 STM32_FLASH_BUF[i + secoff] = pBuffer[i];   
   1 v7 J. n% W) v- T: [4 s4 B8 H- d
10.             }
    $ t0 L6 ]% k3 ?
11.             
      a3 U. x- \( q3 x0 r
12.             // 写入整个扇区
    
13.             Med_Flash_Write_NoCheck(secpos * STM32_SECTOR_SIZE + STM32_FLASH_BASE,STM32_FLASH_BUF,STM32_SECTOR_SIZE / 2);
    
14.         }
      x4 l' L4 [, I3 s3 w
15.         else
    1 U% O2 ~/ f: w/ u9 q7 k- J3 c+ [2 |
16.         {
    7 o6 p) }* ?8 }1 C! T6 k# M
17.             // 写已经擦除了的,直接写入扇区剩余区间
    : t; j, {6 u# g3 P, I
18.             Med_Flash_Write_NoCheck(WriteAddr,pBuffer,secremain);
    
19.         }

复制代码

擦除时，最小单元为一个扇区。在大容量产品中，也就是2048字节。

• 最后，将需要写入的数据，写入到对应位置。如果是需要擦除的情况，写入时是先将原来的内容提取出来，然后在后面填充上需要写入的内容，擦除整个扇区之后再一起写入。如果是不需要擦除的情况，直接写入即可。
2 x6 P  q! J1 L8 q
. j$ V* A2 ^- Q! P3 ^
# |. g  D* g8 z/ M  I) W. _9 Q五、注意事项
在操作Flash时，注意不要对代码区内容进行擦写。如果擦写的地址在代码区，会导致程序运行异常。那么如何确保我们操作的地址不是在代码区？这就需要我们知道我们的代码所占的内存是多少。在Keil5编译完成后，会显示下面的内容
3 P6 v9 R0 S2 y7 `, \4 Y+ D+ |8 R

keil5编译后提示

' W7 T* r) U3 F# F* e" _& o: v5 k
• Code 程序所占用的内存大小（存放在Flash中）
• RO-data 程序定义的常量所占内存大小（存放在Flash中）
• RW-data 已被初始化的全局变量所占内存大小（在程序初始化的时候，RW-data会从FLASH中拷贝到RAM中）
ZI-data 未被初始化的全局变量所占内存大小（存放在RAM中）

最后，计算程序代码所占Flash空间。flash = Code + RO-data + RW-data。
& Z! X  y8 C# C' ?" ^, V
* J# s& F) |  L. j0 }) P
转载自： 二土电子
, p. j. |/ S- W$ G# B0 y6 M如有侵权请联系删除
) P8 f4 s& c: q) Y4 }6 P0 i* Y7 [
3 m9 o' Y6 Z+ b4 p0 i/ p% A4 R
  G. U+ D3 u2 Q5 d' H( b