70.1 初学者重要提示
+ w9 E: z. H$ @' R. }! e  本章2.5小节里面的Flash三级读保护是重点，务必要掌握明白。
$ q. p3 H4 v8 L9 ~+ {5 u7 d! t  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是如果用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，用户应用程序将停止运行，包括中断服务程序。
- G4 B3 r. ?0 Z+ m6 M  \+ R  STM32H7的两个Flash BANK是256bit带宽，CPU访问是采用的两个64bit AXI总线。
  HAL库的内部Flash编程函数HAL_FLASH_Program固定编写32字节数据。
70.2 内部Flash基础知识
# I' T- Y% T2 u* b: y  L5 A70.2.1 内部Flash的硬件框图
" T) D$ ~. g. h0 _* f0 h7 L" _认识一个外设，最好的方式就是看它的框图，方便我们快速的了解内部Flash的基本功能，然后再看手册了解细节。
. K. D6 U: B- R

通过这个框图，我们可以得到如下信息：
! {# U: b2 {# D' h- ~; N8 s% {
( [; h1 @: b! |+ h+ n3 O7 j  sys_ck时钟输入
D1域总线时钟。
3 m1 O, ]" _8 X2 j
6 G/ F0 l4 g, I$ D; b5 U# v  po_rst输入
! [  ?# ^% n$ q! S/ Y% q+ NPower on reset 上电复位。
" V; U. C* p! f3 @  X1 j: ^
+ d; m' Z) X- a) v5 e5 ?( e6 A9 V  d1_rst输入
; n6 ^; j& S8 s" N* RD1域系统复位。

  flash_it输出
; E, W2 n9 E! a. g( f7 i- u  R) `4 |flash中断请求输出。
9 W0 S* V7 ~/ Y1 O0 i4 q
STM32H7的两个Flash BANK是独立的，读写和擦除互补影响，256bit带宽，CPU访问是采用的两个64bit AXI总线。
3 q' R4 g/ `" A+ T) e& ~! S
70.2.2 内部Flash框架
9 A5 C1 e- d* d3 x/ K1 s" l关于内部Flash的框架，了解以下几个知识点即可：
2 N- z2 `: ?) i5 N0 m
' z9 `" I& ~, ]5 `" t  256bit为单位，即32字节，并且每个单位配10bit的ECC校验位。正是这个原因要求大家对Flash进行编程时，必须以32字节为单位。
0 p. g0 [2 i+ D) u5 ~; i0 I: q4 `9 m  两个独立的BANK，每个BANK有1MB容量。并且每个BANK的扇区大小固定为128KB，即8个扇区。
$ o* X" i' C( S8 K( D' h5 [8 f

& M+ i# p5 j) Q6 q; y8 TBANK1的地址范围：0x0800 0000到0x080F FFFF。
) ~5 x# @) M6 k
BANK2的地址范围：0x0810 0000到0x081F FFFF。

70.2.3 内部Flash读操作
STM32H7的内部Flash读操作跟内部RAM的读操作是一样的，支持64bit，32bit，16bt和8bit，使用比较简单。这里我们重点普及一个知识点，H7的内部Flash在不同主频下需要做的延迟参数：

对于上面的表格，大家可以看到，当延迟等待设置为0的时候，即无等待，单周期访问，速度可以做到70MHz。增加1个Flash周期后，访问速度可以做到140MHz。当增加到3个或4个Flash周期后，最高速度可以做到225MHz。
4 r2 P1 [1 _! P8 X$ k0 j
  `: ~$ ?- c% z  I了解了这个知识点后，再来看下面的时序，非常具有参考意义：

% _5 a. @. h8 a注：ACLK、ARADDR、ARVALID、RDATA、RVALID 和RLAST是AXI总线信号。Flash读和Flash数据是 Flash 接口信号。
. i+ k6 Z7 k: {- X$ j) y

' M* d* d. }5 I0 e
关于这个时序要要认识到以下几点：

4 @- r2 u# K3 X- @, u  AXI总线发起读取信号后，Flash端等待了3个时钟周期（注意延迟三个周期，支持的Flash速度），之后连续读取了4个64bit数据。
7 l# L% `* D5 @+ D  由于AXI总线是64bit的，所以1次读取就可以读出64bit数据，连续读取4次后，就是256bit，即Flash接口的一组数据，因为H7的Flash接口带宽是256bit的。
  如果不开Flash Cache的情况下，连续读可以提升性能。
# f9 `) U: N! U# l: e; ?
下面是连续读取8个64bit数据的时序图，跟连续读取4个64bit数据基本是一样的，只是多读取了4组数据。
: G- F8 Y' ]. P: K. X1 D

70.2.4 内部Flash写入和擦除操作
0 T% T% H1 b7 X- h& h# c- |最重要的知识点放在开头说：STM32H7内部Flash的写操作地址必须是32字节对齐（此地址对32求余数为0），写入的数据量也必须是32字节整数倍，不足32字节整数倍，补0也要是整数倍。
; N* g6 I7 m( j
这里我们重点了解Flash的写入和擦除流程。Flash的写入扇区流程如下：

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

/ e' y/ X( _$ nFlash的擦除流程如下：
解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
7 F! y; K2 d; I  t3 f- k  ?1 t, ?如果是BANK1或者BANK2需要擦除，调用函数FLASH_MassErase，然后等待擦除完成，完成之后关闭BANK1和BANK2的擦除请求位BER1/BER2
如果是扇区擦除，调用函数FLASH_Erase_Sector，然后等待擦除完成，完成之后关闭扇区的擦除请求位SER。

# z7 ?* F0 n9 x1 Z$ _
7 ?  R; T  ~6 \0 H% h* t: J70.2.5 内部Flash读保护
内部Flash支持三级读保护RDP（read out protection）。
# w9 T) W+ s( y! w4 c' o; t. F  V  o, }
  Level 0（无保护）
  y) [8 C% v8 p( x9 m# K默认设置，所有读写和擦除操作都可以正常支持。

( S. d6 S7 }! I! t0 D# e  Level 1 （Flash连接保护）
7 q: ?5 U% J% m. {) b% v6 Q5 I  可以防止连接调试器时读取Flash内容，或者RAM中存有恶意获取代码，也是禁止的。因此只要调试器连接芯片，或者从内部RAM启动运行代码，都是禁止访问内部Flash的。
5 i, _" B& p: R7 H" _& J# M  如果没有检测到从内部RAM启动和系统bootloader启动且没有连接调试器，对用户Flash的读写和擦除操作都是允许的，并且其它安全存储区也是可以访问的。否则是禁止访问的，一旦检测到对Flash的读请求，将产生总线错误。
  如果将Level 1切换到Level 0时，用户Flash区和安全区域将被擦除。
& h! P! U" Q  i) |& o
Level 2（设备保护和自举保护）
  所有调试特性被关闭。
  禁止从RAM启动。
1 X6 f/ n. G+ F- O# R# V, ^, Q, I  除了选项字节里面的SWAP位可以配置，其它位都无法更改。
8 U2 ~% r6 U: W. x2 E2 f( r  禁止了调试功能，且禁止了从RAM和系统bootloader启动，用户Flash区是可以执行读写和擦除操作的，访问其它安全存储区也是可以的。
0 n( c' O, N9 N' _
特别注意：Level2修改是永久性的，一旦配置为Level2将不再支持被修改。
2 g6 ~; t2 M* q9 N! [/ h% v  B
如果大家要设置读保护的话，使用HAL的API可以设置，也可以使用STM32CubeProg设置：

( R, F2 _% ^! B  t3 N* d2 w: ~3 W

/ N# u7 s" ~; Q+ G* `& G70.2.6 内部Flash选项字节
2 ~: W3 ]5 w$ ^5 N4 i, uFlash选项字节主要用于boot地址设置，安全保护，Flash扇区保护等，涉及到的选项比较多。如果大家打算了解这一部分的话，使用STM32CubeProg进行设置即可，也比较方便。
, B$ I0 d( C- X8 @# J, h
5 q  z' r4 e) z0 S* F

70.2.7 内部Flash的ECC校验
这里先说下为什么内部Flash要带ECC校验，因为随着芯片的制造工艺水平越高，带电粒子产生的位翻转就越多，此时的ECC是必须要有的，一般可以纠正1-2个bit，安全等级高的Flash类存储器和RAM类都是必须要带ECC的。
/ P3 n- L- A' W+ r
- C4 D: P6 M  B7 ~& O对于STM32H7带的ECC校验，一般不需要用户去管理。
+ m% @% i- ]5 \' P, K
70.3 内部Flash的HAL库用法
70.3.1 内部Flash结构体FLASH_TypeDef
内部Flash相关的寄存器是通过HAL库中的结构体FLASH_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

1. typedef struct
   6 u& g  }. I, v, w" Y3 a
2. {
   
3.   __IO uint32_t ACR;            
   3 h0 E; ^; }# {% u. @" @
4.   __IO uint32_t KEYR1;           
   
5.   __IO uint32_t OPTKEYR;         
   3 p) s! q0 q0 b4 T
6.   __IO uint32_t CR1;            
   * n! R1 f  X5 _) Y! q3 z
7.   __IO uint32_t SR1;            
   
8.   __IO uint32_t CCR1;         
     X' F0 s% g2 d" G9 o
9.   __IO uint32_t OPTCR;           
   
10.   __IO uint32_t OPTSR_CUR;      
    
11.   __IO uint32_t OPTSR_PRG;      
      p! m( n! G$ W
12.   __IO uint32_t OPTCCR;         
    $ w) S6 `/ ^  {& S5 a0 L  U
13.   __IO uint32_t PRAR_CUR1;      
    4 T4 D4 H* @6 Y! w
14.   __IO uint32_t PRAR_PRG1;      
    
15.   __IO uint32_t SCAR_CUR1;      
    1 F; ^) z# e, c9 }$ j. b/ w
16.   __IO uint32_t SCAR_PRG1;      
    
17.   __IO uint32_t WPSN_CUR1;      
    0 p, ^- u4 M) j/ \
18.   __IO uint32_t WPSN_PRG1;      
    
19.   __IO uint32_t BOOT_CUR;      
    " S0 v$ `% w; D: @6 A0 O  E$ o' Y
20.   __IO uint32_t BOOT_PRG;      
    & m9 t7 d" |. e
21.   uint32_t      RESERVED0[2];   
    
22.   __IO uint32_t CRCCR1;         
    
23.   __IO uint32_t CRCSADD1;      
    ; h; |4 t( w7 ?
24.   __IO uint32_t CRCEADD1;        
    
25.   __IO uint32_t CRCDATA;         
    - s! g- e7 Z5 l8 b! T
26.   __IO uint32_t ECC_FA1;         
    
27.   uint32_t      RESERVED1[40];  
    ' ]( x: J7 A5 |) N
28.   __IO uint32_t KEYR2;           
    
29.   uint32_t      RESERVED2;      
    
30.   __IO uint32_t CR2;            
    
31.   __IO uint32_t SR2;            
    # e# w& Z/ d% m1 K5 |: F
32.   __IO uint32_t CCR2;            
    7 U! B, r8 H- s: g" e
33.   uint32_t      RESERVED3[4];   
    
34.   __IO uint32_t PRAR_CUR2;      
    
35.   __IO uint32_t PRAR_PRG2;      
    9 {. |) w+ x; f% U& U: z# w
36.   __IO uint32_t SCAR_CUR2;      
      v0 E" g# f1 s* C: c
37.   __IO uint32_t SCAR_PRG2;      
    
38.   __IO uint32_t WPSN_CUR2;      
    . m# G! U3 q8 M+ B$ j  W
39.   __IO uint32_t WPSN_PRG2;      
    
40.   uint32_t      RESERVED4[4];   
    
41.   __IO uint32_t CRCCR2;         
    
42.   __IO uint32_t CRCSADD2;        
    
43.   __IO uint32_t CRCEADD2;        
    
44.   __IO uint32_t CRCDATA2;        
    
45.   __IO uint32_t ECC_FA2;         
    
46. } FLASH_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。

$ w4 G. D1 ^2 N" d2 W__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   % W* I, z6 w- K- k% h7 M% T
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

  l6 Y% u* v) t6 W! v$ U8 W下面我们看下Flash的定义，在stm32h743xx.h文件。
7 b0 C. u# T% @8 D

1. #define PERIPH_BASE              (0x40000000UL)
   
2. #define D1_AHB1PERIPH_BASE       (PERIPH_BASE + 0x12000000UL)
   & ~- G( e& F. F1 n. Q( H: V
3. #define FLASH_R_BASE             (D1_AHB1PERIPH_BASE + 0x2000UL)
   
4. #define FLASH                    ((FLASH_TypeDef *) FLASH_R_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x52002000

复制代码

9 z/ z! u; q# }6 i  ]9 v' L我们访问Flash的CR1寄存器可以采用这种形式：FLASH->CR1 = 0。

70.3.2 内部Flash擦除结构体FLASH_EraseInitTypeDef
8 U6 V7 b, g4 D: g- p下面是做内部Flash擦除的结构体，用到的地方比较多：
7 U7 w8 |# L5 L% O. I2 a# ?  N6 r
$ ?- g3 Q% v9 Q2 E. Z

1. typedef struct
   % V6 \) E; E9 r/ _/ B& h4 r
2. {
   ) {! m5 B$ N5 \" ?8 t* s. L9 k1 f
3.   uint32_t TypeErase;  
   
4.   uint32_t Banks;      
   
5.   uint32_t Sector;      
     X5 \, z5 D  g; f+ |/ G, ^
6.   uint32_t NbSectors;   
   ' d3 l3 d$ L4 ?$ [* j3 }) w
7.   uint32_t VoltageRange;
   ) l: y9 D3 P. E3 A( ~9 X
8. } FLASH_EraseInitTypeDef;

复制代码

下面将结构体成员逐一做个说明：
: N2 S; y+ R( H  TypeErase
9 a* Q; Q" L% |9 f  L
* j( o, h" G: Q& {1 \
8 X0 i. m$ m% ~( Y用于选择BANK擦除还是扇区擦除，H743有两个BANK，每个BANK有个8个扇区，每个扇区128KB。具体支持的参数如下：
7 M2 [: N3 n1 U+ G8 @3 Q; Z* x

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

复制代码

  Banks
: W% ^. T- i, i8 l) U  _. ~1 ]9 E0 a用于选择要擦除的BANK，或者两个BANK都选择：

1. #define FLASH_BANK_1             0x01U                         /* Bank 1 */
   1 ]! |& ?6 k7 ]% j
2. #define FLASH_BANK_2             0x02U                         /* Bank 2 */
   
3. #define FLASH_BANK_BOTH          (FLASH_BANK_1 | FLASH_BANK_2) /* Bank1 和 Bank2 */

复制代码

; A: W& y/ Y( ~; \3 P- |  Sector
用于选择要擦除的扇区：

1. #define FLASH_SECTOR_0             0U       /* Sector Number 0   */
   
2. #define FLASH_SECTOR_1             1U       /* Sector Number 1   */
   . L7 d) T5 k2 j  U
3. #define FLASH_SECTOR_2             2U       /* Sector Number 2   */
   , Q4 p! @. F/ [- H7 p; h
4. #define FLASH_SECTOR_3             3U       /* Sector Number 3   */
   & b1 @# R9 Q+ H/ e$ H
5. #define FLASH_SECTOR_4             4U       /* Sector Number 4   */
   
6. #define FLASH_SECTOR_5             5U       /* Sector Number 5   */
   
7. #define FLASH_SECTOR_6             6U       /* Sector Number 6   */
   5 Q/ ]2 \# p0 c. C! a% G! i6 C
8. #define FLASH_SECTOR_7             7U       /* Sector Number 7   */

复制代码

  NbSectors
  q! h* X2 F0 b/ h9 i用于设置要擦除的扇区个数，对于STM32H743来说，范围1到8。
5 u9 J+ l" \1 M  _6 J) z- ?
; U3 q6 J  X2 T: y5 R" L  VoltageRange
/ l4 B, p/ E0 _" X( Y3 T+ X用于设置编程的并行位数，电压不同，位数不同：

1. #define FLASH_VOLTAGE_RANGE_1        0x00000000U       /* Flash program/erase by 8 bits  */
   5 ~: |7 a% _9 D7 l8 _4 h/ K) M
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 */
   8 U  k9 T. ]/ G( K1 u; o# p
4. #define FLASH_VOLTAGE_RANGE_4        FLASH_CR_PSIZE    /* Flash program/erase by 64 bits */

复制代码

. N+ L  a/ C+ h! M3 I
70.3.3 内部Flash的操作总结
1 v6 N5 Y+ i$ T, T) a

: B$ A+ c5 ~+ g& V使用方法由HAL库提供：
  Flash编程函数操作流程
7 x, T5 K* k, ?( E: w( u' c7 d" }  Flash解锁函数HAL_FLASH_Unlock。
% A# I- B* y6 {; X  Flash查询方式编程HAL_FLASH_Program。
  Flash中断方式编程HAL_FLASH_Program_IT。
  Flash上锁函数HAL_FLASH_Lock。
- _0 j% Q8 ^* w* `; h  
选项字节编程流程
4 H$ P/ u! R, O4 X& _2 C$ ?4 P' U  选项字节解锁函数HAL_FLASH_OB_Unlock。
$ j) }( w6 P* _. x4 ]+ W  选项字节加载函数HAL_FLASH_OB_Launch。
  选项字节编程函数HAL_FLASHEx_OBProgram。
  选项字节加锁函数HAL_FLASH_OB_Lock。

" t$ x1 W, }2 a; Q Flash擦除流程
  Flash解锁函数HAL_FLASH_Unlock。
* X; q$ U- u" G( m% t. }6 y  Flash查询方式擦除HAL_FLASHEx_Erase。
  Flash中断方式擦除HAL_FLASHEx_Erase_IT。
( i& o; x( a4 V5 o, M1 T5 r( v- q  Flash上锁函数HAL_FLASH_Lock。
4 N- R1 R9 M3 i) }9 X, }+ S

70.4 内部Flash源文件stm32h7xx_hal_flash.c
此文件涉及到的函数较多，这里把几个常用的函数做个说明：

# D9 g; _6 T5 G. r  HAL_FLASH_Unlock
. O  `% y- b- J9 S' J* Q  HAL_FLASH_Lock
" e; u, |  V# l# K& ]1 c  HAL_FLASHEx_Erase
) h/ y/ u) I, P6 i" r0 M  HAL_FLASH_Program

/ [' d- A; k6 N2 X' j4 j* |+ M70.4.1 函数HAL_FLASH_Lock
$ M" o1 |; ^! j: T函数原型：

" a1 }8 d2 _: ?* r% d3 y" `. ]

1. HAL_StatusTypeDef HAL_FLASH_Lock(void)
   
2. {
   
3. /* 设置FLASH Bank1控制寄存器Lock位，即禁止访问 */
   
4.   SET_BIT(FLASH->CR1, FLASH_CR_LOCK);
   8 f. G" F- E8 K; d* m
5. 
   
6. /* 验证Flash Bank1是否已经被锁住 */
   , x, |0 O/ e6 }6 T" [$ I7 B8 ?
7.   if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) == 0U)
   
8.   {
   / d& Q, _+ s4 {' A4 V
9.     return HAL_ERROR;
   
10.   }
    
11. 
    
12. /* 设置FLASH Bank2控制寄存器Lock位，即禁止访问 */
    7 f  b4 ?5 l8 m: S: f! Q
13.   SET_BIT(FLASH->CR2, FLASH_CR_LOCK);
    0 G+ |0 j+ b: W6 J
14. 
    
15. /* 验证Flash Bank2是否已经被锁住 */
    + f0 i" F! p- h+ x$ K, M3 h) `5 o1 S6 ]
16.   if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) == 0U)
    
17.   {
    
18.     return HAL_ERROR;
    
19.   }
    
20. 
    % \: ^7 v/ M) V  a+ }
21.   return HAL_OK;
    3 d2 W- E; o* R4 _/ A/ _3 L+ p
22. }

复制代码

函数描述：
$ C2 K) n1 J" _" W
用于Flash加锁，加锁后将不能对Flash进行编程和擦除。

9 ?  m7 W& ^- G1 n70.4.2 函数HAL_FLASH_Unlock
函数原型：
5 P7 `$ y0 }) M( z4 ~

1. HAL_StatusTypeDef HAL_FLASH_Unlock(void)
   & N5 z! X6 e8 Y3 H6 y# w
2. {
   5 O* s5 V0 P0 W) K5 e3 u
3.   if(READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
   
4.   {
   & e* r2 y( d' A* Q2 k# L3 t
5.     /* 允许访问Flash Bank1 */
   1 r- S  b2 @5 m0 Q0 j* K! ]
6.     WRITE_REG(FLASH->KEYR1, FLASH_KEY1);
   
7.     WRITE_REG(FLASH->KEYR1, FLASH_KEY2);
   : A8 M8 I+ x1 K( I% w
8. 
   7 P7 @# l. x( A+ ~4 B9 g
9.     /* 验证是否已经解锁 */
     [/ G0 r: \% ~. r  M+ E* q/ w
10.     if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
    8 ~  R. `! _7 e- p3 u, d
11.     {
    , b4 u7 U8 F7 e. `
12.       return HAL_ERROR;
    " o3 y0 @7 T+ B% m+ F  \
13.     }
    " r6 y" v+ J) J/ D
14.   }
    9 \2 R2 U. Z1 N/ ]8 R2 j4 Y- l
15. 
    ; n1 i6 p' t& ^& _) l/ I
16.   if(READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    
17.   {
    
18.     /* 允许访问Flash Bank2 */
    5 p; L# i3 j+ n$ B- F3 a
19.     WRITE_REG(FLASH->KEYR2, FLASH_KEY1);
    
20.     WRITE_REG(FLASH->KEYR2, FLASH_KEY2);
    + c( U, t# x2 c6 m1 c" t: j
21. 
    9 c5 K2 _" ^  ]  t4 \- e
22.     /* 验证是否已经解锁 */
    
23.     if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    : R+ _& A1 Q3 Z: W  p5 ]
24.     {
    
25.       return HAL_ERROR;
    
26.     }
    
27.   }
    
28. 
    
29.   return HAL_OK;
    
30. }

复制代码

函数描述：
) m: `% W$ k1 }: V
此函数用于Flash解锁，解锁后可以对Flash进行擦除和编程。
" N( Z8 d6 w* m
70.4.3 函数HAL_FLASH_Program
函数原型：

1. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t FlashAddress, uint32_t DataAddress)
   ) `0 N2 R- @$ i# B" u5 b) X) N
2. {
   + B% m6 F3 R3 f0 x5 b
3.   HAL_StatusTypeDef status;
   
4.   __IO uint32_t *dest_addr = (__IO uint32_t *)FlashAddress;
   
5.   __IO uint32_t *src_addr = (__IO uint32_t*)DataAddress;
   
6.   uint32_t bank;
   / s; f: y' t7 f- D* U$ ]* I
7.   uint8_t row_index = FLASH_NB_32BITWORD_IN_FLASHWORD;
   
8. 
   
9.   /* 检测参数 */
   & L$ R% L) @8 v& D
10.   assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
    
11.   assert_param(IS_FLASH_PROGRAM_ADDRESS(FlashAddress));
    
12. 
    1 ?9 |/ }. t, h7 b& T8 [2 F: v2 \
13.   /* 上锁 */
    * t5 s  H  v0 y9 t' \+ U: a$ f& \
14.   __HAL_LOCK(&pFlash);
    
15. 
    
16. #if defined (FLASH_OPTCR_PG_OTP)
    * V6 Q6 n7 I' b' g" W) y& R) [
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
    , `$ L2 [7 X! a" A
21.   {
    
22.     bank = FLASH_BANK_1;
    
23.   }
    ' o: \7 H7 l: ~2 M8 C
24.   else
    , I% _' o6 W; E: A( `
25.   {
    
26.     bank = FLASH_BANK_2;
    
27.   }
    
28. 
    ! I0 Y8 N2 A* t0 x
29.   /* 错误标识，无错误 */
    ; M% u  W" [  K0 q: \2 p) [
30.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    ( l0 F. b4 W) g% F, W( Q& h* w" D
31. 
    " M/ W% b2 y5 Y8 s
32.   /* 等待操作完成 */
    
33.   status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    
34. 
    
35.   if(status == HAL_OK)
    # \/ B& e8 E5 \" z& Y
36.   {
    & q. l/ d2 y! Z2 I* H& l
37.     if(bank == FLASH_BANK_1)
    
38.     {
    
39. #if defined (FLASH_OPTCR_PG_OTP)
    
40.       if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
41.       {
    
42.         /* 设置OTP寄存器的PG位，使能可以编程 */
    
43.         SET_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    
44.       }
    
45.       else
    
46. #endif
    0 |$ M, N6 E# B( }' v2 J, _" C
47.       {
    4 E% U0 O( R, }% k2 ]
48.         /* 设置PG位，使能可编程 */
    
49.         SET_BIT(FLASH->CR1, FLASH_CR_PG);
    1 X1 l0 z5 B" A  c( G
50.       }
    
51.     }
    
52.     else
    : d. B8 M+ b7 o! O4 i' P/ d, K+ L% ?# P
53.     {
    
54.       /* 设置PG位 */
    
55.       SET_BIT(FLASH->CR2, FLASH_CR_PG);
    # P: H0 p& m, _2 H( J# G* H$ v( A
56.     }
    
57. 
    9 M8 R/ y" L- @/ Y" u
58.     __ISB();
    
59.     __DSB();
    
60. 
    7 K* s) m$ k8 g0 [
61. #if defined (FLASH_OPTCR_PG_OTP)
    
62.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
63.     {
    % j1 J( K3 |8 l% z' s1 {
64.       /* 编程OTP(16 bits) */
    
65.       *(__IO uint16_t *)FlashAddress = *(__IO uint16_t*)DataAddress;
    4 w' x' D  z' e0 e: l
66.     }
    
67.     else
    * m. Z5 A" ?' ~6 D" k
68. #endif
    
69.     {
    
70.       /* 对Flash进行编程 */
    
71.       do
    
72.       {
    , I- p  x, d8 f" Q  D
73.         *dest_addr = *src_addr;
    
74.         dest_addr++;
    
75.         src_addr++;
    
76.         row_index--;
    
77.      } while (row_index != 0U);
    . [$ b9 r8 K; l  i" i
78.     }
    
79. 
    
80.     __ISB();
    / N2 F1 f8 a- v" F5 {/ z
81.     __DSB();
    
82. 
    
83.     /* 等待最后一次操作完成 */
    
84.     status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    " Y, Y* l( J( F# s
85. 
    
86. #if defined (FLASH_OPTCR_PG_OTP)
    
87.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
88.     {
    ; X" E6 k( A5 e2 f/ ~+ e, u
89.       /* 如果编程操作完成，关闭OTP PG位 */
    
90.       CLEAR_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    6 [! Y* o# j7 a$ i/ @
91.     }
    & x+ U# w/ d; o$ l
92.     else
    
93. #endif
    6 U, r0 ^, K/ k
94.     {
    
95.       if(bank == FLASH_BANK_1)
    
96.       {
    2 F3 W! j/ x! y* |# h
97.         /* 如果操作完成，关闭PG位 */
    # P# O7 t1 w) J, C
98.         CLEAR_BIT(FLASH->CR1, FLASH_CR_PG);
    ! y# E- r% }# \1 X- d) n/ x* q
99.       }
    
100.       else
     
101.       {
     
102.         /* 如果操作完成，关闭PG位 */
     ! W- M* r4 p& S2 |, y
103.         CLEAR_BIT(FLASH->CR2, FLASH_CR_PG);
     & j$ b1 h: _" H5 O6 R
104.       }
     4 K$ M' ^. N& f. l
105.     }
     # Y8 L, P0 t" Q- X' Y' }
106.   }
     
107. 
     - K: n4 x) C' n! F" L! o
108.   /* 解锁 */
     
109.   __HAL_UNLOCK(&pFlash);
     
110. 
     
111.   return status;
     5 o. Z/ t) [$ R# [' \
112. }
     $ W0 e5 Q+ w" F5 P4 V" i
113. 
     

复制代码

; a1 F9 ~4 i! y; S- \& l  {4 {7 Z函数描述：
) e3 @0 e9 `* d此函数主要用于Flash编程，固定编程32个字节数据。
) u8 V4 u2 U# a/ ~
函数参数：
第1个参数是要编程的Flash类型，支持两种参数：
  FLASH_TYPEPROGRAM_FLASHWORD，用于芯片内部Flash编程。
" B# @2 K1 P& a4 E6 F; ]  FLASH_TYPEPROGRAM_OTPWORD，用于芯片内部OTP存储区编程，当前的H743并没有这个区域，所以可以忽略。
, U" f% z, I. J3 s" P
第2个参数是要编程的Flash地址。
! S8 i) t2 ~$ ^) \! ^) i- q
$ u$ C/ n- F1 b+ A5 a( S5 ~第3个参数是要编程到Flash的数据地址。
5 Q- j3 b2 H" A" P0 g: {! O( c) y) V返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
: F, T1 T7 g4 V3 X7 W
8 c9 [9 f- X: m' N# U; f$ Y5 w
注意事项：
  第2个参数的Flash地址要是32字节对齐的，即此地址对32求余等于0。
  D) t1 r5 m* M4 a$ V/ H  第3个参数务必要是32字节的整数倍。

70.4.4 函数HAL_FLASHEx_Erase
函数原型：

1. HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *SectorError)
   
2. {
   - s+ ~) a$ ~2 c- j
3.   HAL_StatusTypeDef status = HAL_OK;
   , X' n0 D/ r5 Q
4.   uint32_t sector_index;
   
5. 
   & V, ^+ D5 H) [/ }: z$ G3 {$ Q
6. /* 检查参数 */
   ( E9 c/ t' W! ^( o( V9 @
7.   assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
   
8.   assert_param(IS_FLASH_BANK(pEraseInit->Banks));
   ) G3 h5 S: e1 W% N: ^
9. 
   ! Z) I/ A- w! ]6 \$ a8 M3 M* w  d
10. /* 上锁 */
    & {- d! j/ J9 I% k: o! {
11.   __HAL_LOCK(&pFlash);
    
12. 
    ) m/ l; F( D- U6 f
13. /* 无错误 */
    2 x8 v4 `, y3 P, ?1 [
14.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    : @1 k: H0 z, C
15. 
    $ U3 u! W% |6 g2 k# b  L4 T
16. /* 等待BANK1的操作完成 */
    
17.   if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    
18.   {
    7 Y+ B3 t4 V4 r/ P
19.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
      ]4 y5 e( B! B  D) L
20.     {
    
21.       status = HAL_ERROR;
    / Z1 e: a. T, V7 u: @6 L& N
22.     }
    
23.   }
    , }  k: q, g$ d$ z2 o( A6 p* V* V
24. 
    
25. /* 等待BANK2的操作完成 */
    " M" f3 B2 u; N8 Y
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)
    8 a; @. A6 h6 x) X  y$ q
29.     {
    " j" C6 |4 L& i( O5 u; j
30.       status = HAL_ERROR;
    ( j6 h2 i: X2 _0 L" Y6 V& Y
31.     }
    0 p) I- o) i4 t
32.   }
    - g4 D$ i5 B$ b1 @: A1 g5 P4 B8 W: q
33. 
    
34.   if(status == HAL_OK)
    
35.   {
    
36.     if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
    
37.     {
    5 d: W6 Z+ X5 y7 s5 A4 @/ g
38.   /* 整个BANK1或者BANK2擦除 */
    " W8 j  |9 ]/ ]
39.       FLASH_MassErase(pEraseInit->VoltageRange, pEraseInit->Banks);
    
40. 
    2 _9 {7 {7 f- ]) f
41.   /* 等待操作完成 */
    0 Z/ [, S& w/ N! E, @: B
42.       if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    . d  o7 ^$ V9 I5 F
43.       {
    - y& [6 i9 w% K$ ]( M
44.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    
45.         {
    
46.           status = HAL_ERROR;
    
47.         }
    
48.     /* 如果擦除完成，关闭BANK1的BER位 */
    
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)
    - G6 E+ a3 O* F! _8 i4 _
54.         {
    - o! U; w( V5 w5 t
55.           status = HAL_ERROR;
    
56.         }
    
57.     /* 如果擦除操作完成，关闭BANK2的BER位 */
    6 g3 I0 p* {: d& C$ M% z, Z' h1 y
58.         FLASH->CR2 &= (~FLASH_CR_BER);
    ) e! c8 x5 Y% C, M9 c; Z) H7 T5 K5 x
59.       }
    
60.     }
    
61.     else
    5 V7 W0 a: a( w& b9 O! m1 O3 h
62.     {
    
63.   /* 初始化扇区错误码 */
      `1 X) y- @) ~: b& o2 a" w
64.       *SectorError = 0xFFFFFFFFU;
    
65. 
    
66.   /* 扇区方式擦除 */
    
67.       for(sector_index = pEraseInit->Sector; sector_index < (pEraseInit->NbSectors + pEraseInit->Sector);
    
68. sector_index++)
    
69.       {
    1 ?1 B% ^/ g$ [
70.         FLASH_Erase_Sector(sector_index, pEraseInit->Banks, pEraseInit->VoltageRange);
    5 a9 m5 i! @; _' u. P
71. 
    4 `2 `2 `& z8 o0 A. Z( W
72.         if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    
73.         {
    
74.       /* 等待BANK1操作完成 */
    
75.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1);
    
76. 
    9 Q! O( y1 s& I% ]: M" A4 V
77.       /* 如果擦除操作完成，禁止SER位 */
    6 ?1 b. {% ~7 F* u2 V/ w" x2 z
78.           FLASH->CR1 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
      p! W$ j3 ]/ s; @& c! c
79.         }
    
80.         if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    
81.         {
    : f: y* {1 w7 @& \! _8 F0 B5 t/ A: M
82.       /* 等待BANK2操作完成 */
    
83.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2);
    - D9 l' z. U7 C8 s( g2 J
84. 
    
85.       /* 如果擦除操作完成，禁止SER位 */
    6 l3 Q) V' Q" w* A6 Z' k/ x+ |6 ^0 I
86.           FLASH->CR2 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    
87.         }
    % c( r: [: M% f4 q
88. 
    
89.         if(status != HAL_OK)
    
90.         {
    9 Q% Z( Q* T% M0 j. y1 n. ~
91.       /* 如果擦除出错，停止后续擦除，返回擦除异常的扇区号 */
    + i. B% \  j- a% F- e% f
92.           *SectorError = sector_index;
    . ^5 W/ ^1 K: e4 ~& q/ v3 B
93.           break;
    
94.         }
    ( s* f2 h$ \1 t- I
95.       }
    
96.     }
    , B8 P, u5 `$ m& A9 r! @  r
97.   }
    / Z5 Q1 f. Y7 c. K$ }6 Q
98. 
    3 w" b% S1 Q1 F# G0 |+ o, u+ d/ a3 @' P
99. /* 解锁 */
    # j% ^0 l# L2 J$ S! \0 e2 E  m% a
100.   __HAL_UNLOCK(&pFlash);
     
101. 
     
102.   return status;
     $ ]5 u+ }/ c( S0 x8 d
103. }
     ' E, q% z. w2 r' x  z+ C$ n9 m

复制代码

* s9 `5 `$ ?: m函数描述：
用于内部Flash的批量擦除（BANK擦除）和扇区方式擦除。

函数参数：
  第1个参数是FLASH_EraseInitTypeDef类型结构体指针变量。
; G. `1 C% _" ]5 v( Y) @" O  第2个参数是错误码返回，返回0xFFFFFFFF表示全部正确，返回其它值是擦除过程中的错误扇区。
% T# O: q( F; i1 H, _! t  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

70.5 总结
  s6 y1 E, B+ @" U3 [- q本章节就为大家讲解这么多，对于内部Flash编程来说，掌握本章节的这些知识点就够用了，更多的知识点可以看STM32H7的参考手册学习。
- J* I  j) p9 \  o
% Q. V7 S# G5 D1 E" X
% b6 u6 F; a% }5 o+ p
9 e* N, i6 r* R( a8 p) d5 B