70.1 初学者重要提示
9 k3 U- l; J+ Z  s' u& N  本章2.5小节里面的Flash三级读保护是重点，务必要掌握明白。
  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是如果用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，用户应用程序将停止运行，包括中断服务程序。
0 |5 O  O& O' f- g  STM32H7的两个Flash BANK是256bit带宽，CPU访问是采用的两个64bit AXI总线。
! H2 f6 n; o; r% g7 U* k7 q8 J  HAL库的内部Flash编程函数HAL_FLASH_Program固定编写32字节数据。
70.2 内部Flash基础知识
5 Q! d9 T- U5 F- q' h: |70.2.1 内部Flash的硬件框图
. y) \, ]# s0 q认识一个外设，最好的方式就是看它的框图，方便我们快速的了解内部Flash的基本功能，然后再看手册了解细节。

9 G9 m) y* h  G; |

通过这个框图，我们可以得到如下信息：
& c* C* T& X3 T1 U; n
  sys_ck时钟输入
& \$ a5 o3 J) Z6 w8 q( ?8 uD1域总线时钟。

4 [% O  p" Z0 D  po_rst输入
Power on reset 上电复位。

4 j* @% d* B/ O* R* Q  d1_rst输入
D1域系统复位。
- |% B/ r1 e: e* R- ^. t$ V
  flash_it输出
; X9 L, F1 o) {' b9 F$ z6 }4 fflash中断请求输出。
  ~3 ]$ [( u3 u& t
6 v3 q( \& L+ g4 T1 K+ QSTM32H7的两个Flash BANK是独立的，读写和擦除互补影响，256bit带宽，CPU访问是采用的两个64bit AXI总线。
8 Q; w2 F/ k6 W7 k4 a
70.2.2 内部Flash框架
0 l9 N: j2 b6 `; K2 U# ]1 s关于内部Flash的框架，了解以下几个知识点即可：
9 u+ z2 `8 J9 W' M; h7 G! ]
  256bit为单位，即32字节，并且每个单位配10bit的ECC校验位。正是这个原因要求大家对Flash进行编程时，必须以32字节为单位。
  两个独立的BANK，每个BANK有1MB容量。并且每个BANK的扇区大小固定为128KB，即8个扇区。
1 B+ j/ V4 S# K6 O( m" V4 B
" D$ r6 M& L3 O* [3 K- S

BANK1的地址范围：0x0800 0000到0x080F FFFF。

: {  ^' L3 r- y) hBANK2的地址范围：0x0810 0000到0x081F FFFF。

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

5 ^( \2 M3 l9 j$ I5 v

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

0 p% H; B- M8 w了解了这个知识点后，再来看下面的时序，非常具有参考意义：

* ~. p9 p8 n$ v, C4 E注：ACLK、ARADDR、ARVALID、RDATA、RVALID 和RLAST是AXI总线信号。Flash读和Flash数据是 Flash 接口信号。

' u  z5 s' y; P: r
关于这个时序要要认识到以下几点：

1 b) ~) P1 a2 J8 W* e  AXI总线发起读取信号后，Flash端等待了3个时钟周期（注意延迟三个周期，支持的Flash速度），之后连续读取了4个64bit数据。
9 Z2 l, K5 j' Y: C  由于AXI总线是64bit的，所以1次读取就可以读出64bit数据，连续读取4次后，就是256bit，即Flash接口的一组数据，因为H7的Flash接口带宽是256bit的。
/ H" ]9 ]4 P) A* F  如果不开Flash Cache的情况下，连续读可以提升性能。
! ^7 P3 v* t/ @. z4 S4 O. ]
8 N; \8 Y. c; O! X% B# |! A4 S7 h下面是连续读取8个64bit数据的时序图，跟连续读取4个64bit数据基本是一样的，只是多读取了4组数据。
8 J2 R4 ~9 ^2 \- C
& n( c: _  }  k" g# W4 u" `

70.2.4 内部Flash写入和擦除操作
最重要的知识点放在开头说：STM32H7内部Flash的写操作地址必须是32字节对齐（此地址对32求余数为0），写入的数据量也必须是32字节整数倍，不足32字节整数倍，补0也要是整数倍。
0 ^, p2 R' w, D% v
/ F! G1 e2 e- M- I0 z- M这里我们重点了解Flash的写入和擦除流程。Flash的写入扇区流程如下：
+ |/ {+ r* P' i8 @% I5 u
先保证这块扇区空间之前已经擦除过了。
1 v/ a) W" ^0 U( _解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
" o) ]3 x" Y- [$ o6 U* N/ N( P- M) I检查是否写保护，使能Flash可以编程，然后对其进行编程操作，编程完毕后，等待编程完成，然后禁止Flash编程位。具体操作可以通过HAL库的函数HAL_FLASH_Program实现。
2 n! }5 z. B' p+ J$ p! X5 B
- |/ n- E5 P) U9 o1 {) AFlash的擦除流程如下：
* n0 u  J$ S$ \6 o9 I: ^解锁Flash，通过HAL库的函数HAL_FLASH_Unlock实现。
7 R. w0 T4 E- r3 J' u) G如果是BANK1或者BANK2需要擦除，调用函数FLASH_MassErase，然后等待擦除完成，完成之后关闭BANK1和BANK2的擦除请求位BER1/BER2
2 |' L# }; z) `2 i" T如果是扇区擦除，调用函数FLASH_Erase_Sector，然后等待擦除完成，完成之后关闭扇区的擦除请求位SER。

! [; p& f. x' y3 g9 @4 E" |( N4 }
  w% Z( z4 Q0 l" B0 Z7 x+ p70.2.5 内部Flash读保护
内部Flash支持三级读保护RDP（read out protection）。
$ m2 n1 {$ c$ _7 y7 e
  Level 0（无保护）
默认设置，所有读写和擦除操作都可以正常支持。

  Level 1 （Flash连接保护）
  可以防止连接调试器时读取Flash内容，或者RAM中存有恶意获取代码，也是禁止的。因此只要调试器连接芯片，或者从内部RAM启动运行代码，都是禁止访问内部Flash的。
  如果没有检测到从内部RAM启动和系统bootloader启动且没有连接调试器，对用户Flash的读写和擦除操作都是允许的，并且其它安全存储区也是可以访问的。否则是禁止访问的，一旦检测到对Flash的读请求，将产生总线错误。
  如果将Level 1切换到Level 0时，用户Flash区和安全区域将被擦除。

+ S3 M- C" _3 U/ n% B( d Level 2（设备保护和自举保护）
5 b7 b1 K+ G  g( U3 A+ ~7 i  所有调试特性被关闭。
  禁止从RAM启动。
& X0 G. O+ B! r4 ?- u  除了选项字节里面的SWAP位可以配置，其它位都无法更改。
. ]# O* |7 ?  ]8 a" t  禁止了调试功能，且禁止了从RAM和系统bootloader启动，用户Flash区是可以执行读写和擦除操作的，访问其它安全存储区也是可以的。
  Z* j% Z$ p) Z& U% \4 b
特别注意：Level2修改是永久性的，一旦配置为Level2将不再支持被修改。
' g; x" U/ E8 M- J  W- |# U2 T
( g- X; I% a% |8 e. t如果大家要设置读保护的话，使用HAL的API可以设置，也可以使用STM32CubeProg设置：

# k' {; J3 r' ]1 E

4 p4 L% p# ~+ f3 w3 `& T3 U% W
70.2.6 内部Flash选项字节
Flash选项字节主要用于boot地址设置，安全保护，Flash扇区保护等，涉及到的选项比较多。如果大家打算了解这一部分的话，使用STM32CubeProg进行设置即可，也比较方便。
9 j  T) x! |8 a' V7 B1 v
2 s! o9 W: V2 t& U3 F4 I

) N% X' v8 ^8 r7 Q7 t" {
; y4 w0 p" W' o0 w70.2.7 内部Flash的ECC校验
" t# A" F( @8 ~  z这里先说下为什么内部Flash要带ECC校验，因为随着芯片的制造工艺水平越高，带电粒子产生的位翻转就越多，此时的ECC是必须要有的，一般可以纠正1-2个bit，安全等级高的Flash类存储器和RAM类都是必须要带ECC的。

& ?; a1 P* |7 s6 T7 X对于STM32H7带的ECC校验，一般不需要用户去管理。

70.3 内部Flash的HAL库用法
" w/ q! V: Y: _0 `, `, k; M6 V70.3.1 内部Flash结构体FLASH_TypeDef
内部Flash相关的寄存器是通过HAL库中的结构体FLASH_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

1. typedef struct
   
2. {
   
3.   __IO uint32_t ACR;            
   * P/ z# y+ [; J7 q  l- v
4.   __IO uint32_t KEYR1;           
   ' P: x4 A6 B9 G1 R# d/ L
5.   __IO uint32_t OPTKEYR;         
   1 @) |' a% m7 v2 k
6.   __IO uint32_t CR1;            
   % ~- ?4 m! i+ `
7.   __IO uint32_t SR1;            
   ' K* I9 }7 i. B' l3 l  t6 r$ P* {
8.   __IO uint32_t CCR1;         
   3 F% b! h+ P- r  w: P6 {1 v8 n
9.   __IO uint32_t OPTCR;           
   
10.   __IO uint32_t OPTSR_CUR;      
    ( @, j+ C1 H- N
11.   __IO uint32_t OPTSR_PRG;      
    ! C4 o( _$ W7 s
12.   __IO uint32_t OPTCCR;         
    9 t5 ~: f' N6 s, {9 y2 L
13.   __IO uint32_t PRAR_CUR1;      
    , J0 ]5 Q0 h8 m5 x- s# [" Y
14.   __IO uint32_t PRAR_PRG1;      
    
15.   __IO uint32_t SCAR_CUR1;      
    
16.   __IO uint32_t SCAR_PRG1;      
    1 m5 ^) [8 C2 d3 R
17.   __IO uint32_t WPSN_CUR1;      
    
18.   __IO uint32_t WPSN_PRG1;      
    ; E8 O: J( E' x* c+ P
19.   __IO uint32_t BOOT_CUR;      
    
20.   __IO uint32_t BOOT_PRG;      
    
21.   uint32_t      RESERVED0[2];   
    
22.   __IO uint32_t CRCCR1;         
    - g" G. Y; b+ J( @
23.   __IO uint32_t CRCSADD1;      
    
24.   __IO uint32_t CRCEADD1;        
    : [/ ~& A1 k  c  X: W
25.   __IO uint32_t CRCDATA;         
    
26.   __IO uint32_t ECC_FA1;         
    
27.   uint32_t      RESERVED1[40];  
    
28.   __IO uint32_t KEYR2;           
    8 d  C) V0 m5 Y! ~
29.   uint32_t      RESERVED2;      
    / W' Y( k9 [' r4 ?2 k& o
30.   __IO uint32_t CR2;            
    
31.   __IO uint32_t SR2;            
    
32.   __IO uint32_t CCR2;            
    
33.   uint32_t      RESERVED3[4];   
    / e) ]2 o( Z) e1 {/ I/ e: j
34.   __IO uint32_t PRAR_CUR2;      
    # Q4 l. H! g$ X; |6 x+ Z
35.   __IO uint32_t PRAR_PRG2;      
    $ D% r# ?7 K$ O# \5 t
36.   __IO uint32_t SCAR_CUR2;      
    + m$ }3 e1 a; ?7 y" |
37.   __IO uint32_t SCAR_PRG2;      
    
38.   __IO uint32_t WPSN_CUR2;      
    
39.   __IO uint32_t WPSN_PRG2;      
    
40.   uint32_t      RESERVED4[4];   
    9 b9 E. k% H$ n/ X
41.   __IO uint32_t CRCCR2;         
    
42.   __IO uint32_t CRCSADD2;        
    5 u# a, k4 @  E% A8 f( j4 R
43.   __IO uint32_t CRCEADD2;        
    
44.   __IO uint32_t CRCDATA2;        
    7 r) x2 f4 J" r$ v7 @
45.   __IO uint32_t ECC_FA2;         
    
46. } FLASH_TypeDef;

复制代码

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

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
9 I% n- {! ?& \3 N. v

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   ; G3 j$ x7 \, D: R3 g
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

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

1. #define PERIPH_BASE              (0x40000000UL)
   8 q" l( p- h2 S+ \! ?$ D* W8 b8 J
2. #define D1_AHB1PERIPH_BASE       (PERIPH_BASE + 0x12000000UL)
   
3. #define FLASH_R_BASE             (D1_AHB1PERIPH_BASE + 0x2000UL)
   ; g! T( P" q6 H5 A
4. #define FLASH                    ((FLASH_TypeDef *) FLASH_R_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x52002000

复制代码

+ d! s/ Z, c2 n1 f' j6 D我们访问Flash的CR1寄存器可以采用这种形式：FLASH->CR1 = 0。
) c' Y2 h  n7 s9 S: }2 {
70.3.2 内部Flash擦除结构体FLASH_EraseInitTypeDef
5 [- q6 K, o; ^1 C8 y5 u9 h' ~* G下面是做内部Flash擦除的结构体，用到的地方比较多：

1. typedef struct
   
2. {
   
3.   uint32_t TypeErase;  
   
4.   uint32_t Banks;      
   
5.   uint32_t Sector;      
   
6.   uint32_t NbSectors;   
   
7.   uint32_t VoltageRange;
   
8. } FLASH_EraseInitTypeDef;

复制代码

. M" f8 Q* y1 [2 R  r$ Y下面将结构体成员逐一做个说明：
0 w+ v, M3 M/ b+ u; p8 ~8 q  TypeErase
, m; a4 Q/ G# i# |4 ^" L
) i) E6 U6 \, _: T( f- t" G
. d7 D' N7 y0 G* {, T用于选择BANK擦除还是扇区擦除，H743有两个BANK，每个BANK有个8个扇区，每个扇区128KB。具体支持的参数如下：
1 S* ]& w- Y' D
$ f* d8 N$ P2 k, i5 T

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

复制代码

; g1 _5 @7 L( n1 Z. S& M% h' j& |  Banks
/ R* {$ J% |1 {# f) Q# c用于选择要擦除的BANK，或者两个BANK都选择：

1. #define FLASH_BANK_1             0x01U                         /* Bank 1 */
   
2. #define FLASH_BANK_2             0x02U                         /* Bank 2 */
   ( a5 H8 u9 `4 h1 X
3. #define FLASH_BANK_BOTH          (FLASH_BANK_1 | FLASH_BANK_2) /* Bank1 和 Bank2 */

复制代码

  Sector
用于选择要擦除的扇区：
1 u+ M1 N: [  b* i

1. #define FLASH_SECTOR_0             0U       /* Sector Number 0   */
   ; A. G/ D8 j- x* \6 y0 K/ V
2. #define FLASH_SECTOR_1             1U       /* Sector Number 1   */
   9 b" Z$ V4 [/ ~& n
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   */
   4 Y1 V# q+ q  E5 H6 F
6. #define FLASH_SECTOR_5             5U       /* Sector Number 5   */
   ; D' V* B* Z; \4 L+ W: _
7. #define FLASH_SECTOR_6             6U       /* Sector Number 6   */
   
8. #define FLASH_SECTOR_7             7U       /* Sector Number 7   */

复制代码

2 |3 u/ ~/ B/ }- Y, X  NbSectors
用于设置要擦除的扇区个数，对于STM32H743来说，范围1到8。

! N5 n5 S+ q! @. }0 F9 K  u' S) p  VoltageRange
% Q, r9 ]9 M7 [5 t% F用于设置编程的并行位数，电压不同，位数不同：
1 x& n' |% X: |- u

1. #define FLASH_VOLTAGE_RANGE_1        0x00000000U       /* Flash program/erase by 8 bits  */
   / W* v' W# M; F9 l
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 */
     s+ M/ [. g& l& K! N! r
4. #define FLASH_VOLTAGE_RANGE_4        FLASH_CR_PSIZE    /* Flash program/erase by 64 bits */

复制代码

8 C6 S! y# O1 p6 t# N( Z" ~
70.3.3 内部Flash的操作总结


使用方法由HAL库提供：
  Flash编程函数操作流程
" ]/ U$ ^' l0 l$ u1 |& [1 Y. t9 Q0 g  Flash解锁函数HAL_FLASH_Unlock。
9 j# C( Z: i! k  Flash查询方式编程HAL_FLASH_Program。
  Flash中断方式编程HAL_FLASH_Program_IT。
; v  Y1 a2 b! l  Flash上锁函数HAL_FLASH_Lock。
; M+ C! O9 G2 w- @  A1 |* B  
4 u; [0 _* u' p/ }0 Z选项字节编程流程
  选项字节解锁函数HAL_FLASH_OB_Unlock。
1 D3 g5 Z) D6 o& r8 \  选项字节加载函数HAL_FLASH_OB_Launch。
8 S) n9 w  w, l0 T# D  选项字节编程函数HAL_FLASHEx_OBProgram。
2 g9 T" _& I* s) U4 C2 d  选项字节加锁函数HAL_FLASH_OB_Lock。
: f( Q: M) [: {/ g5 Y8 H- y
& p+ [5 N9 p, f. @9 V( `% W* S Flash擦除流程
' u3 e: I7 l- F& ?0 ?  Flash解锁函数HAL_FLASH_Unlock。
  Flash查询方式擦除HAL_FLASHEx_Erase。
+ W1 T: N8 A5 b1 s# D0 c  Flash中断方式擦除HAL_FLASHEx_Erase_IT。
2 ^1 ^1 {, q0 J% a  Flash上锁函数HAL_FLASH_Lock。
2 y+ g; f* {  K( ^

5 \* X& W" F- y& p70.4 内部Flash源文件stm32h7xx_hal_flash.c
, R% z# _/ J$ S( }. c, i9 y) E此文件涉及到的函数较多，这里把几个常用的函数做个说明：
% |) f. \" y  }& h$ x
  HAL_FLASH_Unlock
( l. O( m9 y5 U% `6 W$ ?  HAL_FLASH_Lock
; d# \( }8 W% y5 s  P* z! O  HAL_FLASHEx_Erase
  HAL_FLASH_Program
! H9 S- c, x4 b& D- ?; u
70.4.1 函数HAL_FLASH_Lock
函数原型：

1. HAL_StatusTypeDef HAL_FLASH_Lock(void)
   
2. {
   / e% T  p, Q- s" x2 v
3. /* 设置FLASH Bank1控制寄存器Lock位，即禁止访问 */
   
4.   SET_BIT(FLASH->CR1, FLASH_CR_LOCK);
   5 g6 P3 p  u. P+ q7 M# U
5. 
   
6. /* 验证Flash Bank1是否已经被锁住 */
     }$ x! `, A9 f0 n& X
7.   if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) == 0U)
   5 {1 X) D8 H$ h* i( ^, `# c" O$ G
8.   {
   # i6 j: L" F9 |8 g. N
9.     return HAL_ERROR;
   
10.   }
    1 H. P. E# ]' s
11. 
    % f- O- N, ]9 `3 E  R8 y
12. /* 设置FLASH Bank2控制寄存器Lock位，即禁止访问 */
    
13.   SET_BIT(FLASH->CR2, FLASH_CR_LOCK);
    
14. 
    . F: O7 m3 T& S7 F
15. /* 验证Flash Bank2是否已经被锁住 */
    
16.   if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) == 0U)
    * M$ ]# }% G- K1 W' l, m; i
17.   {
    
18.     return HAL_ERROR;
    
19.   }
    
20. 
    # ^" W* Q- \1 O% l) L; @
21.   return HAL_OK;
    
22. }

复制代码

5 v! g* H8 S2 s, }! m5 v) ]( a函数描述：
" S  Z3 C$ Q6 a5 F
用于Flash加锁，加锁后将不能对Flash进行编程和擦除。

4 q0 R. {+ f  x5 O! \70.4.2 函数HAL_FLASH_Unlock
函数原型：
' h. s2 c# O0 ?' e- A

1. HAL_StatusTypeDef HAL_FLASH_Unlock(void)
   ; r1 z5 `' t3 |2 y# Q5 B
2. {
   
3.   if(READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
   6 r& D) [0 Y3 _  r! d3 I2 b7 r
4.   {
   
5.     /* 允许访问Flash Bank1 */
   5 a9 ^$ r$ C0 E& L! f  H& o
6.     WRITE_REG(FLASH->KEYR1, FLASH_KEY1);
   9 n3 _* S7 R  W) w. d( H9 W: K
7.     WRITE_REG(FLASH->KEYR1, FLASH_KEY2);
   , U' Y- R* |3 k$ _; Y
8. 
   
9.     /* 验证是否已经解锁 */
   
10.     if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
    ( K( l# B& @$ O
11.     {
    
12.       return HAL_ERROR;
    % X9 J+ O# \1 X& q* l( v
13.     }
    
14.   }
    2 Z9 `0 C! y1 I1 H7 W
15. 
    
16.   if(READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    
17.   {
    
18.     /* 允许访问Flash Bank2 */
    
19.     WRITE_REG(FLASH->KEYR2, FLASH_KEY1);
    
20.     WRITE_REG(FLASH->KEYR2, FLASH_KEY2);
    
21. 
    , f% F# o+ m+ M2 e, k4 x2 v0 }
22.     /* 验证是否已经解锁 */
    
23.     if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    ( Y8 _3 @0 c) w: O3 h6 M. M! C
24.     {
    
25.       return HAL_ERROR;
    9 y5 Z/ J, c* V7 l
26.     }
    ' ?; S9 h+ K# ^
27.   }
    . O1 `7 c8 C2 V. [% q( K8 u9 D) i3 I3 N
28. 
    7 a% j/ n% v# |# y1 R7 B* C$ w- |$ b# r
29.   return HAL_OK;
    
30. }

复制代码

函数描述：
2 m4 |; ^( t3 H2 F) ?
此函数用于Flash解锁，解锁后可以对Flash进行擦除和编程。

70.4.3 函数HAL_FLASH_Program
函数原型：
0 P$ E, D! C8 Z3 ^0 j9 w; f6 m

1. HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t FlashAddress, uint32_t DataAddress)
   
2. {
   9 k* i; x9 l* _! N
3.   HAL_StatusTypeDef status;
   
4.   __IO uint32_t *dest_addr = (__IO uint32_t *)FlashAddress;
   ! L( s. h, w" i( p( {2 [, m
5.   __IO uint32_t *src_addr = (__IO uint32_t*)DataAddress;
   # h6 g' s5 t; [+ ]( Z( G2 v! V1 t
6.   uint32_t bank;
   
7.   uint8_t row_index = FLASH_NB_32BITWORD_IN_FLASHWORD;
   8 N" o3 z0 M3 S, A4 d( b$ K, G
8. 
   / v5 M# o6 G3 X( e4 T) @5 r5 e$ L) M1 |
9.   /* 检测参数 */
   
10.   assert_param(IS_FLASH_TYPEPROGRAM(TypeProgram));
    * }4 |7 s( D& T
11.   assert_param(IS_FLASH_PROGRAM_ADDRESS(FlashAddress));
    1 j$ n" z- r# @. f
12. 
    
13.   /* 上锁 */
    2 @' N$ q  z2 P- \7 b
14.   __HAL_LOCK(&pFlash);
    
15. 
    8 J% x; p6 U$ u: u7 u- g' Y8 e4 R: m
16. #if defined (FLASH_OPTCR_PG_OTP)
    $ e' d/ {2 l" R& P; B3 H% y
17.   if((IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress)) || (IS_FLASH_PROGRAM_ADDRESS_OTP(FlashAddress)))
    1 R' F( Q' _7 S$ A0 b4 b
18. #else
    9 I0 j/ R8 c+ B$ ^9 e. H2 U$ D
19.   if(IS_FLASH_PROGRAM_ADDRESS_BANK1(FlashAddress))
    
20. #endif
    & I, Y( h  c# \9 Q# ?3 L
21.   {
    9 C8 _0 ^+ y; A
22.     bank = FLASH_BANK_1;
    , r* [  Q: c$ O2 `+ X
23.   }
    8 \% r3 a9 C! q" L
24.   else
    . m; o  M! L$ \
25.   {
    
26.     bank = FLASH_BANK_2;
    & C) y( Z5 S* k8 r
27.   }
    / F( E7 r& ]( l
28. 
    
29.   /* 错误标识，无错误 */
    
30.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
31. 
    
32.   /* 等待操作完成 */
    : ?" d, [6 }, `, K
33.   status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    ! Q( n$ j. d0 {) z
34. 
    4 ~4 E/ X+ p# h, l# \/ F
35.   if(status == HAL_OK)
    
36.   {
    / q. u7 Z' L! Q& p
37.     if(bank == FLASH_BANK_1)
    % R- i. D, F; ~8 ?( _
38.     {
    
39. #if defined (FLASH_OPTCR_PG_OTP)
    
40.       if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
41.       {
    
42.         /* 设置OTP寄存器的PG位，使能可以编程 */
    $ w/ f' S2 P0 h& T6 V8 _
43.         SET_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    9 j, }% T/ C8 Q7 s* |, {! _
44.       }
    
45.       else
    
46. #endif
    , U% a% `4 }. |  T
47.       {
    
48.         /* 设置PG位，使能可编程 */
    9 i! \4 L8 v, n0 h1 ~  g0 l
49.         SET_BIT(FLASH->CR1, FLASH_CR_PG);
    
50.       }
    
51.     }
    
52.     else
    
53.     {
    1 J) O+ ^9 |2 x( n  t
54.       /* 设置PG位 */
    ( Q3 g& k  @8 G' t) d
55.       SET_BIT(FLASH->CR2, FLASH_CR_PG);
    
56.     }
    
57. 
    4 e  P2 P$ H- o# R2 M: c2 Z- k* O/ N
58.     __ISB();
    
59.     __DSB();
    
60. 
    
61. #if defined (FLASH_OPTCR_PG_OTP)
    : z. ^+ v! P+ I7 p1 A$ m
62.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    ) Q5 @. `8 P/ K7 p6 ~. k
63.     {
    
64.       /* 编程OTP(16 bits) */
    
65.       *(__IO uint16_t *)FlashAddress = *(__IO uint16_t*)DataAddress;
    
66.     }
    4 X! T1 [' M% |& N7 M6 {9 z
67.     else
    3 y0 N! d$ X* \
68. #endif
    . ?; M  l$ Q, a
69.     {
    
70.       /* 对Flash进行编程 */
    " Q7 y6 r0 t7 O9 H
71.       do
    2 Z$ H7 x( D9 J# z( j) X
72.       {
    
73.         *dest_addr = *src_addr;
    
74.         dest_addr++;
    
75.         src_addr++;
    3 m, S. X, a! ]# H8 }
76.         row_index--;
    
77.      } while (row_index != 0U);
    / L5 N$ |) i" L) ?& ~1 J
78.     }
    
79. 
    
80.     __ISB();
    / J% u; W6 H+ q- B: G9 l! ?6 p
81.     __DSB();
    7 x! W) Q+ X: t* t$ ]6 r4 n
82. 
    
83.     /* 等待最后一次操作完成 */
    6 \4 S4 y2 O$ e3 H, |" y' q; O% u
84.     status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, bank);
    
85. 
    # F8 h8 w6 k6 H8 Y
86. #if defined (FLASH_OPTCR_PG_OTP)
    
87.     if (TypeProgram == FLASH_TYPEPROGRAM_OTPWORD)
    
88.     {
    $ d2 l5 {9 k- r$ H& I/ ?
89.       /* 如果编程操作完成，关闭OTP PG位 */
    
90.       CLEAR_BIT(FLASH->OPTCR, FLASH_OPTCR_PG_OTP);
    $ N) i6 e1 P/ d* I1 p
91.     }
    
92.     else
    
93. #endif
    $ U. a/ {. ~. E$ E
94.     {
    8 T+ K. _: b0 ~% z. K0 M; y: c
95.       if(bank == FLASH_BANK_1)
    3 O5 T+ K1 V: T
96.       {
    , a/ N$ b# l) o7 {; g
97.         /* 如果操作完成，关闭PG位 */
    $ A$ ~3 Y3 B# W7 @+ D
98.         CLEAR_BIT(FLASH->CR1, FLASH_CR_PG);
    
99.       }
    
100.       else
     
101.       {
     + _+ _/ J. T; |- Y% d9 ]
102.         /* 如果操作完成，关闭PG位 */
     & ]/ c% T3 q8 b5 `
103.         CLEAR_BIT(FLASH->CR2, FLASH_CR_PG);
     
104.       }
     8 `1 R; E/ k7 q- v
105.     }
     4 Y) O, J# r1 H6 L! ?: R
106.   }
     
107. 
     
108.   /* 解锁 */
     . }  h' {1 V# ~) U
109.   __HAL_UNLOCK(&pFlash);
     % n- ?; X- i7 Y+ ^
110. 
     
111.   return status;
     
112. }
     8 _( H1 b8 C, S0 i1 r
113. 
     7 [' c0 c- v  N9 T& o2 w  ^

复制代码

5 g. H6 E0 Z% N) J* t, `* t函数描述：
6 R& R1 R" `/ @- Y) f此函数主要用于Flash编程，固定编程32个字节数据。
' P, L) j2 ]6 i+ i' a# u& g/ d# s! |
+ k5 Q' L5 w  Q2 ?8 Y0 A函数参数：
第1个参数是要编程的Flash类型，支持两种参数：
. I/ }7 T7 C6 [8 Y% W  FLASH_TYPEPROGRAM_FLASHWORD，用于芯片内部Flash编程。
! Q) Y" C9 e& @  FLASH_TYPEPROGRAM_OTPWORD，用于芯片内部OTP存储区编程，当前的H743并没有这个区域，所以可以忽略。
# x, k  M. m# t5 K3 Y# O
第2个参数是要编程的Flash地址。

$ f* I% \; n; a* i" L& a6 b第3个参数是要编程到Flash的数据地址。
) @. H8 ]4 n( s! D4 L1 j; g! P返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
- K. \1 C. G" U9 s; s

注意事项：
* n4 @& H3 v4 ?$ L3 ?- H& {  第2个参数的Flash地址要是32字节对齐的，即此地址对32求余等于0。
" N+ w: i6 r5 S7 c) S  第3个参数务必要是32字节的整数倍。
  X  ]1 f  N7 x0 j/ v2 H# Z, `
70.4.4 函数HAL_FLASHEx_Erase
函数原型：
0 N: X! P& H( L1 v- S- A, R- L. }- z
; x: R  t+ j, {4 |; n

1. HAL_StatusTypeDef HAL_FLASHEx_Erase(FLASH_EraseInitTypeDef *pEraseInit, uint32_t *SectorError)
   
2. {
   0 u. [, P* Z6 z6 t5 n" l2 R
3.   HAL_StatusTypeDef status = HAL_OK;
   - j/ ]9 c: N3 _2 a0 B% P( W( G1 K
4.   uint32_t sector_index;
   8 y% G, |' X" a- o
5. 
   
6. /* 检查参数 */
   0 t/ ~- d( k! z  {# n" D: E
7.   assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
   " R  N2 u' }1 K! M
8.   assert_param(IS_FLASH_BANK(pEraseInit->Banks));
   
9. 
   - |7 y1 m$ |7 ]1 l7 E: V# M. h
10. /* 上锁 */
    # J$ h9 N3 A1 y  ?% O5 C
11.   __HAL_LOCK(&pFlash);
    5 N% R- ^1 q2 [* G
12. 
    
13. /* 无错误 */
    1 O( e3 n# B' `  Z/ s5 h. D* U
14.   pFlash.ErrorCode = HAL_FLASH_ERROR_NONE;
    
15. 
    
16. /* 等待BANK1的操作完成 */
    4 b$ F0 O% m/ N5 Q. t/ ?2 X
17.   if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    
18.   {
    0 ?- w; P; @9 X; |. Z! ?% K7 Q
19.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    " t) P! E0 o5 Y% ?) f7 u  \1 ^
20.     {
    " y" r% X6 [0 Z- G9 x9 n- \" l
21.       status = HAL_ERROR;
    
22.     }
    
23.   }
    3 A0 o+ `: d7 ?: C. f' y% {
24. 
    
25. /* 等待BANK2的操作完成 */
    ) {3 j! r) B0 D  w/ T0 H9 k
26.   if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    7 v% U+ y2 G4 T% `4 E3 u# |7 e' R9 v
27.   {
    0 P: P" Y9 i- V5 M5 \
28.     if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2) != HAL_OK)
    + P' O0 u/ J6 g, d
29.     {
    
30.       status = HAL_ERROR;
    
31.     }
    
32.   }
    * i* E: b% @! p+ I% I# q! F- y
33. 
    ' u" K* \" e6 G5 q! o; t% \% |, p
34.   if(status == HAL_OK)
    
35.   {
    : Y7 b2 h2 u* ~( [& w, [6 I
36.     if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
    
37.     {
    
38.   /* 整个BANK1或者BANK2擦除 */
    & v2 J0 t* I/ ~- p9 d# |& m
39.       FLASH_MassErase(pEraseInit->VoltageRange, pEraseInit->Banks);
    6 n3 W. |# d4 N+ b, K0 Y
40. 
    
41.   /* 等待操作完成 */
    
42.       if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    : F( P  T+ n9 f4 Z
43.       {
    
44.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1) != HAL_OK)
    
45.         {
    # _. B9 ~, _" a1 q
46.           status = HAL_ERROR;
    
47.         }
    4 a1 R0 i% k$ G' `+ I7 R: n5 Y( `
48.     /* 如果擦除完成，关闭BANK1的BER位 */
    
49.         FLASH->CR1 &= (~FLASH_CR_BER);
    
50.       }
    ! e9 U. s  v  T: T/ Q
51.       if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    7 N- `' V3 T9 _; ^/ t# J5 r! u5 n
52.       {
    
53.         if(FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2) != HAL_OK)
    : T+ E* l1 S# v. r* ?
54.         {
    & q3 }6 ]  Z5 O# N
55.           status = HAL_ERROR;
    
56.         }
    ! n) y0 e9 \: u0 p/ q. S
57.     /* 如果擦除操作完成，关闭BANK2的BER位 */
    
58.         FLASH->CR2 &= (~FLASH_CR_BER);
    
59.       }
    ; }& |# e6 `' a* {: ~8 L6 K
60.     }
    
61.     else
    
62.     {
    
63.   /* 初始化扇区错误码 */
    
64.       *SectorError = 0xFFFFFFFFU;
    / j* W: G& }1 R$ K8 Q
65. 
    - T& {/ I2 s, H6 M& y2 K% T
66.   /* 扇区方式擦除 */
    7 Y" z! [* w( j
67.       for(sector_index = pEraseInit->Sector; sector_index < (pEraseInit->NbSectors + pEraseInit->Sector);
    
68. sector_index++)
    . P" P, h# p0 B) ~, A
69.       {
    7 {5 _2 `0 B! L: j& ?9 x  G
70.         FLASH_Erase_Sector(sector_index, pEraseInit->Banks, pEraseInit->VoltageRange);
    * Q! L0 Y2 Q3 x. ]1 b
71. 
    
72.         if((pEraseInit->Banks & FLASH_BANK_1) == FLASH_BANK_1)
    
73.         {
    
74.       /* 等待BANK1操作完成 */
    2 H/ F, ]9 N; K0 Z
75.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1);
    
76. 
    
77.       /* 如果擦除操作完成，禁止SER位 */
    
78.           FLASH->CR1 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    " m( Z) l$ ]4 k* z1 a% ~
79.         }
    
80.         if((pEraseInit->Banks & FLASH_BANK_2) == FLASH_BANK_2)
    
81.         {
    " H# S4 c2 M- E3 i3 R0 J3 k4 B; Q
82.       /* 等待BANK2操作完成 */
    
83.           status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2);
    
84. 
    
85.       /* 如果擦除操作完成，禁止SER位 */
    
86.           FLASH->CR2 &= (~(FLASH_CR_SER | FLASH_CR_SNB));
    
87.         }
    
88. 
    
89.         if(status != HAL_OK)
    8 J- ^+ l8 b9 [! m. C/ ?# _
90.         {
    $ H/ y2 r2 n; @- O- s# G# ?4 ~
91.       /* 如果擦除出错，停止后续擦除，返回擦除异常的扇区号 */
    
92.           *SectorError = sector_index;
    
93.           break;
    
94.         }
    ! Z9 L/ X5 f- v1 q
95.       }
    ( F4 [( F+ v: W2 \9 v4 C
96.     }
    + A& {0 y& m0 Q: u. S7 I  N
97.   }
    
98. 
    & f! d1 N3 @8 R7 N
99. /* 解锁 */
      t- V& x8 X  ~5 m0 c8 D6 g6 c
100.   __HAL_UNLOCK(&pFlash);
     ! d7 j# ?$ S! F" j9 [
101. 
     
102.   return status;
     
103. }
     

复制代码

! G, \$ t5 T& M7 r函数描述：
6 ?- f% S& d7 J. ]用于内部Flash的批量擦除（BANK擦除）和扇区方式擦除。
4 M* I% S# j- X. X' i; o# `9 `
' ~) l* _' V4 |2 i% w( p函数参数：
" t$ I" T8 f4 }1 v. {  第1个参数是FLASH_EraseInitTypeDef类型结构体指针变量。
  第2个参数是错误码返回，返回0xFFFFFFFF表示全部正确，返回其它值是擦除过程中的错误扇区。
% ^: c6 ]* C5 T* M  M0 A, h  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
% v3 `- Q* y- q* n& e6 I" A
70.5 总结
本章节就为大家讲解这么多，对于内部Flash编程来说，掌握本章节的这些知识点就够用了，更多的知识点可以看STM32H7的参考手册学习。