70.1 初学者重要提示
  r4 G, L8 [; d9 X% E  本章2.5小节里面的Flash三级读保护是重点，务必要掌握明白。
6 R+ d( D* v7 c! w  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是如果用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，用户应用程序将停止运行，包括中断服务程序。
  STM32H7的两个Flash BANK是256bit带宽，CPU访问是采用的两个64bit AXI总线。
  HAL库的内部Flash编程函数HAL_FLASH_Program固定编写32字节数据。
9 E$ G0 m9 @. i( W) u  o* D  ]70.2 内部Flash基础知识
7 C" K; a' ]0 M2 V4 E* Z! R70.2.1 内部Flash的硬件框图
1 V4 E+ @: o0 F+ Z6 w/ F: N& y# l认识一个外设，最好的方式就是看它的框图，方便我们快速的了解内部Flash的基本功能，然后再看手册了解细节。

: w, w6 ~; a* y0 m' u
" r+ x- N* W9 ]/ ~: v通过这个框图，我们可以得到如下信息：
# m2 x0 G3 `: g0 }. z# [
  sys_ck时钟输入
" Y' G. x1 q; `; I% L+ }D1域总线时钟。
. ]% z) ~# M7 v
  po_rst输入
1 p) e% c/ ^/ u. m. o" E) I( |% d& yPower on reset 上电复位。

  d1_rst输入
D1域系统复位。
# ^9 ^, T3 B) h" q/ X* n  ^
3 u6 `/ w2 Y1 w% a3 W8 i0 c8 O! J  flash_it输出
/ v- e* Z& d2 T3 \6 [flash中断请求输出。
( p  i  {- [2 @" v0 h  n
STM32H7的两个Flash BANK是独立的，读写和擦除互补影响，256bit带宽，CPU访问是采用的两个64bit AXI总线。
6 L0 T, ?2 F& t& E# n
# R1 w( b' F5 m" ]9 W3 M6 K70.2.2 内部Flash框架
( V8 o( a- x5 W( D关于内部Flash的框架，了解以下几个知识点即可：
& `" M8 G0 V7 a1 ?) m! ~
% p& g6 b( L- I+ E# e) S  256bit为单位，即32字节，并且每个单位配10bit的ECC校验位。正是这个原因要求大家对Flash进行编程时，必须以32字节为单位。
  两个独立的BANK，每个BANK有1MB容量。并且每个BANK的扇区大小固定为128KB，即8个扇区。
: i  F. w& x" T5 I: S9 G# d5 Q

; W0 W) u2 h+ ~* l; w1 m
& t2 Q* u" H( oBANK1的地址范围：0x0800 0000到0x080F FFFF。
) D) D2 D4 ~4 G, q0 \2 L9 ~. W
BANK2的地址范围：0x0810 0000到0x081F FFFF。
6 f: g" V- t( u' `
70.2.3 内部Flash读操作
STM32H7的内部Flash读操作跟内部RAM的读操作是一样的，支持64bit，32bit，16bt和8bit，使用比较简单。这里我们重点普及一个知识点，H7的内部Flash在不同主频下需要做的延迟参数：
6 d5 k! B9 l$ H* T/ j: o% Y

对于上面的表格，大家可以看到，当延迟等待设置为0的时候，即无等待，单周期访问，速度可以做到70MHz。增加1个Flash周期后，访问速度可以做到140MHz。当增加到3个或4个Flash周期后，最高速度可以做到225MHz。
$ D: R" ~# \- p$ [6 g6 u
. j: P2 m& W8 K, u了解了这个知识点后，再来看下面的时序，非常具有参考意义：

) |# b9 i7 }1 U$ H3 q8 ^注：ACLK、ARADDR、ARVALID、RDATA、RVALID 和RLAST是AXI总线信号。Flash读和Flash数据是 Flash 接口信号。
: x4 E& g& [2 X5 z( Y  q; S
) j6 V. W$ E& q, Q6 s' k

; N; `/ R; X2 J0 N+ Q9 _
关于这个时序要要认识到以下几点：
8 \9 L9 k5 D- f+ V/ [7 L
6 B' E0 U# x* P5 u" F  n+ P) [# `  AXI总线发起读取信号后，Flash端等待了3个时钟周期（注意延迟三个周期，支持的Flash速度），之后连续读取了4个64bit数据。
1 g( g& W; O& r+ t" y) v+ z$ |  由于AXI总线是64bit的，所以1次读取就可以读出64bit数据，连续读取4次后，就是256bit，即Flash接口的一组数据，因为H7的Flash接口带宽是256bit的。
& G; E1 I9 R2 V# u7 U9 g; x  如果不开Flash Cache的情况下，连续读可以提升性能。

下面是连续读取8个64bit数据的时序图，跟连续读取4个64bit数据基本是一样的，只是多读取了4组数据。
1 i9 x9 }5 H% |( {$ i7 {

. ]4 z& V) ]! f' x
70.2.4 内部Flash写入和擦除操作
最重要的知识点放在开头说：STM32H7内部Flash的写操作地址必须是32字节对齐（此地址对32求余数为0），写入的数据量也必须是32字节整数倍，不足32字节整数倍，补0也要是整数倍。
# k/ V# e+ @- V  G* b! {/ S
  q0 a* B9 r, R& q4 g/ M, \9 c这里我们重点了解Flash的写入和擦除流程。Flash的写入扇区流程如下：

& M9 _, L& N( A8 P. {先保证这块扇区空间之前已经擦除过了。
( Y% f' R6 _7 m+ g" Z( v4 q( k解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
检查是否写保护，使能Flash可以编程，然后对其进行编程操作，编程完毕后，等待编程完成，然后禁止Flash编程位。具体操作可以通过HAL库的函数HAL_FLASH_Program实现。
# Y" A* k6 `# J/ D8 U
+ C# e) R6 X7 P% D/ `( TFlash的擦除流程如下：
# `6 L$ g' W' o, Q& O  G: |解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
如果是BANK1或者BANK2需要擦除，调用函数FLASH_MassErase，然后等待擦除完成，完成之后关闭BANK1和BANK2的擦除请求位BER1/BER2
如果是扇区擦除，调用函数FLASH_Erase_Sector，然后等待擦除完成，完成之后关闭扇区的擦除请求位SER。
: t( `3 r; Z+ z. D% H5 \
2 U# F1 Y! s# m- p( p! E
70.2.5 内部Flash读保护
内部Flash支持三级读保护RDP（read out protection）。

- F3 M1 G  U+ B  Level 0（无保护）
默认设置，所有读写和擦除操作都可以正常支持。
3 I7 K5 N( y; p7 T1 o1 q# k
5 |0 k- b1 l& S( X0 V: Y, X  Level 1 （Flash连接保护）
  可以防止连接调试器时读取Flash内容，或者RAM中存有恶意获取代码，也是禁止的。因此只要调试器连接芯片，或者从内部RAM启动运行代码，都是禁止访问内部Flash的。
; f% `- Z( ^! ^) `) W  如果没有检测到从内部RAM启动和系统bootloader启动且没有连接调试器，对用户Flash的读写和擦除操作都是允许的，并且其它安全存储区也是可以访问的。否则是禁止访问的，一旦检测到对Flash的读请求，将产生总线错误。
2 a2 \. U1 E6 O+ S/ u3 f- }  如果将Level 1切换到Level 0时，用户Flash区和安全区域将被擦除。
+ {5 `! k8 {" e# V
+ Y1 P7 q4 Y  H+ W; t: B1 d Level 2（设备保护和自举保护）
# b. P3 h, |( q" N, p  所有调试特性被关闭。
5 R9 v1 I8 K6 `' [: _& N  禁止从RAM启动。
  除了选项字节里面的SWAP位可以配置，其它位都无法更改。
5 P& U% j- `6 r+ L& O$ k; U6 W& p  禁止了调试功能，且禁止了从RAM和系统bootloader启动，用户Flash区是可以执行读写和擦除操作的，访问其它安全存储区也是可以的。

) g  R* G# K& @/ s, X# ^  _特别注意：Level2修改是永久性的，一旦配置为Level2将不再支持被修改。

如果大家要设置读保护的话，使用HAL的API可以设置，也可以使用STM32CubeProg设置：
1 s. ?* o+ P* G4 j2 d, c
+ w! G9 ]8 x. q3 z

. f7 I1 K" d' E( R" a; U4 H" H, c
70.2.6 内部Flash选项字节
/ L0 _  @. }- B' J( E" zFlash选项字节主要用于boot地址设置，安全保护，Flash扇区保护等，涉及到的选项比较多。如果大家打算了解这一部分的话，使用STM32CubeProg进行设置即可，也比较方便。
- i: f. m# f4 q+ a, T7 {
8 s* U- {" T% E1 r4 v

# V( [+ V7 j0 u" H* G; C70.2.7 内部Flash的ECC校验
这里先说下为什么内部Flash要带ECC校验，因为随着芯片的制造工艺水平越高，带电粒子产生的位翻转就越多，此时的ECC是必须要有的，一般可以纠正1-2个bit，安全等级高的Flash类存储器和RAM类都是必须要带ECC的。
/ e# m- [. F+ }$ l5 s
对于STM32H7带的ECC校验，一般不需要用户去管理。

70.3 内部Flash的HAL库用法
70.3.1 内部Flash结构体FLASH_TypeDef
内部Flash相关的寄存器是通过HAL库中的结构体FLASH_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
5 i6 l, Q/ `* V4 f& Q% z$ U8 j" i

1. typedef struct
   % D8 j7 ?  M1 c5 d' `
2. {
   - i7 B; Y! |% N( k. i
3.   __IO uint32_t ACR;            
   
4.   __IO uint32_t KEYR1;           
   / V3 P4 v8 c4 [* h; ~1 P
5.   __IO uint32_t OPTKEYR;         
   
6.   __IO uint32_t CR1;            
   
7.   __IO uint32_t SR1;            
   
8.   __IO uint32_t CCR1;         
   ( n; o+ Q/ g4 a
9.   __IO uint32_t OPTCR;           
   
10.   __IO uint32_t OPTSR_CUR;      
    
11.   __IO uint32_t OPTSR_PRG;      
    / N; o. ]0 o3 O
12.   __IO uint32_t OPTCCR;         
    / u& x- q% {7 K1 a2 o
13.   __IO uint32_t PRAR_CUR1;      
    
14.   __IO uint32_t PRAR_PRG1;      
    
15.   __IO uint32_t SCAR_CUR1;      
    
16.   __IO uint32_t SCAR_PRG1;      
    
17.   __IO uint32_t WPSN_CUR1;      
    
18.   __IO uint32_t WPSN_PRG1;      
    4 q2 I# x7 B# J, d8 H
19.   __IO uint32_t BOOT_CUR;      
    
20.   __IO uint32_t BOOT_PRG;      
    
21.   uint32_t      RESERVED0[2];   
    & w# }) K7 Q% T5 B* f$ P
22.   __IO uint32_t CRCCR1;         
    " }1 m$ k1 _6 p7 e4 G8 n
23.   __IO uint32_t CRCSADD1;      
    
24.   __IO uint32_t CRCEADD1;        
    ! U) K  Z6 b- G# G. x! e. o6 ]
25.   __IO uint32_t CRCDATA;         
    & T) Z/ n$ w; N* O( _
26.   __IO uint32_t ECC_FA1;         
    ( b' h& X+ H( c/ J: L
27.   uint32_t      RESERVED1[40];  
    / C- o& G1 d& z4 W- s
28.   __IO uint32_t KEYR2;           
    
29.   uint32_t      RESERVED2;      
    
30.   __IO uint32_t CR2;            
    . G- s! V/ G0 M: `
31.   __IO uint32_t SR2;            
    
32.   __IO uint32_t CCR2;            
    8 @* t6 L4 `8 V' ~5 B' W
33.   uint32_t      RESERVED3[4];   
    6 S1 `. A4 G- K/ }$ C
34.   __IO uint32_t PRAR_CUR2;      
    / q7 b* w: t. X5 W9 u9 C" e
35.   __IO uint32_t PRAR_PRG2;      
    
36.   __IO uint32_t SCAR_CUR2;      
    
37.   __IO uint32_t SCAR_PRG2;      
    " h4 k  ]" o3 C4 @, g+ Y
38.   __IO uint32_t WPSN_CUR2;      
    ; P3 ]* p9 m9 A+ ^, l- o: U3 J  S
39.   __IO uint32_t WPSN_PRG2;      
    
40.   uint32_t      RESERVED4[4];   
    2 {- J& p. [+ w0 L7 ^6 h0 x" w3 D
41.   __IO uint32_t CRCCR2;         
    . b5 I+ k' b2 C" _! |
42.   __IO uint32_t CRCSADD2;        
    ) H3 I$ n8 V7 D! K& b/ a
43.   __IO uint32_t CRCEADD2;        
    
44.   __IO uint32_t CRCDATA2;        
    3 r- N" L# ^! Q  U# w4 h9 ]0 c
45.   __IO uint32_t ECC_FA2;         
    " T: }: e' A: h+ F
46. } FLASH_TypeDef;

复制代码

* }0 u( x* w5 S1 `9 p3 @' D0 P这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。
* @0 P$ ?; d6 s+ C8 h1 [; k
+ T# c/ ]; L. `5 q3 g4 P__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
% X( y- J% `0 d; R

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

下面我们看下Flash的定义，在stm32h743xx.h文件。
% `3 @3 ?) d5 `5 p8 S9 J* s# X

1. #define PERIPH_BASE              (0x40000000UL)
   . j, p) ?* A# g
2. #define D1_AHB1PERIPH_BASE       (PERIPH_BASE + 0x12000000UL)
   
3. #define FLASH_R_BASE             (D1_AHB1PERIPH_BASE + 0x2000UL)
   
4. #define FLASH                    ((FLASH_TypeDef *) FLASH_R_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x52002000

复制代码

: b: m. l/ J5 K+ l$ P, [5 r我们访问Flash的CR1寄存器可以采用这种形式：FLASH->CR1 = 0。

# U) g! ?: Z7 S- R  x70.3.2 内部Flash擦除结构体FLASH_EraseInitTypeDef
3 [! ]* F) x8 o9 }8 T下面是做内部Flash擦除的结构体，用到的地方比较多：

( ^: Z, o' Z8 i" w8 k4 Z! e8 i

1. typedef struct
   
2. {
   
3.   uint32_t TypeErase;  
   # ]* s" ~9 K1 ]* Z, l( e1 R; h* z
4.   uint32_t Banks;      
   0 \0 Q: e( H% m% h; D% ?
5.   uint32_t Sector;      
   + `2 V; T" w$ G0 P+ r
6.   uint32_t NbSectors;   
   3 o- S/ r5 q+ l3 I. L, d+ p
7.   uint32_t VoltageRange;
   
8. } FLASH_EraseInitTypeDef;

复制代码

6 s1 m+ W8 Z+ |- n" p下面将结构体成员逐一做个说明：
* l5 I+ Y) n6 X1 E, A. }  TypeErase
. W  A0 n: x& N/ A. A
# y, p  W5 [; {+ R
用于选择BANK擦除还是扇区擦除，H743有两个BANK，每个BANK有个8个扇区，每个扇区128KB。具体支持的参数如下：

1. #define FLASH_TYPEERASE_SECTORS      0x00U  /* 扇区方式擦除 */
   
2. #define FLASH_TYPEERASE_MASSERASE    0x01U  /* BANK方式擦除 */

复制代码

) \3 o1 I9 r8 u+ E5 ^/ e& p  Banks
6 |& p2 O& N/ u% g6 y用于选择要擦除的BANK，或者两个BANK都选择：
5 X8 ?9 s2 O, G0 |1 S3 S! d

1. #define FLASH_BANK_1             0x01U                         /* Bank 1 */
   
2. #define FLASH_BANK_2             0x02U                         /* Bank 2 */
     u6 n5 x1 c  T2 ?6 J
3. #define FLASH_BANK_BOTH          (FLASH_BANK_1 | FLASH_BANK_2) /* Bank1 和 Bank2 */

复制代码

  Sector
用于选择要擦除的扇区：

1. #define FLASH_SECTOR_0             0U       /* Sector Number 0   */
   
2. #define FLASH_SECTOR_1             1U       /* Sector Number 1   */
   
3. #define FLASH_SECTOR_2             2U       /* Sector Number 2   */
   
4. #define FLASH_SECTOR_3             3U       /* Sector Number 3   */
   
5. #define FLASH_SECTOR_4             4U       /* Sector Number 4   */
   8 i' {/ X. O& I: [- Z. J% e! k
6. #define FLASH_SECTOR_5             5U       /* Sector Number 5   */
   
7. #define FLASH_SECTOR_6             6U       /* Sector Number 6   */
   + o9 E  s# C7 _& T( v: r% x. g
8. #define FLASH_SECTOR_7             7U       /* Sector Number 7   */

复制代码

5 A* Z, N; U' X/ r4 c* w. U1 a  NbSectors
用于设置要擦除的扇区个数，对于STM32H743来说，范围1到8。

0 ?8 E  \! ^" j% ?  VoltageRange
用于设置编程的并行位数，电压不同，位数不同：

1. #define FLASH_VOLTAGE_RANGE_1        0x00000000U       /* Flash program/erase by 8 bits  */
   
2. #define FLASH_VOLTAGE_RANGE_2        FLASH_CR_PSIZE_0  /* Flash program/erase by 16 bits */
   
3. #define FLASH_VOLTAGE_RANGE_3        FLASH_CR_PSIZE_1  /* Flash program/erase by 32 bits */
   2 ]+ T1 q  x$ y3 W0 N/ U5 O
4. #define FLASH_VOLTAGE_RANGE_4        FLASH_CR_PSIZE    /* Flash program/erase by 64 bits */

复制代码

7 `. M! {& V/ s; i1 Q7 d70.3.3 内部Flash的操作总结

5 {  p% R6 ?9 Z2 O& [2 s" [& ]
使用方法由HAL库提供：
  Flash编程函数操作流程
  Flash解锁函数HAL_FLASH_Unlock。
5 l. }9 T, X6 A* h  Flash查询方式编程HAL_FLASH_Program。
" A: A" T2 D2 r& a0 ]4 ~  Flash中断方式编程HAL_FLASH_Program_IT。
  Flash上锁函数HAL_FLASH_Lock。
2 S; S$ F2 _' i" r  
选项字节编程流程
  选项字节解锁函数HAL_FLASH_OB_Unlock。
# d$ j" P0 Z$ i* {. d  选项字节加载函数HAL_FLASH_OB_Launch。
  选项字节编程函数HAL_FLASHEx_OBProgram。
  S7 @7 P, e- N4 J3 `0 E  选项字节加锁函数HAL_FLASH_OB_Lock。

+ J: N+ x- P) q  R2 a4 c9 Q* y Flash擦除流程
  Flash解锁函数HAL_FLASH_Unlock。
  Flash查询方式擦除HAL_FLASHEx_Erase。
0 y4 b! p0 T) g4 Z9 M' e6 [  Flash中断方式擦除HAL_FLASHEx_Erase_IT。
  Flash上锁函数HAL_FLASH_Lock。
8 P# @- U' P. l0 B7 @  N% W8 n

; @8 A- T, W9 A9 J70.4 内部Flash源文件stm32h7xx_hal_flash.c
此文件涉及到的函数较多，这里把几个常用的函数做个说明：

  HAL_FLASH_Unlock
  HAL_FLASH_Lock
, \1 ~6 M+ ~% s' F5 Y  HAL_FLASHEx_Erase
  HAL_FLASH_Program

70.4.1 函数HAL_FLASH_Lock
# }* F; x1 L; @- r0 x0 c) D8 K! A函数原型：
3 r8 K7 V+ K' \5 k

1. HAL_StatusTypeDef HAL_FLASH_Lock(void)
   
2. {
   % U. i+ q) s3 Z+ U  _* D6 f
3. /* 设置FLASH Bank1控制寄存器Lock位，即禁止访问 */
   
4.   SET_BIT(FLASH->CR1, FLASH_CR_LOCK);
   
5. 
   
6. /* 验证Flash Bank1是否已经被锁住 */
   
7.   if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) == 0U)
   
8.   {
   & ~+ |2 ?3 X' S' V+ V
9.     return HAL_ERROR;
   , G0 r7 [# x$ ?# N3 O9 \
10.   }
    - m' A9 s( p8 p" P
11. 
    
12. /* 设置FLASH Bank2控制寄存器Lock位，即禁止访问 */
    ' y$ R7 |4 I% \$ P% V- J/ O
13.   SET_BIT(FLASH->CR2, FLASH_CR_LOCK);
    - I# t. R: Y. L: r1 q4 D
14. 
    * w3 [5 d! d1 O; G" {6 f# i. g  s
15. /* 验证Flash Bank2是否已经被锁住 */
    
16.   if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) == 0U)
    4 v. k5 a1 H3 ?% T
17.   {
    0 k, @% W  X0 O9 Z9 h) N
18.     return HAL_ERROR;
    
19.   }
    
20. 
    ( N# f0 d5 ?* ~1 g. @
21.   return HAL_OK;
    
22. }

复制代码

函数描述：

% d2 ]8 \6 u' U/ p用于Flash加锁，加锁后将不能对Flash进行编程和擦除。

70.4.2 函数HAL_FLASH_Unlock
  m+ M: k6 ^: L& d/ @/ u函数原型：

1. HAL_StatusTypeDef HAL_FLASH_Unlock(void)
   
2. {
   
3.   if(READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
   
4.   {
   - U( E& P0 b$ `$ c! l( @
5.     /* 允许访问Flash Bank1 */
   3 [3 n/ s) k8 [: W3 I0 P
6.     WRITE_REG(FLASH->KEYR1, FLASH_KEY1);
   
7.     WRITE_REG(FLASH->KEYR1, FLASH_KEY2);
   # v' p7 R* z' h7 w7 r; R
8. 
   
9.     /* 验证是否已经解锁 */
   8 e( S% |) c: B$ V* Y
10.     if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
    
11.     {
    
12.       return HAL_ERROR;
    . j7 T3 r% U! L
13.     }
    # S7 K3 D6 u4 r8 K( ~5 f
14.   }
    % i4 K; h, I, `! M1 D! |
15. 
    0 f$ O8 ]0 Y; t
16.   if(READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    7 B2 T6 @* E2 Q6 h0 p
17.   {
    
18.     /* 允许访问Flash Bank2 */
    / e6 k& Q) {5 ~5 z) K% J" j, M3 e
19.     WRITE_REG(FLASH->KEYR2, FLASH_KEY1);
    
20.     WRITE_REG(FLASH->KEYR2, FLASH_KEY2);
    
21. 
    ) l0 C9 D0 p. X7 G0 @3 [
22.     /* 验证是否已经解锁 */
    
23.     if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    
24.     {
    $ G6 K& c; l' c+ C: v
25.       return HAL_ERROR;
    
26.     }
    % d$ L* O- [) C
27.   }
    - ^9 U7 }6 R- y! U5 n' K+ R
28. 
    / L) N  ]  {: z8 b1 y
29.   return HAL_OK;
    
30. }

复制代码

函数描述：

7 _  E+ H3 B( s& c( W% X  k此函数用于Flash解锁，解锁后可以对Flash进行擦除和编程。
) M6 }$ ?+ X. Y8 r2 j6 Y
70.4.3 函数HAL_FLASH_Program
函数原型：
7 b1 X# E1 S" W& h! d
6 j+ Z0 H1 o: g9 e( d% k" c; k

1. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t FlashAddress, uint32_t DataAddress)
   % S" R2 K- K" C& D
2. {
   + o2 w0 _% X. {& q1 _
3.   HAL_StatusTypeDef status;
   - X) P) C4 _7 O( N
4.   __IO uint32_t *dest_addr = (__IO uint32_t *)FlashAddress;
   
5.   __IO uint32_t *src_addr = (__IO uint32_t*)DataAddress;
   
6.   uint32_t bank;
   * v( }& B5 C; N/ ?* L
7.   uint8_t row_index = FLASH_NB_32BITWORD_IN_FLASHWORD;
   
8. 
   8 O% F" F7 u0 q8 F+ d/ I% m2 o
9.   /* 检测参数 */
   ( Q( x1 a) |! K2 c7 y, f/ j, R
10.   assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
    
11.   assert_param(IS_FLASH_PROGRAM_ADDRESS(FlashAddress));
    
12. 
    
13.   /* 上锁 */
    4 {* N7 W4 Z; k
14.   __HAL_LOCK(&pFlash);
    2 j; o7 |( X1 g. M7 {/ }
15. 
    0 }6 i, X  v$ t9 x( ?
16. #if defined (FLASH_OPTCR_PG_OTP)
    5 V: O' P; N, b2 v- a5 ~2 |4 y/ g
17.   if((IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress)) || (IS_FLASH_PROGRAM_ADDRESS_OTP(FlashAddress)))
    5 h0 L& `! Y' V4 K7 ?
18. #else
    - H1 P4 S+ [3 c8 b% K6 B& I
19.   if(IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress))
    
20. #endif
    # X0 ]' }1 \- @8 S" T
21.   {
    
22.     bank = FLASH_BANK_1;
    ; ^! h8 |( u7 d8 t. Q
23.   }
    
24.   else
    / }. V5 g% t' v) ]/ [. ?) C
25.   {
    8 D5 S: {5 l# W) R
26.     bank = FLASH_BANK_2;
    
27.   }
    1 K; F0 D( j3 i1 M& S
28. 
    
29.   /* 错误标识，无错误 */
    ! _* m1 u* i7 c+ K5 F
30.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    ; M: b% V2 Q, `' _" o5 Y
31. 
    
32.   /* 等待操作完成 */
    1 S; T. E$ }$ C) [, y1 y
33.   status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    
34. 
    1 L, \5 `/ L1 b$ Z% G. m
35.   if(status == HAL_OK)
    0 T1 w$ T1 C: ^0 B7 u
36.   {
    4 y" m& P- d1 C# U
37.     if(bank == FLASH_BANK_1)
    
38.     {
    
39. #if defined (FLASH_OPTCR_PG_OTP)
    
40.       if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
41.       {
    7 [6 G3 s. e- C' H* h
42.         /* 设置OTP寄存器的PG位，使能可以编程 */
    1 P# z0 b- }0 A
43.         SET_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    9 d/ p2 `# f7 `; [; o1 R3 v  R( @
44.       }
    6 p3 k0 z8 ~$ E, v
45.       else
    % z: U$ n/ n) V7 T2 r2 a, W
46. #endif
    ( \% q- Q3 o! I0 b+ Y# `/ }" a
47.       {
    
48.         /* 设置PG位，使能可编程 */
    
49.         SET_BIT(FLASH->CR1, FLASH_CR_PG);
    - P1 D/ V& J/ ?+ O" f
50.       }
    / H2 A7 y+ t6 ]& f& X
51.     }
    ! t" ]: M) f0 {# A$ h
52.     else
    
53.     {
    " ^! L+ ^% Y0 P/ Z
54.       /* 设置PG位 */
    6 o% F# z( J! @& i
55.       SET_BIT(FLASH->CR2, FLASH_CR_PG);
    
56.     }
    
57. 
    ( G* d; \! @. t' f3 @
58.     __ISB();
    0 o$ J* F6 A. Q9 L
59.     __DSB();
    2 v7 _4 o% Z% }/ k& x
60. 
    
61. #if defined (FLASH_OPTCR_PG_OTP)
    $ u+ A2 m8 e1 `# o" ~
62.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
63.     {
    
64.       /* 编程OTP(16 bits) */
    4 p8 L: g6 K& E% }
65.       *(__IO uint16_t *)FlashAddress = *(__IO uint16_t*)DataAddress;
    ! d" l8 g) x, U4 \
66.     }
    7 J" B/ V. E* U9 _# ]. U5 |
67.     else
    ; p# |# s& Z. Z6 H6 _# ]
68. #endif
    / }( i2 h# R7 T3 a0 U
69.     {
    
70.       /* 对Flash进行编程 */
    
71.       do
    , j" Q" D; \4 [( @1 T7 ^' p
72.       {
    5 I% x7 t! _! K- T* U: h
73.         *dest_addr = *src_addr;
    # R' J- D8 Z& E, y: S
74.         dest_addr++;
    
75.         src_addr++;
    
76.         row_index--;
    
77.      } while (row_index != 0U);
    
78.     }
    
79. 
    
80.     __ISB();
    + p# X  R- V3 T; g" N0 |
81.     __DSB();
    
82. 
    
83.     /* 等待最后一次操作完成 */
    % i8 F+ b% k0 G( R# ^% s$ X
84.     status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    
85. 
    4 u* p4 n% C. r& l2 j! ?5 N6 e1 z1 M
86. #if defined (FLASH_OPTCR_PG_OTP)
    
87.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    ( l4 w2 M1 U1 j( d; e/ g
88.     {
    
89.       /* 如果编程操作完成，关闭OTP PG位 */
    
90.       CLEAR_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    ; p( m" |& ^8 i* }' t1 b
91.     }
    ( u% I$ q5 R8 _6 z
92.     else
    
93. #endif
    
94.     {
      P# o4 x+ L# f% M: ~
95.       if(bank == FLASH_BANK_1)
    
96.       {
    ; K  w& F0 [  G8 z2 I/ A& l
97.         /* 如果操作完成，关闭PG位 */
    0 g. k  m- t$ |7 y+ ]" @# V
98.         CLEAR_BIT(FLASH->CR1, FLASH_CR_PG);
    3 X- H& l7 j9 }* U' _* `9 B
99.       }
    ; ~& j* F; t1 b: F; N
100.       else
     
101.       {
     ( ]! }+ }$ |5 v3 P7 Z
102.         /* 如果操作完成，关闭PG位 */
     # `& ~6 O4 E/ f, m
103.         CLEAR_BIT(FLASH->CR2, FLASH_CR_PG);
     0 w8 d) i3 t- i2 F7 V
104.       }
     
105.     }
     
106.   }
     , J, D% B! H1 a
107. 
     - Z& t" g4 P) U3 x
108.   /* 解锁 */
     
109.   __HAL_UNLOCK(&pFlash);
     
110. 
     
111.   return status;
     
112. }
     " R2 o& T, g: y0 _# m& \
113. 
     7 P' d! B5 {4 W; }, s# E

复制代码

函数描述：
* M: P( \: t# H此函数主要用于Flash编程，固定编程32个字节数据。

7 |0 ?3 d$ O3 u函数参数：
第1个参数是要编程的Flash类型，支持两种参数：
  FLASH_TYPEPROGRAM_FLASHWORD，用于芯片内部Flash编程。
  FLASH_TYPEPROGRAM_OTPWORD，用于芯片内部OTP存储区编程，当前的H743并没有这个区域，所以可以忽略。

! S9 T, O+ c# z. e第2个参数是要编程的Flash地址。
, Z+ n5 ~" b$ V
第3个参数是要编程到Flash的数据地址。
! L" b& w; e& p返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。

+ e$ s. M2 P! n; T6 E! c
' E0 s' i3 K( I( D  A3 _5 @0 f, ]注意事项：
0 m, {, \; a0 o/ I# i% m2 i  第2个参数的Flash地址要是32字节对齐的，即此地址对32求余等于0。
& N  I+ q2 K7 A6 ~: w" s9 @& C  第3个参数务必要是32字节的整数倍。

: ?4 S6 P4 n$ o70.4.4 函数HAL_FLASHEx_Erase
* k$ V3 G& N0 O, E; a5 d* R函数原型：
: J) m% V* o% v$ y+ ?. D# ~

1. HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *SectorError)
   
2. {
   
3.   HAL_StatusTypeDef status = HAL_OK;
   
4.   uint32_t sector_index;
   $ u8 I, W5 W% w
5. 
   " L# f( k. K4 G+ x: I/ w3 }
6. /* 检查参数 */
   3 D3 E, u/ V8 l( z; P' g* W) f
7.   assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
   4 p, _9 @" E# m
8.   assert_param(IS_FLASH_BANK(pEraseInit->Banks));
   
9. 
   & [: C! ?% g4 e) T, M
10. /* 上锁 */
    
11.   __HAL_LOCK(&pFlash);
    3 ?* t: K  M* @+ y7 h+ S
12. 
    ) _: F7 P# C: T
13. /* 无错误 */
    6 S/ q3 E2 S7 k* S7 ?
14.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    / F& A2 p% V1 F
15. 
    
16. /* 等待BANK1的操作完成 */
    
17.   if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    
18.   {
    - c' G+ m  N0 K4 T
19.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    4 P& j3 J7 v( H; Z$ u9 T; P
20.     {
    9 j5 t- A! f" t
21.       status = HAL_ERROR;
    
22.     }
    2 K+ |; `* C& w9 e+ f. H1 P
23.   }
    ( {; H+ V, Z7 R; L! s5 E" c8 E
24. 
    
25. /* 等待BANK2的操作完成 */
    1 M9 q  F6 l' z' D
26.   if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    
27.   {
    
28.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2) != HAL_OK)
    9 K+ \6 R4 c: h6 u
29.     {
    
30.       status = HAL_ERROR;
    ! c/ Z8 \1 g) a
31.     }
      q8 T( H8 Z7 B0 @" J( p
32.   }
    ) R7 Y' W3 u4 M5 i) ~% q( y" R
33. 
    
34.   if(status == HAL_OK)
    3 _! D7 W# e( V! c& d2 B0 g& c2 f
35.   {
    
36.     if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
    9 i3 e( Z# l/ [5 E
37.     {
    # U6 N% g1 Z* k* _; ?0 A
38.   /* 整个BANK1或者BANK2擦除 */
    5 ^& g( \, ?7 P$ D  e
39.       FLASH_MassErase(pEraseInit->VoltageRange, pEraseInit->Banks);
    1 y' B0 B& M/ Y0 v; U# B" P# N
40. 
    
41.   /* 等待操作完成 */
    1 C% S9 e$ s& M5 L8 N
42.       if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    6 j* e; D/ e0 c; F' ~* i- a% N: B
43.       {
    ) a* U- Q5 o, |; S1 q
44.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    - l& c( q( t8 `; M- `7 |
45.         {
    + g! J; I' R9 t$ U+ j3 O# K9 O
46.           status = HAL_ERROR;
    
47.         }
    
48.     /* 如果擦除完成，关闭BANK1的BER位 */
    : y8 Q, g0 ^) W1 D, T1 k
49.         FLASH->CR1 &= (~FLASH_CR_BER);
    
50.       }
    
51.       if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    
52.       {
    
53.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2) != HAL_OK)
    & t* J- ^7 C! F  }" |
54.         {
    : k6 {4 W& D2 ]7 X# H, ]* P8 W9 i
55.           status = HAL_ERROR;
    & N8 d9 ]  h# N2 h, O1 ~( h
56.         }
    5 {2 x0 C, x1 X- x1 C8 O: }( P
57.     /* 如果擦除操作完成，关闭BANK2的BER位 */
    
58.         FLASH->CR2 &= (~FLASH_CR_BER);
    6 j0 |& d7 V- a
59.       }
    
60.     }
    
61.     else
    
62.     {
    % f1 a& M2 t( R- Y0 g7 x
63.   /* 初始化扇区错误码 */
    ) l* ~  ^( @; v- J& u' d# Q: {/ }; u
64.       *SectorError = 0xFFFFFFFFU;
    ; X) ~$ a9 r0 `" Z' F5 j
65. 
    
66.   /* 扇区方式擦除 */
    
67.       for(sector_index = pEraseInit->Sector; sector_index < (pEraseInit->NbSectors + pEraseInit->Sector);
    + m5 ]  X0 K1 {1 o
68. sector_index++)
    
69.       {
    
70.         FLASH_Erase_Sector(sector_index, pEraseInit->Banks, pEraseInit->VoltageRange);
    & P- e$ l7 G( w5 _$ E( w; P" W
71. 
    
72.         if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    $ Z# b. F/ f2 J1 R% y8 [
73.         {
    
74.       /* 等待BANK1操作完成 */
    
75.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1);
    
76. 
    
77.       /* 如果擦除操作完成，禁止SER位 */
    
78.           FLASH->CR1 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    4 `6 ]! _4 K& z$ |- g
79.         }
    ! |: @* m- V3 M# Z* K* t3 {
80.         if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    % ]" s: e: V, G5 a+ l( R
81.         {
    8 R/ f3 L5 Z1 K/ r. M9 i
82.       /* 等待BANK2操作完成 */
    8 O: u/ Z. U/ a  k3 ^3 v$ H0 b
83.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2);
    
84. 
    
85.       /* 如果擦除操作完成，禁止SER位 */
    % A4 T5 k& Z2 h/ D
86.           FLASH->CR2 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    - c  s9 Y0 Z, H$ o
87.         }
    $ Y  u, c/ p6 N# v* W- k# H
88. 
    
89.         if(status != HAL_OK)
    
90.         {
    + M! n! g: R% u* q7 a, v
91.       /* 如果擦除出错，停止后续擦除，返回擦除异常的扇区号 */
    # o) O+ {( C8 K, r6 H/ [3 x
92.           *SectorError = sector_index;
    
93.           break;
    1 m  ^0 s2 B# W! y' S' p1 j
94.         }
    
95.       }
    
96.     }
    " V4 V7 I3 W8 d$ S
97.   }
    3 C+ Q, F2 t# B6 f. p) x9 O
98. 
    
99. /* 解锁 */
    " v% v* T" F# i2 O& }) {
100.   __HAL_UNLOCK(&pFlash);
     
101. 
     
102.   return status;
     ; P2 ?9 I1 I2 D# ~" d& X! h, l
103. }
     ( {& t6 ~6 L9 S

复制代码

6 b; I0 }" R; r: d+ |( }函数描述：
5 S- }; V# \+ T' ^! B0 f用于内部Flash的批量擦除（BANK擦除）和扇区方式擦除。
7 j! A) Y9 n% d4 S' i3 ]
6 w; N- s5 V  E# J* l7 g函数参数：
  第1个参数是FLASH_EraseInitTypeDef类型结构体指针变量。
  第2个参数是错误码返回，返回0xFFFFFFFF表示全部正确，返回其它值是擦除过程中的错误扇区。
! v5 ]8 h( x5 k' \& b+ W% k  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
2 J3 x0 A6 I" \) q
2 e7 d' J* ~7 q70.5 总结
本章节就为大家讲解这么多，对于内部Flash编程来说，掌握本章节的这些知识点就够用了，更多的知识点可以看STM32H7的参考手册学习。

% D4 h" a1 R- e7 e2 z