一、STM32FLASH简介

　　不同的STM32它的FLASH大小也是不一样的，分为大、中、小容量，容量由16K到1024K不等。这次实验用的开发板FLASH容量大小为128K。

　　STM32的闪存模块由：主存储器、信息块和闪存存储器接口寄存器三部分组成。

　　主存储器：该部分主要是用来存放代码和数据常数，被划分为128页，每页1K字节（小容量产品也是每页1K字节，大容量为每页2K字节）。主存储器的起始地址就是0X08000000， B0、B1都接GND的时候，就是从0X08000000开始运行代码的。

　　信息块：该部分分为2个小部分，其中启动程序代码，是用来存储ST自带的启动程序，用于串口下载代码，当B0接V3.3，B1接GND的时候，运行的就是这部分代码。用户选择字节，则一般用于配置写保护、读保护等功能。

　　闪存存储器接口寄存器：该部分用于控制闪存读写等，是整个闪存模块的控制机构。　

　　对主存储器和信息块的写入由内嵌的闪存编程/擦除控制器(FPEC)管理；编程与擦除的高电压由内部产生。

　　在执行闪存写操作时，任何对闪存的读操作都会锁住总线，在写操作完成后读操作才能正确地进行；既在进行写或擦除操作时，不能进行代码或数据的读取操作

闪存的读取

　　内置闪存模块可以在通用地址空间直接寻址，任何32位数据的读操作都能访问闪存模块的内容并得到相应的数据。读接口在闪存端包含一个读控制器，还包含一个AHB接口与CPU衔接。这个接口的主要工作是产生读闪存的控制信号并预取CPU要求的指令块，预取指令块仅用于在I-Code总线上的取指操作，数据常量是通过D-Code总线访问的。这两条总线的访问目标是相同的闪存模块，访问D-Code将比预取指令优先级高。

　　这里要特别留意一个闪存等待时间，因为CPU运行速度比FLASH快得多，STM32F103的FLASH最快访问速度≤24Mhz，如果CPU频率超过这个速度，那么必须加入等待时间，比如我们一般使用72Mhz的主频，那么FLASH等待周期就必须设置为2，该设置通过FLASH_ACR寄存器设置。

闪存的编程和擦除

　　编程过程：

　　·检查FLASH_CR的LOCK是否解锁，如果没有则先解锁

　　·检查FLASH_SR寄存器的BSY位，以确认没有其他正在进行的编程操作

　　·设置FLASH_CR寄存器的PG位为’1’

　　·在指定的地址写入要编程的半字

　　·等待BSY位变为’0’

　　·读出写入的地址并验证数据

　　擦除过程（页擦除）

　　·检查FLASH_CR的LOCK是否解锁，如果没有则先解锁

　　·检查FLASH_SR寄存器的BSY位，以确认没有其他正在进行的闪存操作

　　·设置FLASH_CR寄存器的PER位为’1’

　　·用FLASH_AR寄存器选择要擦除的页

　　·设置FLASH_CR寄存器的STRT位为’1’

　　·等待BSY位变为’0’

　　·读出被擦除的页并做验证

二、软件实现

　　flash.c文件

1. #include "flash.h"
   6 q$ m$ b, F( M' y+ T/ z( U
2. #include "delay.h"
   
3. #include "usart.h"
   
4. 
   
5. /***flash解锁*****/
   ( V* x* X) n. F& ^, S1 N3 D
6. void STMFLASH_Unlock(void)
   $ R: H2 j! y/ e- {1 A8 p6 D
7. {
   
8.   FLASH->KEYR=FLASH_KEY1;                                    　　　　//写入解锁序列
     }; k  p* C/ \% U' H5 _
9.   FLASH->KEYR=FLASH_KEY2;
   % W) M  Q1 W) n& C: I: s/ F
10. }
    
11. 
      x6 v; y) M, D/ f# d1 n, w! P
12. //flash上锁
    
13. void STMFLASH_Lock(void)
    
14. {
    1 `9 a% m: f0 _, q
15.   FLASH->CR|=1<<7;                                        　　　　　　//上锁
    
16. }
    
17. 
      M0 _* H/ \: m  z5 u" N
18. //得到FLASH状态
      }; q( U" Z  t( R, R
19. u8 STMFLASH_GetStatus(void)
    
20. {   
    
21.    u32 res;         
    
22. 
    
23.    res=FLASH->SR;
    
24.    if(res&(1<<0))return 1;                                        　　//忙
    
25.    else if(res&(1<<2))return 2;                                  　　 //编程错误
    6 K/ z; k) l& u3 ^% e% e
26.    else if(res&(1<<4))return 3;                                  　　 //写保护错误
    " }3 p- f; D% v
27.    return 0;                                                     　　 //操作完成
    & G! Q- i. D# D  v
28. }
    ) T% W2 n1 ?( n$ G" U# L9 _
29. 
    
30. //等待操作完成
    , O- U( L% J* t" g8 V
31. //time:延时长短
    
32. //返回值:状态.
    ) C" F. J2 D1 m' @6 M. p
33. u8 STMFLASH_WaitDone(u16 time)
    * f4 u3 e, z$ ^1 [/ A" n
34. {
    
35.    u8 res;
    - c. L8 s$ H" m
36. 
    7 P/ Q  }" {8 E% }
37.    do
    
38.    {
    , v& b0 _6 b* x; v; F, y
39.       res=STMFLASH_GetStatus();
    
40.       if(res!=1)break;                                        　　　　//非忙,无需等待,直接退出.
    / Q$ H9 H: ~# ]5 k* B( [! I
41.       Delay_us(1); time--;            
    
42.     }while(time);
    . z4 u+ b5 S) B5 b/ s
43.     if(time==0)res=0xff;                                        　　　//TIMEOUT
    ( \0 ?0 S. m! \7 ]4 O
44.     return res;
    1 G* j4 N0 c6 T" Y, S5 |
45. }
    
46. 
    
47. //擦除页
    
48. //paddr:页地址
    
49. //返回值:执行情况
    8 i. Z, ], H! j! r
50. u8 STMFLASH_ErasePage(u32 paddr)
    # A2 u$ G0 p8 K# K$ @- E
51. 
    
52. {
    . n# `- E$ p1 e9 o
53.        u8 res=0;
    
54. 
    - ]& `2 T( [( l* B# w/ _) i
55.        res=STMFLASH_WaitDone(0X5FFF);                            　　//等待上次操作结束,>20ms   
    9 A' z! F! A5 Y2 K* Y5 d! r
56.        if(res==0)
    
57.        {
    
58.               FLASH->CR|=1<<1;                                    　 //页擦除
    
59.               FLASH->AR=paddr;                                    　 //设置页地址
    8 I! E! O' N+ t$ v- [0 F
60.               FLASH->CR|=1<<6;                                    　 //开始擦除           
    
61.               res=STMFLASH_WaitDone(0X5FFF);                    　　　//等待操作结束,>20ms
    
62.               if(res!=1)                                             //非忙
    : N8 H5 v9 a( K5 j  W& O1 k. x7 t7 ~
63.               {
    # V% O2 D- d5 Z  J& |; [' N% D
64.                      FLASH->CR&=~(1<<1);                        　　　//清除页擦除标志.
    % V' W* P: ~% }( [" {( o
65.               }
    * ~& ]3 c$ A) D4 M
66.        }
    
67.        return res;
    5 ?; l2 m2 w1 v
68. }
    ( G# [, `6 r% W2 m
69. 
    " `, U' d" l. d& g8 [
70. //读出指定地址的半字(16位数据)
    
71. //faddr:读地址(此地址必须为2的倍数!!)
    
72. //返回值:对应数据.
    
73. u16 STMFLASH_ReadHalfWord(u32 faddr)
    
74. {
    
75.     return *(vu16*)faddr;
    
76. }
    
77. #if STM32_FLASH_WREN                                            　　 //如果使能了写   
    # H3 ^+ l4 o3 f' S9 _
78. //不检查的写入
    1 G  E( O, r* w1 W  ^1 }
79. //WriteAddr:起始地址
    
80. //pBuffer:数据指针
    + e, U" _/ `( B+ ]6 S) B1 o: L
81. //NumToWrite:半字(16位)数   
    
82. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   
    1 A2 x6 b& K! t: Q+ C& y
83. {                       
    
84.     u16 i;
    
85.     for(i=0;i<NumToWrite;i++)
    / r: n4 b- y- @6 \! J
86.     {
    # e( y7 y: b( y
87.         FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);
    " |" Q/ W# \8 Y0 F5 ?. _: ^
88.         WriteAddr+=2;                                    　　　　　　 //地址增加2.
    
89.     }  
    ' t/ p: |" Z& I6 }& i! L
90. }
    
91. //从指定地址开始写入指定长度的数据
    & w: A! @2 i: B- k& z1 J
92. //WriteAddr:起始地址(此地址必须为2的倍数!!)
    - ~6 D" c6 i5 h, z5 L" e
93. //pBuffer:数据指针
    % X  e6 n1 _' j& I! a
94. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)
    4 d6 G7 q9 c3 m5 v+ M$ H) _+ t
95. #if STM32_FLASH_SIZE<256
    # Q# M9 e+ j, i% r& c
96. #define STM_SECTOR_SIZE 1024                                     　　//字节
    + x) L  U/ N. h. |' w9 g0 i# Y
97. #else
    9 ^$ B6 `  S- R' T* ]( V1 L
98. #define STM_SECTOR_SIZE    2048
    
99. #endif         
    
100. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];                            　　 //最多是2K字节
     " M# y! a! ?2 z' r4 F* o
101. 
     
102. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)
     : X+ ~9 i; ?, @, x4 j
103. {
     9 s0 g; k4 ~5 O& v6 T2 j9 D- v! j
104.     u32 secpos;                                                     //扇区地址
     ; J" K! I$ X' H
105.     u16 secoff;                                                     //扇区内偏移地址(16位字计算)
     
106.     u16 secremain;                                                  //扇区内剩余地址(16位字计算)      
     
107.      u16 i;   
     
108.     u32 offaddr;                                                    //去掉0X08000000后的地址
     " |, y5 _1 d# J8 V  _
109.    
     
110.     if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
     & k/ r1 a. z. F  B2 n( D
111.     FLASH_Unlock();                                                 //解锁
     9 v8 r2 N6 n' j3 t8 s7 O
112.     offaddr=WriteAddr-STM32_FLASH_BASE;                             //实际偏移地址.
     
113.     secpos=offaddr/STM_SECTOR_SIZE;                                 //扇区地址  0~127 for STM32F103RBT6
     ; P6 s6 S  E0 a8 T) e( D
114.     secoff=(offaddr%STM_SECTOR_SIZE)/2;                             //在扇区内的偏移(2个字节为基本单位.)
     
115.     secremain=STM_SECTOR_SIZE/2-secoff;                             //扇区剩余空间大小  
     ! I8 R, @. N" y' n# E! g2 O  N
116.     if(NumToWrite<=secremain)secremain=NumToWrite;                　//不大于该扇区范围
     - X+ P$ a9 e* C$ `
117.     while(1)
     8 n" i0 ], f$ ?
118.     {   
     2 y* N( I7 }* ~8 C
119.         STMFLASH_Read(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
     % S2 `" P# @1 j9 d) m# ^
120.         for(i=0;i<secremain;i++)                                　  //校验数据
     
121.         {
     ' b7 b+ ^8 H- g( ^1 q5 c8 Y
122.             if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;            　　//需要擦除      
     
123.         }
     9 c. @! `5 ]1 H
124.         if(i<secremain)                                            //需要擦除
     , Q: n8 n" w- C9 N& D% K0 I* [
125.         {
     ' j/ Q7 \% ?' {4 N: @" R  M
126.             FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);　　　　　　　　　　　　　　　//擦除这个扇区
     
127.             for(i=0;i<secremain;i++)                            　 //复制
     
128.             {
     " W7 Y  U9 m- {! S5 ~3 ~* j
129.                 STMFLASH_BUF[i+secoff]=pBuffer[i];      
     . `; o# y/ i9 x: k8 `: u. n  Z
130.             }
     
131.             STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区
     4 g' N: I8 F% t+ D
132.         }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain); //写已经擦除了的,直接写入扇区剩余区间.                    
     5 i8 l  R9 C4 @3 ~* E: z
133.         if(NumToWrite==secremain)break;                            //写入结束了
     * R7 c) d" Y0 V# L
134.         else                                                       //写入未结束
     
135.         {
     
136.             secpos++;                                              //扇区地址增1
       f5 l$ b+ E- f: E3 n! o6 A
137.             secoff=0;                                              //偏移位置为0      
     
138.                pBuffer+=secremain;                                 //指针偏移
     # A9 T# G  f5 N) F
139.             WriteAddr+=secremain;                                  //写地址偏移      
     , S; C1 V6 w3 y$ j8 k
140.                NumToWrite-=secremain;                              //字节(16位)数递减
     
141.             if(NumToWrite>(STM_SECTOR_SIZE/2))secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
     
142.             else secremain=NumToWrite;                             //下一个扇区可以写完了
     
143.         }     
     
144.     };   
     
145.     FLASH_Lock();                                                  //上锁
     
146. }
     
147. #endif
     
148. 
     
149. //从指定地址开始读取指定长度的数据
     & w1 X# T+ w; ~3 n/ w
150. //ReadAddr:起始地址
     ( Q0 F  Q- U3 u, O1 T* Z1 f
151. //pBuffer:数据指针
     
152. //NumToWrite:半字(16位)数
     0 `& P# b* W/ ^" i) c. Y* `
153. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)
     + p& b( l/ r& l4 n( E
154. {
     
155.     u16 i;
     
156.     for(i=0;i<NumToRead;i++)
     % x* A# V: F. U7 Z* c
157.     {
     ( w$ K- [9 e; x
158.         pBuffer[i]=STMFLASH_ReadHalfWord(ReadAddr);               //读取2个字节.
     
159.         ReadAddr+=2;                                              //偏移2个字节
     5 E3 W+ y/ R  u  L' r7 r
160.     }
     4 B% w5 t1 R; S2 R4 o4 I
161. }
     0 w( i3 T. m- q6 s6 s" B
162. 
     
163. //////////////////////////////////////////////////////////////////////////////////////////////////////
     
164. //WriteAddr:起始地址
     / q1 D: h. v/ l; [- p) t# J
165. //WriteData:要写入的数据
     6 e5 i. k; P8 h# d5 C
166. void Test_Write(u32 WriteAddr,u16 WriteData)      
     . o: O8 u; ?+ w' E6 {: }$ |% I, _
167. {
     
168.     STMFLASH_Write(WriteAddr,&WriteData,1);                       //写入一个字
     ) b* F- K7 ~2 r1 T2 S4 A
169. }

复制代码

　　flash.h文件

1. #ifndef __FLASH_H__
   
2. #define __FLASH_H__
   
3. #include <stm32f10x.h>
   
4. 
   * l  w' ~& D: F$ ~
5. #define FLASH_KEY1               0X45670123
   
6. #define FLASH_KEY2               0XCDEF89AB
   
7. 
   
8. #define STM32_FLASH_SIZE 128              　　　　 　　　　　　　　　　　　　　//所选STM32的FLASH容量大小(单位为K)
   ; B- K/ q& C  M/ s" h
9. #define STM32_FLASH_WREN 1                          　　 　　　　　　　　　　//使能FLASH写入(0,不使能;1,使能)
   ) S. r+ w' F2 m* p" M3 R: c
10. //////////////////////////////////////////////////////////////////////////////////////////////////////
    
11. 
    2 i! X  u* C# z) Y. V1 o" C
12. //FLASH起始地址
    ( q6 k; L8 ~% u! I1 I0 {% t- K: j
13. #define STM32_FLASH_BASE 0x08000000     　　　　　　　　　　　　　　　　　　　　//STM32 FLASH的起始地址
    
14. 
    ! F. c/ {  o8 N# y4 {
15. 
    % `/ p4 _8 L" I  ?7 P) P8 ]
16. void STMFLASH_Unlock(void);                              　　　　　　　　　　//解锁
    
17. void STMFLASH_Lock(void);                    　　　　     　　　　　　　　　　//上锁
    
18. u8 STMFLASH_GetStatus(void);                             　　　　　　　　　　//获得状态
    
19. u8 STMFLASH_WaitDone(u16 time);                    　　　 　　　　　　　　　　//等待操作结束
    
20. u8 STMFLASH_ErasePage(u32 paddr);                        　　　　　　　　　　//擦除页
    0 {/ z( F& p# y! D2 k
21. u16 STMFLASH_ReadHalfWord(u32 faddr);                      　　　　　　　　　//读出半字  
    + T; b# T7 L1 o/ x
22. void STMFLASH_WriteLenByte(u32 WriteAddr,u32 DataToWrite,u16 Len);    　　 //指定地址开始写入指定长度的数据
    " n$ R3 j5 I. `; c
23. u32 STMFLASH_ReadLenByte(u32 ReadAddr,u16 Len);                　　　　　　 //指定地址开始读取指定长度的数据
    
24. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite);        　　//从指定地址开始写入指定长度的数据
    
25. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead);           　　//从指定地址开始读取指定长度的数据
    2 r1 j, w+ H: q2 |
26. 
    
27. //测试写入
    0 B# B$ j( T) `" c" s$ ^6 N, }
28. void Test_Write(u32 WriteAddr,u16 WriteData);                                   
    
29. #endif

复制代码

　　main.c文件

1. #include "flash.h"
   
2. 
   5 _) X6 c% x0 _9 h" I; w9 s
3. #define SIZE sizeof(TEXT_Buffer)                  ///数组长度
   
4. #define FLASH_SAVE_ADDR  0X08070000   //设置FLASH 保存地址(必须为偶数，且其值要大于本代码所占用FLASH的大小+0X08000000)
   + v2 _& i/ x0 Y8 O
5. 
   * a0 W. i  D; I/ _
6. const u8 TEXT_Buffer[]={"STM32 FLASH TEST"};
   
7. u8 datatemp[SIZE];
   
8. 
   9 _4 n- c3 [' F2 M+ g( ?, W, Q9 m
9. int main(void)
   
10. {
    
11.      while(1)
    4 H3 r. w! }1 m0 o; Y" Q% y
12.     {
    
13.         if(掉电)
    
14. 　　　　　{
    9 v: v+ w2 \+ E7 T6 T. |
15.         　　STMFLASH_Write(FLASH_SAVE_ADDR,(u16*)TEXT_Buffer,SIZE);//flash写函数
    2 e2 U+ D0 J$ Y  J+ N+ L
16. 　　　　　}  
    2 X6 R. Y# H0 \1 q* l) {2 }- [
17.            STMFLASH_Read(FLASH_SAVE_ADDR,(u16*)datatemp,SIZE);     //flash读函数   
    
18.    }
    
19. }

复制代码

  _, {3 n. i; P! z% y

　　以上就是flash在掉电的时候进行读写的程序，项目用到了就记录一下，方便以后查阅学习。其中的大部分代码在库函数中都能够找到参考。