81.1 初学者重要提示
8 N8 E2 J1 u* x# S* p  QSPI Flash的相关知识点可以看第78章和79章。
  QSPI Flash下载算法文件直接采用HAL库制作，方便大家自己修改。
  STM32CubeProg下载算法制作和MDK下载算法制作基本是一样
7 r& R- |- _# u- ~  本教程的第68章USB DFU和第69章串口IAP章节为大家介绍过STM32CubeProg的用法。
: x% ?% V, [) e; R) _81.2 STM32CubeProg简介
STM32CubeProg，此软件实现了之前的 DfuSe，STLINK 小软件和 Flashloader 三合一，并且支持外部 EEPROM，NOR Flash，SPI Flash，NAND Flash 等烧写，也支持 OTA 编程。
  S' f5 P  z8 N& X& g
" }* @$ P# ?/ q

3 F$ ?* y8 m% b4 `& Q/ [: i1 M
( B+ k+ L$ d( y+ Y! w: |81.3 STM32CubeProg下载算法基础知识
5 g' o- y1 t( [7 l% T9 {% M! C3 c( cSTM32CubeProg下载算法是一种用于擦除应用程序或将应用程序下载到Flash的程序代码。ST自家的芯片都自带下载算法，存放在STM32CubeProg安装目录里面，但不支持的需要我们自己制作，本章教程为此而生。

- T4 F5 b9 O0 J5 Q81.3.1 程序能够通过下载算法下载到芯片的核心思想
9 b3 V# h6 }  s- {- R$ A- o4 \  d认识到这点很重要：通过IDE开发环境创建一批与地址信息无关的算法文件，实现的功能主要有初始化，擦除，编程，读取，校验等，然后STM32CubeProg下载阶段，会将算法文件加载到芯片的内部RAM里面，然后STM32CubeProg通过与这个算法文件的交互，实现程序下载，数据读取等操作。

81.3.2 算法程序中擦除操作执行流程
) B: s4 @; o- ]& Q( q3 [- G( h; B注：下面是MDK的算法执行流程，STM32CubeProg是类似的。

擦除操作大致流程：

& b; Q7 ~# r& p  加载算法到芯片RAM。
  执行初始化函数Init。
2 p0 g* V8 B( |) V  执行擦除操作，根据用户配置，这里可以选择整个芯片擦除或者扇区擦除。
  执行Uinit函数。
  操作完毕。
81.3.3 算法程序中编程操作执行流程
+ q* O" ^$ _' O3 a" }注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。

编程操作大致流程：
7 P% L+ N+ O! B4 i* Y
1 T( t2 f" ?9 ?1 j8 U* a' E  y

  N7 R, T  J7 c1 j3 [" _: M  针对IDE生成的axf（elf）可执行文件做Init初始化，这个axf（elf）文件是指的大家自己创建应用程序生成的。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
  加载算法到RAM。
  执行Init函数。
9 y$ h3 `$ b- b3 b- v1 ?/ F  加载用户到RAM缓冲。
1 z' Q6 e, _& h! {  执行Program Page页编程函数。
! j  J4 s( a0 @0 d  执行Uninit函数。
% ]! @1 U2 s4 }; b5 ]/ V; i1 `1 V2 J  操作完毕。
81.3.4 算法程序中校验操作执行流程
$ y% c" p( R& _$ Y8 A7 Y& C; H注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。

. Q1 Q5 R6 x8 `2 ~校验操作大致流程：
: `9 h! t. {9 i
' G, b% o, G( ~. O% b

  校验要用到IDE生成的axf（elf）可执行文件。校验就是axf（elf）文件中下载到芯片的程序和实际下载的程序读出来做比较。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
  加载算法到RAM。
  执行Init函数。
  查看校验算法是否存在
5 n, K# K$ m# {/ }7 Q  如果有，加载应用程序到RAM并执行校验。
  如果没有，执行计算CRC，将芯片中读取数据出来和RAM中加载应用计算输出的CRC值做比较。
- Z0 h# N9 k- a5 C2 L7 w5 Y) F  执行Uninit函数。
- G& X) W, \4 G$ R! \; J  替换BKPT（BreakPoint断点指令）为 B. 死循环指令。
1 b. r+ Q1 ]' B1 {8 g, m7 z  执行RecoverySupportStop，回复支持停止。
  执行DebugCoreStop，调试内核停止。
  运行应用：
) ]: z3 c! e- {; V* X1 G  执行失败
, c- a/ |+ c( s  执行成功，再执行硬件复位。
1 A' P' Y+ q: f' g  操作完毕，停止调试端口。
9 T' M' t1 W" `2 I% u( f- ^81.4 创建STM32CubeProg下载算法通用流程
下面是STM32CubeProg给的一种大致操作流程，不限制必须采用这种方法，自己创建也可以的。

81.4.1 第1步，使用STM32CubeProg提供好的程序模板
位于路径：STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader
$ Q4 t. T! W( y- Y- p) O8 t# x/ }

. |7 C/ }$ \- v以M25P64为例（注，其余步骤就以这个为例子进行说明）：
2 \2 l# x" r4 w/ X+ p0 {
% o8 m# q% Z; y

81.4.2 第2步，修改工程名
STM32CubeProg提供的工程模板原始名字是M25P64_STM3210E-EVAL.uvproj，大家可以根据自己的需要做修改。比如修改为MyDevice.uvproj（MDK4的后缀）或者MyDevice.uvprojx（MDK5的后缀）。
4 o- q) B0 ?: Y# Z4 d  a
* b, m' K. [" ~; ]! [$ N0 L' g81.4.3 第3步，修改使用的器件
. |9 u) g( ^- H( m: M! q在MDK的Option选项里面设置使用的器件。

7 P7 H5 S9 P0 N

. {" }, C6 d: W" v" u. U
81.4.4 第4步，修改输出算法文件的名字
9 m! G% e7 c1 W, Q0 i/ h这个名字是方便用户查看的，比如设置为stm32h7，那么输出的算法文件就是stm32h7.stldr。

1 C& |# x/ R* [  x

% |( c  g$ D9 U  r# s
5 x$ N, e  `% Z* J" F" O注：STM32CubeProg软件里面别的文件名并不采用这个，而是由用户在文件Dev_Inf.c里面定义的：

81.4.5 第5步，修改使用的库文件和头文件路径
根据大家使用的主控芯片，添加相应的库文件和头文件路径。

+ T6 y+ M8 S# Z; @4 D  H$ }81.4.6 第5步，修改编程算法文件Loader_Src.c
1 R9 e, e: b& O6 B* n" b0 k模板工程里面提供的是M25P64，部分代码如下：
4 h) y9 U0 T9 y/ l; z) j: h
1 v# F! S3 X5 i2 {% s* p

1. /**
   6 ~% B6 u: m' O9 T
2.   * Description :
   
3.   * Initilize the MCU Clock, the GPIO Pins corresponding to the
   
4.   * device and initilize the FSMC with the chosen configuration
   # D' X, @9 o5 i  B4 g2 u
5.   * Inputs    :
   ) P1 G% P! w  A2 X0 ~  A" W0 ^
6.   *      None
   
7.   * outputs   :
   0 X1 y. r% E7 @& r4 m
8.   *      R0             : "1"             : Operation succeeded
   3 V" _6 g; g, J" z7 u1 q
9.   *               "0"             : Operation failure
   
10.   * Note: Mandatory for all types of device
    " x! J  o, A- O/ x- T) W
11.   */
    8 I  H' e) V& H
12. int Init (void)
      h9 g% h( k: X1 \  K; w+ x
13. {  
    
14.   SystemInit();
    
15.   sFLASH_Init();
    - M: W4 `3 s' k
16.   return 1;
    3 p1 v" m" j; I  n7 {# B2 M& {$ r
17. }
    . [8 G3 U& a4 G1 p, [8 g! u# I. K
18. 
    9 y, X3 @" K# h5 A7 V; ~1 S
19. 
    
20. /**
    
21.   * Description :
    
22.   * Read data from the device
      M2 U; [5 w% C: s# E6 ~5 r! F
23.   * Inputs    :
    
24.   *      Address       : Write location
    . {3 _: t8 s6 u- J7 {
25.   *      Size          : Length in bytes  
    
26.   *      buffer        : Address where to get the data to write
    
27.   * outputs   :
    
28.   *      R0             : "1"             : Operation succeeded
    
29.   *               "0"             : Operation failure
    
30.   * Note: Mandatory for all types except SRAM and PSRAM   
    - f7 O, ]( H& `, Z8 V: \7 U( ~
31.   */
    5 h7 g0 @/ K8 d: M
32. int Read (uint32_t Address, uint32_t Size, uint8_t* buffer)
    
33. {
    
34.   sFLASH_ReadBuffer(buffer, Address, Size);
    
35.   return 1;
    $ m4 S! o+ [4 f  i
36. }
    3 ]3 }1 S, t& L2 {" q
37. 
    
38. 
    % V$ s. k5 E' |! b% c. B1 v0 V, U
39. /**
    ! X0 {( H% P- @9 F
40.   * Description :
    1 a0 u; }5 E" z% p, d1 G% p
41.   * Write data from the device
    + U2 j( D) @) M% F
42.   * Inputs    :
    
43.   *      Address       : Write location
    , @8 ?5 {2 H" z# O, ^1 @
44.   *      Size          : Length in bytes  
    
45.   *      buffer        : Address where to get the data to write
    
46.   * outputs   :
    " [" f5 D9 A  Q
47.   *      R0           : "1"             : Operation succeeded
    / K' V& P: W1 n* L0 x0 a
48.   *                     "0"             : Operation failure
    * u9 L, W$ o: T3 }! w
49.   * Note: Mandatory for all types except SRAM and PSRAM   
    
50.   */
    
51. int Write (uint32_t Address, uint32_t Size, uint8_t* buffer)
    
52. {
    % k8 x2 Q" F9 p% B
53.   sFLASH_WriteBuffer(buffer, Address, Size);
    : [& R9 Y# Y4 q+ @. m1 O
54.   return 1;
    + q# L. R2 A8 C& t1 q% }/ y
55. }
    
56. 
    7 ^  z* j, x9 g2 z7 k- s, U
57. 
    
58. /**
    
59.   * Description :
    
60.   * Erase a full sector in the device
    
61.   * Inputs    :
    1 U$ b* j/ v5 @
62.   *     None
    ) T! z! A, L+ e3 G2 I. ?
63.   * outputs   :
    
64.   *     R0             : "1" : Operation succeeded
    ) T/ l( E! F: e8 A$ y/ {0 X: d
65.   *              "0" : Operation failure
      d9 F0 e- a. W
66.   * Note: Not Mandatory for SRAM PSRAM and NOR_FLASH
    
67.   */
    ' K5 n  c( U7 \5 O# d
68. int MassErase (void)
    8 m: l( P* B, e9 _3 ?6 G4 \
69. {  
    
70.   sFLASH_EraseBulk();
    
71.   return 1;   
    
72. }

复制代码

& @7 D1 y. I: T6 s: [5 |) R81.4.7 第6步，修改配置文件Dev_Inf.c
- w0 v2 l/ t  k" f# U5 M模板工程里面提供简单的配置说明：
1 b$ K" u) v+ L; M. i" o! l

1. #if defined (__ICCARM__)
   7 `4 o5 T+ w4 @- ]* [0 S  g6 F& {/ K
2. __root struct StorageInfo const StorageInfo  =  {
   & a1 U, c* z4 H
3. #else
     Y7 L8 g3 B, T* X
4. struct StorageInfo const StorageInfo  =  {
   2 _6 O" c5 m4 e8 Y  L, k
5. #endif
   : l0 s7 G1 j0 B" X, Y) F7 f
6.    "M25P64_STM3210E-EVAL",           // Device Name + version number
   " q* M3 b( |: I" Q7 u2 c3 {! N; s8 n+ B
7.    SPI_FLASH,                       // Device Type
   & ~8 Q0 h* N/ f- p' H
8.    0x00000000,                     // Device Start Address
   % d8 a  V  S8 Q% ]
9.    0x00800000,                      // Device Size in Bytes (8MBytes/64Mbits)
   
10.    0x00000100,                      // Programming Page Size 16Bytes
    
11.    0xFF,                            // Initial Content of Erased Memory
    : \0 a9 T2 j( P! D( I
12. // Specify Size and Address of Sectors (view example below)
    
13.    0x00000080, 0x00010000,          // Sector Num : 128 ,Sector Size: 64KBytes
    4 [5 t6 a4 J; p& y- m% L" M
14.    0x00000000, 0x00000000,
    5 @0 |: _- O: i- y" l7 X4 G; t8 Z' n
15. };

复制代码

注：名字M25P64_STM3210E-EVAL就是我们第4步所说的。STM32CubeProg会识别出这个名字。
, T/ Y7 L' k1 h


$ L8 ?: a- d* l+ ~0 X81.4.8 第7步，保证生成的算法文件中RO和RW段的独立性，即与地址无关。
C和汇编的配置都勾选上：

0 Q6 r3 K' p4 H5 U( J

汇编：
0 j$ l. Z) V* h' k
4 k0 I+ S, A6 |8 A

4 w7 o( g$ f1 C7 ^4 h# {
+ m% Y' E7 E2 t) B+ ]3 H  x" s! s如果程序的所有只读段都与位置无关，则该程序为只读位置无关（ROPI, Read-only position independence）。ROPI段通常是位置无关代码（PIC,position-independent code），但可以是只读数据，也可以是PIC和只读数据的组合。选择“ ROPI”选项，可以避免不得不将代码加载到内存中的特定位置。这对于以下例程特别有用：

3 i9 W5 {* J% `: z8 D5 E（1）加载以响应运行事件。
, \# \+ }4 b- m/ ]5 K5 t8 x# A
（2）在不同情况下使用其他例程的不同组合加载到内存中。

% m" _9 p0 z" D5 n* _0 t（3）在执行期间映射到不同的地址。

- V- H7 r$ j( j+ R; [使用Read-Write position independence同理，表示的可读可写数据段。
6 v/ Y" s: [& z% K3 K: J
6 y7 |1 s$ e9 {* a% d/ _81.4.9 第8步，将程序可执行文件axf修改为stldr格式
通过下面的命令就可以将生成的axf可执行文件修改为stldr。

; |) y/ N7 N" v, F( ]
81.4.10   第9步，分散加载设置
% w$ s' i7 u) s2 G* `* x0 D. [我们这里的分散加载文件直接使用MDK模板工程里提供好的即可。

8 `: l4 S* O. Z& C% ^& D

8 F; A; }5 g7 H( u+ F9 A& i
& V7 h# R' L; c/ u# Z& J5 _分散加载文件中的内容如下：
4 P  L6 z/ U3 k2 l7 ?
6 A# v2 O$ q1 f8 y: N1 S; Y

1. FLASH_LOADER 0x20000004 PI   ; FlashLoader Functions
   
2. {
   ( N7 d$ D) \6 r' N" D9 ~
3.   PrgCode +0           ; Code
   0 d2 Z' ?8 d+ p
4.   {
   
5.     * (+RO)
   1 `* d! g' v$ M( W7 j. @5 I
6.   }
   7 `4 _( D/ B; K' C
7.   PrgData +0           ; Data
   
8.   {
   
9.     * (+RW,+ZI)
     a6 u5 C) c" J2 l4 E2 o
10.   }
    % d( O" w' }% ~) m3 S# j
11. }
    
12. 
    
13. DEVICE_INFO +0               ; Device Info
    
14. {
    
15.   DevInfo +0           ; Info structure
    / V' s9 Y6 V: J( I
16.   {
    2 V6 U% r- i0 I& ~9 u+ X  w
17.     dev_inf.o
    * u1 ^4 d% I# a+ _0 P, \
18.   }
    6 y5 z* W: n5 f
19. }

复制代码

9 C) ]/ A9 ]) C& P9 Z这里要修改下Flash算法加载地址，将0x20000004修改为STM32H7的RAM地址，任何RAM块地址均可，只要够存储Flash算法。推荐设置为AXI SRAM地址0x24000004，因为空间够大，有512KB。

( u# x& G, N( X; [4 r--diag_suppress L6305用于屏蔽L6503类型警告信息。
9 V' T# N0 r  a) H% x. o: K
7 [+ N' t4 o7 l: T( W2 C! r特别注意，设置了分散加载后，此处的配置就不再起作用了：
, ^+ |1 P4 z* D+ F

2 I, V& z/ V0 Q6 u% J% X/ L& U
81.5 QSPI Flash的STM32CubeProg下载算法制作
下面将QSPI Flash算法制作过程中的几个关键点为大家做个说明。
3 a" H% v2 B- @7 `2 R* f8 R
' D& V0 ~0 S* D, ], X3 |) k81.5.1 第1步，制作前重要提示
/ G) h4 C# ?  m1 P4 t这两点非常重要：
3 U5 a) N( E1 `0 w7 H
' V9 b. W& T, V; l+ _- [5 c  P. O  程序里面不要开启任何中断，全部查询方式。
  HAL库里面各种时间基准相关的API全部处理掉。简单省事些，我们这里是直接注释，采用死等即可。无需做超时等待，因为超时后，已经意味着操作失败了，跟死等没有区别。
81.5.2 第2步，准备一个工程模板
推荐大家直接使用我们本章工程准备好的模板即可，如果大家自己制作，注意一点，请使用当前最新的HAL库。
' h. k+ F: u3 D1 d1 Y6 _, c
4 r" V7 |  O; T% x3 E

+ z6 O- ?8 O9 ~
81.5.3 第3步，修改HAL库
这一步比较重要，主要修改了以下三个文件：

) A& r. ^1 p+ j8 ]1 [# t8 Q

: O: r( C7 e" w8 v- L. U
主要是修改了HAL库时间基准相关的几个API，并注释掉了一批无关的API。具体修改内容，大家可以找个比较软件，对比修改后的这个文件和CubeH7软件包V1.8.0（软件包里面的HAL库版本是V1.9.0）的差异即可。

5 W; X9 j/ a6 d4 n% d# n  N* m/ x81.5.4 第4步，时钟初始化
$ \: L" ?  R7 {5 M5 x! x/ s我们已经用不到滴答定时器了，直接在bsp.c文件里面对滴答初始化函数做重定向：

& G0 u. N8 j( f3 T: F

1. /*
   
2. *********************************************************************************************************
   - h8 O; C4 J7 r7 @6 h
3. *    函 数 名: HAL_InitTick
   
4. *    功能说明: 重定向，不使用
   + a, {4 d* ?* q! I' J
5. *    形    参: TickPriority
   : ]$ D+ C) N" J( }4 N5 @
6. *    返 回 值: 无
   - L; P7 A& `8 ?9 ?% c7 j6 E
7. *********************************************************************************************************
   ' R8 W. `+ W' M: e
8. */
   ( L5 Y% Q0 q- \
9. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
   / [, D6 u0 E  _( p4 h" c
10. {
    & S0 L0 d, M6 Y) b
11.     return HAL_OK;
    % D( C& G+ l6 d
12. }

复制代码

5 S$ ]5 X( ^! Z; J6 u6 g然后就是HSE外置晶振的配置，大家根据自己的板子实际外挂晶振大小，修改stm32h7xx_hal_conf.h文件中HSE_VALUE大小，实际晶振多大，这里就修改为多大：
0 C. x* b) a3 c. X$ i0 H
+ h; o' j: |1 A

1. #if !defined  (HSE_VALUE)
     p) e- ?/ I+ ~
2. #define HSE_VALUE    ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
   
3. #endif /* HSE_VALUE */

复制代码

最后修改PLL：
$ T$ q( b  I( x$ {+ E" i

1. /*
   3 S. t- Y4 i) \( z2 o4 i& A; h
2. *********************************************************************************************************
   
3. *    函 数 名: SystemClock_Config
   
4. *    功能说明: 初始化系统时钟
   
5. *                System Clock source            = PLL (HSE)
   - g8 O6 v& L& G+ r1 m
6. *                SYSCLK(Hz)                     = 400000000 (CPU Clock)
   
7. *               HCLK(Hz)                       = 200000000 (AXI and AHBs Clock)
   
8. *                AHB Prescaler                  = 2
   
9. *                D1 APB3 Prescaler              = 2 (APB3 Clock  100MHz)
   ( o9 e0 P! |& ?, r1 N
10. *                D2 APB1 Prescaler              = 2 (APB1 Clock  100MHz)
    
11. *                D2 APB2 Prescaler              = 2 (APB2 Clock  100MHz)
    0 D2 N8 ?/ F8 ]0 j
12. *                D3 APB4 Prescaler              = 2 (APB4 Clock  100MHz)
    
13. *                HSE Frequency(Hz)              = 25000000
    
14. *               PLL_M                          = 5
    + \& t% h6 w3 n& r
15. *                PLL_N                          = 160
    ( l6 i  A8 T+ I" {6 L. z
16. *                PLL_P                          = 2
    
17. *                PLL_Q                          = 4
    ' I. `' \) X: i! `% ^* H
18. *                PLL_R                          = 2
    ( M' J' n4 \, E. Y! K' C3 O
19. *                VDD(V)                         = 3.3
    
20. *                Flash Latency(WS)              = 4
    8 M- k5 O% P* O$ e
21. *    形    参: 无
    
22. *    返 回 值: 1 表示失败，0 表示成功
    
23. *********************************************************************************************************
    
24. */
    ' J" ~% n. i, Q, U6 z2 }
25. int SystemClock_Config(void)
    / M# Y( N* i0 g, q
26. {
    " d! x0 ]3 `: v2 f9 e  E8 L* e
27.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    
28.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
      b" w1 B0 a5 Q( L
29.     HAL_StatusTypeDef ret = HAL_OK;
    / E5 a/ ]* x0 c& I
30. 
    2 Y2 L0 T' p- ^' o, y
31.     /* 锁住SCU(Supply configuration update) */
    
32.     MODIFY_REG(PWR->CR3, PWR_CR3_SCUEN, 0);
    . Y7 P2 t* l( S& E
33. 
    + [5 @  o/ y) J% z* W# o; W  o! B5 ^
34.     /*

复制代码

      1、芯片内部的LDO稳压器输出的电压范围，可选VOS1，VOS2和VOS3，不同范围对应不同的Flash读速度，
         详情看参考手册的Table 12的表格。
1 ~8 x. P/ p% W9 b  j0 ^: x+ D      2、这里选择使用VOS1，电压范围1.15V - 1.26V。
' |2 P: e" y* ^   

1. */
   
2.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
   - O" E" t! ]% W- N% [+ h
3. 
   
4.     while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
   
5. 
   / K, `5 ]9 q- d2 k7 @2 I
6.     /* 使能HSE，并选择HSE作为PLL时钟源 */
   1 N5 v: e$ t9 ^; ?/ p/ q" u
7.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   : _3 w( B! }# y+ j, r9 Q* v* ^
8.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
   
9.     RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
   * B0 k3 S8 I3 ]; Y, M
10.     RCC_OscInitStruct.CSIState = RCC_CSI_OFF;
    
11.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    
12.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    / i6 k5 X4 p6 E/ ]
13. 
    
14.     RCC_OscInitStruct.PLL.PLLM = 5;
    
15.     RCC_OscInitStruct.PLL.PLLN = 160;
    ; e: Y- g' J% }  p: G' e
16.     RCC_OscInitStruct.PLL.PLLP = 2;
    
17.     RCC_OscInitStruct.PLL.PLLR = 2;
    
18.     RCC_OscInitStruct.PLL.PLLQ = 4;        
    
19. 
    
20.     RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
    ' R" M. Z$ }) B2 g' Z1 u) n8 \
21.     RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;   
    : r- d7 j* ^$ E, K
22.     ret = HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
23.     if(ret != HAL_OK)
      F. y9 k+ T: `2 |+ Y
24.     {
    
25.         return 1;        
    % Y( J. p0 S# U
26.     }
    
27. 
    
28.     /*
    
29.        选择PLL的输出作为系统时钟
    
30.        配置RCC_CLOCKTYPE_SYSCLK系统时钟
    . c0 p3 y- U2 i8 N: Q5 I
31.        配置RCC_CLOCKTYPE_HCLK 时钟，对应AHB1，AHB2，AHB3和AHB4总线
    9 Y6 z/ s, n+ ?* H
32.        配置RCC_CLOCKTYPE_PCLK1时钟，对应APB1总线
    1 G3 E! l0 ~! k6 R$ c: Q, \
33.        配置RCC_CLOCKTYPE_PCLK2时钟，对应APB2总线
    
34.        配置RCC_CLOCKTYPE_D1PCLK1时钟，对应APB3总线
    
35.        配置RCC_CLOCKTYPE_D3PCLK1时钟，对应APB4总线     
    : t  w! l8 G9 s6 W* c  o& f, g
36.     */
    
37.     RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_D1PCLK1 | RCC_CLOCKTYPE_PCLK1 | \
    1 p- [' r6 z/ {. K
38.                                  RCC_CLOCKTYPE_PCLK2  | RCC_CLOCKTYPE_D3PCLK1);
    & t3 ~& N3 C8 j- [) {3 I( w
39. 
    + _: H( C. _  {5 I( P' F8 K  \
40.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    ) X% M5 E+ W$ J, W0 T
41.     RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
    
42.     RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
    * z+ Q( B) e5 |. l
43.     RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;  
    , Q; J% N* t: a8 l& A/ U0 ]
44.     RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
    
45.     RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
    ( g( A# G0 m& m' g6 y) `
46.     RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
    
47. 
    
48.     /* 此函数会更新SystemCoreClock，并重新配置HAL_InitTick */
    
49.     ret = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4);
    * F- l8 D5 t- h: U- w! i
50.     if(ret != HAL_OK)
    : U& p5 q( X$ O4 G- V+ Z: V
51.     {
    
52.         return 1;
    
53.     }
    ' G, |, f- P5 f& O0 v& ?
54. 
    . }2 E" `+ @' }. n, H2 {4 I
55.     /*
    
56.       使用IO的高速模式，要使能IO补偿，即调用下面三个函数
    ) U+ @  a+ N8 E) Y3 o8 {
57.       （1）使能CSI clock
    + J# n0 p! e( O- _, v8 S
58.       （2）使能SYSCFG clock
    ( ^$ a7 ]9 n  \
59.       （3）使能I/O补偿单元， 设置SYSCFG_CCCSR寄存器的bit0
    
60.     */
    
61.     __HAL_RCC_CSI_ENABLE() ;
    
62. 
    1 D  }, A: T0 R4 [0 B
63.     __HAL_RCC_SYSCFG_CLK_ENABLE() ;
    4 s1 R9 U8 u/ \6 t: m3 d* o
64. 
    . E( h5 A& B. j; Q- N; \; \
65.     HAL_EnableCompensationCell();
      F. k' s9 p; N0 E9 Z
66. 
    
67.     __HAL_RCC_D2SRAM1_CLK_ENABLE();
    8 ]8 w# n4 Z( [4 W; w3 Y
68.     __HAL_RCC_D2SRAM2_CLK_ENABLE();
    
69.     __HAL_RCC_D2SRAM3_CLK_ENABLE();
    + g8 B9 D0 L' X( a- O1 G8 F4 ?
70. 
    
71.     return 0;
    
72. }

复制代码

- z3 Z. S4 N8 B. ]& z81.5.5 第5步，配置文件Dev_Inf.c的实现
' s6 r1 o% ^+ Z配置如下：
- t: D5 t1 |& E! N: u

1. #if defined (__ICCARM__)
   3 @5 t4 ^$ q3 O& }* T
2. __root struct StorageInfo const StorageInfo  =  {
   
3. #else
   1 ~5 l' O" z" ]' M( @# Z3 |0 W
4. struct StorageInfo const StorageInfo =  {
   ) b7 y  O4 [1 _
5. #endif
   ) R1 X- Z; P, m4 O( ]
6.     "ARMFLY_STM32H7x_QSPI_W25Q256", /* 算法名，添加算法到STM32CubeProg安装目录会显示此名字 */
   5 K: k% s1 S- c: c2 _6 X
7.     NOR_FLASH,                      /* 设备类型 */
   
8.     0x90000000,                     /* Flash起始地址 */
   & U/ g6 l9 }: Z3 D4 `3 N2 d) g
9.     32 * 1024 * 1024,               /* Flash大小，32MB */
   + g9 f$ a5 r! H& A
10.     4*1024,                         /* 编程页大小 */
    * d. W, e, y* E7 F& Y4 F
11.     0xFF,                           /* 擦除后的数值 */
    
12.     512 , 64 * 1024,                /* 块个数和块大小 */
    - J* M6 [7 B$ s: O1 [# _$ ]3 R& v
13.     0x00000000, 0x00000000,
    
14. };

复制代码

注释已经比较详细，大家根据自己的需要做修改即可。注意一点，算法名ARMFLY_STM32H7x_QSPI_W25Q256会反馈到这个地方：

  l4 w2 D( P: s" j, H

4 @& K0 K) \/ R4 S5 Y! \
1 _0 Q/ I2 p4 f6 M' ?81.5.6 第6步，编程文件Loader_Src.c的实现
下面将变成文件中实现的几个函数为大家做个说明：

# e1 i; z9 h( v3 e( N5 j  初始化函数Init
5 @0 K/ t% c3 j0 {% g9 ^4 U

1. /*
   : [$ M! {: e; }
2. *********************************************************************************************************
   : P% B$ r: W; C2 _; o7 R# w7 @
3. *    函 数 名: Init
   + L# l; s; M1 J8 V) M
4. *    功能说明: Flash编程初始化
   ' K! J, t- y$ S" Y0 k
5. *    形    参: 无
   
6. *    返 回 值: 0 表示失败， 1表示成功
   1 C5 d. f8 r4 \9 `$ J3 d9 F! t2 A8 L7 I
7. *********************************************************************************************************
   $ b% I$ q$ d/ t& h1 r
8. */
   
9. int Init(void)
   
10. {   
    
11.     int result = 1;
    3 {: Y" r/ ?  H  F$ c8 z
12. 
    
13.     /* 系统初始化 */
    
14.     SystemInit();
    : {- k9 L5 u" z6 _$ n- v3 `6 w
15. 
    8 H: R" u& N6 V
16.     /* 时钟初始化 */
    
17.     result = SystemClock_Config();
    
18.     if (result == 1)
    7 t, H/ q& I2 T" Z, D
19.     {
    
20.         return 0;        
    * c4 D0 B. M# s( z' f) f
21.     }
    " M+ \. S9 T# v+ k
22. 
    0 ?) H+ I6 o! O# V' r( l  i/ S
23.     /* W25Q256初始化 */
    % I3 b1 K  ?- q
24.     result = bsp_InitQSPI_W25Q256();
    $ X, j) \% c% d" g. z: v, [8 J1 r7 O
25.     if (result == 1)
    
26.     {
    
27.         return 0;
    : t* V4 e5 x( ~
28.     }
    7 ~. ^% ?8 d, u) C1 x
29. 
    - O. x' g+ t0 A, `! y8 W- i. Y
30.     /* 内存映射 */   
    
31.     result = QSPI_MemoryMapped();
    - y2 x' g, ~8 t5 n/ g9 c
32.     if (result == 1)
    4 k9 p: H: d+ y4 m! |8 N9 A
33.     {
    
34.         return 0;
    
35.     }
    
36. 
    & M) {- f$ v9 r7 R6 O, k
37.     return 1;
    : c2 c( R, K2 f( ]
38. }

复制代码

初始化完毕后将其设置为内存映射模式。
0 U* f+ |0 L' e0 @2 f. ]8 B
  整个芯片擦除函数MassErase
整个芯片的擦除实现如下：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MassErase
   
4. *    功能说明: 整个芯片擦除
   5 `; `6 A/ w  l6 R- X- ~
5. *    形    参: 无
   3 i8 c! h+ l, [
6. *    返 回 值: 1 表示成功，0表示失败
   2 t0 g% O5 Y- G( q- b0 ~
7. *********************************************************************************************************
   
8. */
   8 A. D* l8 Y  f) ~6 M3 {
9. int MassErase(void)
   8 w( M7 X, t3 S
10. {
    
11.     int result = 1;
    
12. 
    # Z; ?/ K* v! b  z( [
13.     /* W25Q256初始化 */
    ( H0 m" @/ K, z9 n; \& \
14.     result = bsp_InitQSPI_W25Q256();
    1 J# w3 J( u, K, o- J+ Z
15.     if (result == 1)
    
16.     {
    
17.         return 0;
    5 w! o/ S. a7 K9 C; j+ D
18.     }
    
19. 
    : l  L' A# p' m: i
20.     result = QSPI_EraseChip();
    3 S! ~* s. ]2 v4 `! Z% t
21.     if (result == 1)
    
22.     {
    $ i% V3 ~4 c5 R1 Y/ @
23.         return 0;
    
24.     }   
    
25. 
    6 J, x9 b: o1 t- b
26.     /* 内存映射 */   
    ( f5 ^2 j1 d/ r
27.     result = QSPI_MemoryMapped();
    9 ^+ |" g; O- l, Z. A0 _- B
28.     if (result == 1)
    - N3 y1 |) u% J6 ], k! l
29.     {
    
30.         return 0;
    
31.     }
    
32. 
    
33.     return result;         
    , k( B7 r% [/ s+ L" f; `
34. }

复制代码

0 Y/ y4 l) K( A; f3 g/ d1 u  扇区擦除函数SectorErase
, w1 q* f5 D+ U8 z3 @扇区擦除实现：

1 ~# b) ~$ N- t- u0 |' Q# U

1. /*
   $ g+ k  o0 b7 F0 @9 Q3 S
2. *********************************************************************************************************
   . }( w* G3 x( s. ^# B4 @# E1 U* {& O
3. *    函 数 名: SectorErase
   2 R' w! y& A. o+ N
4. *    功能说明: EraseStartAddress 擦除起始地址
   
5. *             EraseEndAddress   擦除结束地址
     O; b  }0 u6 @4 P+ o
6. *    形    参: adr 擦除地址
   5 @8 t" ~& X4 p, H& {4 Z
7. *    返 回 值: 1 表示成功，0表示失败
   
8. *********************************************************************************************************
   
9. */
   $ @3 x; V4 T" ~
10. int SectorErase (uint32_t EraseStartAddress ,uint32_t EraseEndAddress)
    
11. {
    % b* o1 G" L6 x* i, V. a
12.     uint32_t BlockAddr, result;
      l5 M5 X) y9 R. H& C
13. 
    
14.     EraseStartAddress -= QSPI_FLASH_MEM_ADDR;
    - r1 Q) z' N( d1 q
15.     EraseEndAddress -= QSPI_FLASH_MEM_ADDR;
    
16.     EraseStartAddress = EraseStartAddress -  EraseStartAddress % 0x10000; /* 64KB首地址 */
    
17. 
    9 i% {- w; \4 ^$ f3 b' O; R
18.     /* W25Q256初始化 */
    & u) g" U1 N3 a9 ~2 M
19.     result = bsp_InitQSPI_W25Q256();
    ) A  \$ ]7 g& C, C
20.     if (result == 1)
    
21.     {
    : K! b# k! o; ?; z# K0 c/ i8 |
22.         return 0;        
    5 _6 k* U0 j7 S1 u  P# n* [1 C7 t
23.     }
    : L2 x% P8 w5 n3 f3 s* g
24. 
    4 V2 X7 K3 [7 G7 ?0 f5 Z
25.     while (EraseEndAddress >= EraseStartAddress)
    
26.     {
    
27.         /* 防止超出256MB空间 */
    
28.         BlockAddr = EraseStartAddress & 0x0FFFFFFF;
    9 \, A' h3 X: I+ V
29. 
    
30.         result = QSPI_EraseSector(BlockAddr);   
    
31.         if (result == 1)
    
32.         {
    
33.             QSPI_MemoryMapped();
    
34.             return 0;        
    
35.         }
    
36. 
    6 I4 i& g4 O5 n/ a8 Y) n  h- b
37.         EraseStartAddress += 0x10000;
    5 a9 |6 l6 k5 \
38.     }
    $ G; L. b; e- w7 J
39. 
    6 T2 |% a. R' C, I& n
40.     /* 内存映射 */   
    
41.     result = QSPI_MemoryMapped();
    
42.     if (result == 1)
    & a0 H$ ^+ x+ w* B
43.     {
    2 j1 y8 W3 U- N  _- X( z; Q6 d
44.         return 0;
    
45.     }
    
46. 
    
47.     return 1;
    
48. }

复制代码

8 s8 [% S- K) E- |这里要注意两点：

（1）     程序里面的操作EraseStartAddress-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。

（2）     这里执行的擦除大小要前面Dev_Inf.c文件中配置的扇区大小一致，这里是执行的64KB为扇区进行擦除。

  页编程函数Write
, x. q* r- S0 q: O  E: {  X3 a页编程函数实现如下：

$ ~* P  t* c  z+ Z9 p2 o

1. int Write(uint32_t Address, uint32_t Size, uint8_t* buffer)
   ; O( _/ j' ]) F+ S8 o) @
2. {
   
3.     int result = 0;
   
4.     uint32_t end_addr, current_size, current_addr;
   
5. 
   
6. 
   
7.     if (Address < QSPI_FLASH_MEM_ADDR || Address >= QSPI_FLASH_MEM_ADDR + QSPI_FLASH_SIZES)
   
8.     {
   
9.         return 0;
   
10.     }
    
11. 
    
12.     Address -= QSPI_FLASH_MEM_ADDR;
    
13. 
    
14.     /* 计算写入地址和页末的字节大小 */
    
15.     current_size = QSPI_PAGE_SIZE - (Address % QSPI_PAGE_SIZE);
    
16. 
    3 _8 y7 L5 `3 U6 _4 S! \
17.     /* 检测页剩余空间是否够用 */
    $ S+ v, ^2 a7 m6 L
18.     if (current_size > Size)
    
19.     {
    . ]0 `3 h! |$ ]- A4 I& p( u
20.         current_size = Size;
    - D( I/ X4 M" i4 W4 K/ |; _6 h
21.     }
    
22. 
    
23.     /* W25Q256初始化 */
    
24.     result = bsp_InitQSPI_W25Q256();
    0 C$ T$ s5 ^1 ~* j4 |* r, r! l
25.     if (result == 1)
    2 o7 A3 D5 {' V- A
26.     {
    
27.         return 0;
    $ W. U# t/ }: U/ k+ K
28.     }
    
29. 
    & j8 ^5 Z/ E1 t1 o* \% e: Y7 M/ U
30.     current_addr = Address;
    % z+ }5 E1 N) `
31.     end_addr = Address + Size;
    0 p% g3 G% E1 _. u
32. 
    
33.     do{
    
34.         if (QSPI_WriteBuffer(buffer, current_addr, current_size) == 1)
    - J! `* m9 B# J+ I6 H; ]7 H
35.         {
    
36.             QSPI_MemoryMapped();  
    - o) E5 d* v6 S4 N; Y+ @7 c- M
37.             return 0;  
    
38.         }
    
39. 
    8 M. r( V- v7 Z+ _1 y
40.         /* 更新地址 */
    
41.         current_addr += current_size;
    3 i" q' Q$ x, n( X0 H( m
42.         buffer += current_size;
    / p8 O! z( `. Z) S0 C4 z: O5 y
43.         current_size = ((current_addr + QSPI_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : QSPI_PAGE_SIZE;
    
44. 
    
45.     }while(current_addr < end_addr);
    ; o9 n* B9 Q4 }
46. 
    7 q% h% m8 i- K; @0 e
47.     /* 内存映射 */   
    , D" _6 \, l* q7 o9 A5 D$ C
48.     result = QSPI_MemoryMapped();
    4 d7 T6 b5 j+ l
49.     if (result == 1)
    - ?9 f# q6 K" m9 l( I6 p1 Z
50.     {
    
51.         return 0;
    
52.     }
    7 S# r8 u0 E8 Q3 u  B2 m% X) f# O$ W
53. 
    8 a% s2 i& B6 K! ~
54.     return (1);  
    : ^& w5 q3 a" A8 Z
55. }

复制代码

5 g* B+ R8 ?/ [& ]1 ?, w2 ^! G这里注意两点：
; f3 _" o- }- Y
（1）     W25Q256的页大小是256字节，前面FlashDev.c中将页编程大小设置为4096字节，所以此程序要做处理。

9 h1 j/ v, Q; c) f（2）     程序里面的操作Address-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。
( D+ F5 T. d- I5 H$ I) S
  读取和校验函数
" L; J- g# A4 `4 j) T我们程序中未做读取和校验函数。

1 d5 v# ]1 e4 x（1）     如果程序中未做读取函数，那么STM32CubeProg会以总线方式进行读取，这也是为什么每个函数执行完毕都设置为内存映射模式的原因。

（2）     如果程序中未做校验函数，那么STM32CubeProg会读取数据做校验。
0 ~" L1 s7 u# d
2 C' z% ^$ q. ^; K81.5.7 第7步，修改QSPI Flash驱动文件（引脚，命令等）
( ^3 Q8 s7 \- b; ~最后一步就是QSPI Flash（W25Q256）的驱动修改，大家可以根据自己的需求做修改。使用的引脚定义在文件bsp_qspi_w25q256.c（做了条件编译，包含了H7-TOOL和STM32-V7板子）：
) k6 u7 j- ^+ b
2 z1 l' S$ `* a9 m# U

1. /*
   
2.     STM32-V7开发板接线
   9 b: X0 [, t- R- l+ _
3. 
   
4.     PG6/QUADSPI_BK1_NCS     AF10
   7 P2 m8 v7 q9 `6 u. B. \6 t
5.     PF10/QUADSPI_CLK        AF9
   ( x8 ]& S9 a4 `+ j4 M
6.     PF8/QUADSPI_BK1_IO0     AF10
   
7.     PF9/QUADSPI_BK1_IO1     AF10
   
8.     PF7/QUADSPI_BK1_IO2     AF9
   
9.     PF6/QUADSPI_BK1_IO3     AF9
   4 Y$ E6 ?+ W2 C% h4 r/ R3 b
10. 
      p+ O8 c: A) i% A
11.     W25Q256JV有512块，每块有16个扇区，每个扇区Sector有16页，每页有256字节，共计32MB
    
12. 
    
13.     H7-TOOL开发板接线
    ' u6 x1 n8 _: }0 X4 }, c
14. 
    / s1 |" h9 }" u9 G! V
15.     PG6/QUADSPI_BK1_NCS     AF10
    
16.     PB2/QUADSPI_CLK         AF9
    
17.     PD11/QUADSPI_BK1_IO0    AF10
    + m5 Z7 d8 C- B  ~1 m/ a
18.     PD12/QUADSPI_BK1_IO1    AF10
    : e6 D& Q6 G) A4 @
19.     PF7/QUADSPI_BK1_IO2     AF9
    
20.     PD13/QUADSPI_BK1_IO3    AF9
    
21. */
    * m6 W5 t7 C. T; j) k. X
22. 
    ( h$ D: O. f0 G1 Y4 P
23. /* QSPI引脚和时钟相关配置宏定义 */
    
24. #if 0
    # o; s# @# o9 w
25. #define QSPI_CLK_ENABLE()               __HAL_RCC_QSPI_CLK_ENABLE()
    9 c% |3 o: T* s! T  R
26. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    9 q. F3 f+ l& M% a
27. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    
28. #define QSPI_CLK_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOB_CLK_ENABLE()
    
29. #define QSPI_BK1_D0_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOD_CLK_ENABLE()
    
30. #define QSPI_BK1_D1_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOD_CLK_ENABLE()
    1 h2 W7 S- w& @$ y
31. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    , x' U$ j1 A8 `
32. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOD_CLK_ENABLE()
    2 {. y& b6 I; b) Z4 s0 L) k& P
33. 
    ; }* S, ~4 E9 B$ Y# o+ x/ K, D
34. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    
35. #define QSPI_FORCE_RESET()              __HAL_RCC_QSPI_FORCE_RESET()
    + X1 v: B% H% A3 ]% d
36. #define QSPI_RELEASE_RESET()            __HAL_RCC_QSPI_RELEASE_RESET()
      G* V; L1 L* {0 D1 P0 i
37. 
    
38. #define QSPI_CS_PIN                     GPIO_PIN_6
    
39. #define QSPI_CS_GPIO_PORT               GPIOG
    " D: ]& ?: f0 @+ B
40. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    
41. 
    
42. #define QSPI_CLK_PIN                    GPIO_PIN_2
    9 ^5 A% `# _$ C* t
43. #define QSPI_CLK_GPIO_PORT              GPIOB
    
44. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    
45. 
    6 m* ^( _2 U0 r5 L  e* I: a7 [
46. #define QSPI_BK1_D0_PIN                 GPIO_PIN_11
    
47. #define QSPI_BK1_D0_GPIO_PORT           GPIOD
    
48. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF9_QUADSPI
    ! Q: e% q, j% o) ^; k& K. y) D
49. 
    # @: O; b. K+ P& N8 T( b! Z
50. #define QSPI_BK1_D1_PIN                 GPIO_PIN_12
    ' P$ T! h6 @: H+ E0 j
51. #define QSPI_BK1_D1_GPIO_PORT           GPIOD
    4 u+ S8 K. N' ~% P( J
52. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF9_QUADSPI
    
53. 
    
54. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    
55. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    
56. #define QSPI_BK1_D2_GPIO_AF             GPIO_AF9_QUADSPI
    
57. 
    
58. #define QSPI_BK1_D3_PIN                 GPIO_PIN_13
    
59. #define QSPI_BK1_D3_GPIO_PORT           GPIOD
    
60. #define QSPI_BK1_D3_GPIO_AF             GPIO_AF9_QUADSPI
    
61. #else
    
62. #define QSPI_CLK_ENABLE()               __HAL_RCC_QSPI_CLK_ENABLE()
    . Z5 N/ z5 g& P) n
63. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    
64. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    
65. #define QSPI_CLK_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOF_CLK_ENABLE()
    
66. #define QSPI_BK1_D0_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    ! s# y& s3 A( f0 P
67. #define QSPI_BK1_D1_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    ( m1 b5 o( H5 w7 F* _
68. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    ! s/ V0 j0 Y# R
69. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    
70. 
      R. W7 I( }5 ]0 k5 f. x+ J; Z: \5 B" t& J
71. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    $ r% j% F3 U; n; g" W3 ~7 J9 u: \
72. #define QSPI_FORCE_RESET()              __HAL_RCC_QSPI_FORCE_RESET()
    
73. #define QSPI_RELEASE_RESET()            __HAL_RCC_QSPI_RELEASE_RESET()
    : R7 e+ p2 {( L( G/ G! M7 n' t8 T
74. 
    ( R7 r/ g# y2 A2 t/ L
75. #define QSPI_CS_PIN                     GPIO_PIN_6
    # M% s1 A/ _2 ]' X- p$ U1 e+ Z. L
76. #define QSPI_CS_GPIO_PORT               GPIOG
    . Q3 P; K$ O; s/ a# I" N) U
77. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    
78. 
    ( f9 S/ f% g8 M3 s6 V! A1 m
79. #define QSPI_CLK_PIN                    GPIO_PIN_10
    9 j+ T- X; m, L8 W6 z- e% q6 X
80. #define QSPI_CLK_GPIO_PORT              GPIOF
    & M, g1 w! M6 e! H% N
81. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    + u2 _7 c" \- c
82. 
    
83. #define QSPI_BK1_D0_PIN                 GPIO_PIN_8
    
84. #define QSPI_BK1_D0_GPIO_PORT           GPIOF
    8 ~: I  q6 d8 @* S+ x9 d4 b
85. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF10_QUADSPI
    ' K' w) D6 `- J
86. 
    - v) K6 A3 a; t
87. #define QSPI_BK1_D1_PIN                 GPIO_PIN_9
    , F: a% a6 ^1 ^4 L2 [
88. #define QSPI_BK1_D1_GPIO_PORT           GPIOF
    
89. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF10_QUADSPI
    
90. 
    
91. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    ! @# p" {8 I2 O6 O9 d3 n% b- P* ?1 M$ B
92. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    & B: k" C! n$ O+ N% C" a0 }4 Y- \
93. #define QSPI_BK1_D2_GPIO_AF             GPIO_AF9_QUADSPI
    . J' o" j6 h/ u+ [( I+ [5 z
94. 
    ; i9 w/ ^: L2 N- Z! _" H% s
95. #define QSPI_BK1_D3_PIN                 GPIO_PIN_6
      R$ e' k9 O0 v' Z
96. #define QSPI_BK1_D3_GPIO_PORT           GPIOF
    
97. #define QSPI_BK1_D3_GPIO_AF             GPIO_AF9_QUADSPI
    " _9 i$ q, A9 U4 ?& S7 f' Y
98. #endif

复制代码

硬件设置了之后，剩下就是QSPI Flash相关的几个配置，在文件bsp_qspi_w25q256.h：
7 Z8 S/ p) U& W! ~, u
# J( w8 D! O$ V. o% d8 b主要是下面这几个：
( S3 |  q' Z: W/ c# S
  O% D. m8 s. y3 M

1. #define QSPI_FLASH_MEM_ADDR         0x90000000
   ( c! R  _! s; I: j2 B  V' ~
2. 
   : a. {5 ]$ [$ i2 u3 t# P
3. /* W25Q256JV基本信息 */
   
4. #define QSPI_FLASH_SIZE     25                      /* Flash大小，2^25 = 32MB*/
   
5. #define QSPI_SECTOR_SIZE    (4 * 1024)              /* 扇区大小，4KB */
   
6. #define QSPI_PAGE_SIZE      256                     /* 页大小，256字节 */
   2 U1 E1 P- w; u  j$ [, g
7. #define QSPI_END_ADDR       (1 << QSPI_FLASH_SIZE)  /* 末尾地址 */
   
8. #define QSPI_FLASH_SIZES    32 * 1024 * 1024         /* Flash大小，2^25 = 32MB*/
   ! L2 V/ H6 X4 ~! I
9. 
   3 b. \; i2 E: r
10. /* W25Q256JV相关命令 */
    
11. #define WRITE_ENABLE_CMD                        0x06    /* 写使能指令 */
    ( Z- y3 q; c' c2 p# s
12. #define READ_ID_CMD2                            0x9F    /* 读取ID命令 */
    
13. #define READ_STATUS_REG_CMD                     0x05    /* 读取状态命令 */
    
14. #define SUBSECTOR_ERASE_4_BYTE_ADDR_CMD         0x21    /* 32bit地址扇区擦除指令, 4KB */
    1 Y- x( E6 Z7 C! x2 d
15. #define QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD       0x34    /* 32bit地址的4线快速写入命令 */
    
16. #define QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD    0xEC    /* 32bit地址的4线快速读取命令 */
    2 }% |3 n! }- G' A5 x6 F! [1 K
17. 
    
18. #define BLOCK_ERASE_64K_4_BYTE_ADDR_CMD         0xDC    /* 4字节地址，64K扇区 */
    
19. 
    , {) a( L/ D/ x/ @' `
20. #define BULK_ERASE_CMD                          0xC7    /* 整片擦除 */

复制代码

) X' V" M0 e  t9 [! u! M5 e. \. v81.6 QSPI Flash的STM32CubeProg下载算法使用方法
3 n4 J/ {1 ~) C* z1 B+ O3 e编译本章教程配套的例子，生成的算法文件位于此路径下：
- T1 b/ Y  i8 |7 `; ?8 t

81.6.1 下载算法存放位置
生成此文件后，需要大家将其存放到STM32CubeProg安装目录路径：
6 I# Q- J5 s. v4 B& W% q
' q: A2 ~, ^$ ?1 ~: e\STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader

* r# ]" X, ]2 ?( C- B" a! M

% ~' O* Z# _$ h0 Z4 g- g81.6.2 STM32CubeProg下载配置
. u" U, i: F9 b我们这里以STLINK连接开发板为例进行说明（USB DFU或者串口方式不支持下载外部Flash）。

' N) j/ m4 g8 i! _9 d& Y' V7 \! c# A点击Connect后效果如下：

5 m) Y! q$ p" r: T+ B$ F& G  }

7 L" L7 ]% z" H. _
在这里选择我们制作的下载算法：
0 o4 a& O9 y( c: O# p/ }8 P  W

% ^4 a6 _& N' J; E- ^1 @7 g7 y- Y% K4 M任意加载个hex或者bin文件，并按照如下配置，然后点击Start Programming
) q7 \6 q( Y. x: d

) T) b$ T5 |; ?$ H下载完成后的效果如下：
. l; P3 k6 i9 D+ S$ s" Q9 }; _

3 w/ a; Q4 L2 G- @- {# b+ @6 \$ X
5 c3 O' x# x4 d81.6.3 验证算法文件是否可以正常使用
. \/ O* D+ J5 s" F8 T2 B为了验证算法文件是否可以正常使用，大家可以运行本教程第82章或者83章配套的例子。也可以使用STM32CubeProg直接读取：
4 V5 g7 ^: g8 l( x7 y/ k8 k" D

81.7 实验例程说明
本章配套例子：V7-061_QSPI Flash的STM32CubeProg下载算法制作。
; T/ D* _/ U" {% T2 D
编译本章教程配套的例子，生成的算法文件位于此路径下：
7 b! [) J# I9 i& o9 j2 |

. p; W8 [$ `; W3 w: Y
5 }4 ^" I# L% u& f81.8 总结
本章节就为大家讲解这么多，为了熟练掌握，大家可以尝试自己实现一个Flash下载算法。
) H2 z1 b+ q% u7 \
9 R7 E, y1 f1 q: Z6 a. w" j- B5 d