一、介绍

首先我们需要了解一个内存映射：

1 p# ]& m- Z  V# E! z( B) b

stm32的flash地址起始于0x0800 0000，结束地址是0x0800 0000加上芯片实际的flash大小，不同的芯片flash大小不同。

% d) O( c& e" q& z! W

RAM起始地址是0x2000 0000，结束地址是0x2000 0000加上芯片的RAM大小。不同的芯片RAM也不同。

  }$ b: x% I. s0 t" r7 l

Flash中的内容一般用来存储代码和一些定义为const的数据，断电不丢失，

RAM可以理解为内存，用来存储代码运行时的数据，变量等等。掉电数据丢失。

STM32将外设等都映射为地址的形式，对地址的操作就是对外设的操作。

stm32的外设地址从0x4000 0000开始，可以看到在库文件中，是通过基于0x4000 0000地址的偏移量来操作寄存器以及外设的。

3 v7 ^7 s5 S! m* ~- L6 {! ~

一般情况下，程序文件是从 0x0800 0000 地址写入，这个是STM32开始执行的地方，0x0800 0004是STM32的中断向量表的起始地址。

在使用keil进行编写程序时，其编程地址的设置一般是这样的：

程序的写入地址从0x08000000（数好零的个数）开始的，其大小为0x80000也就是512K的空间，换句话说就是告诉编译器flash的空间是从0x08000000-0x08080000，RAM的地址从0x20000000开始，大小为0x10000也就是64K的RAM。这与STM32的内存地址映射关系是对应的。

1 _. U( X1 @, F5 _/ h9 ^2 ?

M3复位后，从0x08000004取出复位中断的地址，并且跳转到复位中断程序，中断执行完之后会跳到我们的main函数，main函数里边一般是一个死循环，进去后就不会再退出，当有中断发生的时候，M3将PC指针强制跳转回中断向量表，然后根据中断源进入对应的中断函数，执行完中断函数之后，再次返回main函数中。大致的流程就是这样。

1.1、内部Flash的构成：

STM32F429 的内部 FLASH 包含主存储器、系统存储器、 OTP 区域以及选项字节区域，它们的地址分布及大小如下：

STM32F103的中容量内部 FLASH 包含主存储器、系统存储器、 OTP 区域以及选项字节区域，它们的地址分布及大小如下：

注意STM32F105VC的是有64K或128页x2K=256k字节的内置闪存存储器，用于存放程序和数据。

) ]; _7 |- |* I* }

1.主存储器：一般我们说 STM32 内部 FLASH 的时候，都是指这个主存储器区域它是存储用户应用程序的空间，芯片型号说明中的 1M FLASH、 2M FLASH 都是指这个区域的大小。与其它 FLASH 一样，在写入数据前，要先按扇区擦除，

2.系统存储区：系统存储区是用户不能访问的区域，它在芯片出厂时已经固化了启动代码，它负责实现串口、 USB 以及 CAN 等 ISP 烧录功能。

3.OTP 区域：OTP(One Time Program)，指的是只能写入一次的存储区域，容量为 512 字节，写入后数据就无法再更改， OTP 常用于存储应用程序的加密密钥。

4.选项字节：选项字节用于配置 FLASH 的读写保护、电源管理中的 BOR 级别、软件/硬件看门狗等功能，这部分共 32 字节。可以通过修改 FLASH 的选项控制寄存器修改。

1.2、对内部Flash的写入过程：

1. 解锁 （固定的KEY值）

(1) 往 Flash 密钥寄存器 FLASH_KEYR 中写入 KEY1 = 0x45670123

(2) 再往 Flash 密钥寄存器 FLASH_KEYR 中写入 KEY2 = 0xCDEF89AB

2. 数据操作位数

最大操作位数会影响擦除和写入的速度，其中 64 位宽度的操作除了配置寄存器位外，还需要在 Vpp 引脚外加一个 8-9V 的电压源，且其供电间不得超过一小时，否则 FLASH可能损坏，所以 64 位宽度的操作一般是在量产时对 FLASH 写入应用程序时才使用，大部分应用场合都是用 32 位的宽度。

3. 擦除扇区

在写入新的数据前，需要先擦除存储区域， STM32 提供了扇区擦除指令和整个FLASH 擦除(批量擦除)的指令，批量擦除指令仅针对主存储区。

4 _7 Y' X! Y3 M0 f0 S) ?3 ^

扇区擦除的过程如下：

(1) 检查 FLASH_SR 寄存器中的“忙碌寄存器位 BSY”，以确认当前未执行任何

Flash 操作；

(2) 在 FLASH_CR 寄存器中，将“激活扇区擦除寄存器位 SER ”置 1，并设置“扇

区编号寄存器位 SNB”，选择要擦除的扇区；

(3) 将 FLASH_CR 寄存器中的“开始擦除寄存器位 STRT ”置 1，开始擦除；

(4) 等待 BSY 位被清零时，表示擦除完成。

# m* Y0 Q9 a" @; H+ c

4. 写入数据

擦除完毕后即可写入数据，写入数据的过程并不是仅仅使用指针向地址赋值，赋值前还还需要配置一系列的寄存器，步骤如下：

(1) 检查 FLASH_SR 中的 BSY 位，以确认当前未执行任何其它的内部 Flash 操作；

(2) 将 FLASH_CR 寄存器中的 “激活编程寄存器位 PG” 置 1；

(3) 针对所需存储器地址（主存储器块或 OTP 区域内）执行数据写入操作；

(4) 等待 BSY 位被清零时，表示写入完成。

1.3、查看工程内存的分布：

由于内部 FLASH 本身存储有程序数据，若不是有意删除某段程序代码，一般不应修改程序空间的内容，所以在使用内部 FLASH 存储其它数据前需要了解哪一些空间已经写入了程序代码，存储了程序代码的扇区都不应作任何修改。通过查询应用程序编译时产生的“ *.map”后缀文件，

打开 map 文件后，查看文件最后部分的区域，可以看到一段以“ Memory Map of the

image”开头的记录(若找不到可用查找功能定位)，

. g4 i6 W) ~2 q$ H6 }1 E

【注】ROM加载空间

这一段是某工程的 ROM 存储器分布映像，在 STM32 芯片中， ROM 区域的内容就是 指存储到内部 FLASH 的代码。

在上面 map 文件的描述中，我们了解到加载及执行空间的基地址(Base)都是0x08000000，它正好是 STM32 内部 FLASH 的首地址，即 STM32 的程序存储空间就直接是执行空间；它们的大小(Size)分别为 0x00000b50 及 0x00000b3c，执行空间的 ROM 比较小的原因就是因为部分 RW-data 类型的变量被拷贝到 RAM 空间了；它们的最大空间(Max)均为 0x00100000，即 1M 字节，它指的是内部 FLASH 的最大空间。

计算程序占用的空间时，需要使用加载区域的大小进行计算，本例子中应用程序使用

的内部 FLASH 是从 0x08000000 至(0x08000000+0x00000b50)地址的空间区域。

所以从扇区 1(地址 0x08004000)后的存储空间都可以作其它用途，使用这些存储空间时不会篡改应用程序空间的数据。

/ h! _" h  M4 p! f' Q$ E8 T! C

二、代码拆分介绍（以STM32F105系列为例，如上图表5所示）

2.1 读/写入数据流程

                                      写数据流程

4 N0 R* o( v3 O9 T

2.1.1、Flash 解锁，直接调用#include "stm32f10x_flash.h"中的void FLASH_Unlock(void)函数，这个函数是官方提供的，其内部代码如下：

View Code

: ?5 Y0 x' h- C. F

) D- Q1 b2 [" U5 q' O1 X

2.1.2、擦除扇区，也是直接调用固件库官方的函数FLASH_Status FLASH_ErasePage(uint32_t Page_Address)，这个官方函数代码也贴出来看看，代码如下：

' i2 q% ^  g$ ?, g% b( o& k

View Code

, q& K* t# S6 q$ H0 p  k- P

注意这个擦除扇区函数是你提供一个STM32f105系列扇区的开始地址即可，擦除是按照页擦除（每页2KB=1024Byte）或者整个擦除（见STM32参考手册的第二章2.3.3嵌入式闪存部分介绍）

+ @4 h+ D  o4 M' s9 Y/ H: F7 C

比如我们要擦除互联网型的127页，我们只需要FLASH_ErasePage(0x0803f800);执行后，第127页的0x0803f800-0x0803FFFF数据都将被擦除。

7 N- H2 p. k9 ~% D) D( [

当然官方提供的也不知一个擦除函数，而是三个，具体如下，对于32位系统：一个是字节=4byte=32bite；一个是半字=2byte=16bite；一个是字节=1byte=8bite；进行擦除。

) d2 B0 }  w* ^  J2 H) @

FLASH_Status FLASH_ErasePage(uint32_t Page_Address);

* G" e+ Z4 {4 K- G3 v- X& @

FLASH_Status FLASH_EraseAllPages(void);

' a- Y( H  ]+ s

FLASH_Status FLASH_EraseOptionBytes(void);

2.1.3、接下来是写/读数据函数，该函数也是官方给出的，我们只需要用就好了。但要注意，这个是个半字的写操作，威少是uint16_t 的数据算半字呢，因为单片机是32的，对于32位单片机系统来说，一个字是4个字节的，8位的比如51单片机系统一个字就是2位的，64位单片机系统一个字就是8个字节，脱离单片机系统说字是多少个字节是没意义的。所以这里写入/读出半字也就是一次写入2个字节，写完/读出一次地址会加2。

# d$ Z. ~3 h% j1 F& O  W9 e( _. z6 Y

写数据操作：

View Code

( G4 Y6 `8 a% P3 Q( k" ?; T

! g2 d7 ^- p; V; @

当然官方给的不止是这一个函数写数据，官方提供了3个

FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data);//一次写一个字，对于32系统，一次写的是4个字节，uint32_t 变量大小，32bit

) {2 F/ h) q( L* D" y8 J& W% X. O7 d

FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);//一次写一个半字，对于32系统，一次写的是2个字节，uint16_t 变量大小，16bit

" k' O) `  ^0 d' N' N, i

FLASH_Status FLASH_ProgramOptionByteData(uint32_t Address, uint8_t Data);//一次写一个字节，对于32系统，一次写的是1个字节，uint8_t 变量大小，8bit

读数据操作：

6 w) D& x- A& b

读数据的函数，官方并没有给出：下面我们自己给出，具体的读法代码如下

8 R. L+ d4 M. @$ Z7 o( T# f

1. 1 //读取指定地址的半字(16位数据)
   
2. 2 //也是按照半字读出，即每次读2个字节数据返回
   
3. 3 uint16_t FLASH_ReadHalfWord(uint32_t address)
   
4. 4 {
   
5. 5   return *(__IO uint16_t*)address;
   
6. 6 }

复制代码

如果要连续都区多个地址数据，可以进行如下代码操作

1. 1 //从指定地址开始读取多个数据
   * x6 S4 z; U. Y3 s" S- G* c+ J* i
2. 2 void FLASH_ReadMoreData(uint32_t startAddress,uint16_t *readData,uint16_t countToRead)
   
3. 3 {
   
4. 4   uint16_t dataIndex;
   ! X0 v' H" P/ ]
5. 5   for(dataIndex=0;dataIndex<countToRead;dataIndex++)
   
6. 6   {
   * [/ C9 q+ t8 A1 Q
7. 7     readData[dataIndex]=FLASH_ReadHalfWord(startAddress+dataIndex*2);
   % ^6 j7 p/ ~) a/ H' {5 T
8. 8   }
   
9. 9 }

复制代码

5 I8 m# z+ Q$ x) b' }! u$ A+ G

2.1.4、这步骤应该就是再次上锁，保护存储区不被重写覆盖了，直接使用官方的函数即可：FLASH_Lock();//上锁写保护

& W- r' a  b& f* ^5 B( P" s) ^

具体官方代码贴出如下

1. 1 /**
   , x, a" Y/ ~) i+ |6 h! k. c
2. 2   * @brief  Locks the FLASH Program Erase Controller.
   
3. 3   * @note   This function can be used for all STM32F10x devices.
   
4. 4   *         - For STM32F10X_XL devices this function Locks Bank1 and Bank2.
   * y* D' j5 l. f6 t+ b
5. 5   *         - For all other devices it Locks Bank1 and it is equivalent
   / I  j# G; o9 s; {
6. 6   *           to FLASH_LockBank1 function.
   
7. 7   * @param  None
   ( Y$ @; Z$ P/ s; f# {) ?8 H
8. 8   * @retval None
   
9. 9   */
   
10. 10 void FLASH_Lock(void)
    
11. 11 {
    
12. 12   /* Set the Lock Bit to lock the FPEC and the CR of  Bank1 */
    
13. 13   FLASH->CR |= CR_LOCK_Set;
    
14. 14
    ( u8 B6 d/ i$ e" n* K+ @
15. 15 #ifdef STM32F10X_XL
    6 w6 `2 v: y  |
16. 16   /* Set the Lock Bit to lock the FPEC and the CR of  Bank2 */
    - r4 u5 e! A0 l" g
17. 17   FLASH->CR2 |= CR_LOCK_Set;
    ' u: Y5 y4 \" S; \1 ]: I. i5 b& d
18. 18 #endif /* STM32F10X_XL */
    
19. 19 }

复制代码

7 q9 N1 l. y2 J% {

三、简单的小例程代码实现

( r" J# {% y% H  `' |! `

例子功能：

       1、将数据存储在stm32F105单片机的主存储区0x08036000地址开始的扇区，（0x08036000应该是该单片机大约108个扇区的开始地址位置即页108起始地址）。

: U0 i- a& {- x6 B0 A$ I- y

       2、将该单片机的页108（page108=0x08036000）处的数据再读出来;

具体实现代码如下，作为例子，只进行了半字的读写操作，我们写的数据buff为空，内容默认值为0

, H6 B4 i. P7 ~1 G6 Y/ e

1. 1 #include "stm32f10x_flash.h"
   
2. 2
   
3. 3 #define StartServerManageFlashAddress    ((u32)0x08036000)//读写起始地址（内部flash的主存储块地址从0x08036000开始）
   4 N: g; t, m' \$ i# A
4. 4
   
5. 5 //从指定地址开始写入多个数据
   
6. 6 void FLASH_WriteMoreData(uint32_t startAddress,uint16_t *writeData,uint16_t countToWrite)
   " p9 U8 X' q; o7 F8 w6 O! y2 F1 n
7. 7 {   
   
8. 8     uint32_t offsetAddress=startAddress - FLASH_BASE;               //计算去掉0X08000000后的实际偏移地址
   
9. 9   uint32_t sectorPosition=offsetAddress/SECTOR_SIZE;            //计算扇区地址，对于STM32F103VET6为0~255
   : L) @0 |) {/ j$ E  Y
10. 10   uint32_t sectorStartAddress=sectorPosition*SECTOR_SIZE+FLASH_BASE;    //对应扇区的首地址
    
11. 11     uint16_t dataIndex;
    0 {  B7 x: n+ O+ Q' J$ L
12. 12     
    / w" Z5 w6 f5 O) U! c: }) P  b1 G
13. 13   if(startAddress<FLASH_BASE||((startAddress+countToWrite*2)>=(FLASH_BASE + SECTOR_SIZE * FLASH_SIZE)))
    , L# C+ T4 a" c% o/ X% B
14. 14   {
    
15. 15     return;//非法地址
    
16. 16   }
    ' B( a2 ]5 Q0 e) p: O, l4 X
17. 17   FLASH_Unlock();         //解锁写保护
    
18. 18
    $ \6 Y$ C) U: x
19. 19   FLASH_ErasePage(sectorStartAddress);//擦除这个扇区
    3 W5 q9 D. a, S) z, Z
20. 20   
    8 S' [% j( C# q6 Q
21. 21   for(dataIndex=0;dataIndex<countToWrite;dataIndex++)
    
22. 22   {
    
23. 23     FLASH_ProgramHalfWord(startAddress+dataIndex*2,writeData[dataIndex]);
    ; H) Y, G4 t/ |) w5 H9 `4 ?& a
24. 24   }
      |# r5 T) D/ i3 s" i+ o
25. 25   
    1 M; U/ K( e0 k2 G! Q/ W6 M
26. 26   FLASH_Lock();//上锁写保护
    ( ]8 F5 i3 d- z/ i# t( D
27. 27 }
    
28. 28
    9 m6 t& d* j+ ]& B! m
29. 29 //读取指定地址的半字(16位数据)
    
30. 30 uint16_t FLASH_ReadHalfWord(uint32_t address)
    - H( X8 `# \, r2 j
31. 31 {
    7 a0 q9 F/ L4 v9 q
32. 32   return *(__IO uint16_t*)address;
    
33. 33 }
    
34. 34
    ' z2 }  Y% x0 b
35. 35 //从指定地址开始读取多个数据
    
36. 36 void FLASH_ReadMoreData(uint32_t startAddress,uint16_t *readData,uint16_t countToRead)
    
37. 37 {
    ; ~7 H- B& ?: S1 W. K3 B
38. 38   uint16_t dataIndex;
    
39. 39   for(dataIndex=0;dataIndex<countToRead;dataIndex++)
    
40. 40   {
    ; Z& x* x: b" N5 S
41. 41     readData[dataIndex]=FLASH_ReadHalfWord(startAddress+dataIndex*2);
      r+ S( k1 D7 d: C6 |. f
42. 42   }
    
43. 43 }
    ( [* R- F5 l. x- ^: O( ]2 [9 J
44. 44
    
45. 45 void write_to_flash(void)
    
46. 46 {
    " S! ?: P- t& `& H$ g# I. q' [. o+ H
47. 47     u16 buff[1200];
    
48. 48     u16 count_len = 2272 / 2;
    0 p1 _9 G' i0 }" E
49. 50     FLASH_WriteMoreData(StartServerManageFlashAddress,buff,count_len);
    
50. 55 }
    $ a" ]  {; G& n$ x: w
51. 56
    
52. 57 void read_from_flash(void)
    & y0 [. ?$ r& e9 l# R
53. 58 {
    * |: \: V* ?- F  F! p+ }$ ^- H; Z
54. 59     u16 buff[1200];
    
55. 60     u16 count_len = 2272 / 2;
    
56. 61     FLASH_WriteMoreData(StartServerManageFlashAddress,buff,count_len);
    . X, Q+ E* _' u
57. 66
    , Q  e. F) c" ?. ]
58. 67  }

复制代码

1. 1 void mian(void)
   
2. 2 {
   . V" s& p. V3 t( ?) Q: z
3. 3     .........//初始化其他外设
   ' K, p/ y* k( E" \+ g
4. 4     while(1)
   8 j& {& g) S0 F/ p* Y
5. 5     {
   
6. 6         ...........//其他外设执行函数
   6 Z! ]2 Z0 q" D! A" V# ]! B" F2 `- e
7. 7         if(满足条件真)//写数据操作
   
8. 8        ｛
   
9. 9             write_to_flash();
   ( |6 `0 \8 `8 U3 J; U0 L
10. 10         ｝
    
11. 11         else //读数据操作
      U. o! F/ o* T5 u) p0 K/ Y$ D: \: {
12. 12         {
    
13. 13             read_from_flash();
    ) n# J# }) O$ X/ n! z/ w! Z
14. 14         }
    * V) M1 M; V4 P
15. 15
    
16. 16     }
    % J/ [3 s0 U3 w1 b
17. 17  }

复制代码

四、附言

  a& U  w+ a. }) }9 I- v) a, i1 Z

值得的注意的是，我们读写的地址是0x08036000，读写方式是半字，这里地址空间对于stm32f105芯片来说是第108扇区，每个扇区2KB，stm32F105VC总共是256KB空间,128页。所以地址能取到0x08036000，像小中容量stm32f103单片机，64KB和128KB的主存储区地址都是到不了0x08036000，除非是stm32f103VE的256KB芯片的主存储快，0x08036000才是有效的存储地址，中小型这个地址都不是有效的主存储开地址

转载自：xqhrs232