STM32心得：FLASH闪存编程原理与实验

[复制链接]

STMCU小助手发布时间：2022-11-22 14:15

文章
文章封面:
文章简介:	STM32心得：FLASH闪存编程原理与实验

主要内容：
1） STM32 Flash操作介绍；
2）寄存器和库函数介绍；
3）相关实验代码解读。

实验功能：利用 STM32 内部的 FLASH 来实现类似I2C通讯实验的效果（参考I2C通讯实验），不过这次是将数据直接存放在STM32内部，而不是存放在W25Q128。
1. STM32 Flash操作介绍
1.1 STM32编程方式
1）在线编程（ICP,In-Circuit Programming）
通过JTAG/SWD协议（用JLINK或ST LINK下载程序）或者系统加载程序(Bootloader)下载用户应用程序（用串口下载）到微控制器中。
2）在程序中编程(IAP,In Application Programming)
通过任何一种通信接口(如IO端口,USB,CAN,UART,I2C,SPI等)下载程序或者应用数据到存储器中。也就是说，STM32允许用户在应用程序中重新烧写闪存存储器中的内容。然而，IAP需要至少有一部分程序已经使用ICP方式烧到闪存存储器中（Bootloader)（与系统加载程序的Bootloaer不同）。

1.2 闪存模块存储器组织
按照不同容量，存储器组织成32个1K字节/页（小容量），128个1K字节/页（中容量），256个2K字节/页（大容量）的主存储器和一些信息块等。战舰/精英板FLASH容量为512K，所以一共有256页（0-255）。

STM32的闪存模块由：主存储器、信息块和闪存存储器接口寄存器等3部分组成。
1）主存储器，该部分用来存放代码和数据常数（如const类型的数据）。对于大容量产品，其被划分为256页，每页2K字节。注意，小容量和中容量产品则每页只有1K字节。从上图可以看出主存储器的起始地址就是0X08000000， B0、B1都接GND的时候，就是从0X08000000开始运行代码的。
2）信息块，该部分分为2个小部分，其中启动程序代码（系统存储器），是用来存储ST自带的启动程序，用于串口下载代码，当B0接V3.3，B1接GND的时候，运行的就是这部分代码。用户选择字节，则一般用于配置写保护、读保护等功能。
3）闪存存储器接口寄存器，该部分用于控制闪存读写等，是整个闪存模块的控制机构。
对主存储器和信息块的写入由内嵌的闪存编程/擦除控制器(FPEC)管理。编程与擦除的高电压由内部产生。

1.3 Flash闪存的读取
内置闪存模块可以在通用地址空间直接寻址，任何32位数据的读操作都能访问闪存模块的内容并得到相应的数据。例如，我们要从地址addr，读取一个半字（半字为16位，1个字为32位），可以通过如下的语句读取：

data=*(vu16*)addr;

复制代码

将addr强制转换为vu16指针，然后取该指针所指向的地址的值，即得到了addr地址的值。类似的，将上面的vu16改为vu8，即可读取指定地址的一个字节。

1.4 Flash闪存的编程（写）和擦除操作
STM32的闪存编程是由FPEC（闪存编程和擦除控制器）模块处理的，这个模块包含7个32位寄存器，他们分别是：
1） FPEC键寄存器 (FLASH_KEYR)
其中FPEC总共有3个键值：RDPRT键=0X000000A5、KEY1=0X45670123、KEY2=0XCDEF89AB。
2）选择字节键寄存器 (FLASH_OPTKEYR)
3）闪存控制寄存器 (FLASH_CR)
4）闪存状态寄存器 (FLASH_SR)
5）闪存地址寄存器 (FLASH_AR)
6）选择字节寄存器 (FLASH_OBR)
7）写保护寄存器 (FLASH_WRPR)
( s, \' ^8 A2 v. z; u! Q
1.5 Flash编程注意事项
1.5.1 STM32复位后，FPEC模块是被保护的，不能写入FLASH_CR寄存器；通过写入特定的序列到FLASH_KEYR寄存器可以打开FPEC模块（即写入KEY1和KEY2），只有在写保护被解除后，我们才能操作相关寄存器。叫Unlock。键值不正确会产生总线错误。
1.5.2 STM32闪存的编程每次必须写入16位（不能单纯的写入8位数据！），当FLASH_CR寄存器的PG位为‘1’时，在一个闪存地址写入一个半字将启动一次编程。写入任何非半字的数据，FPEC都会产生总线错误。
1.5.3 在编程过程中(FALSH_SR的BSY位为‘1’)，任何读写闪存的操作都会使CPU暂停，直到此次闪存编程结束。
1.5.4 STM32的FLASH在编程的时候，也必须要求其写入地址的FLASH是被擦除了的（也就是其值必须是0XFFFF），否则无法写入，在FLASH_SR寄存器的PGERR位将得到一个警告。

1.6 STM32 Falsh编程过程
1.6.1 检查FLASH_CR的LOCK是否解锁，如果没有则先解锁；
1.6.2 检查FLASH_SR寄存器的BSY位，以确认没有其他正在进行的编程操作；
1.6.3 设置FLASH_CR寄存器的PG位为‘1’在指定的地址写入要编程的半字；
1.6.4 等待BSY位变为‘0’；
1.6.5 读出写入的地址并验证数据。

1.7 STM32 Flash擦除过程
STM32 FLASH编程的时候，要先判断所写地址是否被擦除了。闪存擦除分为两种：页擦除和整片擦除。
1.7.1 Flash页擦除过程
1）检查FLASH_CR的LOCK是否解锁，如果没有则先解锁；
2）检查FLASH_SR寄存器的BSY位，以确认没有其他正在进行的闪存操作；
3）设置FLASH_CR寄存器的PER位为‘1’；
4）用FLASH_AR寄存器选择要擦除的页；
5）设置FLASH_CR寄存器的STRT位为‘1’；
6）等待BSY位变为‘0’；
7）读出被擦除的页并做验证。
1.7.2 Flash整片擦除过程
1）检查FLASH_SR寄存器的BSY位，以确定没有其他操作在进行；
2）设置FLASH_CR寄存器的MER为1；
3）设置FLASH_CR寄存器的STRT为1；
4）等待BSY为0；
5）读出所有页并验证。

1.8 Flash操作相关寄存器
1） FPEC键寄存器（FLASH_KEYR)；

2）闪存控制寄存器（FLASH_CR)；

3）闪存状态寄存器（FLASH_SR)；

4）闪存地址寄存器（FLASH_AR)。

1.9 相关库函数
官方给出的库函数位于：stm32f10x_flash.c/stm32f10x_flash.h。

1.9.1 闪存操作常用库函数

void FLASH_Unlock(void); //检查 FLASH_CR寄存器的LOCK位//! i: U4 D$ V/ j% h
void FLASH_Lock(void); //检查 FLASH_CR寄存器的LOCK位//
! R4 H) x/ M1 b. U
FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data); //对主存储区编程//
5 n8 P( R& a" y
FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data); //对主存储区编程//0 _% R# `# `; l5 X$ j
FLASH_Status FLASH_ProgramOptionByteData(uint32_t Address, uint8_t Data);; e4 T; J2 i) d& J6 w* j* }
FLASH_Status FLASH_ErasePage(uint32_t Page_Address); //对FLASH_AR寄存器进行操作//
) j' _6 P; w5 c$ I
FLASH_Status FLASH_EraseAllPages(void);3 ]1 a8 y5 ?7 Z* S* w
FLASH_Status FLASH_EraseOptionBytes(void);
$ y; ^( t/ i) r8 c
FLASH_Status FLASH_GetStatus(void);
9 O/ H1 | B" ]/ _% ]
FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout); //等待FLASH_SR寄存器的BSY位变0//

复制代码

1.10 Flash操作总结
1.10.1 锁定解锁函数
在对FLASH进行写操作前必须先解锁，解锁操作也就是必须在FLASH_KEYR寄存器写入特定的序列（KEY1和KEY2）,固件库函数实现：

void FLASH_Unlock(void);

复制代码

同理，在对FLASH写操作完成之后，我们要锁定FLASH：

void FLASH_Lock(void);

复制代码

1.10.2 写操作函数
固件库提供了三个FLASH写函数：

FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data);
- P& f* I3 u+ N. ?0 k! b9 ^
FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);
r7 u& I! @3 Q2 g! p
FLASH_Status FLASH_ProgramOptionByteData(uint32_t Address, uint8_t Data);

复制代码

顾名思义：FLASH_ProgramWord为 32位字写入函数，其他分别为16位半字写入和用户选择字节写入函数。这里需要说明，32位字节写入实际上是写入的两次16位数据，写完第一次后地址+2，这与我们前面讲解的STM32闪存的编程每次必须写入16位并不矛盾。写入8位实际也是占用的两个地址了，跟写入16位基本上没啥区别。

1.10.3 擦除函数
固件库提供三个FLASH擦除函数：

FLASH_Status FLASH_ErasePage(uint32_t Page_Address);
/ m& i, ]- S% ]& A: Y
FLASH_Status FLASH_EraseAllPages(void);
, _6 V" S- N* r1 W
FLASH_Status FLASH_EraseOptionBytes(void);

复制代码

顾名思义：第一个函数是页擦除函数，根据页地址擦除特定的页数据，第二个函数是擦除所有的页数据，第三个函数是擦除用户选择字节数据。这三个函数使用非常简单。

1.10.4 获取状态函数
主要是用的函数是：

FLASH_Status FLASH_GetStatus(void)；

复制代码

返回值是通过枚举类型定义的：

typedef enum, D$ B& d) ~# r
{
5 V) m3 V9 Y w5 K( ]/ f
FLASH_BUSY = 1, //忙
* X& o3 ~/ ^# P/ R5 \* C: y
FLASH_ERROR_PG, //编程错误! ~: ~7 T f$ z% q% s
FLASH_ERROR_WRP, //写保护错误
! `! A" l0 _% ^
FLASH_COMPLETE, //操作完成5 N2 k% N0 x- m3 i# `5 d" k
FLASH_TIMEOUT //操作超时
3 d$ K' S+ N, E$ d* e
}FLASH_Status;

复制代码

1.10.5 等待操作完成函数
在执行闪存写操作时，任何对闪存的读操作都会锁住总线，在写操作完成后读操作才能正确地进行；既在进行写或擦除操作时，不能进行代码或数据的读取操作。所以在每次操作之前，我们都要等待上一次操作完成这次操作才能开始。使用的函数是：

FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout)；

复制代码

入口参数为等待时间，返回值是FLASH的状态，这个很容易理解，这个函数本身我们在固件库中使用得不多，但是在固件库函数体中间可以多次看到。

1.10.6 读FLASH特定地址数据函数
有写就必定有读，而读取FLASH指定地址的半字的函数固件库并没有给出来，这里我们自己写的一个函数：

u16 STMFLASH_ReadHalfWord(u32 faddr)
# k" x1 ^' T: R( Z% C+ Z
{9 M4 M1 e- e/ G" C: {+ T4 f
return *(vu16*)faddr; - x& g7 {2 S8 ^
}

复制代码

2. 相关实验代码解读, I! W+ h, k+ T# ?! y% X" F
2.1 stmflash.h头文件代码解读

/**) s# v' b1 }: \1 D
******************************** STM32F10x *********************************
/ }$ V6 u9 Y" V$ D) u
* @文件名称： STMFLASH.h3 R+ o# v$ ?) ]$ j
* @作者名称： -----! |/ w; m( s) y4 H! n2 k. x* ~& H
* @库版本号： V3.5.0
: Y8 @( w2 ?- U
* @工程版本： V1.0.0
, K6 @/ d7 n" b/ g2 t8 B
* @开发日期： 2020年9月15日
; G0 e+ v T- n$ f, L- z9 Z
* @摘要简述： STMFLASH头文件; g' ?8 c$ F) J5 P! @
******************************************************************************/9 O" p# O4 h) L" ^
/*----------------------------------------------------------------------------/ |8 `' p9 R( j" g9 y; V- R
* @更新日志：* I b2 ~ E; | k6 Q2 B1 R
* @无
9 F/ d' m9 ?& x: Y, t' d2 j
* ---------------------------------------------------------------------------*/
) D0 j3 ?# c) |1 z
#ifndef __STMFLASH_H__: x; n; h$ e X R/ e
#define __STMFLASH_H__
5 k$ I, l1 S) n, ]) `6 h
/* 包含的头文件 ---------------------------------------------------------------*/: w: l: n" ~" L0 V$ r& C
#include "stm32f10x.h"2 n' P! a8 ~# `0 @+ r' A
/* 常量 ----------------------------------------------------------------------*/
1 H/ D6 s: v3 J, k
#define STM32_FLASH_SIZE 512 /* STM32F103ZET6的FLASH是512K */
- o1 @& ~7 m) W3 i3 s+ }" t
#define STM32_FLASH_WREN 1 /* 使能FLASH写入(0，不是能;1，使能) */8 `2 A" G' v! }% Z& k6 H
#define STM32_FLASH_BASE 0x08000000 /* STM32 FLASH的起始地址 */; C5 I( _' q( l; G, w F- o6 L2 S
/* 函数申明 ------------------------------------------------------------------*/) W: m* [( K9 w# g0 @/ V" P
u16 STMFLASH_ReadHalfWord(u32 faddr); /* 读出半字 */
) C k- t0 u; E1 A- x W
u32 STMFLASH_ReadLenByte(u32 ReadAddr,u16 Len); /* 指定地址开始读取指定长度数据 */0 O# A' V z9 \ `1 @, R
void STMFLASH_WriteLenByte(u32 WriteAddr,u32 DataToWrite,u16 Len); /* 指定地址开始写入指定长度的数据 */
1 X, h8 q4 D( x
void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite); /* 从指定地址开始写入指定长度的数据 */
( B8 M- N- J3 L1 W, b
void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead); /* 从指定地址开始读出指定长度的数据 */ Q# r r( x0 [5 |/ A
#endif /* __STMFLASH_H */
/ @8 E& B/ F9 Q

复制代码

2.2 stmflash.c文件代码解读

/**( ?8 u0 X- R. B
******************************** STM32F10x *********************************! n0 q( R1 }$ H9 v
* @文件名称： stmflash.c( ~$ w: q8 F' e
* @作者名称： -----
6 e6 n7 n. f) N w" y# w( a
* @库版本号： V3.5.0
' Z) F% R; o. U, r1 b$ A
* @工程版本： V1.0.0& \/ \- f$ J7 U p
* @开发日期： 2020年9月15日
! b! @! j6 x6 d+ s" v
* @摘要简述： stmflash源文件4 w# F$ k3 H# D5 m- K) O
******************************************************************************/" U; o {& p! b
/*----------------------------------------------------------------------------- p' R9 M( t* X
* @更新日志：
. S0 y& g: W' e' r. t4 L4 K+ b' `
* @无4 M" t. T1 }( Q/ C
* ---------------------------------------------------------------------------*/
) k; z2 a# c/ S+ M( {! v" U2 R
/* 包含的头文件 ---------------------------------------------------------------*/
% E* J8 t2 s0 u- w4 J
#include "stmflash.h"8 {% t: n5 Q0 a1 Q
#include "delay.h"7 V& N0 ` x( l5 H
#include "usart.h" r8 X2 ?9 W3 g' Y1 _9 X* y
/************************************************: _5 j; I$ w' u: }5 M
函数名称：u16 STMFLASH_ReadHalfWord(u32 faddr)
# i# h; t+ T+ C. b) h& j' T
函数功能：读取指定地址的半字(16位数据)" T7 N( z2 B4 a2 O2 R e
入口参数：u32 faddr:读地址(此地址必须为2的倍数!!)3 e: Z0 N1 G$ t% f8 V, {
返回参数：对应数据
/ O+ F" E% B5 M3 ~& Y% R$ N
开发作者：-----0 W+ m7 F: r s/ h9 C
*************************************************/2 _8 l2 W4 N; w' t' v1 Z: `- V. q& F
u16 STMFLASH_ReadHalfWord(u32 faddr)
. b+ b# Y5 B" d' k3 l* k- |
{
# t( ]- t2 K1 o! t9 K! P
return *(vu16*)faddr;
, `3 [8 b4 e, |7 p. Z) r& {# i. U
}, i! ]+ f' R. l+ m9 G
#if STM32_FLASH_WREN /* 如何使能写入，默认使能 */ 8 W5 X9 X% `7 S, h! `* h A( g- y
/***************************************************************************% E7 ?/ m: g) D/ {/ X6 ?
函数名称：STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite) 3 ]4 H1 I" o% h& h0 H
函数功能：不检查的写入
/ d; C" ?" f* _
入口参数：WriteAddr:起始地址；pBuffer:数据指针；NumToWrite:半字(16位)数
2 g2 w; n y; L8 |" B+ I( g
返回参数：无1 [" Y8 }9 U, D: I9 M' N8 N
开发作者：-----
1 R+ p# }6 F0 g1 ^9 }& H9 h2 C3 S w
****************************************************************************/& Y* Y, I9 V7 @: @% X- X
void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite) 5 Q& B# D: `( C* ~& m' V, k' V& n3 D
{
# t: }2 L8 c1 O& T
u16 i;
$ [! Y2 A! p$ Y
for(i=0;i<NumToWrite;i++)
U! M1 O' ?$ a: w2 p
{
5 p. Z7 L- r. _
FLASH_ProgramHalfWord(WriteAddr,pBuffer); W5 `; q0 z/ ~. U6 U X- B
WriteAddr+=2; /* 地址增加2 */
x1 t \0 {! U- Z5 m* m
}
& ^( x( A# V4 W; Z6 n8 l. i" ^
} : x! y7 y! F' e0 E
/***************************************************************************9 E" V1 i# i n6 d9 _
函数名称：STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)
; \, Z) J2 B4 _5 v( [7 Y( m
函数功能：从指定地址开始写入指定长度的数据0 U3 W* ~/ F! @. u
入口参数：WriteAddr:起始地址(此地址必须为2的倍数!!)；/ o1 G4 s4 i: Y7 P0 M- n
pBuffer:数据指针；
, g* }. H5 n4 v {$ m
NumToWrite:半字(16位)数(就是要写入的16位数据的个数.), w% P/ H1 n7 g. [: r1 s9 p" q
返回参数：无
2 C' u7 ]: `0 J- ]
开发作者：-----
. x) k: X; i1 G; o* ]; K
****************************************************************************/( ]% Y l9 N8 ^0 e# Q" Y5 ?2 q: _
#if STM32_FLASH_SIZE<256* M4 \, a8 I- B8 O# i9 R
#define STM_SECTOR_SIZE 1024 /* 字节 */# s& G& ]- f Q- w& }( `6 p
#else
: b* @7 ]' a# o4 a
#define STM_SECTOR_SIZE 2048
2 M" t$ F, G7 Q5 a' ^) Q& z
#endif
2 `+ b- i, s4 N3 c; A
u16 STMFLASH_BUF[STM_SECTOR_SIZE/2]; /* 最多是2K字节 */
( T! U, W1 O' L: C0 \, x& |
void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)
: L6 C: ?9 O# I8 w' i. `* `1 O
{: F8 i; G: U% v, `
u32 secpos; /* 扇区地址 */
9 b* D4 D' S) Y
u16 secoff; /* 扇区内偏移地址(16位字计算) */! O5 X+ f' u( t* ^/ m4 `; x
u16 secremain; /* 扇区内剩余地址(16位字计算) */
$ f' i. B4 l( q f8 ~/ F& }) p: \
u16 i; 1 @9 J; n- v- h# j
u32 offaddr; /* 去掉0X08000000后的地址 */% Z- |4 {& t; B" R1 j, S
if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return; /* 非法地址 */
+ g; {5 @0 p' Y( F6 a
FLASH_Unlock(); /* 解锁 */ q' C0 P: y5 B# w7 m
offaddr=WriteAddr-STM32_FLASH_BASE; /* 实际偏移地址 */ z; P" X [+ i
secpos=offaddr/STM_SECTOR_SIZE; /* 扇区地址 0~127 for STM32F103RBT6 */8 ]6 @) K$ F; ^
secoff=(offaddr%STM_SECTOR_SIZE)/2; /* 在扇区内的偏移(2个字节为基本单位.) */
* }' Y. z2 [4 K$ H
secremain=STM_SECTOR_SIZE/2-secoff; /* 扇区剩余空间大小 */ 5 R% M+ P2 L6 f$ S
if(NumToWrite<=secremain)secremain=NumToWrite; /* 不大于该扇区范围 */3 v1 `$ I$ D) J( I4 f, r
while(1) 9 r2 r. P) W( M
{ 5 E1 R/ c7 S# q! C) i
STMFLASH_Read(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2); /* 读出整个扇区的内容 */
! u# l$ H' q- _, Y
for(i=0;i<secremain;i++) /* 校验数据 */& u+ m6 Z ?9 _8 o4 A1 ~( d8 U* b
{
! _: A/ b3 _ c1 H5 i8 D
if(STMFLASH_BUF[secoff+i]!=0XFFFF)break; /* 需要擦除 */
" h. F2 q7 r! z- q" B
}/ N9 _7 E/ @7 o2 ~. Y0 o$ a
if(i<secremain) /* 需要擦除 */
, k% @2 ]( p: O3 D# `' x! R
{3 q, ~9 p6 h1 {6 H) M4 ]1 S4 N# ?8 X
FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE); /* 擦除这个扇区 */
( |. P2 H( v8 b8 u
for(i=0;i<secremain;i++) /* 复制 */
7 m2 P7 K9 n) f5 `
{; v( @0 Q. V+ x3 y% N- o' X. N
STMFLASH_BUF[i+secoff]=pBuffer; : i( t7 \, m7 ]3 ?9 l" S; Q6 T
}4 V8 S, K7 V! N0 a* f
STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2); /* 写入整个扇区 */
; G% J* U" h6 b
}else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain); /* 写已经擦除了的,直接写入扇区剩余区间 */ 6 R# w0 `$ U* r; {9 `6 o
if(NumToWrite==secremain)break; /* 写入结束了 */$ f; n+ `. T- U! R
else /* 写入未结束 */% m! o! Y. |" ^$ c9 o& a9 H) e
{$ F5 E! `3 w; h. e
secpos++; /* 扇区地址增1 */2 S a) O: J! O
secoff=0; /* 偏移位置为0 */ ! f: Y* v# e$ }* Q/ ^- L( w
pBuffer+=secremain; /* 指针偏移 */
$ t2 L6 {- s1 m
WriteAddr+=secremain; /* 写地址偏移 */ $ A# ~3 v% S0 X! `* G: N
NumToWrite-=secremain; /* 字节(16位)数递减 */
7 M: P, `% k7 }9 c8 }: S
if(NumToWrite>(STM_SECTOR_SIZE/2))secremain=STM_SECTOR_SIZE/2; /* 下一个扇区还是写不完 */
' I% _' G" v9 c1 Y [- i
else secremain=NumToWrite; /* 下一个扇区可以写完了 */
/ R5 U, Z) G! ]; K) K8 O8 E, ^) _
} # ~1 J9 O9 K* O* J
};
0 R/ K8 q# b0 W2 ~ y: }) k$ ~
FLASH_Lock(); /* 上锁 */
; m" w+ O1 E ~+ _
}
, }( C/ E8 x$ ^$ O
#endif( O2 t" d& E3 j/ C
/******************************************************************************
+ K; \2 l7 |6 F4 z9 X3 ?
函数名称：STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)
8 Q! \3 E' K$ A+ \
函数功能：从指定地址开始读出指定长度的数据
2 `% z4 ^4 k' n
入口参数：ReadAddr:起始地址；pBuffer:数据指针；NumToWrite:半字(16位)数' `. x. P4 E- }2 r, Y/ }% K |
返回参数：无7 \$ D% ~+ M3 _% G
开发作者：-----
$ k- K6 z4 c' \# D0 s8 J( L1 c
*******************************************************************************/
- v) |/ V" G( L
void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead) # \8 u- ^2 Z; ]6 m- z8 ^+ ~* |1 e
{
5 H; J0 w6 b) [* r* I p' v3 L" V' o
u16 i;
8 r0 C0 e$ d2 M) F4 k$ x1 y* L
for(i=0;i<NumToRead;i++)# L2 s' e: l U8 k- n
{
1 L- J4 N5 l6 }
pBuffer=STMFLASH_ReadHalfWord(ReadAddr); /* 读取2个字节 */
1 ?1 a \8 M9 ~* x
ReadAddr+=2; /* 偏移2个字节 */7 j4 e* t' l4 S6 S- D
}
7 U/ M) E8 L/ K( K5 q9 G$ u; p
}
! J6 d9 @8 ^( h0 y2 W" K

复制代码

2.3 main.c文件代码解读

/**
- _) X7 a: Y; ~4 b7 i
******************************** STM32F10x *********************************/ s( g' u! w( {. B$ l- F; K
* @文件名称： main.c
% K7 T* m: B- }# w
* @作者名称： -----9 I- W- p) ^: b/ Y7 L$ |, A5 b
* @库版本号： V3.5.0
" a- _, g# K1 L) X" i9 {
* @工程版本： V1.0.0
6 T& m W& K) Y% U/ D
* @开发日期： 2020年9月15日
) r0 c* l+ v+ @
* @摘要简述： main源文件
! o8 |. w3 h @4 f/ X/ c6 K% B3 G
******************************************************************************/1 L' t: s6 W" O' s" ]) B" S% T
/*-----------------------------------------------------------------------------2 H3 h/ e Q% ~% C3 X) J O8 U* S; ~
* @更新日志：% J$ X2 y% w' V2 Z$ r
* @无
" d8 g0 Y) S& b1 d+ S
* ---------------------------------------------------------------------------*/* A8 s& m4 O' Y. o& S8 X, ?
/* 包含的头文件 ---------------------------------------------------------------*/
# F I" L: y$ b+ ~ _9 t8 D
#include "led.h"
3 ?( P9 B- Z, a) D1 q D
#include "key.h"
2 q' h3 J% y- d$ W3 h. Q4 @
#include "delay.h"
7 U% \, p; b; l8 p. M* v" x2 ?
#include "usart.h" , U( H3 b5 {: ?7 B
#include "stmflash.h"% o! x9 a, s6 Z, l2 \, I# q! Q% B
/* 包含的头文件 ---------------------------------------------------------------*/
+ J% [0 K* _0 j% \0 r" G
const u8 TEXT_Buffer[]={"STM32F103 FLASH TEST"}; /* 要写入到STM32 FLASH的字符串数组 */! A k' l* n! y5 g3 \! K; ]5 |! {# E
#define SIZE sizeof(TEXT_Buffer) /* 数组长度 */- B$ n: A d, Y& F5 J& o: [: q
#define FLASH_SAVE_ADDR 0X08070000 /* 设置FLASH保存地址(必须为偶数，且其值要大于本代码所占用FLASH的大小+0X08000000) */
4 i& c5 b( w+ S! ]
/****************************************************************5 {3 `. L( q f7 G0 }
函数名称：int main()
" C4 n5 G3 Z$ i7 q/ Q
函数功能：主函数+ U4 h! E# e2 x0 N/ k) P% C$ m4 w
入口参数：无
- y5 v) M1 ?& F" S% h4 K
返回参数：int
; v( n5 H, I; o o% A
开发作者：-----5 U! K( N! e2 v5 [$ o$ e9 A% H6 h1 V
*****************************************************************/
: D# ^* Z% A8 z, [2 | ]2 \
int main(void)
' g$ K' v+ V% c g; ~
{
& B! w( }6 E1 m( z4 Y
u8 key;4 O9 Y9 }8 t: P7 b
u16 i=0;
8 ]6 p' C) e4 V' A
u8 datatemp[SIZE];( c2 j2 O, J+ H0 ? _- \! _
delay_init(); /* 延时函数初始化 */ " J8 x* X- A6 h! [% s5 M- |, @
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); /* 设置中断优先级分组为组2：2位抢占优先级，2位响应优先级 */
9 P7 g& J" ^" x6 w+ t( C
uart_init(115200); /* 串口初始化为115200 */
# [. I. O3 ]" U6 J( M9 I
LED_Init(); /* 初始化LED管脚接口 */
' B; o) l7 B6 p" D3 B
KEY_Init(); /* 初始化KEY管脚接口 */3 |5 Q/ @. U7 W/ T8 @4 o
printf("KEY1:Write KEY0:Read");
9 t9 S/ u+ {8 n8 w* h- z
while(1)
A% q* H, R r2 c7 d" C
{8 [ G, F# N+ Y
key=KEY_Scan(0); /* 0表示不支持连按 */6 Z( x0 C& I+ w9 X8 U! N8 w
if(key==KEY1_PRES) /* KEY1按下,写入STM32 FLASH */3 {$ p$ o* ~* V/ O% T
{
# f9 `4 d8 P2 R/ Z/ u! Q
printf("Start Write FLASH....\r\n");
" ]6 ]4 _+ z" Y
STMFLASH_Write(FLASH_SAVE_ADDR,(u16*)TEXT_Buffer,SIZE);, i2 j+ h2 w6 ~, n! ?. T+ q
printf("FLASH Write Finished!\r\n"); /* 提示传送完成 */6 c" W% _, w& `: _5 [/ ]( V; {
}
0 \9 @9 y; ^+ _4 I# E
if(key==KEY0_PRES) /* KEY0按下,读取字符串并显示 */
/ I" l+ v. J7 t1 N) X' S
{" D9 D$ e6 v2 Q4 X2 H1 k
printf("Start Read FLASH....\r\n");
4 Y, s$ d& B, R! w4 g( \5 x
STMFLASH_Read(FLASH_SAVE_ADDR,(u16*)datatemp,SIZE); W9 J% B6 |$ ^
printf("The Data Readed Is:%s\r\n",datatemp); /* 提示传送完成 */
) C/ h b/ x6 F2 @; R0 R: h
}; A3 b0 A9 z: s3 H% t9 c
i++;
# ]1 A: U" a% R
delay_ms(10); 0 Y; Y4 k) [; |. H) H! S u z
if(i==20)% z3 @; E6 e$ n
{
! P, h+ J7 ~. @% @/ b
LED0=!LED0; /* 提示系统正在运行 */, [/ Q+ P- L9 w+ q" W, i
i=0;
( q% t6 M$ Z/ ~; S7 _
}
$ c& e1 n/ G# ]5 b5 R6 C. b3 y6 G
} 4 l( B! d% x2 V9 s
}, ?& b4 T. P5 C3 Z. [5 l7 M2 M