70.1 初学者重要提示
& L  B- t" Z7 F/ }( m  本章2.5小节里面的Flash三级读保护是重点，务必要掌握明白。
  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是如果用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，用户应用程序将停止运行，包括中断服务程序。
& Z0 r2 @6 z0 D( X! Y  STM32H7的两个Flash BANK是256bit带宽，CPU访问是采用的两个64bit AXI总线。
  HAL库的内部Flash编程函数HAL_FLASH_Program固定编写32字节数据。
70.2 内部Flash基础知识
70.2.1 内部Flash的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解内部Flash的基本功能，然后再看手册了解细节。

通过这个框图，我们可以得到如下信息：
$ R6 A% U. E0 H# }4 |% C
  sys_ck时钟输入
8 h) E9 o/ F, S& RD1域总线时钟。

5 Z3 `# u/ d# B9 j1 i5 T  po_rst输入
Power on reset 上电复位。
2 p# [5 v) W. [# R( \& z) u; s: C6 ~
  d1_rst输入
( m- X  u4 ?2 s. T& N) K% V' H8 e) _. YD1域系统复位。
6 J% Y! F( k6 t4 g& I# j
  flash_it输出
flash中断请求输出。

, m5 ~, p* ^8 _0 J' L, MSTM32H7的两个Flash BANK是独立的，读写和擦除互补影响，256bit带宽，CPU访问是采用的两个64bit AXI总线。
- [* U. I0 f9 k, K2 E$ Z/ f
70.2.2 内部Flash框架
  K' P. X- w2 N# L, A关于内部Flash的框架，了解以下几个知识点即可：
9 E( d6 v/ w: P0 x) [
  256bit为单位，即32字节，并且每个单位配10bit的ECC校验位。正是这个原因要求大家对Flash进行编程时，必须以32字节为单位。
+ X7 M7 K8 z: {3 `* D$ R  两个独立的BANK，每个BANK有1MB容量。并且每个BANK的扇区大小固定为128KB，即8个扇区。
1 a6 h) }% h: u# `
7 {8 T8 Y1 b% R; U' r

$ I  N9 u- t2 V$ g4 F' Z& [5 Q
BANK1的地址范围：0x0800 0000到0x080F FFFF。
% ~  J* W. n+ K' x' S3 l- `
) q+ V% d6 L- g6 K8 A' g1 V; ABANK2的地址范围：0x0810 0000到0x081F FFFF。

70.2.3 内部Flash读操作
4 W: V7 F; @' I* V$ l" MSTM32H7的内部Flash读操作跟内部RAM的读操作是一样的，支持64bit，32bit，16bt和8bit，使用比较简单。这里我们重点普及一个知识点，H7的内部Flash在不同主频下需要做的延迟参数：
* [! K+ _5 g: i& {) x7 ], w9 h

' Z" p+ ?( I6 k' y$ x; g
: v8 e( z6 n2 c' T: b对于上面的表格，大家可以看到，当延迟等待设置为0的时候，即无等待，单周期访问，速度可以做到70MHz。增加1个Flash周期后，访问速度可以做到140MHz。当增加到3个或4个Flash周期后，最高速度可以做到225MHz。
* Q* a; A4 ^7 R
& Z- f8 y: _6 M' A5 K& p. x- @) e了解了这个知识点后，再来看下面的时序，非常具有参考意义：
- p9 F+ L, {. [
3 `2 z' J  T- {' x; {" Z: A1 P注：ACLK、ARADDR、ARVALID、RDATA、RVALID 和RLAST是AXI总线信号。Flash读和Flash数据是 Flash 接口信号。

/ r9 G* g5 _$ E' k

关于这个时序要要认识到以下几点：

  AXI总线发起读取信号后，Flash端等待了3个时钟周期（注意延迟三个周期，支持的Flash速度），之后连续读取了4个64bit数据。
6 a  o) q. b( ^8 L4 L5 W4 p  由于AXI总线是64bit的，所以1次读取就可以读出64bit数据，连续读取4次后，就是256bit，即Flash接口的一组数据，因为H7的Flash接口带宽是256bit的。
* ?* P7 r! b: m7 c* T5 L  如果不开Flash Cache的情况下，连续读可以提升性能。
) [) C$ y' q3 d6 ~/ i, c" u
下面是连续读取8个64bit数据的时序图，跟连续读取4个64bit数据基本是一样的，只是多读取了4组数据。
) r$ Z& u/ U; }, C5 o
: G- R9 V; ^; a! D8 e5 s+ {5 V

& M& l+ l  o$ A8 |% h: H
70.2.4 内部Flash写入和擦除操作
最重要的知识点放在开头说：STM32H7内部Flash的写操作地址必须是32字节对齐（此地址对32求余数为0），写入的数据量也必须是32字节整数倍，不足32字节整数倍，补0也要是整数倍。

这里我们重点了解Flash的写入和擦除流程。Flash的写入扇区流程如下：
) Z: q$ [8 E" F
先保证这块扇区空间之前已经擦除过了。
% k  `9 n% x2 Q6 o6 p5 L& Z$ l* ]解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
! d7 [: w- t) y+ t; B检查是否写保护，使能Flash可以编程，然后对其进行编程操作，编程完毕后，等待编程完成，然后禁止Flash编程位。具体操作可以通过HAL库的函数HAL_FLASH_Program实现。

Flash的擦除流程如下：
解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
如果是BANK1或者BANK2需要擦除，调用函数FLASH_MassErase，然后等待擦除完成，完成之后关闭BANK1和BANK2的擦除请求位BER1/BER2
如果是扇区擦除，调用函数FLASH_Erase_Sector，然后等待擦除完成，完成之后关闭扇区的擦除请求位SER。
- W* t& Z' J4 z! K/ |6 O* M7 n
9 f$ \" i* i) {, ?
70.2.5 内部Flash读保护
) v) P( Y$ Q3 u$ M4 Z# D6 o内部Flash支持三级读保护RDP（read out protection）。
7 S) K! T1 g* v  `+ e. q" @: b
  Level 0（无保护）
+ D, C& `: M  G& ]& N7 H% P9 z默认设置，所有读写和擦除操作都可以正常支持。

  Level 1 （Flash连接保护）
  O# C1 a8 Y  H' x+ w" R0 ]  可以防止连接调试器时读取Flash内容，或者RAM中存有恶意获取代码，也是禁止的。因此只要调试器连接芯片，或者从内部RAM启动运行代码，都是禁止访问内部Flash的。
8 P) ?. o8 p: d$ V1 ?5 u8 K  如果没有检测到从内部RAM启动和系统bootloader启动且没有连接调试器，对用户Flash的读写和擦除操作都是允许的，并且其它安全存储区也是可以访问的。否则是禁止访问的，一旦检测到对Flash的读请求，将产生总线错误。
  如果将Level 1切换到Level 0时，用户Flash区和安全区域将被擦除。

Level 2（设备保护和自举保护）
+ M4 ?( s/ D* T/ Z2 d4 N) m4 O  所有调试特性被关闭。
0 b& G4 O& i; P% w  D% y! F1 Y! B( G5 e  禁止从RAM启动。
  除了选项字节里面的SWAP位可以配置，其它位都无法更改。
  禁止了调试功能，且禁止了从RAM和系统bootloader启动，用户Flash区是可以执行读写和擦除操作的，访问其它安全存储区也是可以的。
( j9 q' _2 T) h! a6 U
5 ^) b2 f% N2 W9 B  A特别注意：Level2修改是永久性的，一旦配置为Level2将不再支持被修改。

如果大家要设置读保护的话，使用HAL的API可以设置，也可以使用STM32CubeProg设置：
6 H8 d" g- h0 b/ U+ t

) K# H' T7 @4 Z0 d% R6 Y0 I# z) G
70.2.6 内部Flash选项字节
. i* G* ], C3 e* L& w! n1 lFlash选项字节主要用于boot地址设置，安全保护，Flash扇区保护等，涉及到的选项比较多。如果大家打算了解这一部分的话，使用STM32CubeProg进行设置即可，也比较方便。
/ J8 i0 M" E( p1 O+ c
7 s% P4 J( s% V: k: I

1 C" U1 V5 }0 g6 B3 \) ^
70.2.7 内部Flash的ECC校验
! J; U3 U; e) z' i5 O& e8 ]这里先说下为什么内部Flash要带ECC校验，因为随着芯片的制造工艺水平越高，带电粒子产生的位翻转就越多，此时的ECC是必须要有的，一般可以纠正1-2个bit，安全等级高的Flash类存储器和RAM类都是必须要带ECC的。

3 M: ~0 D3 H* a. w" p对于STM32H7带的ECC校验，一般不需要用户去管理。

$ \  r/ w7 o0 ~6 H70.3 内部Flash的HAL库用法
; e2 `/ W4 K( a( Q: [6 }70.3.1 内部Flash结构体FLASH_TypeDef
6 L7 N9 x2 ^5 ]/ ~+ I. U内部Flash相关的寄存器是通过HAL库中的结构体FLASH_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
" ]# m2 B+ ?8 ]& K
1 k4 m& [! i! V, X* c

1. typedef struct
   " Z2 O2 N8 N; O
2. {
   
3.   __IO uint32_t ACR;            
   
4.   __IO uint32_t KEYR1;           
   
5.   __IO uint32_t OPTKEYR;         
   1 |6 e# Y* I# a1 T( i* V
6.   __IO uint32_t CR1;            
   
7.   __IO uint32_t SR1;            
   * F: C# B+ L8 v& Q/ T% ?
8.   __IO uint32_t CCR1;         
   6 Z, P* d) N( M* k
9.   __IO uint32_t OPTCR;           
   1 l. _! f* B4 w2 ]7 t- k* r$ B3 s
10.   __IO uint32_t OPTSR_CUR;      
    : M! c' S% H' j( H1 p
11.   __IO uint32_t OPTSR_PRG;      
    
12.   __IO uint32_t OPTCCR;         
      @- X9 Y. ]+ m& q7 p" E, z2 _
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;      
    
19.   __IO uint32_t BOOT_CUR;      
    , }1 N5 }( O! m+ z! _
20.   __IO uint32_t BOOT_PRG;      
    
21.   uint32_t      RESERVED0[2];   
    
22.   __IO uint32_t CRCCR1;         
    3 N1 \8 H( x% |; U  f
23.   __IO uint32_t CRCSADD1;      
    , c, ]7 {& r+ {" z
24.   __IO uint32_t CRCEADD1;        
    8 C$ T1 q$ i4 n3 ]; ~: u7 d
25.   __IO uint32_t CRCDATA;         
    
26.   __IO uint32_t ECC_FA1;         
    
27.   uint32_t      RESERVED1[40];  
    & ~8 n# {. g0 s; r7 W
28.   __IO uint32_t KEYR2;           
    
29.   uint32_t      RESERVED2;      
    
30.   __IO uint32_t CR2;            
    
31.   __IO uint32_t SR2;            
    / e( |, r; q5 t. y
32.   __IO uint32_t CCR2;            
    
33.   uint32_t      RESERVED3[4];   
    . e/ N) F2 `& A" c& j
34.   __IO uint32_t PRAR_CUR2;      
    , t  R& }5 ~4 r3 j, @; e
35.   __IO uint32_t PRAR_PRG2;      
    
36.   __IO uint32_t SCAR_CUR2;      
    3 X" m/ B3 d) O; o  q( p; v
37.   __IO uint32_t SCAR_PRG2;      
    " _1 ]8 f  P( L' D# g- l: J
38.   __IO uint32_t WPSN_CUR2;      
    
39.   __IO uint32_t WPSN_PRG2;      
    " h: @( J! P& n
40.   uint32_t      RESERVED4[4];   
    $ l! `9 n3 x6 a) a+ c  {& C$ a
41.   __IO uint32_t CRCCR2;         
    4 K" L6 T0 P2 C, f( r1 M, R
42.   __IO uint32_t CRCSADD2;        
    0 V7 I* j3 o' L1 b6 }
43.   __IO uint32_t CRCEADD2;        
    1 r. h3 h/ ~4 j
44.   __IO uint32_t CRCDATA2;        
    
45.   __IO uint32_t ECC_FA2;         
    - ^/ b6 D) y- ]4 P
46. } FLASH_TypeDef;

复制代码

9 q7 O3 p  V) c0 X, E3 X这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
5 C( |& t, R. U! X  |

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   , J+ i& j( k# X' n( E* U5 p6 [) i
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

下面我们看下Flash的定义，在stm32h743xx.h文件。
: i) N8 q  `6 }5 G; K. d/ b
' x0 M6 x8 H1 m4 J$ [

1. #define PERIPH_BASE              (0x40000000UL)
   & r* U$ K  E8 X; d
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

复制代码

- n% P/ X0 M* b我们访问Flash的CR1寄存器可以采用这种形式：FLASH->CR1 = 0。

70.3.2 内部Flash擦除结构体FLASH_EraseInitTypeDef
3 P& t( z, s1 t5 D, l& Y% O  A下面是做内部Flash擦除的结构体，用到的地方比较多：
7 ~8 I9 o3 j" W& C) q

1. typedef struct
   
2. {
   
3.   uint32_t TypeErase;  
   : h& s( f4 d# ?
4.   uint32_t Banks;      
     Z3 ]( [/ p# W/ ^" f
5.   uint32_t Sector;      
   
6.   uint32_t NbSectors;   
   
7.   uint32_t VoltageRange;
   % A/ `! m, C. k
8. } FLASH_EraseInitTypeDef;

复制代码

下面将结构体成员逐一做个说明：
3 ?4 N: ?: A* k6 i1 c# P  TypeErase

$ U5 G" P( U+ e1 z4 a
+ }5 B: g* n6 I- @0 I- M7 x用于选择BANK擦除还是扇区擦除，H743有两个BANK，每个BANK有个8个扇区，每个扇区128KB。具体支持的参数如下：

1. #define FLASH_TYPEERASE_SECTORS      0x00U  /* 扇区方式擦除 */
   4 ]7 ?% ?0 n7 H; B3 Y
2. #define FLASH_TYPEERASE_MASSERASE    0x01U  /* BANK方式擦除 */

复制代码

" }. ]( q; S0 m  Banks
" T5 J' L* P4 n1 d4 k用于选择要擦除的BANK，或者两个BANK都选择：
- g/ R& _! d6 q
; n2 j9 s0 s; I5 Q- `

1. #define FLASH_BANK_1             0x01U                         /* Bank 1 */
   3 k$ h% a5 F% R! t
2. #define FLASH_BANK_2             0x02U                         /* Bank 2 */
   ! F: z) X4 n" U( B& Z/ `( f. _0 s0 k
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   */
   
6. #define FLASH_SECTOR_5             5U       /* Sector Number 5   */
   " E5 e; a: S& v9 I7 Y, e. w3 A6 D
7. #define FLASH_SECTOR_6             6U       /* Sector Number 6   */
   " E5 y5 I. H! M8 }, e
8. #define FLASH_SECTOR_7             7U       /* Sector Number 7   */

复制代码

  NbSectors
1 c( i  v4 o+ }" V+ }  \" x* ~用于设置要擦除的扇区个数，对于STM32H743来说，范围1到8。
: ?$ a) [; ~3 ^* u/ U$ s/ a
7 k4 }& ?' P5 d  VoltageRange
用于设置编程的并行位数，电压不同，位数不同：
5 \; |. J( D. F

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 */
   * c  E" n' M6 N1 A8 _6 b
3. #define FLASH_VOLTAGE_RANGE_3        FLASH_CR_PSIZE_1  /* Flash program/erase by 32 bits */
   5 F7 ]- x8 |3 T6 S% V' W; e
4. #define FLASH_VOLTAGE_RANGE_4        FLASH_CR_PSIZE    /* Flash program/erase by 64 bits */

复制代码

70.3.3 内部Flash的操作总结

2 N1 Z1 V+ {  a& b# ^) c
使用方法由HAL库提供：
  Flash编程函数操作流程
  Flash解锁函数HAL_FLASH_Unlock。
2 k( z$ X$ y7 p% n8 [7 o/ _  q  Flash查询方式编程HAL_FLASH_Program。
  Flash中断方式编程HAL_FLASH_Program_IT。
% \1 |' B0 J1 v/ Z& W3 [6 _  Flash上锁函数HAL_FLASH_Lock。
3 r, A" I3 v) F  
选项字节编程流程
  |! K1 P, m) u  选项字节解锁函数HAL_FLASH_OB_Unlock。
6 H+ j; ]+ C6 t  选项字节加载函数HAL_FLASH_OB_Launch。
3 Y1 l. E( E& s( a  选项字节编程函数HAL_FLASHEx_OBProgram。
  选项字节加锁函数HAL_FLASH_OB_Lock。
8 E' l+ }- j& i% c1 q
8 T% Y' ~6 B! g% H$ P Flash擦除流程
6 O& V/ s: C) W  Flash解锁函数HAL_FLASH_Unlock。
  Flash查询方式擦除HAL_FLASHEx_Erase。
& y5 t7 @3 Y- X% E9 l. R  Flash中断方式擦除HAL_FLASHEx_Erase_IT。
1 e+ g& ]1 ^" y  Flash上锁函数HAL_FLASH_Lock。
  q+ n7 z4 M* I! n6 N+ \

70.4 内部Flash源文件stm32h7xx_hal_flash.c
3 ~, i8 p6 H  t' p6 t, R: M此文件涉及到的函数较多，这里把几个常用的函数做个说明：
9 O* t" ?" q9 ]' G0 u9 J! z7 O
' F5 {3 ~4 Q/ u: s2 v" Z  HAL_FLASH_Unlock
, ]1 V8 s) F4 s3 s1 \  r/ X  HAL_FLASH_Lock
  HAL_FLASHEx_Erase
, T9 a* m& i, U+ d9 }5 _  HAL_FLASH_Program

70.4.1 函数HAL_FLASH_Lock
函数原型：
7 p$ U" |4 J+ Y1 t8 i8 b

1. HAL_StatusTypeDef HAL_FLASH_Lock(void)
   1 A" a: ?1 Q# `6 [( g8 H) h, r
2. {
   - I- D4 I  G0 P! Q" q* f. [& L
3. /* 设置FLASH Bank1控制寄存器Lock位，即禁止访问 */
   
4.   SET_BIT(FLASH->CR1, FLASH_CR_LOCK);
   + F' O% J/ O4 Z% ]7 V: {" g/ n8 H
5. 
   
6. /* 验证Flash Bank1是否已经被锁住 */
   
7.   if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) == 0U)
   
8.   {
   . Z* K) M4 l% j
9.     return HAL_ERROR;
   
10.   }
    0 w$ n' }4 \; ~
11. 
    
12. /* 设置FLASH Bank2控制寄存器Lock位，即禁止访问 */
    : D" l. O( O% f. R5 a* h( ^
13.   SET_BIT(FLASH->CR2, FLASH_CR_LOCK);
    9 f3 W1 E! f, b% u
14. 
    
15. /* 验证Flash Bank2是否已经被锁住 */
    
16.   if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) == 0U)
    ; E; f* j+ u  t$ w* Y
17.   {
    ' Z. A) {+ w+ @% r4 h  p
18.     return HAL_ERROR;
    
19.   }
    ) L. U/ T- D3 X* m6 \
20. 
    
21.   return HAL_OK;
    3 A( N: l- \& z& {
22. }

复制代码

函数描述：

用于Flash加锁，加锁后将不能对Flash进行编程和擦除。

: Q8 |/ p! s# z' k70.4.2 函数HAL_FLASH_Unlock
4 w( u1 a  ]( l4 r7 W( Q函数原型：

1. HAL_StatusTypeDef HAL_FLASH_Unlock(void)
   
2. {
   : _% T4 l7 Z# G% c  J, s+ \
3.   if(READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
   
4.   {
   
5.     /* 允许访问Flash Bank1 */
   5 F9 _# D- h+ V. W$ F, K) U
6.     WRITE_REG(FLASH->KEYR1, FLASH_KEY1);
   
7.     WRITE_REG(FLASH->KEYR1, FLASH_KEY2);
   
8. 
   
9.     /* 验证是否已经解锁 */
   
10.     if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
    # R2 _$ G# r: D8 A/ H2 H/ R+ p
11.     {
    / U& q1 E: O% Z  U, F0 l  v: `1 v
12.       return HAL_ERROR;
    
13.     }
    
14.   }
    
15. 
    ' m3 n( B" r6 W6 Y6 O* D( r& v
16.   if(READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    
17.   {
    
18.     /* 允许访问Flash Bank2 */
    
19.     WRITE_REG(FLASH->KEYR2, FLASH_KEY1);
    2 C  q  g" r& G
20.     WRITE_REG(FLASH->KEYR2, FLASH_KEY2);
    7 C0 T4 Z# W% o) Z# _1 U* k
21. 
    
22.     /* 验证是否已经解锁 */
    " b. v9 r7 x. V! L  c% t; d$ e( z
23.     if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    - h7 E3 w6 r5 |2 z! L
24.     {
    7 c( U: E# l( P5 W: t. p" c
25.       return HAL_ERROR;
    
26.     }
    & I& c: k8 I! L& N) D# i. I# ]) n
27.   }
    # I9 g$ x0 S6 a# Y4 n0 H" i8 R
28. 
    , a, ^6 C; G( r4 c2 k1 L0 }
29.   return HAL_OK;
    
30. }

复制代码

& K1 n: G- t5 [% g% b9 n函数描述：

此函数用于Flash解锁，解锁后可以对Flash进行擦除和编程。

70.4.3 函数HAL_FLASH_Program
* _% b) u; c2 @, @" K/ i函数原型：

. M+ u* z# d0 L# I

1. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t FlashAddress, uint32_t DataAddress)
   
2. {
   
3.   HAL_StatusTypeDef status;
   7 z$ _8 l: q5 A7 s' g% l/ s
4.   __IO uint32_t *dest_addr = (__IO uint32_t *)FlashAddress;
   * Q! j1 [- c  }# |
5.   __IO uint32_t *src_addr = (__IO uint32_t*)DataAddress;
   
6.   uint32_t bank;
   
7.   uint8_t row_index = FLASH_NB_32BITWORD_IN_FLASHWORD;
   
8. 
   
9.   /* 检测参数 */
   ; h, i7 [7 R: z" X5 ]
10.   assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
    6 D3 S0 D/ Y+ Z- Y+ w2 K: [
11.   assert_param(IS_FLASH_PROGRAM_ADDRESS(FlashAddress));
    0 \' k) `1 z% T& n* a$ U" J9 B$ u0 D
12. 
    
13.   /* 上锁 */
    , P8 A* {, q! n, X4 @
14.   __HAL_LOCK(&pFlash);
    
15. 
    2 t3 X7 B" I! ~; L7 T- S2 I' Y! H
16. #if defined (FLASH_OPTCR_PG_OTP)
    % N, Z, i0 i4 C, \7 y2 F& G
17.   if((IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress)) || (IS_FLASH_PROGRAM_ADDRESS_OTP(FlashAddress)))
    
18. #else
    
19.   if(IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress))
    * R( B; e/ t" x+ G& N, G* C/ i
20. #endif
    # ^7 u/ D0 B$ O2 `& C: `" Z
21.   {
    
22.     bank = FLASH_BANK_1;
    
23.   }
    
24.   else
    
25.   {
    9 a3 A% ?  L) o: ]" ?/ Y& ]
26.     bank = FLASH_BANK_2;
    
27.   }
    
28. 
    
29.   /* 错误标识，无错误 */
    
30.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    4 i5 [4 S% N) h
31. 
    6 `- d9 V  N7 {  [8 q( h2 W
32.   /* 等待操作完成 */
    
33.   status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    $ @2 t* v+ \$ h4 [& _
34. 
    
35.   if(status == HAL_OK)
    
36.   {
    
37.     if(bank == FLASH_BANK_1)
    
38.     {
    6 _; g) L+ n' e: N
39. #if defined (FLASH_OPTCR_PG_OTP)
    # Q- c$ Y, _7 f1 K$ ^
40.       if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
41.       {
    . c# I# T7 \- R) C
42.         /* 设置OTP寄存器的PG位，使能可以编程 */
    0 n4 F- Q; I* S$ ^
43.         SET_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    
44.       }
    3 y9 u2 z2 J% ~, J2 V5 M# \$ ~# X, R
45.       else
    . {) {- Z. |( h0 n) d
46. #endif
    
47.       {
    
48.         /* 设置PG位，使能可编程 */
    
49.         SET_BIT(FLASH->CR1, FLASH_CR_PG);
    
50.       }
    
51.     }
    
52.     else
    ' M  Y( P1 d* L% E- B4 F
53.     {
    5 u! P+ |. o- j) h2 u
54.       /* 设置PG位 */
    7 K$ k5 R* @% a5 @8 T, U
55.       SET_BIT(FLASH->CR2, FLASH_CR_PG);
    $ _* ?: B8 R3 d; x5 _! ~4 B1 s
56.     }
    
57. 
    
58.     __ISB();
    3 Q0 ^  }0 v4 Q( D( ?" n
59.     __DSB();
    
60. 
    ! Y# f' g6 C2 Y' n
61. #if defined (FLASH_OPTCR_PG_OTP)
    
62.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    # [# U( Y( _  V; t: U/ ^
63.     {
    , j, _4 T! Q4 H% W1 X' {
64.       /* 编程OTP(16 bits) */
    
65.       *(__IO uint16_t *)FlashAddress = *(__IO uint16_t*)DataAddress;
    
66.     }
    ) S$ o0 T( Q. ]) ?2 Q$ O
67.     else
    6 f0 m5 D& t5 v  a* `: v: N
68. #endif
    
69.     {
    % H: `) M( S5 a1 }
70.       /* 对Flash进行编程 */
    
71.       do
    
72.       {
    
73.         *dest_addr = *src_addr;
    
74.         dest_addr++;
    % X/ L7 r2 t, a( y
75.         src_addr++;
    5 R8 x' A: ]: h. B
76.         row_index--;
    
77.      } while (row_index != 0U);
    ) Q) d' n/ N4 f9 a
78.     }
    
79. 
    : [, u' t" s. c2 }  k- H
80.     __ISB();
    
81.     __DSB();
    ! L: p3 W  [6 C1 A. K- M1 W; }
82. 
    
83.     /* 等待最后一次操作完成 */
    - x4 i) j0 {8 o6 [& ]
84.     status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    0 V+ }# ]* L/ J$ R! X
85. 
    - f0 F/ ]$ }4 B7 p% s* C
86. #if defined (FLASH_OPTCR_PG_OTP)
    / A& Q2 C- Z1 z+ |& l( \
87.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    8 k: f6 C' }9 N! w& ^
88.     {
    
89.       /* 如果编程操作完成，关闭OTP PG位 */
    
90.       CLEAR_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    
91.     }
    
92.     else
    ( R2 f/ m* T* K; T, M1 `
93. #endif
    
94.     {
    
95.       if(bank == FLASH_BANK_1)
    
96.       {
    
97.         /* 如果操作完成，关闭PG位 */
    
98.         CLEAR_BIT(FLASH->CR1, FLASH_CR_PG);
    6 M, _0 c9 j3 s6 i2 K
99.       }
    - v1 U4 q- T, G' k5 l" S
100.       else
     
101.       {
     
102.         /* 如果操作完成，关闭PG位 */
     
103.         CLEAR_BIT(FLASH->CR2, FLASH_CR_PG);
     
104.       }
     ) q1 E! P, G, a- v7 B
105.     }
     1 W  n1 u6 K$ S: H5 G3 @$ u
106.   }
     
107. 
     
108.   /* 解锁 */
       V; a2 t- |; R! A$ W
109.   __HAL_UNLOCK(&pFlash);
     * t2 C/ N4 [3 v6 N; V
110. 
     5 g9 K- Z9 h. {" s
111.   return status;
     ; L# [8 o3 K; c- @! P2 V! L
112. }
     
113. 
     

复制代码

6 T! r; H) l* o# f8 {6 {% Q: R. Z函数描述：
, l3 n  E1 p" y5 t此函数主要用于Flash编程，固定编程32个字节数据。
# M3 g0 j0 z  i" [& \7 x/ d
函数参数：
' w7 ?( c) q' Z9 }第1个参数是要编程的Flash类型，支持两种参数：
  FLASH_TYPEPROGRAM_FLASHWORD，用于芯片内部Flash编程。
6 y, T1 N6 r- H  FLASH_TYPEPROGRAM_OTPWORD，用于芯片内部OTP存储区编程，当前的H743并没有这个区域，所以可以忽略。
: A% V5 y% [0 R/ \5 k: a9 C
7 Q. J* i$ C& E+ c' Y* Y" ?第2个参数是要编程的Flash地址。
% n  J  T' A2 @
( P. T# V# B- H% K第3个参数是要编程到Flash的数据地址。
. R4 r( }" K: d6 R6 H, y( }+ z# y5 e返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。


/ K+ P( H# i9 m注意事项：
: [4 M" [, n5 c5 o3 L  第2个参数的Flash地址要是32字节对齐的，即此地址对32求余等于0。
9 e* q, `6 G& c$ {# ^0 P  第3个参数务必要是32字节的整数倍。
% T6 Q: M& y4 z  k
70.4.4 函数HAL_FLASHEx_Erase
2 K2 U- t8 @# _8 j函数原型：

1. HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *SectorError)
   - @' d# g2 D  ]$ ?0 I( }" W$ S; G
2. {
   & l  [9 N$ e# \! e( ^
3.   HAL_StatusTypeDef status = HAL_OK;
   . S( q$ e8 f7 ?5 N6 W! }3 T
4.   uint32_t sector_index;
   
5. 
   
6. /* 检查参数 */
   1 ], X2 Z% I- [- |6 x
7.   assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
   ) i1 B- _5 u( q( }5 U
8.   assert_param(IS_FLASH_BANK(pEraseInit->Banks));
   
9. 
   : |/ n; H/ `- I) W# }9 s: n/ E
10. /* 上锁 */
    - _  h1 Y  h3 L4 b0 l1 g
11.   __HAL_LOCK(&pFlash);
    
12. 
    : P( I* j( h7 u( X
13. /* 无错误 */
    
14.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    - s9 X7 f4 z' Z6 |
15. 
    
16. /* 等待BANK1的操作完成 */
    & A0 Y/ ^- G9 q6 Z3 w# `. {
17.   if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    / q( w6 t: f; j: s& z# z) ^0 c
18.   {
    
19.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    . }8 m; I+ ^2 C: l* |3 t. z  G  G# V
20.     {
    
21.       status = HAL_ERROR;
    
22.     }
    1 ?+ |" S' N$ ^) f3 d* U) X
23.   }
    9 Z; C5 y. k, J" Q
24. 
    
25. /* 等待BANK2的操作完成 */
    ' b* I" b2 y- n/ n
26.   if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
      }6 W1 x% m8 F9 `
27.   {
    9 h( h  R9 |4 y; |" c  r; S1 W# r
28.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2) != HAL_OK)
    
29.     {
    ( j7 U9 P$ H- {3 Q6 D
30.       status = HAL_ERROR;
    7 Y- ~3 X' l& r* \2 ^5 d1 x
31.     }
    $ I3 `2 Z5 Z) l% l: G2 A
32.   }
    
33. 
    / D+ f) f1 e5 n) H6 M- _' d5 t  H
34.   if(status == HAL_OK)
    
35.   {
    
36.     if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
    % }$ ~3 L3 D2 j' [3 u# T9 `! v
37.     {
    ' O4 h$ `( k# J% W" y. L( @
38.   /* 整个BANK1或者BANK2擦除 */
    ' f& h9 |4 @; J( `
39.       FLASH_MassErase(pEraseInit->VoltageRange, pEraseInit->Banks);
    " q- e5 d( _& I- @
40. 
    
41.   /* 等待操作完成 */
    
42.       if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    9 @8 W0 z* _# I: c" T
43.       {
    
44.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    5 k4 }# V7 ?" j# c1 r
45.         {
    
46.           status = HAL_ERROR;
    2 l9 o0 S6 {& n5 m! `4 m) N  a
47.         }
    
48.     /* 如果擦除完成，关闭BANK1的BER位 */
    2 K; h4 d+ L0 d+ ]- k8 o- O
49.         FLASH->CR1 &= (~FLASH_CR_BER);
    
50.       }
    ; _, E5 I6 H8 _9 X% e; r
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)
    - J0 X8 }, C7 v
54.         {
    
55.           status = HAL_ERROR;
    . X0 `  X  H8 B" M& g0 N/ f' e
56.         }
    
57.     /* 如果擦除操作完成，关闭BANK2的BER位 */
    # k* T6 W* x# B) `
58.         FLASH->CR2 &= (~FLASH_CR_BER);
    " m' |+ o$ b8 l+ n, c. L
59.       }
    % |5 X! ]" K, s# A
60.     }
    
61.     else
    5 ?/ \+ q* a! M1 q, R. P
62.     {
    
63.   /* 初始化扇区错误码 */
    ' o* I6 C, F* m6 S; P
64.       *SectorError = 0xFFFFFFFFU;
    
65. 
    
66.   /* 扇区方式擦除 */
    ( H5 G7 q+ R% ^" w3 h
67.       for(sector_index = pEraseInit->Sector; sector_index < (pEraseInit->NbSectors + pEraseInit->Sector);
    
68. sector_index++)
    0 V  U/ n6 A3 ^$ a! {- z2 m; m( d' F/ G6 h
69.       {
    ; a$ m- l, d1 E+ P: l: X
70.         FLASH_Erase_Sector(sector_index, pEraseInit->Banks, pEraseInit->VoltageRange);
    
71. 
    
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. 
    
77.       /* 如果擦除操作完成，禁止SER位 */
    
78.           FLASH->CR1 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    
79.         }
    
80.         if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    , p# ?0 F3 u0 l2 W, O& K2 _9 j& @
81.         {
    
82.       /* 等待BANK2操作完成 */
    
83.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2);
    
84. 
    3 ^% l( Y) x3 v5 g- z( x
85.       /* 如果擦除操作完成，禁止SER位 */
    
86.           FLASH->CR2 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    : w3 F* ]! M1 m; Y
87.         }
    8 f- T- D/ `# G; |" D3 z  L& v
88. 
    
89.         if(status != HAL_OK)
    $ R3 l# o! D# K  t0 B
90.         {
    . F  A7 t1 b4 }9 G0 A
91.       /* 如果擦除出错，停止后续擦除，返回擦除异常的扇区号 */
    2 f& F' m$ y+ u: A! @: k# d
92.           *SectorError = sector_index;
    
93.           break;
    
94.         }
    
95.       }
    9 ~" a* j: W+ `4 m! A* b7 [/ l
96.     }
    ; ~9 X$ s: W6 p" B/ P& X1 V5 n
97.   }
    
98. 
    
99. /* 解锁 */
    
100.   __HAL_UNLOCK(&pFlash);
     
101. 
     
102.   return status;
     
103. }
     . Q% b0 O; m& c) q

复制代码

函数描述：
用于内部Flash的批量擦除（BANK擦除）和扇区方式擦除。

函数参数：
  第1个参数是FLASH_EraseInitTypeDef类型结构体指针变量。
% i5 Q) g+ x0 {6 P# R  第2个参数是错误码返回，返回0xFFFFFFFF表示全部正确，返回其它值是擦除过程中的错误扇区。
  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

70.5 总结
本章节就为大家讲解这么多，对于内部Flash编程来说，掌握本章节的这些知识点就够用了，更多的知识点可以看STM32H7的参考手册学习。

7 ^' K. H  Q$ [& t2 X* x

: S1 O1 O) j& ^& z$ d) \