70.1 初学者重要提示
. N8 T# p$ j8 H! z4 f1 u8 [  本章2.5小节里面的Flash三级读保护是重点，务必要掌握明白。
1 ?/ R4 q; S: k- g- w9 ~1 Z  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是如果用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，用户应用程序将停止运行，包括中断服务程序。
  STM32H7的两个Flash BANK是256bit带宽，CPU访问是采用的两个64bit AXI总线。
4 Z) @; f2 S* P8 j# C/ X# ]  HAL库的内部Flash编程函数HAL_FLASH_Program固定编写32字节数据。
70.2 内部Flash基础知识
- h' f$ [# q3 [) V8 _1 p70.2.1 内部Flash的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解内部Flash的基本功能，然后再看手册了解细节。

% p6 r5 ^* j& Y5 }通过这个框图，我们可以得到如下信息：

  sys_ck时钟输入
/ O2 P0 N( S  gD1域总线时钟。

, Q7 [% x4 F. L: a* ~, d  po_rst输入
Power on reset 上电复位。
: r5 @1 D$ S1 C9 X
# C* f6 h$ [) q( f6 C6 `0 n  d1_rst输入
D1域系统复位。
/ l. T1 V/ l$ D7 K' {5 O/ k8 L
+ N* M$ _- a! u5 W  flash_it输出
flash中断请求输出。
; L0 q. z( j* N0 Z0 H) @
/ G; i+ _- O# v( e# X2 NSTM32H7的两个Flash BANK是独立的，读写和擦除互补影响，256bit带宽，CPU访问是采用的两个64bit AXI总线。
, t" ~4 n1 q4 R$ t/ b
6 ~$ R# M- \  G7 U0 X70.2.2 内部Flash框架
! i7 d6 A5 M* {. T! o4 m关于内部Flash的框架，了解以下几个知识点即可：

' e# c5 C' h- Y2 T3 T, r. {# W5 e  256bit为单位，即32字节，并且每个单位配10bit的ECC校验位。正是这个原因要求大家对Flash进行编程时，必须以32字节为单位。
. h) }) K$ I6 C" p- y0 O  V  两个独立的BANK，每个BANK有1MB容量。并且每个BANK的扇区大小固定为128KB，即8个扇区。

8 {$ m5 k" z( v0 i) H) ]6 K
& F+ T: m0 e* E7 FBANK1的地址范围：0x0800 0000到0x080F FFFF。
' y3 A% t  l2 s' U7 T
BANK2的地址范围：0x0810 0000到0x081F FFFF。

70.2.3 内部Flash读操作
STM32H7的内部Flash读操作跟内部RAM的读操作是一样的，支持64bit，32bit，16bt和8bit，使用比较简单。这里我们重点普及一个知识点，H7的内部Flash在不同主频下需要做的延迟参数：
; J. r! b* j: k3 {) H  W& E
7 s, I1 M5 W( Z  ?( K

对于上面的表格，大家可以看到，当延迟等待设置为0的时候，即无等待，单周期访问，速度可以做到70MHz。增加1个Flash周期后，访问速度可以做到140MHz。当增加到3个或4个Flash周期后，最高速度可以做到225MHz。

了解了这个知识点后，再来看下面的时序，非常具有参考意义：
3 M% f" o# I/ I6 C9 K2 i3 y3 b1 C
注：ACLK、ARADDR、ARVALID、RDATA、RVALID 和RLAST是AXI总线信号。Flash读和Flash数据是 Flash 接口信号。

3 K1 k  z) m) W0 a) g
关于这个时序要要认识到以下几点：
2 M/ X2 c# ]0 J0 `) n
  AXI总线发起读取信号后，Flash端等待了3个时钟周期（注意延迟三个周期，支持的Flash速度），之后连续读取了4个64bit数据。
; G) m  I5 N  f5 R7 l  由于AXI总线是64bit的，所以1次读取就可以读出64bit数据，连续读取4次后，就是256bit，即Flash接口的一组数据，因为H7的Flash接口带宽是256bit的。
9 p2 t8 }3 Z' d$ _* Y! L* ^  如果不开Flash Cache的情况下，连续读可以提升性能。

* P, \' T9 {6 v  s4 R+ Y3 L7 f" D下面是连续读取8个64bit数据的时序图，跟连续读取4个64bit数据基本是一样的，只是多读取了4组数据。

+ G0 K! g- m, a% [$ g
! q1 h4 x( W, ?/ R1 l  n  G70.2.4 内部Flash写入和擦除操作
最重要的知识点放在开头说：STM32H7内部Flash的写操作地址必须是32字节对齐（此地址对32求余数为0），写入的数据量也必须是32字节整数倍，不足32字节整数倍，补0也要是整数倍。

这里我们重点了解Flash的写入和擦除流程。Flash的写入扇区流程如下：

先保证这块扇区空间之前已经擦除过了。
解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
检查是否写保护，使能Flash可以编程，然后对其进行编程操作，编程完毕后，等待编程完成，然后禁止Flash编程位。具体操作可以通过HAL库的函数HAL_FLASH_Program实现。

Flash的擦除流程如下：
2 \: [- i" O" o0 ^; S3 y解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
如果是BANK1或者BANK2需要擦除，调用函数FLASH_MassErase，然后等待擦除完成，完成之后关闭BANK1和BANK2的擦除请求位BER1/BER2
9 V5 s4 Z  u/ _; t如果是扇区擦除，调用函数FLASH_Erase_Sector，然后等待擦除完成，完成之后关闭扇区的擦除请求位SER。


9 {  Z1 L2 s" e" a70.2.5 内部Flash读保护
; y& w& @6 [- s( K! B( W) r% {内部Flash支持三级读保护RDP（read out protection）。

  Level 0（无保护）
默认设置，所有读写和擦除操作都可以正常支持。

4 y7 r4 i; p2 v: A+ D- T3 `9 y/ |* S  Level 1 （Flash连接保护）
  可以防止连接调试器时读取Flash内容，或者RAM中存有恶意获取代码，也是禁止的。因此只要调试器连接芯片，或者从内部RAM启动运行代码，都是禁止访问内部Flash的。
# @" c3 p+ z) M  如果没有检测到从内部RAM启动和系统bootloader启动且没有连接调试器，对用户Flash的读写和擦除操作都是允许的，并且其它安全存储区也是可以访问的。否则是禁止访问的，一旦检测到对Flash的读请求，将产生总线错误。
  如果将Level 1切换到Level 0时，用户Flash区和安全区域将被擦除。
8 I! G/ ^9 p5 O/ L+ C5 e2 p
Level 2（设备保护和自举保护）
# i4 v/ V0 X  q" l  所有调试特性被关闭。
  v& N" ]1 _; e* q% B' X' t: n  禁止从RAM启动。
  除了选项字节里面的SWAP位可以配置，其它位都无法更改。
  禁止了调试功能，且禁止了从RAM和系统bootloader启动，用户Flash区是可以执行读写和擦除操作的，访问其它安全存储区也是可以的。
1 N* _2 r4 P4 i  B
特别注意：Level2修改是永久性的，一旦配置为Level2将不再支持被修改。
( i$ D  W  H( ?1 S% P4 a
' K$ C" n- Y8 {! i) a. T如果大家要设置读保护的话，使用HAL的API可以设置，也可以使用STM32CubeProg设置：
4 p! K+ U; Q. G" y) y3 A
+ i" b( M: S9 |, J

' b2 B) k+ K4 b! Q3 Y
% N; X( q  N6 a: F70.2.6 内部Flash选项字节
Flash选项字节主要用于boot地址设置，安全保护，Flash扇区保护等，涉及到的选项比较多。如果大家打算了解这一部分的话，使用STM32CubeProg进行设置即可，也比较方便。

1 I9 S6 b' e* f: B! L$ n
70.2.7 内部Flash的ECC校验
9 P+ h+ X3 W$ ^. ?# T! y" H这里先说下为什么内部Flash要带ECC校验，因为随着芯片的制造工艺水平越高，带电粒子产生的位翻转就越多，此时的ECC是必须要有的，一般可以纠正1-2个bit，安全等级高的Flash类存储器和RAM类都是必须要带ECC的。
* D/ D+ A8 _3 X, c7 |9 `
对于STM32H7带的ECC校验，一般不需要用户去管理。
6 J: j0 q8 s6 v2 P) Z% H
70.3 内部Flash的HAL库用法
" _' l7 G5 s% n70.3.1 内部Flash结构体FLASH_TypeDef
: c: [9 f8 v' L% N1 P/ ^( j内部Flash相关的寄存器是通过HAL库中的结构体FLASH_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
. c4 d* H4 z9 ^+ a- o' O0 L) @, h. `

1. typedef struct
   
2. {
   5 q; P$ s2 s3 o
3.   __IO uint32_t ACR;            
   + U. W' r! V. q5 e1 E/ G" _
4.   __IO uint32_t KEYR1;           
   
5.   __IO uint32_t OPTKEYR;         
   8 z# X" o7 \/ S2 |
6.   __IO uint32_t CR1;            
   
7.   __IO uint32_t SR1;            
   
8.   __IO uint32_t CCR1;         
   
9.   __IO uint32_t OPTCR;           
   
10.   __IO uint32_t OPTSR_CUR;      
    
11.   __IO uint32_t OPTSR_PRG;      
      O" b) y1 e% L7 o
12.   __IO uint32_t OPTCCR;         
    
13.   __IO uint32_t PRAR_CUR1;      
    
14.   __IO uint32_t PRAR_PRG1;      
    9 E% C: Y" _) a' n
15.   __IO uint32_t SCAR_CUR1;      
    ) f) f2 l- Z# k' a7 [3 M8 x. o6 C& ]
16.   __IO uint32_t SCAR_PRG1;      
    6 ]7 X7 i& n5 M+ V7 X
17.   __IO uint32_t WPSN_CUR1;      
    3 g  Y2 c: |" K" v- v
18.   __IO uint32_t WPSN_PRG1;      
    ( _. M  _- @* p  |& i3 ^* X# M7 E
19.   __IO uint32_t BOOT_CUR;      
    7 G: h( S$ ^* ?, M5 ]3 C1 f. V
20.   __IO uint32_t BOOT_PRG;      
    # q7 Z- r, M! z7 I3 c1 \* {
21.   uint32_t      RESERVED0[2];   
    
22.   __IO uint32_t CRCCR1;         
    & \) Q' q3 E+ v
23.   __IO uint32_t CRCSADD1;      
    ) X! ]& R+ M! D$ ^
24.   __IO uint32_t CRCEADD1;        
    
25.   __IO uint32_t CRCDATA;         
    " |$ i9 M+ G6 v* l6 u
26.   __IO uint32_t ECC_FA1;         
    
27.   uint32_t      RESERVED1[40];  
    $ Z" b$ C5 @' f+ Z# p: c: _
28.   __IO uint32_t KEYR2;           
    4 N/ }) R) ^$ L3 s! D7 L& [
29.   uint32_t      RESERVED2;      
    
30.   __IO uint32_t CR2;            
    , l; A& Q$ d" F4 B- V  q# Q9 L
31.   __IO uint32_t SR2;            
    # G$ [4 c4 l& V; j( S& X: \' O
32.   __IO uint32_t CCR2;            
    
33.   uint32_t      RESERVED3[4];   
    1 u/ t/ ^4 H: `3 b8 W# c
34.   __IO uint32_t PRAR_CUR2;      
    
35.   __IO uint32_t PRAR_PRG2;      
    
36.   __IO uint32_t SCAR_CUR2;      
      z8 l9 t# C  Q' n( o, S
37.   __IO uint32_t SCAR_PRG2;      
    
38.   __IO uint32_t WPSN_CUR2;      
    ' T3 t% F. w) x% o) M3 e
39.   __IO uint32_t WPSN_PRG2;      
    
40.   uint32_t      RESERVED4[4];   
    ' Y- o/ h9 |* ^; u2 q; F; P( r( j
41.   __IO uint32_t CRCCR2;         
    
42.   __IO uint32_t CRCSADD2;        
    0 w# }6 p4 @0 ?+ I) m- |( o  o
43.   __IO uint32_t CRCEADD2;        
    
44.   __IO uint32_t CRCDATA2;        
      E' z5 K0 k8 N$ r! q
45.   __IO uint32_t ECC_FA2;         
    ' f! L* n  z. m+ \9 x
46. } FLASH_TypeDef;

复制代码

' @) ?+ ^+ R" U1 F6 a这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。
; v0 o8 r+ I2 w& `
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
7 T! R- q2 Z7 N

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   $ K6 E0 E- E# B* r: J3 P2 l
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

5 M7 V0 c6 a2 i3 T下面我们看下Flash的定义，在stm32h743xx.h文件。
. [8 u" L9 g3 C# }2 D

1. #define PERIPH_BASE              (0x40000000UL)
   
2. #define D1_AHB1PERIPH_BASE       (PERIPH_BASE + 0x12000000UL)
   
3. #define FLASH_R_BASE             (D1_AHB1PERIPH_BASE + 0x2000UL)
   ( l, G* I: T8 w1 C$ I/ Y0 g% @
4. #define FLASH                    ((FLASH_TypeDef *) FLASH_R_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x52002000

复制代码

我们访问Flash的CR1寄存器可以采用这种形式：FLASH->CR1 = 0。

: o4 K1 f1 `% _7 W70.3.2 内部Flash擦除结构体FLASH_EraseInitTypeDef
下面是做内部Flash擦除的结构体，用到的地方比较多：

6 O* y5 Q* s% `' p9 K$ c

1. typedef struct
   # C0 u  x9 X) A0 U/ \5 d
2. {
   
3.   uint32_t TypeErase;  
   
4.   uint32_t Banks;      
   " X3 v; S' `5 {8 a& Q9 M
5.   uint32_t Sector;      
   7 l$ f7 R* l6 r7 m$ v& H4 g4 I
6.   uint32_t NbSectors;   
   + [8 H. A  E4 H5 P$ U
7.   uint32_t VoltageRange;
   
8. } FLASH_EraseInitTypeDef;

复制代码

  E6 b" o) K4 ~2 ~8 i% l& O下面将结构体成员逐一做个说明：
  TypeErase


用于选择BANK擦除还是扇区擦除，H743有两个BANK，每个BANK有个8个扇区，每个扇区128KB。具体支持的参数如下：
9 N' g4 w$ M. J' b
7 d" X  n% t2 a6 }

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

复制代码

5 X1 Q6 o5 Q# U& j* b+ b* h# a& ]  Banks
用于选择要擦除的BANK，或者两个BANK都选择：
1 M5 ]$ |  q( s8 Z4 o

1. #define FLASH_BANK_1             0x01U                         /* Bank 1 */
   8 W' P, B* F7 M) i6 y, l- Y
2. #define FLASH_BANK_2             0x02U                         /* Bank 2 */
   % D1 p% A' p0 \. @9 _
3. #define FLASH_BANK_BOTH          (FLASH_BANK_1 | FLASH_BANK_2) /* Bank1 和 Bank2 */

复制代码

  Sector
# r4 i+ @& Y. c6 {& @' f8 A用于选择要擦除的扇区：

1. #define FLASH_SECTOR_0             0U       /* Sector Number 0   */
   
2. #define FLASH_SECTOR_1             1U       /* Sector Number 1   */
   2 e* W3 w7 _/ _0 B
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   */
   3 _, ~2 c4 A5 y$ K* ~9 ]
6. #define FLASH_SECTOR_5             5U       /* Sector Number 5   */
   ! u( X2 `8 I5 s
7. #define FLASH_SECTOR_6             6U       /* Sector Number 6   */
   
8. #define FLASH_SECTOR_7             7U       /* Sector Number 7   */

复制代码

2 A. s( ]2 f4 ~  NbSectors
用于设置要擦除的扇区个数，对于STM32H743来说，范围1到8。

  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 */
   * Y  Q+ q. Y, X
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 */

复制代码

3 _' [3 ?0 T" ]+ D# I7 @2 s70.3.3 内部Flash的操作总结
7 t6 C2 {8 h7 c0 Z0 b

使用方法由HAL库提供：
/ T# k+ E( c- Q( C9 M  Flash编程函数操作流程
  Flash解锁函数HAL_FLASH_Unlock。
  a; C  @" C) Q7 S! }% k  Flash查询方式编程HAL_FLASH_Program。
! N0 e+ ^# a7 f" S. V; d  Flash中断方式编程HAL_FLASH_Program_IT。
  Flash上锁函数HAL_FLASH_Lock。
/ \+ o. J" C6 j0 y5 i! r, j6 W  
; Q! [: F3 m. a9 n  F选项字节编程流程
  选项字节解锁函数HAL_FLASH_OB_Unlock。
  选项字节加载函数HAL_FLASH_OB_Launch。
  选项字节编程函数HAL_FLASHEx_OBProgram。
7 i* k+ k# |% _" H( M8 G  选项字节加锁函数HAL_FLASH_OB_Lock。

" v2 K+ a. B! E( D" c Flash擦除流程
  Flash解锁函数HAL_FLASH_Unlock。
" Z5 P2 [1 {  g/ g# G+ f& y8 ]  Flash查询方式擦除HAL_FLASHEx_Erase。
5 ~$ {% A. {' `% I/ q8 z  Flash中断方式擦除HAL_FLASHEx_Erase_IT。
2 @- Y3 j9 {0 E# Q) z4 _' K  Flash上锁函数HAL_FLASH_Lock。


! a) S4 I. V& O8 T- e70.4 内部Flash源文件stm32h7xx_hal_flash.c
% w) x/ Q! D2 H  ?3 `  J# o! i此文件涉及到的函数较多，这里把几个常用的函数做个说明：

9 o7 B# G2 ]! U" O% Y  HAL_FLASH_Unlock
  HAL_FLASH_Lock
  HAL_FLASHEx_Erase
  HAL_FLASH_Program
. k5 \6 z" y7 K; p( X$ Y5 y. {4 _
70.4.1 函数HAL_FLASH_Lock
函数原型：
/ [; Q0 _# ?* r0 J3 D  i
0 ]6 N# l. q5 x$ w

1. HAL_StatusTypeDef HAL_FLASH_Lock(void)
   - G6 h5 V! Z/ x, ^' T- u( p
2. {
   * V9 p: y( v7 r, h3 O; g+ C
3. /* 设置FLASH Bank1控制寄存器Lock位，即禁止访问 */
   
4.   SET_BIT(FLASH->CR1, FLASH_CR_LOCK);
   
5. 
   9 T1 k9 {. T! t
6. /* 验证Flash Bank1是否已经被锁住 */
   
7.   if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) == 0U)
   
8.   {
   , |. o. V; Z8 a/ f( p
9.     return HAL_ERROR;
   . [0 C7 D$ n8 n; ?
10.   }
    # t: G& n  y1 l
11. 
    
12. /* 设置FLASH Bank2控制寄存器Lock位，即禁止访问 */
    , M( Q8 V+ L! o; A: I
13.   SET_BIT(FLASH->CR2, FLASH_CR_LOCK);
    # E3 N! b- X9 m( u- G' I" R
14. 
    
15. /* 验证Flash Bank2是否已经被锁住 */
    
16.   if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) == 0U)
    
17.   {
    
18.     return HAL_ERROR;
    
19.   }
    
20. 
    
21.   return HAL_OK;
    
22. }

复制代码

函数描述：
( s; `- Q2 Y) n0 B! e& M8 l6 j
1 W3 P$ f) `+ A6 p6 I用于Flash加锁，加锁后将不能对Flash进行编程和擦除。
4 i  h- t6 i# b0 d
& O( ^' e3 I1 T, T6 ]70.4.2 函数HAL_FLASH_Unlock
函数原型：
6 B3 \2 {4 r6 c' y

1. HAL_StatusTypeDef HAL_FLASH_Unlock(void)
   & @0 b" `9 t( ?: U- O# @
2. {
   ) p% f# B5 C+ I9 u
3.   if(READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
   2 g" M+ R# Q& h
4.   {
   2 s" f; T6 D, q$ @: e
5.     /* 允许访问Flash Bank1 */
   
6.     WRITE_REG(FLASH->KEYR1, FLASH_KEY1);
   * O- Y5 w4 u: G. l! t5 {- M
7.     WRITE_REG(FLASH->KEYR1, FLASH_KEY2);
   
8. 
   
9.     /* 验证是否已经解锁 */
   
10.     if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
    
11.     {
    
12.       return HAL_ERROR;
    ( _" L0 L5 U3 j: p
13.     }
    / Y' u# A8 V8 l- X' o
14.   }
    # G* F/ R+ k1 v7 q: @% m
15. 
    , t! w9 d( |9 |1 v8 P5 ]4 h
16.   if(READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    
17.   {
    6 I  [% D% K& a$ [8 f2 O; d
18.     /* 允许访问Flash Bank2 */
    
19.     WRITE_REG(FLASH->KEYR2, FLASH_KEY1);
    
20.     WRITE_REG(FLASH->KEYR2, FLASH_KEY2);
    
21. 
    
22.     /* 验证是否已经解锁 */
    2 p: C4 s5 i) J( L  N/ ?0 y! Q0 Z
23.     if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    
24.     {
    + F0 S1 ^* b9 g0 ^
25.       return HAL_ERROR;
    6 ^+ N% F9 ^4 ~( [5 e
26.     }
    
27.   }
    ; U7 S  u% O2 Z% t" S* v
28. 
    
29.   return HAL_OK;
    ! R% A! G6 x& c4 I# t, R
30. }

复制代码

7 ]% X% j7 l, O' ?4 V: G4 \5 O函数描述：
0 P; x* h6 d6 {# Y
此函数用于Flash解锁，解锁后可以对Flash进行擦除和编程。

70.4.3 函数HAL_FLASH_Program
! |5 e, }8 H) k5 e; [! x函数原型：
# p1 v1 q# i7 j, f, ~; Y& m% e& ?

1. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t FlashAddress, uint32_t DataAddress)
   
2. {
   
3.   HAL_StatusTypeDef status;
   * f' C) D, K( `; P
4.   __IO uint32_t *dest_addr = (__IO uint32_t *)FlashAddress;
   
5.   __IO uint32_t *src_addr = (__IO uint32_t*)DataAddress;
   
6.   uint32_t bank;
   6 H! e9 s0 e* T) |! B* X8 w
7.   uint8_t row_index = FLASH_NB_32BITWORD_IN_FLASHWORD;
   
8. 
   " F7 a  C+ l" q/ S& o
9.   /* 检测参数 */
   
10.   assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
    
11.   assert_param(IS_FLASH_PROGRAM_ADDRESS(FlashAddress));
    4 a0 |- ^! U* N$ J+ v) J
12. 
    ) R' a% z- _" G9 t) v4 o
13.   /* 上锁 */
    + m7 R+ v  m5 [, J
14.   __HAL_LOCK(&pFlash);
    4 c% o' [$ s! O; u3 V
15. 
    $ }) U) s' Z& J6 q8 g1 j
16. #if defined (FLASH_OPTCR_PG_OTP)
    
17.   if((IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress)) || (IS_FLASH_PROGRAM_ADDRESS_OTP(FlashAddress)))
    / v1 F3 H  N6 u9 |5 y* p
18. #else
    
19.   if(IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress))
    
20. #endif
    
21.   {
    
22.     bank = FLASH_BANK_1;
    
23.   }
    
24.   else
    $ U, A5 p0 {9 [! d5 p3 R  G* b
25.   {
    0 m9 R+ V4 C! F; T( n1 y
26.     bank = FLASH_BANK_2;
    7 d# J% |; ]8 P$ \
27.   }
    
28. 
    - q& N9 o/ X) K" ?5 ]9 A
29.   /* 错误标识，无错误 */
    
30.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
31. 
    2 _  h; ~4 y, p; P, d* u7 {
32.   /* 等待操作完成 */
    1 r0 I  C/ Z# z+ f" d/ v; Z
33.   status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    : V+ `2 }! w5 n6 _
34. 
    
35.   if(status == HAL_OK)
    
36.   {
      _$ N/ C' e  p3 N
37.     if(bank == FLASH_BANK_1)
    ( {% ~. D. g& w1 G' Z* N: p
38.     {
    4 ]2 }" }& L+ v6 r/ x% @
39. #if defined (FLASH_OPTCR_PG_OTP)
    
40.       if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    ; ~& v8 K2 \1 @  U! U
41.       {
    9 y- |% C2 L; y# Z$ ^
42.         /* 设置OTP寄存器的PG位，使能可以编程 */
    / J/ @4 Z0 [/ }4 V- r7 j/ V
43.         SET_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    $ {# ^; S; J( [" ], \7 i
44.       }
    
45.       else
    
46. #endif
    
47.       {
    ; T1 Q4 L# Z# H& P7 }( V3 c. R
48.         /* 设置PG位，使能可编程 */
    % ~" Z" c1 V% i3 {' e3 H
49.         SET_BIT(FLASH->CR1, FLASH_CR_PG);
    
50.       }
    . Y$ p0 I' j/ B8 }/ F" U8 M
51.     }
    
52.     else
    # `! [) I7 S4 i: q2 `+ Q8 |
53.     {
    ! h" S6 M; w/ o
54.       /* 设置PG位 */
    . z' L. ^! z" j( x9 N5 ?
55.       SET_BIT(FLASH->CR2, FLASH_CR_PG);
    
56.     }
    $ n2 \, |, O$ q  I* M2 T/ Z1 M! d. o
57. 
    4 h) ^$ A) s9 s5 n
58.     __ISB();
    
59.     __DSB();
    * C# @% I' t+ c# H; K$ |% [/ ?) m2 ~9 }
60. 
    / J, ?8 f6 d$ H2 x' [: F
61. #if defined (FLASH_OPTCR_PG_OTP)
    
62.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    8 |2 {; o5 l7 F. R% O! {
63.     {
    5 ?' b8 D1 D) ~# B
64.       /* 编程OTP(16 bits) */
    
65.       *(__IO uint16_t *)FlashAddress = *(__IO uint16_t*)DataAddress;
    # h1 h' }9 [+ P" g% w% D9 _
66.     }
    
67.     else
    
68. #endif
    
69.     {
    $ m$ W5 I) j4 a# \
70.       /* 对Flash进行编程 */
    
71.       do
    
72.       {
    
73.         *dest_addr = *src_addr;
    
74.         dest_addr++;
    ) R% w+ s$ h3 F3 H! |7 V( l
75.         src_addr++;
    9 N4 n: P% S# e; G1 }& `4 b
76.         row_index--;
    
77.      } while (row_index != 0U);
    7 d% K5 R3 l! D; x3 i/ [: K
78.     }
    
79. 
    % ~0 P' Y! k/ I" n6 v8 U" ~
80.     __ISB();
    
81.     __DSB();
    
82. 
    
83.     /* 等待最后一次操作完成 */
    7 b6 Z" u& j7 H3 f2 V/ }4 k5 D
84.     status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    0 m+ I! n3 r  g7 e9 f
85. 
    
86. #if defined (FLASH_OPTCR_PG_OTP)
    
87.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
88.     {
    
89.       /* 如果编程操作完成，关闭OTP PG位 */
    6 R4 \! w) K* t% x6 d) R$ X6 i
90.       CLEAR_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    ; C: h" N$ z/ |
91.     }
    
92.     else
    " [  S( d2 c& |! K" ^9 R, }! U! F
93. #endif
    : ]' I9 W" T; O
94.     {
    
95.       if(bank == FLASH_BANK_1)
    
96.       {
    
97.         /* 如果操作完成，关闭PG位 */
    
98.         CLEAR_BIT(FLASH->CR1, FLASH_CR_PG);
    8 r' l' z. f9 j8 T: a- M1 B
99.       }
    
100.       else
     / J' N+ m* ~; M2 W. {$ K) T( r/ o
101.       {
     . B# D$ B/ Q0 J: \, p2 R' b
102.         /* 如果操作完成，关闭PG位 */
     
103.         CLEAR_BIT(FLASH->CR2, FLASH_CR_PG);
     
104.       }
     - ^3 M, R* h/ h4 K* h% C6 o8 s
105.     }
     . ~9 u4 p+ \) E+ i2 ~4 X
106.   }
     
107. 
     
108.   /* 解锁 */
     ' `/ p: M3 e9 j8 ~3 F
109.   __HAL_UNLOCK(&pFlash);
     
110. 
     
111.   return status;
     2 ~3 T4 P& a, h4 U1 }
112. }
     
113. 
     

复制代码

! _3 w! S' U2 G; }5 b, I- B! v函数描述：
. K/ Q6 ]7 c: ~此函数主要用于Flash编程，固定编程32个字节数据。

8 x, a1 l4 o  v2 w% W, D" M函数参数：
第1个参数是要编程的Flash类型，支持两种参数：
  FLASH_TYPEPROGRAM_FLASHWORD，用于芯片内部Flash编程。
  FLASH_TYPEPROGRAM_OTPWORD，用于芯片内部OTP存储区编程，当前的H743并没有这个区域，所以可以忽略。

" @  L6 u0 D- w# C第2个参数是要编程的Flash地址。

9 j' ]8 T0 E$ ^5 P& x3 Z第3个参数是要编程到Flash的数据地址。
返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
0 H9 y/ `* E  _

+ E1 l+ f3 W3 [, r7 d" A8 V: B注意事项：
  第2个参数的Flash地址要是32字节对齐的，即此地址对32求余等于0。
" l. v" L# a1 K0 u# b  第3个参数务必要是32字节的整数倍。

- R8 Z- B# F  r( B% G70.4.4 函数HAL_FLASHEx_Erase
函数原型：
( T/ Y+ d* B2 h  Z$ D1 v4 N

1. HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *SectorError)
   
2. {
   
3.   HAL_StatusTypeDef status = HAL_OK;
   ; }& s& J' c0 N/ ]
4.   uint32_t sector_index;
   ( m$ X" U2 S7 v& _+ ?
5. 
   
6. /* 检查参数 */
   9 w. I+ g0 L2 P4 T
7.   assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
   
8.   assert_param(IS_FLASH_BANK(pEraseInit->Banks));
   
9. 
   & x  Z' ?: r% n0 p* k* a2 w& ~9 N
10. /* 上锁 */
    5 r, F& I3 R: y. u( v& A2 o
11.   __HAL_LOCK(&pFlash);
    
12. 
      M% ^( ?! X' j1 g* a9 @
13. /* 无错误 */
    
14.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
15. 
    ' k  A; F% k# O8 R
16. /* 等待BANK1的操作完成 */
    
17.   if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    4 e( d$ P5 K' i, t- X# L" d  {
18.   {
    
19.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    1 T5 t- w! c, W1 E
20.     {
    
21.       status = HAL_ERROR;
    
22.     }
    
23.   }
    3 |- d: |# u! u6 v( S
24. 
    7 {9 ]) @3 C8 S0 [7 |
25. /* 等待BANK2的操作完成 */
    $ x' _5 ]$ Q$ p7 o" t
26.   if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    8 E$ z, o. \/ [( |
27.   {
    8 j& m' l( M- i- m" j  U
28.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2) != HAL_OK)
    
29.     {
    
30.       status = HAL_ERROR;
    & q0 m5 I8 ^# E  @( ^2 O" w
31.     }
    5 Z0 V+ X- g2 P( [
32.   }
    
33. 
    
34.   if(status == HAL_OK)
    
35.   {
    & ?. Y& {& a! O( N
36.     if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
    % e: r. S( u( f0 U. s( J
37.     {
    - j- b5 {/ S1 F- k. Q# Q5 i
38.   /* 整个BANK1或者BANK2擦除 */
    ; a' @' d/ n' u5 _* k* B/ O  |
39.       FLASH_MassErase(pEraseInit->VoltageRange, pEraseInit->Banks);
    
40. 
    
41.   /* 等待操作完成 */
    
42.       if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    : v9 S  x* M: i4 m$ O2 i
43.       {
    ) F* m% W, _4 T0 t( j1 c
44.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    * r: k) F/ C" J% ^
45.         {
    , Z, v" v- l5 N7 n1 Q) \
46.           status = HAL_ERROR;
    . H' A2 ^; V% x& ~( a4 b) v
47.         }
    
48.     /* 如果擦除完成，关闭BANK1的BER位 */
    : ]& I7 u: M* @" |" i( c- T( Z
49.         FLASH->CR1 &= (~FLASH_CR_BER);
    " x5 d% l5 F2 o) _
50.       }
    0 v8 `4 L5 {0 r
51.       if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    + J0 @3 v, h$ F5 {* m
52.       {
    
53.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2) != HAL_OK)
    
54.         {
    # c2 x0 q' o7 Z% Y. K/ O
55.           status = HAL_ERROR;
    9 U2 d, Z. @# B8 Z/ C" p
56.         }
    ! g( u' i; N- j. N# b( s; ^
57.     /* 如果擦除操作完成，关闭BANK2的BER位 */
    " e( j' p6 [9 W4 a
58.         FLASH->CR2 &= (~FLASH_CR_BER);
    8 T! c' L' c( i/ R4 w! j6 k
59.       }
    
60.     }
    
61.     else
    0 w7 _5 W+ m2 W- I' x' b! Y
62.     {
    1 n& T9 }; S7 H  s4 S
63.   /* 初始化扇区错误码 */
    " G& J8 b8 f' m, z
64.       *SectorError = 0xFFFFFFFFU;
    + W; C& d. N( g: Z6 X
65. 
    
66.   /* 扇区方式擦除 */
    . a3 `& h. E* C7 M! }
67.       for(sector_index = pEraseInit->Sector; sector_index < (pEraseInit->NbSectors + pEraseInit->Sector);
    9 ^- ~* }$ v1 S. K# H; x3 F
68. sector_index++)
    + Y/ Q" I: T5 {& z' b
69.       {
    # T2 B& J3 w: J& e& X
70.         FLASH_Erase_Sector(sector_index, pEraseInit->Banks, pEraseInit->VoltageRange);
    $ B' j- O: v2 ?  [( `% z
71. 
    * D. y1 T5 `4 w$ C+ \& d6 W3 D
72.         if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    
73.         {
    
74.       /* 等待BANK1操作完成 */
    3 o# W5 t* M5 Y4 A
75.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1);
    
76. 
    # n2 q/ N9 M! E) n& _9 U$ B
77.       /* 如果擦除操作完成，禁止SER位 */
    
78.           FLASH->CR1 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    
79.         }
    
80.         if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    
81.         {
    
82.       /* 等待BANK2操作完成 */
    % r4 Y# r4 ]6 n* r& G: r
83.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2);
    , N! A6 N' C. n0 B5 N
84. 
    
85.       /* 如果擦除操作完成，禁止SER位 */
    2 e3 L0 c6 q, a/ P+ w$ \
86.           FLASH->CR2 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    - m8 }0 ?- X3 F5 x4 @5 ]
87.         }
    
88. 
    
89.         if(status != HAL_OK)
    
90.         {
    
91.       /* 如果擦除出错，停止后续擦除，返回擦除异常的扇区号 */
    
92.           *SectorError = sector_index;
    
93.           break;
    & m5 U; k: x0 T# _( E
94.         }
    
95.       }
    
96.     }
    / Y; W- s" T% C( s! U" g' h
97.   }
    
98. 
    0 }( Q) R. \$ `9 N4 H3 T( P
99. /* 解锁 */
    ; h/ v1 N% Z: Y1 X  ?3 w. D
100.   __HAL_UNLOCK(&pFlash);
     7 n7 F% |1 E$ x2 m* U# h
101. 
     
102.   return status;
     
103. }
     

复制代码

函数描述：
用于内部Flash的批量擦除（BANK擦除）和扇区方式擦除。
- _5 C4 J9 W! v: X, i% ~1 o2 w) B. V4 a- C: K
( Y+ {( p5 E8 ?, l% Q. ?% T函数参数：
  第1个参数是FLASH_EraseInitTypeDef类型结构体指针变量。
+ O2 a+ L  q" T. e  第2个参数是错误码返回，返回0xFFFFFFFF表示全部正确，返回其它值是擦除过程中的错误扇区。
5 |- X9 [! I/ x* e4 ~  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

70.5 总结
3 F' X( k! A* t9 \# e本章节就为大家讲解这么多，对于内部Flash编程来说，掌握本章节的这些知识点就够用了，更多的知识点可以看STM32H7的参考手册学习。
8 J0 j- q3 W; d4 D8 r, Q
0 e7 w! {0 _4 p0 z& A7 @4 A( p