70.1 初学者重要提示
4 Y* H4 o6 q, J$ m, ?  本章2.5小节里面的Flash三级读保护是重点，务必要掌握明白。
, n/ l( d$ S& t  \) \3 c  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是如果用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，用户应用程序将停止运行，包括中断服务程序。
  STM32H7的两个Flash BANK是256bit带宽，CPU访问是采用的两个64bit AXI总线。
2 k/ S8 x* u! v4 b  HAL库的内部Flash编程函数HAL_FLASH_Program固定编写32字节数据。
70.2 内部Flash基础知识
& g! k9 e$ T6 y( _$ x1 m70.2.1 内部Flash的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解内部Flash的基本功能，然后再看手册了解细节。

  {4 r& [; q0 w2 w8 r

通过这个框图，我们可以得到如下信息：

( R; L: z- Z8 N/ W- n* V# r0 U% v  sys_ck时钟输入
1 X, }4 Y" G- sD1域总线时钟。
3 V  o* S, _5 L* t* s5 L' B
  po_rst输入
Power on reset 上电复位。
- _  x" l& v+ l( ?; \8 ~* ^
6 k; q) K$ _) A* g  d1_rst输入
5 h: v6 C3 E# k! bD1域系统复位。

) H* P/ Y8 W0 F; T5 l1 |% J, j  flash_it输出
- v) X. [$ i: v" `" oflash中断请求输出。

STM32H7的两个Flash BANK是独立的，读写和擦除互补影响，256bit带宽，CPU访问是采用的两个64bit AXI总线。
+ h# z) g% O+ {0 q5 H7 Z5 t6 @8 _+ e3 ?
70.2.2 内部Flash框架
关于内部Flash的框架，了解以下几个知识点即可：

# I. U  |, Y! B' P: Z1 `  256bit为单位，即32字节，并且每个单位配10bit的ECC校验位。正是这个原因要求大家对Flash进行编程时，必须以32字节为单位。
8 J: z2 a/ z; i, E  两个独立的BANK，每个BANK有1MB容量。并且每个BANK的扇区大小固定为128KB，即8个扇区。

5 G) T+ B4 ?% @
9 q3 A' M% a4 |, [# b* ]BANK1的地址范围：0x0800 0000到0x080F FFFF。
" S/ w0 L7 |0 J: T- |" f4 C
# N9 z7 p0 I" h- R3 hBANK2的地址范围：0x0810 0000到0x081F FFFF。
6 H' k$ W, p7 e4 T
70.2.3 内部Flash读操作
! r/ G; F7 a' C4 g# ]* |STM32H7的内部Flash读操作跟内部RAM的读操作是一样的，支持64bit，32bit，16bt和8bit，使用比较简单。这里我们重点普及一个知识点，H7的内部Flash在不同主频下需要做的延迟参数：

* K) D& j& r9 x/ Z- b

6 Z, K8 [9 b. q6 E1 o
$ s1 u$ u3 E& K4 @对于上面的表格，大家可以看到，当延迟等待设置为0的时候，即无等待，单周期访问，速度可以做到70MHz。增加1个Flash周期后，访问速度可以做到140MHz。当增加到3个或4个Flash周期后，最高速度可以做到225MHz。
8 [# s+ ?  Z  a4 ]: _  Q
& x' b9 m) i# f% ^9 `' x了解了这个知识点后，再来看下面的时序，非常具有参考意义：
# _( _! y6 n5 V& l- s7 B
注：ACLK、ARADDR、ARVALID、RDATA、RVALID 和RLAST是AXI总线信号。Flash读和Flash数据是 Flash 接口信号。
% I! ~* `. d7 F" y
' t. w0 p+ Q% P& M0 j( Y; G# g8 G

7 v1 O4 a* M4 C! }, I5 l/ J
关于这个时序要要认识到以下几点：

  AXI总线发起读取信号后，Flash端等待了3个时钟周期（注意延迟三个周期，支持的Flash速度），之后连续读取了4个64bit数据。
2 E" g5 f1 t: a6 T  由于AXI总线是64bit的，所以1次读取就可以读出64bit数据，连续读取4次后，就是256bit，即Flash接口的一组数据，因为H7的Flash接口带宽是256bit的。
/ }# l' B$ |0 i: g" `4 r  如果不开Flash Cache的情况下，连续读可以提升性能。
; @# C! C! w7 p, ~
  X+ A7 B2 s3 \; x# s/ d下面是连续读取8个64bit数据的时序图，跟连续读取4个64bit数据基本是一样的，只是多读取了4组数据。
+ c0 O- n/ m! f' W6 w: C9 U1 G9 E
! H+ [$ ?5 _7 E

. Y$ Z" r2 T# w# |. g3 p- Y
. u/ m6 U* {5 T+ ], M7 c70.2.4 内部Flash写入和擦除操作
- M$ W. s3 g3 [5 O1 U0 j最重要的知识点放在开头说：STM32H7内部Flash的写操作地址必须是32字节对齐（此地址对32求余数为0），写入的数据量也必须是32字节整数倍，不足32字节整数倍，补0也要是整数倍。
1 H% j7 a7 y' x& H4 B! _) B: w
8 l9 S& M1 H4 q) K5 i这里我们重点了解Flash的写入和擦除流程。Flash的写入扇区流程如下：

! J4 G9 r1 P- s4 F( C9 A0 {' F先保证这块扇区空间之前已经擦除过了。
解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
; y  ~+ E' {: y  d检查是否写保护，使能Flash可以编程，然后对其进行编程操作，编程完毕后，等待编程完成，然后禁止Flash编程位。具体操作可以通过HAL库的函数HAL_FLASH_Program实现。

Flash的擦除流程如下：
解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
0 P  W2 m* X7 v6 U& `如果是BANK1或者BANK2需要擦除，调用函数FLASH_MassErase，然后等待擦除完成，完成之后关闭BANK1和BANK2的擦除请求位BER1/BER2
0 t' A# Z, @. Y' b6 M如果是扇区擦除，调用函数FLASH_Erase_Sector，然后等待擦除完成，完成之后关闭扇区的擦除请求位SER。
# _: G1 u* X2 c$ |; F6 e) e2 E0 @

" N3 [- q1 t0 _* B* a70.2.5 内部Flash读保护
& v  w. K& @6 X7 q内部Flash支持三级读保护RDP（read out protection）。
6 O3 Z! e2 D. k& }3 i+ s3 g
2 P6 }5 |+ D6 R6 t  Level 0（无保护）
默认设置，所有读写和擦除操作都可以正常支持。

  Level 1 （Flash连接保护）
) z  m- j; i' v  可以防止连接调试器时读取Flash内容，或者RAM中存有恶意获取代码，也是禁止的。因此只要调试器连接芯片，或者从内部RAM启动运行代码，都是禁止访问内部Flash的。
$ C* H5 q9 \% e! k2 X, p2 i  如果没有检测到从内部RAM启动和系统bootloader启动且没有连接调试器，对用户Flash的读写和擦除操作都是允许的，并且其它安全存储区也是可以访问的。否则是禁止访问的，一旦检测到对Flash的读请求，将产生总线错误。
' L) r) R" f6 W2 L3 g  如果将Level 1切换到Level 0时，用户Flash区和安全区域将被擦除。
! J# J. w, e0 w: R+ w
2 _  f% h0 b: G$ i2 w" p9 W Level 2（设备保护和自举保护）
  所有调试特性被关闭。
, g9 t' `3 }7 `2 x5 o: B6 B% W( S  禁止从RAM启动。
; Z  w  M* p) G7 I! }0 U8 @  除了选项字节里面的SWAP位可以配置，其它位都无法更改。
9 |. Y* b1 Q. b% x; P  禁止了调试功能，且禁止了从RAM和系统bootloader启动，用户Flash区是可以执行读写和擦除操作的，访问其它安全存储区也是可以的。
# w  {$ n, X4 n+ A9 N/ X
+ q4 w: M$ M5 m. p# P7 M3 i: i% u: U特别注意：Level2修改是永久性的，一旦配置为Level2将不再支持被修改。

, H8 m% z) X5 x$ \如果大家要设置读保护的话，使用HAL的API可以设置，也可以使用STM32CubeProg设置：

! |% [5 z$ R! M
. \; O6 K$ h" {) n6 t4 I
0 q3 T* `9 `8 i70.2.6 内部Flash选项字节
( G" U: f$ S6 E# L5 g- k: [0 FFlash选项字节主要用于boot地址设置，安全保护，Flash扇区保护等，涉及到的选项比较多。如果大家打算了解这一部分的话，使用STM32CubeProg进行设置即可，也比较方便。
* w: X/ O+ _9 r
; r% Y# z1 [# [! _

# ]( \" S8 I2 r6 @: H" [/ S, ]
70.2.7 内部Flash的ECC校验
这里先说下为什么内部Flash要带ECC校验，因为随着芯片的制造工艺水平越高，带电粒子产生的位翻转就越多，此时的ECC是必须要有的，一般可以纠正1-2个bit，安全等级高的Flash类存储器和RAM类都是必须要带ECC的。

2 w; x$ h4 K# o. m+ ]对于STM32H7带的ECC校验，一般不需要用户去管理。

+ C1 f7 [1 X8 o70.3 内部Flash的HAL库用法
70.3.1 内部Flash结构体FLASH_TypeDef
, R& k% D4 a0 J. `/ j内部Flash相关的寄存器是通过HAL库中的结构体FLASH_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
) C7 L9 p8 A8 {' W
. k2 V4 c. X" M" c) }3 w

1. typedef struct
   & X/ n+ F* o8 g8 G  S2 `4 g
2. {
   ; w( h  [& o5 M& G& q: k
3.   __IO uint32_t ACR;            
   
4.   __IO uint32_t KEYR1;           
   
5.   __IO uint32_t OPTKEYR;         
   
6.   __IO uint32_t CR1;            
   # {8 w( {8 z$ a
7.   __IO uint32_t SR1;            
   
8.   __IO uint32_t CCR1;         
   9 p) e  O* |( b9 d
9.   __IO uint32_t OPTCR;           
   
10.   __IO uint32_t OPTSR_CUR;      
    
11.   __IO uint32_t OPTSR_PRG;      
    6 x8 W. @  e* S$ D8 j1 o
12.   __IO uint32_t OPTCCR;         
    
13.   __IO uint32_t PRAR_CUR1;      
    / X. W0 e# x! I) P
14.   __IO uint32_t PRAR_PRG1;      
    
15.   __IO uint32_t SCAR_CUR1;      
    
16.   __IO uint32_t SCAR_PRG1;      
    
17.   __IO uint32_t WPSN_CUR1;      
    " T4 e0 n% N2 t
18.   __IO uint32_t WPSN_PRG1;      
    4 y+ e) W) X% C" h
19.   __IO uint32_t BOOT_CUR;      
    2 W3 U% N, M6 C# y2 d: _
20.   __IO uint32_t BOOT_PRG;      
    
21.   uint32_t      RESERVED0[2];   
    1 U2 H$ p9 m. a1 C0 o: e" e/ ]: y
22.   __IO uint32_t CRCCR1;         
    ! D# p! D! k' z: d9 h! S
23.   __IO uint32_t CRCSADD1;      
    
24.   __IO uint32_t CRCEADD1;        
    
25.   __IO uint32_t CRCDATA;         
    4 r3 b  J% z) G. B; K. {- f
26.   __IO uint32_t ECC_FA1;         
    4 I9 z# n: z  C$ U+ I& o6 p5 d
27.   uint32_t      RESERVED1[40];  
    
28.   __IO uint32_t KEYR2;           
    ; Z0 R4 g* I  r
29.   uint32_t      RESERVED2;      
    
30.   __IO uint32_t CR2;            
    + {! q1 C% f- E' r1 s: [
31.   __IO uint32_t SR2;            
    + d/ `# Y& [5 ~: k1 _5 c- X0 |
32.   __IO uint32_t CCR2;            
    
33.   uint32_t      RESERVED3[4];   
    
34.   __IO uint32_t PRAR_CUR2;      
    3 {$ L/ ]$ w9 y
35.   __IO uint32_t PRAR_PRG2;      
    
36.   __IO uint32_t SCAR_CUR2;      
    2 ~2 G9 ~& A$ _" X+ @
37.   __IO uint32_t SCAR_PRG2;      
    3 A8 p9 _5 Z, r$ z' @7 q
38.   __IO uint32_t WPSN_CUR2;      
    
39.   __IO uint32_t WPSN_PRG2;      
    ( B5 s! d; q; ]
40.   uint32_t      RESERVED4[4];   
    
41.   __IO uint32_t CRCCR2;         
    & m  C" t! @( T" N* t
42.   __IO uint32_t CRCSADD2;        
    / F1 G9 s; d6 _$ D5 i; a6 y
43.   __IO uint32_t CRCEADD2;        
    * x" f4 u7 d7 M0 v8 s# M" j
44.   __IO uint32_t CRCDATA2;        
    
45.   __IO uint32_t ECC_FA2;         
    : B' Z$ ?0 ^6 U+ j' Q4 V+ Q
46. } FLASH_TypeDef;

复制代码

# X$ B. M) ~0 K' q. x% G这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
' P" I- O- \- `- o2 O  j7 Y$ u! A( }  E

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

复制代码

下面我们看下Flash的定义，在stm32h743xx.h文件。

0 @: ]: m4 l' M4 q4 a; J. e

1. #define PERIPH_BASE              (0x40000000UL)
   0 ~0 f. D: c/ {2 o
2. #define D1_AHB1PERIPH_BASE       (PERIPH_BASE + 0x12000000UL)
   4 Y! o8 Q& k$ G. ^5 r- u
3. #define FLASH_R_BASE             (D1_AHB1PERIPH_BASE + 0x2000UL)
   # d2 W  q; z6 C# g9 u5 g$ b
4. #define FLASH                    ((FLASH_TypeDef *) FLASH_R_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x52002000

复制代码

8 f  y9 G; K8 i- v我们访问Flash的CR1寄存器可以采用这种形式：FLASH->CR1 = 0。

70.3.2 内部Flash擦除结构体FLASH_EraseInitTypeDef
4 q* K+ C& N. S3 g/ A下面是做内部Flash擦除的结构体，用到的地方比较多：
: v' Y8 Q  R9 W7 ]

1. typedef struct
   
2. {
   % V+ F$ y/ K. l2 c5 J
3.   uint32_t TypeErase;  
   ! O% P! u. G: J. g
4.   uint32_t Banks;      
   
5.   uint32_t Sector;      
   
6.   uint32_t NbSectors;   
   . k1 b. q8 H: c' m, z+ ?9 R
7.   uint32_t VoltageRange;
   
8. } FLASH_EraseInitTypeDef;

复制代码

- W7 s4 q# y0 W$ v) s4 ?- f; ]; M下面将结构体成员逐一做个说明：
4 k  M0 u, ^6 P+ [; k6 c3 |  TypeErase


' d5 o- L( _5 h; \$ H1 M用于选择BANK擦除还是扇区擦除，H743有两个BANK，每个BANK有个8个扇区，每个扇区128KB。具体支持的参数如下：
' u! J! g/ ^' }5 R* D
) P, E% U2 F  b8 |

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

复制代码

  Banks
用于选择要擦除的BANK，或者两个BANK都选择：
6 J* @) j1 ^# R% c. g; n; D5 s) @
5 H0 ~* b1 Y" U

1. #define FLASH_BANK_1             0x01U                         /* Bank 1 */
   
2. #define FLASH_BANK_2             0x02U                         /* Bank 2 */
   " f* \( l' r( w5 \
3. #define FLASH_BANK_BOTH          (FLASH_BANK_1 | FLASH_BANK_2) /* Bank1 和 Bank2 */

复制代码

  Sector
' z* q) I5 |* h- o用于选择要擦除的扇区：

1. #define FLASH_SECTOR_0             0U       /* Sector Number 0   */
   / V' J! _1 v' Q+ C  {
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   */
   : G5 b0 c0 v2 [1 L8 h6 f
6. #define FLASH_SECTOR_5             5U       /* Sector Number 5   */
   
7. #define FLASH_SECTOR_6             6U       /* Sector Number 6   */
   ' V$ P0 |% |& l. H' S. R2 V
8. #define FLASH_SECTOR_7             7U       /* Sector Number 7   */

复制代码

  NbSectors
9 v  g4 P, T+ W. v! H1 r. y1 b, |  Y* R用于设置要擦除的扇区个数，对于STM32H743来说，范围1到8。

  VoltageRange
# D5 f0 l; v& N" y5 ^9 A  Q用于设置编程的并行位数，电压不同，位数不同：
  R! q: _$ d, B; B/ W% B

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 */
   
4. #define FLASH_VOLTAGE_RANGE_4        FLASH_CR_PSIZE    /* Flash program/erase by 64 bits */

复制代码

4 `" e  F! e# w; v* E70.3.3 内部Flash的操作总结

6 L; @0 s' C2 E1 ]  ~( k7 b
) Y% {! x' A, J. d使用方法由HAL库提供：
/ i3 H; i$ h, O( g' p  Flash编程函数操作流程
1 M: f9 q% y" H& [  Flash解锁函数HAL_FLASH_Unlock。
% Y) Z* X$ T$ ]  a1 z) {$ V7 `  Flash查询方式编程HAL_FLASH_Program。
  Flash中断方式编程HAL_FLASH_Program_IT。
  Flash上锁函数HAL_FLASH_Lock。
  
选项字节编程流程
0 u  i' A9 A  V& Q6 ]9 I9 l# _9 U  选项字节解锁函数HAL_FLASH_OB_Unlock。
  选项字节加载函数HAL_FLASH_OB_Launch。
  选项字节编程函数HAL_FLASHEx_OBProgram。
  选项字节加锁函数HAL_FLASH_OB_Lock。

Flash擦除流程
  Flash解锁函数HAL_FLASH_Unlock。
  Flash查询方式擦除HAL_FLASHEx_Erase。
+ ]: Z( D5 O, X/ H  Flash中断方式擦除HAL_FLASHEx_Erase_IT。
  Flash上锁函数HAL_FLASH_Lock。

: f1 y) y4 w3 E' P; @
70.4 内部Flash源文件stm32h7xx_hal_flash.c
此文件涉及到的函数较多，这里把几个常用的函数做个说明：
8 [( @0 _" X+ V
# n& v2 L9 [/ r% k! a  HAL_FLASH_Unlock
  HAL_FLASH_Lock
  HAL_FLASHEx_Erase
  HAL_FLASH_Program

& q3 Z; Z3 e0 \. P7 t. O1 v$ L6 n! C/ j70.4.1 函数HAL_FLASH_Lock
! R6 E- l! h7 A( b! k4 e7 N函数原型：
: {* l0 D" R0 {$ j; j0 |% T
- N* {- s: K; g6 Z. S  ?6 ]

1. HAL_StatusTypeDef HAL_FLASH_Lock(void)
   
2. {
   
3. /* 设置FLASH Bank1控制寄存器Lock位，即禁止访问 */
   & L; i2 Y$ u' W# N/ x+ K6 \8 k6 D2 s
4.   SET_BIT(FLASH->CR1, FLASH_CR_LOCK);
   
5. 
   : v5 u6 y3 M  a, u, V7 u/ }
6. /* 验证Flash Bank1是否已经被锁住 */
   4 G- Q  N+ C% w4 U3 K# O2 ~# m
7.   if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) == 0U)
   6 d$ e7 H' P7 q6 @) v/ w
8.   {
   $ v  q6 ?" V0 r9 z- F  V3 Z: i& y" ]
9.     return HAL_ERROR;
   + a( U7 e$ R( W1 m( ]
10.   }
    4 s/ j! `; g9 ^" n% c
11. 
    
12. /* 设置FLASH Bank2控制寄存器Lock位，即禁止访问 */
    
13.   SET_BIT(FLASH->CR2, FLASH_CR_LOCK);
    % k# o% k+ i: W
14. 
    
15. /* 验证Flash Bank2是否已经被锁住 */
    
16.   if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) == 0U)
    
17.   {
    ; q- Z. r- ^: H5 J  x9 ^
18.     return HAL_ERROR;
    
19.   }
    9 ~8 I9 ^: l. Y3 m7 m" Y6 j2 `
20. 
    ! M& z0 X+ [  D6 |+ ]
21.   return HAL_OK;
    
22. }

复制代码

# B5 X  K' s  H( G% @函数描述：
3 ?8 o8 H6 v+ n# g% d+ y! _' j
用于Flash加锁，加锁后将不能对Flash进行编程和擦除。
, `  m* S3 D, `; _# G
1 S% M8 T& ~2 A. {8 Q8 Q- Z70.4.2 函数HAL_FLASH_Unlock
函数原型：
: s0 Q5 k5 g1 o+ i, o/ q" u

1. HAL_StatusTypeDef HAL_FLASH_Unlock(void)
   
2. {
   
3.   if(READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
   
4.   {
   
5.     /* 允许访问Flash Bank1 */
   
6.     WRITE_REG(FLASH->KEYR1, FLASH_KEY1);
   
7.     WRITE_REG(FLASH->KEYR1, FLASH_KEY2);
   5 F# D9 Z, U( w4 n7 O
8. 
   1 B' F* M4 ^+ q2 o0 z5 c" W
9.     /* 验证是否已经解锁 */
   ' B# ~+ ^0 B7 M4 E
10.     if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
    % t" x/ B' t/ w& u8 F' ^4 U  K
11.     {
    * l) E1 x. z0 Q( Q
12.       return HAL_ERROR;
      s$ X: j! C! x4 j; F/ I, I( w
13.     }
    
14.   }
    8 S/ H, i3 C' I. ^& N6 n3 _
15. 
    8 O2 M. l8 z" H  g
16.   if(READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    
17.   {
    ( {& f- J7 D2 \9 R& m
18.     /* 允许访问Flash Bank2 */
    2 q% ~+ {# l  w: L+ V) C0 C
19.     WRITE_REG(FLASH->KEYR2, FLASH_KEY1);
    , V$ B3 }: [. x& i( m
20.     WRITE_REG(FLASH->KEYR2, FLASH_KEY2);
    & G  z$ o$ n! q
21. 
    + }. ^$ M1 N/ W7 B  e. J# U  J1 j3 H" p
22.     /* 验证是否已经解锁 */
    
23.     if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    # B& d0 ?9 h, |" t, K
24.     {
    
25.       return HAL_ERROR;
    
26.     }
    
27.   }
    ; F3 a. m) y1 P( P, r
28. 
    
29.   return HAL_OK;
    + e* ?0 k8 `. V: i
30. }

复制代码

% ]/ b, h) A; G. }5 j" T函数描述：
# ^( `' q, D; `2 z1 t$ o6 C5 ?
此函数用于Flash解锁，解锁后可以对Flash进行擦除和编程。

6 F9 q0 y- F+ E- |% I" Z+ f70.4.3 函数HAL_FLASH_Program
函数原型：

1. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t FlashAddress, uint32_t DataAddress)
   8 p3 D5 C5 W, x
2. {
   
3.   HAL_StatusTypeDef status;
   % S! j9 @) S8 _  {% G
4.   __IO uint32_t *dest_addr = (__IO uint32_t *)FlashAddress;
   ( Z& i8 Z7 R; J- Q/ Z+ G+ y, x
5.   __IO uint32_t *src_addr = (__IO uint32_t*)DataAddress;
   
6.   uint32_t bank;
   8 I! d5 v. i1 Y/ p9 v- `
7.   uint8_t row_index = FLASH_NB_32BITWORD_IN_FLASHWORD;
   
8. 
   / J6 x9 c4 i& E( X2 }
9.   /* 检测参数 */
   " X) y0 x1 w0 K
10.   assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
    
11.   assert_param(IS_FLASH_PROGRAM_ADDRESS(FlashAddress));
    
12. 
    ( d* d; c/ A4 |' g
13.   /* 上锁 */
    8 U$ d5 j  W8 b# F1 V
14.   __HAL_LOCK(&pFlash);
    / W; \! F( q1 V: a
15. 
    + c" t1 y4 j; N* R0 k% {
16. #if defined (FLASH_OPTCR_PG_OTP)
    
17.   if((IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress)) || (IS_FLASH_PROGRAM_ADDRESS_OTP(FlashAddress)))
    
18. #else
    
19.   if(IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress))
    
20. #endif
    
21.   {
    7 N3 M# T$ R+ _) N- a3 {2 m
22.     bank = FLASH_BANK_1;
    
23.   }
    
24.   else
    1 ]1 Q) N  E! z3 P  F6 g
25.   {
    ; _$ U  q1 u! s" V0 X% M: Y, ^- z
26.     bank = FLASH_BANK_2;
    3 x& w9 N6 X( O2 j5 a
27.   }
    
28. 
    : O- H0 K( \, v
29.   /* 错误标识，无错误 */
    1 f6 b  R/ W) p7 b: t
30.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
31. 
    9 g! V8 C( |3 i9 w
32.   /* 等待操作完成 */
    
33.   status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    
34. 
    
35.   if(status == HAL_OK)
    
36.   {
    3 R7 ]# l  ^. Z/ b- g
37.     if(bank == FLASH_BANK_1)
    % k9 d5 u+ j; ]3 x' N; X1 F8 Z
38.     {
    
39. #if defined (FLASH_OPTCR_PG_OTP)
    
40.       if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    ) T7 H: P7 Q" Z9 g8 J, U* f
41.       {
    7 T( ]7 Z- z# U1 W2 P2 }9 V' ], @
42.         /* 设置OTP寄存器的PG位，使能可以编程 */
    - Q9 E  ?+ q2 y8 P& P
43.         SET_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    $ q; j+ |8 a# h( {# [! W
44.       }
    / N" C' T( O! x" c( _1 }2 x! M
45.       else
    
46. #endif
    
47.       {
    
48.         /* 设置PG位，使能可编程 */
    
49.         SET_BIT(FLASH->CR1, FLASH_CR_PG);
    
50.       }
    
51.     }
    8 a: u$ o+ n! c, \+ `! X9 c  K
52.     else
    
53.     {
    9 t, j* l9 i+ u8 `  Q* W. X
54.       /* 设置PG位 */
    ; K3 N  e& S/ M3 L
55.       SET_BIT(FLASH->CR2, FLASH_CR_PG);
    ; h! x- W' f! w" O1 T3 A
56.     }
    5 q) E, W$ U4 N: a: f" E" z, D
57. 
    
58.     __ISB();
    
59.     __DSB();
    
60. 
    / b9 `( ~% m0 r9 U% v
61. #if defined (FLASH_OPTCR_PG_OTP)
    ( a" g. ~- i1 ~+ W1 b/ f
62.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
63.     {
      e7 ]1 p. o; K; M# _; M! C
64.       /* 编程OTP(16 bits) */
    ; w3 `; Q- x- h: v  ?9 [2 o
65.       *(__IO uint16_t *)FlashAddress = *(__IO uint16_t*)DataAddress;
    
66.     }
    " S* \" {2 w  W: N+ @- \9 i- ~
67.     else
    
68. #endif
    . Z9 n& ~' s7 b1 s
69.     {
    6 w  B: u: Z7 b0 Q
70.       /* 对Flash进行编程 */
    ! C" A# f6 c5 H6 E, k7 ?% d* h
71.       do
    ; {6 x. H/ U$ w& i; J
72.       {
    , w- g4 P' Q2 a
73.         *dest_addr = *src_addr;
    
74.         dest_addr++;
    
75.         src_addr++;
    
76.         row_index--;
    ) q! I) u2 G+ Y+ N; {  Q
77.      } while (row_index != 0U);
    
78.     }
    ! d) L) I3 k5 q9 M, g
79. 
    
80.     __ISB();
    9 G$ U8 E; v" w9 N
81.     __DSB();
    4 P2 B6 f( h& i. x( r0 u
82. 
    
83.     /* 等待最后一次操作完成 */
    
84.     status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    
85. 
    ; f( Z# {: |0 O/ ?5 k* p
86. #if defined (FLASH_OPTCR_PG_OTP)
    
87.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
88.     {
    1 l; Q) H  D2 v- S( }/ S. l
89.       /* 如果编程操作完成，关闭OTP PG位 */
    
90.       CLEAR_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    - i# E$ M  C  v* d7 v: L
91.     }
    
92.     else
    ! \, m  J7 X% [% X
93. #endif
    . v: u6 s, P4 e
94.     {
    
95.       if(bank == FLASH_BANK_1)
    % P0 ?0 N  m1 V4 ^5 o
96.       {
    1 V+ Y) U$ T2 v* n. [: @) e
97.         /* 如果操作完成，关闭PG位 */
    
98.         CLEAR_BIT(FLASH->CR1, FLASH_CR_PG);
    
99.       }
    $ L) n4 a9 N9 x  m
100.       else
     
101.       {
     & h. o) w$ {$ e" r8 J0 {! Y3 f
102.         /* 如果操作完成，关闭PG位 */
     
103.         CLEAR_BIT(FLASH->CR2, FLASH_CR_PG);
     9 m; o5 @0 {/ h: p: O" @
104.       }
     3 M9 K' f, f: t  I) D
105.     }
     
106.   }
     
107. 
     , p3 Q1 B5 x' h! c
108.   /* 解锁 */
     
109.   __HAL_UNLOCK(&pFlash);
     
110. 
     
111.   return status;
     6 ]4 J# R- L' p
112. }
     
113. 
     

复制代码

: q! k9 I/ ?" z5 q7 a) ^, t; e函数描述：
, f; F: e$ X7 J9 b! O0 m! O, g此函数主要用于Flash编程，固定编程32个字节数据。
1 Z5 Y+ V6 d# T. S4 ?; v. ?. [4 Q
函数参数：
第1个参数是要编程的Flash类型，支持两种参数：
  FLASH_TYPEPROGRAM_FLASHWORD，用于芯片内部Flash编程。
* ~3 a8 z; i7 A" f  FLASH_TYPEPROGRAM_OTPWORD，用于芯片内部OTP存储区编程，当前的H743并没有这个区域，所以可以忽略。
* f0 H# J; O) m
第2个参数是要编程的Flash地址。

第3个参数是要编程到Flash的数据地址。
返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。


+ O3 u! O7 x! a5 R! d注意事项：
  第2个参数的Flash地址要是32字节对齐的，即此地址对32求余等于0。
  第3个参数务必要是32字节的整数倍。
! q9 Z$ M3 z4 G4 M9 j3 u, G  I- q% E
70.4.4 函数HAL_FLASHEx_Erase
( P; P* U& K% [( Y# j: T0 q9 w函数原型：

1. HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *SectorError)
   
2. {
   
3.   HAL_StatusTypeDef status = HAL_OK;
   ( R" w: n8 x0 |) g7 q$ B, r4 a
4.   uint32_t sector_index;
   
5. 
   1 _6 O+ i$ l2 @6 Y
6. /* 检查参数 */
   % D- K8 W+ X% A' b5 q$ k
7.   assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
     u& @5 y1 y+ L; ?. b
8.   assert_param(IS_FLASH_BANK(pEraseInit->Banks));
   ( r+ V+ e  N) b$ R( W4 |
9. 
   2 _- i) [/ J9 `, t( l7 Z/ q
10. /* 上锁 */
    
11.   __HAL_LOCK(&pFlash);
    
12. 
    
13. /* 无错误 */
    : l* H- b8 y% t4 f
14.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    6 T5 W$ }* ^; N) Z
15. 
    
16. /* 等待BANK1的操作完成 */
    * _2 F5 e4 m, J
17.   if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    
18.   {
    
19.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    9 [! R4 \! |3 Z. E
20.     {
      ^" D1 |9 b& I0 C6 `5 F2 I# \
21.       status = HAL_ERROR;
    
22.     }
    
23.   }
    
24. 
    
25. /* 等待BANK2的操作完成 */
    9 y# h3 C: w! O# r3 A: P
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)
    - Z  Z6 {" w# V/ }/ Q
29.     {
    % Z. k0 F. I. o# K# _! F1 y( \
30.       status = HAL_ERROR;
    ) ]  c9 K/ `- H+ g4 v
31.     }
    8 x2 L: K4 P! Z) _8 M) y& D+ l0 S- D) ]
32.   }
    
33. 
    . o! x3 d9 t7 u% f  Y/ r9 |+ C6 M
34.   if(status == HAL_OK)
    
35.   {
    
36.     if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
    7 ^9 \2 T# ?8 C- l4 U' q6 G: [' J
37.     {
    ( _. n( q7 A4 A: `1 _* I
38.   /* 整个BANK1或者BANK2擦除 */
    
39.       FLASH_MassErase(pEraseInit->VoltageRange, pEraseInit->Banks);
    5 |; b5 r! l1 h1 C# q
40. 
    
41.   /* 等待操作完成 */
    / l. K* Y  w4 h. y6 ~5 d- m" g5 I
42.       if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    + }$ x1 a' P! [
43.       {
    
44.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    
45.         {
    $ F7 c. m' ]  Y
46.           status = HAL_ERROR;
    ' m0 J( s1 j+ g" O% j% z
47.         }
    
48.     /* 如果擦除完成，关闭BANK1的BER位 */
    
49.         FLASH->CR1 &= (~FLASH_CR_BER);
    ! [; n6 e2 Q& f0 O5 O  Q
50.       }
    2 g! e) f9 v; U. g" J& x
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)
    
54.         {
    
55.           status = HAL_ERROR;
    
56.         }
    
57.     /* 如果擦除操作完成，关闭BANK2的BER位 */
    % S  ~# p( L+ z- k$ B
58.         FLASH->CR2 &= (~FLASH_CR_BER);
    
59.       }
    6 W) `* W, t. n& \' ^- u2 u8 N
60.     }
    
61.     else
    6 x0 K: q0 g- {5 H" `
62.     {
    + u6 X+ N/ Z* Y  u
63.   /* 初始化扇区错误码 */
    
64.       *SectorError = 0xFFFFFFFFU;
    
65. 
    
66.   /* 扇区方式擦除 */
    , t1 k7 K* e) P2 B# Q" s
67.       for(sector_index = pEraseInit->Sector; sector_index < (pEraseInit->NbSectors + pEraseInit->Sector);
    
68. sector_index++)
    ' C- L. ]; C; c- E3 _# g: \. V
69.       {
    6 T, x# `+ ?0 l8 `4 U' @
70.         FLASH_Erase_Sector(sector_index, pEraseInit->Banks, pEraseInit->VoltageRange);
    ( Z6 O) t* ~( ]& v1 z3 r% B; v
71. 
    
72.         if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    ! l0 c- `( S3 H. Y$ T! S* u
73.         {
    
74.       /* 等待BANK1操作完成 */
    
75.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1);
    : }1 R: D4 P4 G; U6 \5 q
76. 
    ) I1 n- q' x6 s: F
77.       /* 如果擦除操作完成，禁止SER位 */
    
78.           FLASH->CR1 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    
79.         }
    ' f: d; N+ s" Q
80.         if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    
81.         {
    2 k- U7 Z8 F, e" `# z
82.       /* 等待BANK2操作完成 */
    
83.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2);
    4 X) }! C$ t$ m; b( c
84. 
    
85.       /* 如果擦除操作完成，禁止SER位 */
    # `, P% E8 m& P% h" q# y% l
86.           FLASH->CR2 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    3 t: }0 y( d" e5 Q- O) ?3 Z
87.         }
    4 P* h4 r% w( B/ b. g& F9 {/ ^
88. 
    
89.         if(status != HAL_OK)
    6 z/ x$ `$ d9 q: W% c% K
90.         {
    1 j% k4 D7 Z! }& d3 ]+ d: p5 G
91.       /* 如果擦除出错，停止后续擦除，返回擦除异常的扇区号 */
    
92.           *SectorError = sector_index;
    $ w0 U/ E* L' Q  j( u" m
93.           break;
    * c% L: u7 @/ w: d: o
94.         }
    
95.       }
    
96.     }
    
97.   }
    
98. 
    6 g) {, R8 H4 t, J! q
99. /* 解锁 */
    2 M7 {7 C/ d9 i0 g
100.   __HAL_UNLOCK(&pFlash);
     " C2 P7 h6 m" N
101. 
     
102.   return status;
     " d+ H! T, T5 V- B6 P: A
103. }
     

复制代码

$ u3 j( t6 p' P( s函数描述：
# [. T" L  w4 k+ f8 [用于内部Flash的批量擦除（BANK擦除）和扇区方式擦除。
7 W# f6 l2 y3 y, s" G( b& V4 m- c
# J- N# U4 s5 Y9 K函数参数：
( H6 R' T' n  h- f5 @0 P  第1个参数是FLASH_EraseInitTypeDef类型结构体指针变量。
  第2个参数是错误码返回，返回0xFFFFFFFF表示全部正确，返回其它值是擦除过程中的错误扇区。
  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
) ]) o) Q# Y% S. ?% A  r, t
0 H9 g" a" [: i+ q* Z70.5 总结
本章节就为大家讲解这么多，对于内部Flash编程来说，掌握本章节的这些知识点就够用了，更多的知识点可以看STM32H7的参考手册学习。
. X, a; ^7 f( U+ d9 y) d* K
7 @$ U& d( G$ d3 ?( h
) w4 O# j6 b" x( O9 \
) j2 `% ]4 E% {$ M, X2 M