一、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"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. 
   + t5 f% `  o5 U7 ]8 u$ _
5. /***flash解锁*****/
   
6. void STMFLASH_Unlock(void)
   
7. {
   
8.   FLASH->KEYR=FLASH_KEY1;                                    　　　　//写入解锁序列
   
9.   FLASH->KEYR=FLASH_KEY2;
   
10. }
    8 |- y' n' w2 h
11. 
    / i/ t/ B$ b- n) f0 ]. E' M) s" s
12. //flash上锁
    
13. void STMFLASH_Lock(void)
    
14. {
    
15.   FLASH->CR|=1<<7;                                        　　　　　　//上锁
    & ~( l: p2 ~, _. X
16. }
    
17. 
    
18. //得到FLASH状态
    ( L( _( l1 n. _, ]# ?. a, }
19. u8 STMFLASH_GetStatus(void)
    
20. {   
    ' }5 Y% @/ p' M% v# }5 {- b' H& _
21.    u32 res;         
    
22. 
    1 X% u7 x" H1 e( c
23.    res=FLASH->SR;
    
24.    if(res&(1<<0))return 1;                                        　　//忙
    
25.    else if(res&(1<<2))return 2;                                  　　 //编程错误
    
26.    else if(res&(1<<4))return 3;                                  　　 //写保护错误
    
27.    return 0;                                                     　　 //操作完成
    
28. }
    0 D+ c6 B* k) H2 j" Y
29. 
    
30. //等待操作完成
    6 }6 E9 d! y2 \% h) w$ N/ Z
31. //time:延时长短
    
32. //返回值:状态.
    1 {' Y7 l( S8 m7 ]/ K
33. u8 STMFLASH_WaitDone(u16 time)
    4 N/ Y8 i( X7 T- G5 ^, B$ V& {1 M! l
34. {
    
35.    u8 res;
    4 G3 B; X. p$ m8 ~' J* K
36. 
    
37.    do
    
38.    {
    
39.       res=STMFLASH_GetStatus();
    3 s& v- v+ |' e" X; ~: f
40.       if(res!=1)break;                                        　　　　//非忙,无需等待,直接退出.
    ; \' Y' F/ C% K" M! f1 q" I$ D' [
41.       Delay_us(1); time--;            
    , ~2 f& Y1 i- R9 G; C
42.     }while(time);
    
43.     if(time==0)res=0xff;                                        　　　//TIMEOUT
    ' H$ F- d$ S* k
44.     return res;
    # H/ U& K0 t5 s9 i: V6 `/ b
45. }
    ! e* e) S, }- Z4 `# W- S* r/ G7 v
46. 
    
47. //擦除页
    4 ?( Y. R0 }/ Y4 y
48. //paddr:页地址
    
49. //返回值:执行情况
    
50. u8 STMFLASH_ErasePage(u32 paddr)
    
51. 
    
52. {
    4 x8 x1 @1 t& H4 A# B5 h+ `
53.        u8 res=0;
    ' P# j+ U6 ]+ _8 O, H% R
54. 
    
55.        res=STMFLASH_WaitDone(0X5FFF);                            　　//等待上次操作结束,>20ms   
    3 z6 ^- {/ y4 |- M# u
56.        if(res==0)
    ; G. K. I/ |7 \  Y2 R" l& T
57.        {
    
58.               FLASH->CR|=1<<1;                                    　 //页擦除
    0 M$ [! W" G% E4 |
59.               FLASH->AR=paddr;                                    　 //设置页地址
    
60.               FLASH->CR|=1<<6;                                    　 //开始擦除           
    
61.               res=STMFLASH_WaitDone(0X5FFF);                    　　　//等待操作结束,>20ms
    
62.               if(res!=1)                                             //非忙
    
63.               {
    
64.                      FLASH->CR&=~(1<<1);                        　　　//清除页擦除标志.
    " d9 z9 D% s7 o7 G2 v
65.               }
    
66.        }
    
67.        return res;
    " w; t5 T3 r9 q5 g  q1 I1 v% X
68. }
    
69. 
    
70. //读出指定地址的半字(16位数据)
    
71. //faddr:读地址(此地址必须为2的倍数!!)
    
72. //返回值:对应数据.
    ' S& t: I9 C2 g% `, N8 ]) ?7 R- L- _
73. u16 STMFLASH_ReadHalfWord(u32 faddr)
    9 Y; P5 Z9 ]2 ~" K8 Y" |
74. {
    # r# h) `* Q4 Y
75.     return *(vu16*)faddr;
    , q6 W, J, k. o$ ?
76. }
    3 [7 }2 `, O7 }% Y
77. #if STM32_FLASH_WREN                                            　　 //如果使能了写   
    
78. //不检查的写入
    # i+ {( R+ b& P
79. //WriteAddr:起始地址
    
80. //pBuffer:数据指针
    ! k4 F% ^, J$ s- C
81. //NumToWrite:半字(16位)数   
    * X. ~0 {5 V4 H( F9 K) j
82. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   
    0 r! O  N9 v8 m  L( `/ H
83. {                       
    
84.     u16 i;
    * G8 a" G) C1 {) t: p
85.     for(i=0;i<NumToWrite;i++)
    
86.     {
    
87.         FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);
    
88.         WriteAddr+=2;                                    　　　　　　 //地址增加2.
    + Q$ D& o+ V$ [
89.     }  
    
90. }
    3 A% n1 F8 G4 P3 w% H- z
91. //从指定地址开始写入指定长度的数据
    6 L1 Y. u  ?- z; m
92. //WriteAddr:起始地址(此地址必须为2的倍数!!)
    ' T/ o! |' L( F3 h7 s
93. //pBuffer:数据指针
    ; s. I5 x' w2 J9 V4 r
94. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)
    ) S( w' ]; i$ m2 W" U7 Y/ Q3 r
95. #if STM32_FLASH_SIZE<256
    
96. #define STM_SECTOR_SIZE 1024                                     　　//字节
    
97. #else
    
98. #define STM_SECTOR_SIZE    2048
      n+ [# F0 j& j0 M: f
99. #endif         
    * I0 a" _& A, J. I6 i8 S
100. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];                            　　 //最多是2K字节
     ; n  _9 L1 ~+ ]
101. 
     
102. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)
     2 b0 z; H9 Q$ w0 p
103. {
     ( L" ]# k, E) m8 n; {2 v; f
104.     u32 secpos;                                                     //扇区地址
     : I; S5 Y+ C% n$ ?
105.     u16 secoff;                                                     //扇区内偏移地址(16位字计算)
     / P% H6 {+ S; v$ W4 z7 X: t
106.     u16 secremain;                                                  //扇区内剩余地址(16位字计算)      
     
107.      u16 i;   
     
108.     u32 offaddr;                                                    //去掉0X08000000后的地址
     ) D6 ~9 |0 [# S  r# _
109.    
     
110.     if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
     # L" Z' g( S- i3 S; r0 t
111.     FLASH_Unlock();                                                 //解锁
     
112.     offaddr=WriteAddr-STM32_FLASH_BASE;                             //实际偏移地址.
     
113.     secpos=offaddr/STM_SECTOR_SIZE;                                 //扇区地址  0~127 for STM32F103RBT6
     
114.     secoff=(offaddr%STM_SECTOR_SIZE)/2;                             //在扇区内的偏移(2个字节为基本单位.)
     8 C* E5 [& p/ Q* l
115.     secremain=STM_SECTOR_SIZE/2-secoff;                             //扇区剩余空间大小  
     $ m7 \3 h8 y# |4 u# a: J
116.     if(NumToWrite<=secremain)secremain=NumToWrite;                　//不大于该扇区范围
     
117.     while(1)
     
118.     {   
     
119.         STMFLASH_Read(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
     7 |, h, e/ z- `; J/ p
120.         for(i=0;i<secremain;i++)                                　  //校验数据
     9 ~& K) k+ }2 m4 O+ p$ ?+ E
121.         {
     
122.             if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;            　　//需要擦除      
     5 r* O# @1 K8 [2 O
123.         }
     
124.         if(i<secremain)                                            //需要擦除
     
125.         {
     ' f, s' o4 c3 `9 d- B% [
126.             FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);　　　　　　　　　　　　　　　//擦除这个扇区
     
127.             for(i=0;i<secremain;i++)                            　 //复制
     . Z( b8 V' T- U+ y" d
128.             {
     
129.                 STMFLASH_BUF[i+secoff]=pBuffer[i];      
     
130.             }
     $ l  U6 N/ Q/ R" r. R+ O! b$ C
131.             STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区
     # w- I/ u3 z; b! n; _3 M" O0 ]
132.         }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain); //写已经擦除了的,直接写入扇区剩余区间.                    
     5 m* ?9 v+ r3 T
133.         if(NumToWrite==secremain)break;                            //写入结束了
     * `1 [8 F( R2 F0 F$ i  V
134.         else                                                       //写入未结束
     
135.         {
     5 H& r2 r, M2 R' y, M
136.             secpos++;                                              //扇区地址增1
     8 X  G0 G7 e9 D  w! v3 y
137.             secoff=0;                                              //偏移位置为0      
     1 n; ?6 ]( ^6 W2 h# l
138.                pBuffer+=secremain;                                 //指针偏移
     
139.             WriteAddr+=secremain;                                  //写地址偏移      
     
140.                NumToWrite-=secremain;                              //字节(16位)数递减
     
141.             if(NumToWrite>(STM_SECTOR_SIZE/2))secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
     
142.             else secremain=NumToWrite;                             //下一个扇区可以写完了
     
143.         }     
     3 q+ F# Z0 U, }- v0 F. E
144.     };   
     : P* L/ t# n0 Y
145.     FLASH_Lock();                                                  //上锁
     : F+ E; k' Y  g
146. }
     & E9 c- x4 p3 Q5 M0 O- d
147. #endif
     
148. 
     ) i) P+ c* b; q, X' w: c+ U
149. //从指定地址开始读取指定长度的数据
     
150. //ReadAddr:起始地址
     ; g) ^( Q9 S1 R, q/ d9 k- E
151. //pBuffer:数据指针
     % A5 G: X& J+ Q! X+ x0 Q1 |
152. //NumToWrite:半字(16位)数
     
153. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)
     * k/ ~6 a& m9 j7 T
154. {
     
155.     u16 i;
     
156.     for(i=0;i<NumToRead;i++)
     
157.     {
     
158.         pBuffer[i]=STMFLASH_ReadHalfWord(ReadAddr);               //读取2个字节.
     
159.         ReadAddr+=2;                                              //偏移2个字节
     ' H9 ]7 `  P' i- ~- [! e1 T
160.     }
       |2 b  n1 H" h! N9 o
161. }
     
162. 
     
163. //////////////////////////////////////////////////////////////////////////////////////////////////////
     5 c$ B6 k  l1 l# O. j
164. //WriteAddr:起始地址
     ! P; J) Y. ^- X' G2 a
165. //WriteData:要写入的数据
     
166. void Test_Write(u32 WriteAddr,u16 WriteData)      
     
167. {
     
168.     STMFLASH_Write(WriteAddr,&WriteData,1);                       //写入一个字
     5 T, |7 l  C! T5 X% U% l
169. }

复制代码

! p+ @4 r" ^, w$ v2 u& {

　　flash.h文件

1. #ifndef __FLASH_H__
   ! C$ d- O; d# m* X$ g+ Q. U4 a) R
2. #define __FLASH_H__
   
3. #include <stm32f10x.h>
   
4. 
   
5. #define FLASH_KEY1               0X45670123
   ) L) x! m$ f  Z+ w* O% b
6. #define FLASH_KEY2               0XCDEF89AB
   $ Z" o* f) A- b, R0 r9 E7 x9 T
7. 
   ( o2 ?  o$ P8 I
8. #define STM32_FLASH_SIZE 128              　　　　 　　　　　　　　　　　　　　//所选STM32的FLASH容量大小(单位为K)
   
9. #define STM32_FLASH_WREN 1                          　　 　　　　　　　　　　//使能FLASH写入(0,不使能;1,使能)
   
10. //////////////////////////////////////////////////////////////////////////////////////////////////////
    
11. 
    
12. //FLASH起始地址
    # {. V6 g/ f+ r! Z- b4 F4 W
13. #define STM32_FLASH_BASE 0x08000000     　　　　　　　　　　　　　　　　　　　　//STM32 FLASH的起始地址
    
14. 
      v2 Y9 c4 {4 g' c8 i, D/ L5 f
15. 
    - a: p9 D8 \& O+ z9 q
16. void STMFLASH_Unlock(void);                              　　　　　　　　　　//解锁
    4 L0 P% e1 Q3 ]2 h' a; I
17. void STMFLASH_Lock(void);                    　　　　     　　　　　　　　　　//上锁
    ! u$ K/ l$ d! ?& X# P# l
18. u8 STMFLASH_GetStatus(void);                             　　　　　　　　　　//获得状态
    6 R: k/ q: a  N: p7 u
19. u8 STMFLASH_WaitDone(u16 time);                    　　　 　　　　　　　　　　//等待操作结束
    
20. u8 STMFLASH_ErasePage(u32 paddr);                        　　　　　　　　　　//擦除页
    
21. u16 STMFLASH_ReadHalfWord(u32 faddr);                      　　　　　　　　　//读出半字  
    
22. void STMFLASH_WriteLenByte(u32 WriteAddr,u32 DataToWrite,u16 Len);    　　 //指定地址开始写入指定长度的数据
    
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);           　　//从指定地址开始读取指定长度的数据
    
26. 
    7 m- W3 o) H* V7 u9 c# u5 _
27. //测试写入
    , J* ]6 G* c- |3 u
28. void Test_Write(u32 WriteAddr,u16 WriteData);                                   
    : D. ]: R: U4 ~" \8 z3 E# ~0 b
29. #endif

复制代码

& O0 V& R  ?7 o) j. [, r

　　main.c文件

1. #include "flash.h"
   . Y5 G& Q  L  C) X1 c" q
2. 
   ; ^7 O6 _( N9 q- V
3. #define SIZE sizeof(TEXT_Buffer)                  ///数组长度
   
4. #define FLASH_SAVE_ADDR  0X08070000   //设置FLASH 保存地址(必须为偶数，且其值要大于本代码所占用FLASH的大小+0X08000000)
   
5. 
   . {& e' `9 |0 _" n
6. const u8 TEXT_Buffer[]={"STM32 FLASH TEST"};
   
7. u8 datatemp[SIZE];
   
8. 
   
9. int main(void)
   
10. {
    1 \. X. @# W% I3 h. `# R
11.      while(1)
    
12.     {
    9 I) M* O9 m* L; B: k
13.         if(掉电)
    * `6 _. N3 D; D2 O9 x) g) F
14. 　　　　　{
    # a1 D  ]) p; }& ?' P8 N
15.         　　STMFLASH_Write(FLASH_SAVE_ADDR,(u16*)TEXT_Buffer,SIZE);//flash写函数
    
16. 　　　　　}  
    ! D* m6 [% X+ l) k) M4 n7 }
17.            STMFLASH_Read(FLASH_SAVE_ADDR,(u16*)datatemp,SIZE);     //flash读函数   
    
18.    }
    4 b- K1 c9 r2 A  G0 z' x- |1 {1 B
19. }

复制代码

( Y' @: @( T: x; _

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