81.1 初学者重要提示
  QSPI Flash的相关知识点可以看第78章和79章。
  QSPI Flash下载算法文件直接采用HAL库制作，方便大家自己修改。
( x' _+ j  H" X. f; G  STM32CubeProg下载算法制作和MDK下载算法制作基本是一样
8 j6 Q! j- z8 l) R9 p" P) l- R' B  本教程的第68章USB DFU和第69章串口IAP章节为大家介绍过STM32CubeProg的用法。
- E; W+ O) E& q. O81.2 STM32CubeProg简介
& P0 g9 O( s' X# F) T7 _% B6 sSTM32CubeProg，此软件实现了之前的 DfuSe，STLINK 小软件和 Flashloader 三合一，并且支持外部 EEPROM，NOR Flash，SPI Flash，NAND Flash 等烧写，也支持 OTA 编程。
) e0 v' u/ E7 g6 u; ^3 ?
' n5 G0 Y/ s! i8 H

% ^4 ^! l$ S  W+ R$ _7 P6 H
81.3 STM32CubeProg下载算法基础知识
STM32CubeProg下载算法是一种用于擦除应用程序或将应用程序下载到Flash的程序代码。ST自家的芯片都自带下载算法，存放在STM32CubeProg安装目录里面，但不支持的需要我们自己制作，本章教程为此而生。
! b  q6 ]* w* s; a0 X3 s" g7 {" p+ D
, g. m' f4 t5 X& R* C9 \81.3.1 程序能够通过下载算法下载到芯片的核心思想
& a% s- W8 R6 f  ~% B认识到这点很重要：通过IDE开发环境创建一批与地址信息无关的算法文件，实现的功能主要有初始化，擦除，编程，读取，校验等，然后STM32CubeProg下载阶段，会将算法文件加载到芯片的内部RAM里面，然后STM32CubeProg通过与这个算法文件的交互，实现程序下载，数据读取等操作。

2 r# N/ @9 A7 Q9 r( c) z* Z81.3.2 算法程序中擦除操作执行流程
注：下面是MDK的算法执行流程，STM32CubeProg是类似的。

擦除操作大致流程：
, T$ J# c  x1 U+ S5 E. I
0 D& s& M: b) X3 a2 {' t) E

  加载算法到芯片RAM。
) H! V: ~, m5 b, J  执行初始化函数Init。
  执行擦除操作，根据用户配置，这里可以选择整个芯片擦除或者扇区擦除。
' ~8 C) c3 n3 L# k# W# C8 Q% J  执行Uinit函数。
+ h0 z2 [+ `8 @) W: f- J  操作完毕。
' I3 r- m3 @- \. U! r- D* u81.3.3 算法程序中编程操作执行流程
. k9 U. s, h$ T  {, K, X注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。
/ U  _& C7 Z5 P5 F7 T) _' ~
编程操作大致流程：
1 [' P( G' L* L3 X/ x

, D( f) A+ _9 g8 m6 D
  针对IDE生成的axf（elf）可执行文件做Init初始化，这个axf（elf）文件是指的大家自己创建应用程序生成的。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
" O, X$ ]* [, H4 |  加载算法到RAM。
  执行Init函数。
  P; Z7 f  ]$ w& p  加载用户到RAM缓冲。
' B2 D; b( `8 Z! B! z7 d0 D  o/ p  执行Program Page页编程函数。
  执行Uninit函数。
  操作完毕。
81.3.4 算法程序中校验操作执行流程
注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。

1 C4 e# u. n3 T; y" m6 P  a3 a. O校验操作大致流程：

  校验要用到IDE生成的axf（elf）可执行文件。校验就是axf（elf）文件中下载到芯片的程序和实际下载的程序读出来做比较。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
+ U3 r# r2 C8 h  加载算法到RAM。
1 e" E* L( b/ y5 Z, Y5 ]  执行Init函数。
  查看校验算法是否存在
  如果有，加载应用程序到RAM并执行校验。
  如果没有，执行计算CRC，将芯片中读取数据出来和RAM中加载应用计算输出的CRC值做比较。
  执行Uninit函数。
% F; B4 Z( ~# s. }  替换BKPT（BreakPoint断点指令）为 B. 死循环指令。
" N0 p) l3 j0 l' R8 H( F  执行RecoverySupportStop，回复支持停止。
% o8 O. z  ~7 O) c+ V( N  \+ G  执行DebugCoreStop，调试内核停止。
1 f0 `0 P2 a  |0 x  }  X/ Q2 z+ p- i  运行应用：
- i1 y7 h9 h+ }# n  执行失败
; H$ u0 H! ~* z) Y, z" E1 D  执行成功，再执行硬件复位。
  操作完毕，停止调试端口。
' K6 \# A5 ^4 l+ i) Q- \% d: Y! y81.4 创建STM32CubeProg下载算法通用流程
7 n" o+ s) l; p: Z2 ?! C! @下面是STM32CubeProg给的一种大致操作流程，不限制必须采用这种方法，自己创建也可以的。
7 ]9 ]; e' r5 i! H, Q  G: X
" V6 G4 A$ B& {  \1 G- y0 C* J81.4.1 第1步，使用STM32CubeProg提供好的程序模板
1 S5 ^2 l# j6 t位于路径：STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader
# F' ~& U+ Q1 R- y1 M/ ^  q
' F! s9 J  i8 O3 O9 v

  P% f7 B0 J% W( u/ Y8 s以M25P64为例（注，其余步骤就以这个为例子进行说明）：

/ ]! i# s/ ~' G9 g+ X4 ]  k
4 h& k/ g+ d2 N8 L& c# I! m4 ^81.4.2 第2步，修改工程名
! S6 \- B" J6 D! ?9 f+ M) E2 _STM32CubeProg提供的工程模板原始名字是M25P64_STM3210E-EVAL.uvproj，大家可以根据自己的需要做修改。比如修改为MyDevice.uvproj（MDK4的后缀）或者MyDevice.uvprojx（MDK5的后缀）。
& b  y/ {* f5 w6 f
81.4.3 第3步，修改使用的器件
在MDK的Option选项里面设置使用的器件。
/ x! I  c' x( }  a8 `
" Z+ J0 [- o  F# V8 {7 ?

) c( y/ k0 r% u! O, t# K$ Q
81.4.4 第4步，修改输出算法文件的名字
  Z% _" E( h* {这个名字是方便用户查看的，比如设置为stm32h7，那么输出的算法文件就是stm32h7.stldr。

; z6 x/ `# W2 ^

& T) w& ^2 W" {# [5 [6 W4 |; S注：STM32CubeProg软件里面别的文件名并不采用这个，而是由用户在文件Dev_Inf.c里面定义的：
/ W9 U2 ~  I! B- T; H4 y

2 E- E! }3 v1 Q/ f/ a* k
+ r* e6 C, |# s) }$ D: [81.4.5 第5步，修改使用的库文件和头文件路径
  j% \0 A# m3 f+ |: @9 h0 o; }" U根据大家使用的主控芯片，添加相应的库文件和头文件路径。
* Z2 Q$ C+ w$ p( p8 ]
' E1 P# G8 J6 r: \0 e81.4.6 第5步，修改编程算法文件Loader_Src.c
模板工程里面提供的是M25P64，部分代码如下：

  P# X9 s! r! B, L% S9 o' P$ V4 {

1. /**
   5 y) z7 R, k2 L9 N
2.   * Description :
   
3.   * Initilize the MCU Clock, the GPIO Pins corresponding to the
   
4.   * device and initilize the FSMC with the chosen configuration
   
5.   * Inputs    :
   2 p! ^# k* A6 a- f, I5 ]
6.   *      None
   . O6 Q9 C( J/ g: |5 g/ }  a
7.   * outputs   :
   
8.   *      R0             : "1"             : Operation succeeded
   
9.   *               "0"             : Operation failure
   
10.   * Note: Mandatory for all types of device
    
11.   */
    ; d( x% D& k$ F8 {1 }5 u' V& V
12. int Init (void)
    . {' S7 C' L; F4 r; G' r/ k6 K' r# [
13. {  
    % j: r1 s" Q/ t, ]! f
14.   SystemInit();
    : {8 P- L! Q# h* l# r
15.   sFLASH_Init();
    % L! M$ m# \0 g. p9 M( k
16.   return 1;
    
17. }
    
18. 
    
19. 
    * i+ s# l' g. |# C% y: u. G
20. /**
    , V7 I0 O3 d; Q& C! L; l( Z( j/ m7 ]- V
21.   * Description :
    
22.   * Read data from the device
    ! q8 E9 R4 R/ N& ]2 m. `9 B+ ]
23.   * Inputs    :
    4 d. z9 c/ \. C8 }$ p
24.   *      Address       : Write location
    3 M% O# C# }# N0 t  {6 z
25.   *      Size          : Length in bytes  
    9 V* N& {; p  u7 Y- O" ~- \
26.   *      buffer        : Address where to get the data to write
    
27.   * outputs   :
    ; S3 M# l* e( O
28.   *      R0             : "1"             : Operation succeeded
      |1 k) ?$ h4 d6 N' N
29.   *               "0"             : Operation failure
    / v- Q$ o! R% e7 l* P3 g5 m
30.   * Note: Mandatory for all types except SRAM and PSRAM   
    4 \8 T. Y7 ]: c9 o
31.   */
    & T4 h7 Q; Z2 w& E2 f
32. int Read (uint32_t Address, uint32_t Size, uint8_t* buffer)
    " V, O7 M) o  g) ^
33. {
    
34.   sFLASH_ReadBuffer(buffer, Address, Size);
    
35.   return 1;
    " B# s! M: Z9 P
36. }
    
37. 
    3 y, X' @+ E* Z5 c
38. 
    
39. /**
    0 q3 V7 I, h' T1 T8 q! C( }
40.   * Description :
    
41.   * Write data from the device
    
42.   * Inputs    :
    & X3 ?3 @5 V- {7 u. I+ T
43.   *      Address       : Write location
    ! w, \2 @1 X  Z$ t# C
44.   *      Size          : Length in bytes  
    ' C/ ]% [; _' F+ {2 Y
45.   *      buffer        : Address where to get the data to write
    
46.   * outputs   :
    
47.   *      R0           : "1"             : Operation succeeded
    - S* M# o9 y' Y* T/ z& g
48.   *                     "0"             : Operation failure
    
49.   * Note: Mandatory for all types except SRAM and PSRAM   
    / J/ n% T# n" V2 k& w, a
50.   */
    $ `5 p' }6 {( ]7 R8 h
51. int Write (uint32_t Address, uint32_t Size, uint8_t* buffer)
    
52. {
    
53.   sFLASH_WriteBuffer(buffer, Address, Size);
      V5 O& v! t# W, N$ N3 V# J4 ^: D
54.   return 1;
    * i' I* s8 `. B4 l
55. }
    
56. 
    
57. 
    2 i' r! E3 P! u) H# F9 t5 k6 M
58. /**
    
59.   * Description :
    
60.   * Erase a full sector in the device
    
61.   * Inputs    :
    
62.   *     None
    
63.   * outputs   :
    9 w8 E+ }/ w# @/ s
64.   *     R0             : "1" : Operation succeeded
    , B) F+ b! ^5 C4 S- q2 e
65.   *              "0" : Operation failure
    
66.   * Note: Not Mandatory for SRAM PSRAM and NOR_FLASH
    ) Q7 J6 p: w* p0 g- r6 e3 _
67.   */
    : l0 h- p! r) v% J2 G/ Z
68. int MassErase (void)
    
69. {  
    / `5 Y- N5 r4 G7 ~
70.   sFLASH_EraseBulk();
    : B1 f/ V2 K% e; `1 \
71.   return 1;   
    
72. }

复制代码

! [, y% y# g- R7 H0 ^81.4.7 第6步，修改配置文件Dev_Inf.c
+ t. _0 b6 {2 ]6 S模板工程里面提供简单的配置说明：

1. #if defined (__ICCARM__)
   . R0 B( }# U( H2 M$ A
2. __root struct StorageInfo const StorageInfo  =  {
   # L7 P% g$ r* _) Y; s( m
3. #else
   " |/ i1 ?. |, l, j8 f
4. struct StorageInfo const StorageInfo  =  {
   7 z1 _, p$ D. z
5. #endif
   
6.    "M25P64_STM3210E-EVAL",           // Device Name + version number
   3 x: H7 O3 @3 Q! N3 `
7.    SPI_FLASH,                       // Device Type
   , Q$ d  |3 e( F/ Q1 X
8.    0x00000000,                     // Device Start Address
   
9.    0x00800000,                      // Device Size in Bytes (8MBytes/64Mbits)
   $ U% h" f& A1 w: N0 I+ m' T
10.    0x00000100,                      // Programming Page Size 16Bytes
    
11.    0xFF,                            // Initial Content of Erased Memory
    & m/ i! ]3 l1 L* X) m% {
12. // Specify Size and Address of Sectors (view example below)
    
13.    0x00000080, 0x00010000,          // Sector Num : 128 ,Sector Size: 64KBytes
    
14.    0x00000000, 0x00000000,
    
15. };

复制代码

注：名字M25P64_STM3210E-EVAL就是我们第4步所说的。STM32CubeProg会识别出这个名字。
7 X* m# U/ k' t8 h/ ?! m: \) ~) {, n
7 m- y) ^4 z$ K1 V5 S

! V# y9 V; M# @: ?5 Z81.4.8 第7步，保证生成的算法文件中RO和RW段的独立性，即与地址无关。
: ^/ R9 H+ X$ h4 zC和汇编的配置都勾选上：

. Y+ z7 q- g8 i! `& f6 A/ J0 d汇编：

2 `4 r- c/ H! c: X- Q

4 i0 L) |/ U! Q6 m如果程序的所有只读段都与位置无关，则该程序为只读位置无关（ROPI, Read-only position independence）。ROPI段通常是位置无关代码（PIC,position-independent code），但可以是只读数据，也可以是PIC和只读数据的组合。选择“ ROPI”选项，可以避免不得不将代码加载到内存中的特定位置。这对于以下例程特别有用：
9 p2 @; X3 g+ @; r. r
（1）加载以响应运行事件。
% y! `& e* |0 r- O7 Z
（2）在不同情况下使用其他例程的不同组合加载到内存中。
5 E( F% b0 D; N4 S) @% V9 Z5 W
0 s/ R; o4 N  k1 Z! T- @（3）在执行期间映射到不同的地址。
8 A+ E0 ^' D5 X& k
7 N8 X0 s9 Q/ Y" N/ K) l! }7 f使用Read-Write position independence同理，表示的可读可写数据段。
/ q; A: Z" f& k, }
( A+ B, @3 P' X0 q1 m2 w" P81.4.9 第8步，将程序可执行文件axf修改为stldr格式
通过下面的命令就可以将生成的axf可执行文件修改为stldr。
  ?- S9 b( _$ H. L9 a
' R2 ?, \+ N! G% [: t

- U$ t) y' K  g% a! b4 G
81.4.10   第9步，分散加载设置
) p6 Z7 P1 T- K5 Z( g: ~9 U! i- w我们这里的分散加载文件直接使用MDK模板工程里提供好的即可。

分散加载文件中的内容如下：
" K% n' a- h* {7 ]

1. FLASH_LOADER 0x20000004 PI   ; FlashLoader Functions
   
2. {
   0 _0 X) Y& j* G
3.   PrgCode +0           ; Code
   
4.   {
   
5.     * (+RO)
   $ l4 G2 ~7 g$ C+ n. A+ m" v. V
6.   }
   
7.   PrgData +0           ; Data
   ! B9 ~( D: V4 \+ y; w* E
8.   {
   # E$ y2 F  |6 F! u
9.     * (+RW,+ZI)
   6 F4 K7 ?6 s5 U% z3 u
10.   }
    . p5 ]9 z+ V( v, f& d8 i2 M
11. }
    & n( V& V6 D  N. ^( h
12. 
    ( c" X# `  e6 T
13. DEVICE_INFO +0               ; Device Info
    , L" ^% D8 e  B2 o: R
14. {
    0 |6 N  M) I( `8 C; `! j
15.   DevInfo +0           ; Info structure
    
16.   {
    8 N8 M  y: X  f! X) a0 e1 `& w' A
17.     dev_inf.o
    
18.   }
    
19. }

复制代码

" T3 p& H6 q% l& q0 ~) a这里要修改下Flash算法加载地址，将0x20000004修改为STM32H7的RAM地址，任何RAM块地址均可，只要够存储Flash算法。推荐设置为AXI SRAM地址0x24000004，因为空间够大，有512KB。

--diag_suppress L6305用于屏蔽L6503类型警告信息。
; u4 L3 o0 o- p  }" G" A( b  @
特别注意，设置了分散加载后，此处的配置就不再起作用了：
% ], p8 U# h! M' Y2 _( N

6 \, ~, ]! e7 a7 h0 O+ [( U4 }! s
5 U2 N4 ]' h' b2 f: U7 L81.5 QSPI Flash的STM32CubeProg下载算法制作
+ U: C$ W6 A0 ]4 W& Y& R! f8 k下面将QSPI Flash算法制作过程中的几个关键点为大家做个说明。
# v5 r% Z9 i# h5 ^
81.5.1 第1步，制作前重要提示
这两点非常重要：
" C, g% \. j8 Z1 P4 V. P
+ F9 o9 e- ^0 Q: N4 Z3 d' Q  程序里面不要开启任何中断，全部查询方式。
  HAL库里面各种时间基准相关的API全部处理掉。简单省事些，我们这里是直接注释，采用死等即可。无需做超时等待，因为超时后，已经意味着操作失败了，跟死等没有区别。
4 n, E8 r5 T0 ~5 |2 |! W81.5.2 第2步，准备一个工程模板
推荐大家直接使用我们本章工程准备好的模板即可，如果大家自己制作，注意一点，请使用当前最新的HAL库。

5 w: M* s$ Z0 h5 o( w7 _# \* E

. z7 S# N- g- R! F3 Q81.5.3 第3步，修改HAL库
这一步比较重要，主要修改了以下三个文件：

- p. K% N4 f: b2 a6 U
& u( N- J9 [, c+ j* h  e主要是修改了HAL库时间基准相关的几个API，并注释掉了一批无关的API。具体修改内容，大家可以找个比较软件，对比修改后的这个文件和CubeH7软件包V1.8.0（软件包里面的HAL库版本是V1.9.0）的差异即可。
3 e1 b( e. U# y. }
81.5.4 第4步，时钟初始化
7 U/ t; V) `  g  P我们已经用不到滴答定时器了，直接在bsp.c文件里面对滴答初始化函数做重定向：
: P+ {1 a/ L& L

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: HAL_InitTick
   
4. *    功能说明: 重定向，不使用
   # m: N, ?- _) s+ D: Y
5. *    形    参: TickPriority
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ; N; k- ?, @( v* h( k
8. */
   9 {  A' b2 f  ]9 J+ i$ i
9. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
   1 j5 e( ]6 k* R7 [
10. {
    0 @2 ^2 N" f4 u* }0 K4 a7 P
11.     return HAL_OK;
    7 F0 L/ H, H) o. ^! R9 V
12. }

复制代码

然后就是HSE外置晶振的配置，大家根据自己的板子实际外挂晶振大小，修改stm32h7xx_hal_conf.h文件中HSE_VALUE大小，实际晶振多大，这里就修改为多大：
! @3 T2 m9 O  z8 z
; i' m, d5 e: p. z) b  c% Q) ?* I

1. #if !defined  (HSE_VALUE)
   
2. #define HSE_VALUE    ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
   
3. #endif /* HSE_VALUE */

复制代码

8 |+ `: V4 L0 J最后修改PLL：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: SystemClock_Config
   
4. *    功能说明: 初始化系统时钟
   / P7 q7 i- g8 o( `+ G
5. *                System Clock source            = PLL (HSE)
   " @+ q4 q0 J4 F, m9 O; T% C
6. *                SYSCLK(Hz)                     = 400000000 (CPU Clock)
   
7. *               HCLK(Hz)                       = 200000000 (AXI and AHBs Clock)
   " ~( _1 d2 R5 H; O, X
8. *                AHB Prescaler                  = 2
   ' l* \1 s+ E* I8 Z
9. *                D1 APB3 Prescaler              = 2 (APB3 Clock  100MHz)
   ( V0 y+ y8 H" ]& \9 y( h
10. *                D2 APB1 Prescaler              = 2 (APB1 Clock  100MHz)
    + y3 O' F+ @9 |
11. *                D2 APB2 Prescaler              = 2 (APB2 Clock  100MHz)
    
12. *                D3 APB4 Prescaler              = 2 (APB4 Clock  100MHz)
    
13. *                HSE Frequency(Hz)              = 25000000
      X( v% s5 O9 ]- b/ A9 X. Q4 T
14. *               PLL_M                          = 5
    & v& z8 a+ O  C5 |6 b# a9 J2 F. V% V: a
15. *                PLL_N                          = 160
    : j0 ?8 c7 }+ U, R% v
16. *                PLL_P                          = 2
    & m4 z* T" ^  n/ q) E
17. *                PLL_Q                          = 4
    
18. *                PLL_R                          = 2
    ; Z& d1 x/ j4 i  i
19. *                VDD(V)                         = 3.3
    
20. *                Flash Latency(WS)              = 4
    
21. *    形    参: 无
    
22. *    返 回 值: 1 表示失败，0 表示成功
    / Y# N( f/ v) x
23. *********************************************************************************************************
    
24. */
    
25. int SystemClock_Config(void)
    
26. {
    , X# n# F) L5 ]
27.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    ( @" K' ]8 s5 s/ E6 _) |/ \
28.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    0 L& E" q% h0 s/ N) p: r
29.     HAL_StatusTypeDef ret = HAL_OK;
    5 x7 j: F: Z0 S0 u; _5 G
30. 
    
31.     /* 锁住SCU(Supply configuration update) */
    
32.     MODIFY_REG(PWR->CR3, PWR_CR3_SCUEN, 0);
    
33. 
    
34.     /*

复制代码

" c) _, g! k1 U' i, u7 T      1、芯片内部的LDO稳压器输出的电压范围，可选VOS1，VOS2和VOS3，不同范围对应不同的Flash读速度，
         详情看参考手册的Table 12的表格。
2 Q- ~* I5 H4 e" Z7 t      2、这里选择使用VOS1，电压范围1.15V - 1.26V。
4 X" X8 C: l8 M) Z  d   

1. */
   2 k8 p4 z4 [) X' [
2.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
   ) _' H7 o# n% d! U0 m/ z
3. 
     ~) R8 u6 p! @+ d/ P! d0 ~
4.     while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
   
5. 
   
6.     /* 使能HSE，并选择HSE作为PLL时钟源 */
   / T' x8 o% ~; u7 x
7.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   
8.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
     ]& J( m+ K5 [9 m6 U
9.     RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
   
10.     RCC_OscInitStruct.CSIState = RCC_CSI_OFF;
    
11.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    
12.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    3 `4 |3 U& [6 C* E8 e
13. 
    + r( f* o1 ^8 }: t2 F8 ^
14.     RCC_OscInitStruct.PLL.PLLM = 5;
    6 s( _; k# ~" X$ e1 u
15.     RCC_OscInitStruct.PLL.PLLN = 160;
    
16.     RCC_OscInitStruct.PLL.PLLP = 2;
    
17.     RCC_OscInitStruct.PLL.PLLR = 2;
    / I2 K, M% M8 D' T' W
18.     RCC_OscInitStruct.PLL.PLLQ = 4;        
    6 `' a1 ~  P0 w* E( ]. U
19. 
      K4 J& n, `9 L6 Z
20.     RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
    $ F, |( `, ]! u5 k, P
21.     RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;   
    
22.     ret = HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
23.     if(ret != HAL_OK)
    
24.     {
    & m+ A- v" b  H% r
25.         return 1;        
    
26.     }
    4 ]) Z2 r7 x+ r: t2 {& c
27. 
    
28.     /*
    ' z7 L2 O, O2 g/ P/ f
29.        选择PLL的输出作为系统时钟
    
30.        配置RCC_CLOCKTYPE_SYSCLK系统时钟
    ' C2 e2 s1 N: |: }& H
31.        配置RCC_CLOCKTYPE_HCLK 时钟，对应AHB1，AHB2，AHB3和AHB4总线
    
32.        配置RCC_CLOCKTYPE_PCLK1时钟，对应APB1总线
    / ?" u4 }: J) B% _& I
33.        配置RCC_CLOCKTYPE_PCLK2时钟，对应APB2总线
    + l1 g! N6 b3 {, O) r0 ~
34.        配置RCC_CLOCKTYPE_D1PCLK1时钟，对应APB3总线
    * i7 S, j; f6 o  s; l" B  ^
35.        配置RCC_CLOCKTYPE_D3PCLK1时钟，对应APB4总线     
    ! F6 |: G& S* }& _; b: p$ U
36.     */
    
37.     RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_D1PCLK1 | RCC_CLOCKTYPE_PCLK1 | \
    
38.                                  RCC_CLOCKTYPE_PCLK2  | RCC_CLOCKTYPE_D3PCLK1);
    
39. 
    7 ]& H  Z" i' @0 B+ k2 v
40.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    + X5 ^/ w3 R: r3 ]1 w
41.     RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
    ) }4 z1 c& F+ {" \: s1 J" F
42.     RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
    ' g! y* o, P% O6 u% |( i6 I& K
43.     RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;  
    
44.     RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
    5 V) m6 U5 e0 L% l4 i
45.     RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
      k0 X8 n, C$ {& g3 i9 Q; r* n
46.     RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
    & C; @5 Z  X4 `% B/ a: F
47. 
    
48.     /* 此函数会更新SystemCoreClock，并重新配置HAL_InitTick */
    ' r5 f  @# \/ {: V( V
49.     ret = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4);
    
50.     if(ret != HAL_OK)
    
51.     {
      B/ A' {+ K3 d, M( }
52.         return 1;
    
53.     }
    % S1 n1 k$ q+ ]" `& m# n
54. 
    ( l! S& m# ^# _% [
55.     /*
    
56.       使用IO的高速模式，要使能IO补偿，即调用下面三个函数
    5 \- S9 D0 ^( z( X/ H
57.       （1）使能CSI clock
    ' t9 C% S* a% G1 _2 k% M. r9 _
58.       （2）使能SYSCFG clock
    
59.       （3）使能I/O补偿单元， 设置SYSCFG_CCCSR寄存器的bit0
    
60.     */
    
61.     __HAL_RCC_CSI_ENABLE() ;
    1 t, m* w) h0 r2 G, g$ L
62. 
    
63.     __HAL_RCC_SYSCFG_CLK_ENABLE() ;
    
64. 
    9 f+ M9 }, I  m3 R5 {
65.     HAL_EnableCompensationCell();
    
66. 
    7 t$ w6 G5 i1 c% C0 _
67.     __HAL_RCC_D2SRAM1_CLK_ENABLE();
    
68.     __HAL_RCC_D2SRAM2_CLK_ENABLE();
    
69.     __HAL_RCC_D2SRAM3_CLK_ENABLE();
      q# M6 t; p' n  i5 L
70. 
    ! p3 b1 n  i  x/ {) U! g3 r
71.     return 0;
    
72. }

复制代码

) H" H3 H' H3 J. x) F0 H6 O2 e81.5.5 第5步，配置文件Dev_Inf.c的实现
2 P3 _, S2 N( H: F3 ~$ ^  i5 ]配置如下：

1. #if defined (__ICCARM__)
   ; m6 U- a# N! J* S3 G& O
2. __root struct StorageInfo const StorageInfo  =  {
   
3. #else
   1 [0 P9 t6 E# y) S+ Y# ~
4. struct StorageInfo const StorageInfo =  {
   * ^: O6 W5 w2 E. j" |6 Y5 z- E: \
5. #endif
   8 q4 O9 k- L, X7 c, K
6.     "ARMFLY_STM32H7x_QSPI_W25Q256", /* 算法名，添加算法到STM32CubeProg安装目录会显示此名字 */
   % Q7 a1 o. U6 G
7.     NOR_FLASH,                      /* 设备类型 */
   + Q1 x. c. j2 O4 J- T; @
8.     0x90000000,                     /* Flash起始地址 */
   
9.     32 * 1024 * 1024,               /* Flash大小，32MB */
   
10.     4*1024,                         /* 编程页大小 */
    # v; |$ e. M6 F" k  M7 f
11.     0xFF,                           /* 擦除后的数值 */
    
12.     512 , 64 * 1024,                /* 块个数和块大小 */
    9 z; C2 H9 [/ F/ o  C
13.     0x00000000, 0x00000000,
    
14. };

复制代码

" m: C4 l) V5 Z8 M注释已经比较详细，大家根据自己的需要做修改即可。注意一点，算法名ARMFLY_STM32H7x_QSPI_W25Q256会反馈到这个地方：
$ w# ]- T9 ]! g; K# A
* `% r% Y0 v9 @1 I- m

81.5.6 第6步，编程文件Loader_Src.c的实现
4 F8 @" t! z$ x1 X下面将变成文件中实现的几个函数为大家做个说明：
- h% M0 k- P2 m2 P2 G$ o. S3 x4 O! X
1 l4 O1 Q5 X& m; Z% Z' y5 z/ j  初始化函数Init
6 s% ]. C% v0 @8 c

1. /*
   1 F6 }8 c) M7 I' v% |
2. *********************************************************************************************************
   
3. *    函 数 名: Init
   
4. *    功能说明: Flash编程初始化
   8 w9 \3 ~7 c0 A" v  g
5. *    形    参: 无
   . H2 |4 ^( m" a, _- m
6. *    返 回 值: 0 表示失败， 1表示成功
   
7. *********************************************************************************************************
   7 J- g( `- s( b5 j) c5 y
8. */
   + o5 I4 i* W( S( ^' _0 b7 g2 u
9. int Init(void)
   5 K, T  V1 u; U4 v
10. {   
    
11.     int result = 1;
    
12. 
    
13.     /* 系统初始化 */
    " Q6 r: F7 [+ A) d
14.     SystemInit();
    
15. 
    2 r+ {6 u- E2 U3 I
16.     /* 时钟初始化 */
    3 ~: G, ~" o/ g
17.     result = SystemClock_Config();
    
18.     if (result == 1)
    
19.     {
    
20.         return 0;        
    ) ]/ x  C; d6 G! V+ I! w
21.     }
    
22. 
    
23.     /* W25Q256初始化 */
    
24.     result = bsp_InitQSPI_W25Q256();
    
25.     if (result == 1)
    - b, `% H$ t9 Z$ L0 t8 Z+ H  G
26.     {
    
27.         return 0;
    
28.     }
    ) v' j; ^4 [3 [
29. 
    : [6 ]1 L% T! d& L. m$ U
30.     /* 内存映射 */   
    
31.     result = QSPI_MemoryMapped();
    + G0 o, S: a8 {1 t
32.     if (result == 1)
    5 S  X; d. N) X( d
33.     {
    
34.         return 0;
    0 {/ W( }" t# A* |4 B3 L. j
35.     }
    ; ~. {( _, I9 p# R
36. 
    : L. j$ [; y, ]/ p. A; ~( j/ b
37.     return 1;
      O; O7 H0 @6 B( e  A
38. }

复制代码

8 T' Z8 e5 }# Z+ v初始化完毕后将其设置为内存映射模式。
- W2 A: }9 x$ i4 m0 P
  整个芯片擦除函数MassErase
整个芯片的擦除实现如下：

1. /*
   : w; O3 r7 ~5 C- S; Q
2. *********************************************************************************************************
   
3. *    函 数 名: MassErase
   
4. *    功能说明: 整个芯片擦除
   
5. *    形    参: 无
   
6. *    返 回 值: 1 表示成功，0表示失败
   ! y; m& e. ^- C" d( j
7. *********************************************************************************************************
   $ S# H4 P( P8 X  \8 C+ U
8. */
   
9. int MassErase(void)
   
10. {
    
11.     int result = 1;
    
12. 
    . X' H% c8 E# p: G( U
13.     /* W25Q256初始化 */
    6 B# A2 m2 [7 L; S5 N
14.     result = bsp_InitQSPI_W25Q256();
    
15.     if (result == 1)
    
16.     {
    
17.         return 0;
    ; j5 e7 O" m: Y2 Y" y% C6 h( V! b
18.     }
    
19. 
    
20.     result = QSPI_EraseChip();
    
21.     if (result == 1)
    
22.     {
    / }  D1 E1 w- R" }5 H
23.         return 0;
    5 {2 s7 e3 K1 X9 K) X. l( q% U
24.     }   
    
25. 
    
26.     /* 内存映射 */   
    
27.     result = QSPI_MemoryMapped();
    
28.     if (result == 1)
    ' P! u; s/ G, k  j( c0 y6 q
29.     {
    
30.         return 0;
    % ~1 o# u# c; j# Z  }+ [: i3 m
31.     }
    
32. 
    
33.     return result;         
    
34. }

复制代码

  扇区擦除函数SectorErase
扇区擦除实现：

1. /*
   
2. *********************************************************************************************************
   ( M, B" s; m7 l
3. *    函 数 名: SectorErase
   
4. *    功能说明: EraseStartAddress 擦除起始地址
   
5. *             EraseEndAddress   擦除结束地址
   
6. *    形    参: adr 擦除地址
   + X  O3 F: I, q( K
7. *    返 回 值: 1 表示成功，0表示失败
   1 b* [) G8 Z7 J8 ]3 A
8. *********************************************************************************************************
   8 U, F/ W0 D( e3 G
9. */
   , j1 b% s+ J. s7 a: a+ m9 m
10. int SectorErase (uint32_t EraseStartAddress ,uint32_t EraseEndAddress)
    
11. {
    
12.     uint32_t BlockAddr, result;
    $ o! w# P2 }' O6 J6 B) w0 E+ O- k
13. 
    
14.     EraseStartAddress -= QSPI_FLASH_MEM_ADDR;
    
15.     EraseEndAddress -= QSPI_FLASH_MEM_ADDR;
    
16.     EraseStartAddress = EraseStartAddress -  EraseStartAddress % 0x10000; /* 64KB首地址 */
    
17. 
    - u- f, q5 K3 L# |5 ?0 p
18.     /* W25Q256初始化 */
    
19.     result = bsp_InitQSPI_W25Q256();
    
20.     if (result == 1)
    6 B/ q- s  {, h3 E3 A/ @
21.     {
    
22.         return 0;        
    
23.     }
    1 M5 [. f, l. a# x) E' p
24. 
    8 c0 U5 W; h9 M; i, X$ m0 G
25.     while (EraseEndAddress >= EraseStartAddress)
    % ~( _5 C8 z; C; {' b
26.     {
    / L  [( |, u3 H
27.         /* 防止超出256MB空间 */
    
28.         BlockAddr = EraseStartAddress & 0x0FFFFFFF;
    
29. 
    
30.         result = QSPI_EraseSector(BlockAddr);   
    
31.         if (result == 1)
    1 V) |8 X4 D5 X, Y+ T- J9 Z
32.         {
    3 `& n! }' H3 E  ]3 `8 o
33.             QSPI_MemoryMapped();
    * F# X9 l8 o6 _- P7 X
34.             return 0;        
    
35.         }
    9 G8 D1 j3 z  F9 f. l* c
36. 
    9 I4 }4 J4 P. t, ~& {3 {# D4 F' `
37.         EraseStartAddress += 0x10000;
    
38.     }
    & D8 X  x  Y1 z" F7 [; W
39. 
    
40.     /* 内存映射 */   
    , [( D0 C( H3 @: w
41.     result = QSPI_MemoryMapped();
    : @( Z4 u' d* h4 R
42.     if (result == 1)
    
43.     {
    " _: a5 L/ O1 J" F+ ?$ d& \
44.         return 0;
    8 V1 \8 V( E) ^& ?2 {) [5 f
45.     }
    
46. 
    
47.     return 1;
    
48. }

复制代码

6 X$ d8 [# C" x& {这里要注意两点：

/ ]+ [8 I: t; C9 q（1）     程序里面的操作EraseStartAddress-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。
9 Q1 Y8 U- g% M  I
（2）     这里执行的擦除大小要前面Dev_Inf.c文件中配置的扇区大小一致，这里是执行的64KB为扇区进行擦除。
# n; @: h, V! [! Y& D
  页编程函数Write
4 R+ P: g7 A2 A0 t6 |- f! v2 e3 z页编程函数实现如下：
1 m3 p" X+ l3 q8 m6 y
* Z, O2 R6 s& A: r4 l

1. int Write(uint32_t Address, uint32_t Size, uint8_t* buffer)
   : V, s# S) D, [9 z6 ?
2. {
   8 C2 X- \5 T2 K6 R0 g5 ]* {7 O
3.     int result = 0;
   
4.     uint32_t end_addr, current_size, current_addr;
   # ^3 w8 J/ _3 ?& H, I6 O# f
5. 
   ! m3 f# r4 m8 Q- F6 m: R
6. 
   
7.     if (Address < QSPI_FLASH_MEM_ADDR || Address >= QSPI_FLASH_MEM_ADDR + QSPI_FLASH_SIZES)
   # J8 r/ q: D" F7 E& K$ J
8.     {
   
9.         return 0;
     a" |  v* X. T& B
10.     }
    
11. 
    : w, ]& S  F, Z8 H
12.     Address -= QSPI_FLASH_MEM_ADDR;
    
13. 
    & Y, ?0 \% D! x$ u0 K$ c
14.     /* 计算写入地址和页末的字节大小 */
    
15.     current_size = QSPI_PAGE_SIZE - (Address % QSPI_PAGE_SIZE);
    # j9 f% [8 b0 v9 a  O" z7 p; D
16. 
    
17.     /* 检测页剩余空间是否够用 */
    / I/ c9 D& }) P% }  }
18.     if (current_size > Size)
    0 k6 v$ \4 b9 A* y
19.     {
    
20.         current_size = Size;
    
21.     }
    
22. 
    
23.     /* W25Q256初始化 */
    % s$ z2 x4 ^/ w# W+ b0 d4 J" O- }4 L4 W
24.     result = bsp_InitQSPI_W25Q256();
    & m$ T  c# ^1 }2 M, I
25.     if (result == 1)
    
26.     {
    
27.         return 0;
    
28.     }
    
29. 
    3 x0 S5 T. \2 R
30.     current_addr = Address;
    
31.     end_addr = Address + Size;
    
32. 
    
33.     do{
    
34.         if (QSPI_WriteBuffer(buffer, current_addr, current_size) == 1)
    
35.         {
    7 P2 S! k/ ]0 ~8 j
36.             QSPI_MemoryMapped();  
    
37.             return 0;  
    - h6 S' I" }9 J8 T
38.         }
    1 W- C' t, s% U# t8 t, \/ r
39. 
    & K7 o9 V& Y. c' Q
40.         /* 更新地址 */
    " P" T6 p5 @! E. t- y9 @" g
41.         current_addr += current_size;
    
42.         buffer += current_size;
    
43.         current_size = ((current_addr + QSPI_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : QSPI_PAGE_SIZE;
    
44. 
    
45.     }while(current_addr < end_addr);
    
46. 
    % S' |  R+ F3 a+ m
47.     /* 内存映射 */   
    
48.     result = QSPI_MemoryMapped();
    
49.     if (result == 1)
    
50.     {
    
51.         return 0;
    
52.     }
    6 @% H+ X8 o0 ]: x/ W
53. 
    4 ^+ A) O& C8 z: T
54.     return (1);  
    
55. }

复制代码

4 V3 d) T/ ]4 F3 o  \1 G这里注意两点：
) E" ~$ _. a0 Y( g7 L
  C0 I) @' _" I9 w% X% Z% D（1）     W25Q256的页大小是256字节，前面FlashDev.c中将页编程大小设置为4096字节，所以此程序要做处理。
3 N) A) ]9 U; d; i! u) j
  V- \; p' [2 S8 Q（2）     程序里面的操作Address-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。
# m% Z8 b3 }, Y
* T3 z( {- i& g0 {: h5 o  读取和校验函数
我们程序中未做读取和校验函数。

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

& T( s9 }2 N! Y+ u/ y% J! x8 Y: I1 ^（2）     如果程序中未做校验函数，那么STM32CubeProg会读取数据做校验。
6 d( n% t, x4 ]( I" v  z* k
81.5.7 第7步，修改QSPI Flash驱动文件（引脚，命令等）
* y) L) i5 a0 G- l- J最后一步就是QSPI Flash（W25Q256）的驱动修改，大家可以根据自己的需求做修改。使用的引脚定义在文件bsp_qspi_w25q256.c（做了条件编译，包含了H7-TOOL和STM32-V7板子）：

1. /*
   " N" s( [" b6 a, A4 ^
2.     STM32-V7开发板接线
   
3. 
   8 q2 E- W- \/ S& i- V
4.     PG6/QUADSPI_BK1_NCS     AF10
   : v( X/ r: S5 j, P/ J
5.     PF10/QUADSPI_CLK        AF9
   ) M7 D) t" w, ?) o) q
6.     PF8/QUADSPI_BK1_IO0     AF10
   
7.     PF9/QUADSPI_BK1_IO1     AF10
   - L; [" b3 N- n9 ~; x8 T
8.     PF7/QUADSPI_BK1_IO2     AF9
   : ]! Q1 _  V9 R& t
9.     PF6/QUADSPI_BK1_IO3     AF9
   
10. 
    , Y! m* ?+ ^) Z2 l; x/ e1 [
11.     W25Q256JV有512块，每块有16个扇区，每个扇区Sector有16页，每页有256字节，共计32MB
    
12. 
    
13.     H7-TOOL开发板接线
    - V" h7 Y. x& [
14. 
    7 u) ?) S; }$ {6 m6 z
15.     PG6/QUADSPI_BK1_NCS     AF10
      m7 p6 G7 k+ `" F& {  n
16.     PB2/QUADSPI_CLK         AF9
    3 e- A' ~# {' }" b2 t4 E2 K
17.     PD11/QUADSPI_BK1_IO0    AF10
    
18.     PD12/QUADSPI_BK1_IO1    AF10
    
19.     PF7/QUADSPI_BK1_IO2     AF9
    
20.     PD13/QUADSPI_BK1_IO3    AF9
    8 V1 h6 z- }, @* }. H# [
21. */
    . H) b2 c) x8 ^3 t" i1 D
22. 
    
23. /* QSPI引脚和时钟相关配置宏定义 */
    0 ]" f' m: J' I, P2 s
24. #if 0
    
25. #define QSPI_CLK_ENABLE()               __HAL_RCC_QSPI_CLK_ENABLE()
    
26. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    
27. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    + h; z6 [6 d! P: P6 T
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()
    
31. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    " I2 q; [8 w. r; w" K- b7 g' L# P& ^
32. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOD_CLK_ENABLE()
    * M, E; H" N- Z9 f8 e. |6 _6 W
33. 
    0 ?) |+ |& ]4 o+ @2 [4 ^
34. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    2 d5 C- N5 R4 @9 @, R2 |. p
35. #define QSPI_FORCE_RESET()              __HAL_RCC_QSPI_FORCE_RESET()
    
36. #define QSPI_RELEASE_RESET()            __HAL_RCC_QSPI_RELEASE_RESET()
    + u/ b5 H' y/ y. i
37. 
    + W% G7 h9 b" s- Y3 L
38. #define QSPI_CS_PIN                     GPIO_PIN_6
    
39. #define QSPI_CS_GPIO_PORT               GPIOG
    
40. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    
41. 
    
42. #define QSPI_CLK_PIN                    GPIO_PIN_2
    0 H5 E" v& z& M' J' q8 ?: v
43. #define QSPI_CLK_GPIO_PORT              GPIOB
    
44. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    
45. 
    
46. #define QSPI_BK1_D0_PIN                 GPIO_PIN_11
    
47. #define QSPI_BK1_D0_GPIO_PORT           GPIOD
    1 e1 u; R: M$ B& z( h
48. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF9_QUADSPI
    / d  T9 g# h3 _! [; ^' I$ K
49. 
    & J5 \. Y, @: ~; L0 g) K8 u
50. #define QSPI_BK1_D1_PIN                 GPIO_PIN_12
    
51. #define QSPI_BK1_D1_GPIO_PORT           GPIOD
    4 Q$ }  ^& V; f* o9 \) Q7 g
52. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF9_QUADSPI
    $ `$ }1 R  C! Z' `" t
53. 
    
54. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    " `& K/ s1 a1 H8 v' [; o7 t
55. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    6 N8 T. |/ |4 I- X6 `" V
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
    8 o* v* d' A. T2 N; s
60. #define QSPI_BK1_D3_GPIO_AF             GPIO_AF9_QUADSPI
    : ?9 I; H, I- t
61. #else
    
62. #define QSPI_CLK_ENABLE()               __HAL_RCC_QSPI_CLK_ENABLE()
    
63. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    " r5 q# o: y5 L4 w7 ~+ F
64. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    ! h! X* E+ y( D! Z2 c: i
65. #define QSPI_CLK_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOF_CLK_ENABLE()
    0 @+ I/ R, {' `
66. #define QSPI_BK1_D0_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    
67. #define QSPI_BK1_D1_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    
68. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    
69. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    
70. 
    
71. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    
72. #define QSPI_FORCE_RESET()              __HAL_RCC_QSPI_FORCE_RESET()
    
73. #define QSPI_RELEASE_RESET()            __HAL_RCC_QSPI_RELEASE_RESET()
    
74. 
    
75. #define QSPI_CS_PIN                     GPIO_PIN_6
    $ d# P  x( l, v& P* X2 \4 R* j
76. #define QSPI_CS_GPIO_PORT               GPIOG
    2 T! B' k$ d2 O  f5 w) L8 H
77. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    ( l4 u4 y  |! z) s! e
78. 
    2 E4 w: j1 |% `: v; F
79. #define QSPI_CLK_PIN                    GPIO_PIN_10
    
80. #define QSPI_CLK_GPIO_PORT              GPIOF
    / t6 P1 {7 g% _2 [" A# X# I' v
81. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    
82. 
    7 A+ j/ G1 L: d% b
83. #define QSPI_BK1_D0_PIN                 GPIO_PIN_8
    
84. #define QSPI_BK1_D0_GPIO_PORT           GPIOF
    / C( z. [+ K% `7 _6 }1 c" V5 O
85. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF10_QUADSPI
    9 v) [/ d6 ^6 P% u0 [( _
86. 
    " [" R. W  U* c3 v1 ~9 u) s$ R5 p
87. #define QSPI_BK1_D1_PIN                 GPIO_PIN_9
    
88. #define QSPI_BK1_D1_GPIO_PORT           GPIOF
    + n1 G/ p" P( O( t
89. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF10_QUADSPI
    
90. 
    : @- _. c; D% X% [8 _
91. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    / w: t  E( G4 u4 }# D
92. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    7 R6 {. k5 p# a+ x+ P3 ]; `7 Y2 {8 A
93. #define QSPI_BK1_D2_GPIO_AF             GPIO_AF9_QUADSPI
    
94. 
    0 s: S7 f, [- m9 m# A2 L9 t
95. #define QSPI_BK1_D3_PIN                 GPIO_PIN_6
    
96. #define QSPI_BK1_D3_GPIO_PORT           GPIOF
    
97. #define QSPI_BK1_D3_GPIO_AF             GPIO_AF9_QUADSPI
    ) h) V  E! z# \8 ~0 ]: Y
98. #endif

复制代码

硬件设置了之后，剩下就是QSPI Flash相关的几个配置，在文件bsp_qspi_w25q256.h：

主要是下面这几个：
4 Q. Q( s3 i$ S$ P, J  |
- y/ D+ E! F) N. t" ]6 x- i

1. #define QSPI_FLASH_MEM_ADDR         0x90000000
   
2. 
   7 |4 D5 A* u3 V/ ~# l( m7 r! Q
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字节 */
   ) D: w: i' o# Y$ A
7. #define QSPI_END_ADDR       (1 << QSPI_FLASH_SIZE)  /* 末尾地址 */
   
8. #define QSPI_FLASH_SIZES    32 * 1024 * 1024         /* Flash大小，2^25 = 32MB*/
   
9. 
   : }. K, V2 \* [! n' @
10. /* W25Q256JV相关命令 */
    6 U1 y$ N" ^, k: H
11. #define WRITE_ENABLE_CMD                        0x06    /* 写使能指令 */
    
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 */
    
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线快速读取命令 */
    
17. 
    ; T4 U& F5 g- p) V; {
18. #define BLOCK_ERASE_64K_4_BYTE_ADDR_CMD         0xDC    /* 4字节地址，64K扇区 */
    5 L$ ?2 K: g5 j* [
19. 
    3 Q8 s* M! W) E# V( \
20. #define BULK_ERASE_CMD                          0xC7    /* 整片擦除 */

复制代码

% c$ L' c- Q% C/ E  a81.6 QSPI Flash的STM32CubeProg下载算法使用方法
编译本章教程配套的例子，生成的算法文件位于此路径下：

: i- l) @6 L. {1 x

; {" {1 f4 F( h5 S5 R
( i( ^2 W. H4 U* \. ~81.6.1 下载算法存放位置
! v+ C+ G& b5 e3 K; F- u2 \: A生成此文件后，需要大家将其存放到STM32CubeProg安装目录路径：
2 G. r5 M  E! N) Z$ \, E
\STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader

" x7 b$ E* {0 k4 ]6 f

7 d& ?* f& [, O! y
/ Q& H9 R5 q/ z; F4 i* j- |7 F81.6.2 STM32CubeProg下载配置
+ S4 M: L  y/ F  k' B8 @9 ?我们这里以STLINK连接开发板为例进行说明（USB DFU或者串口方式不支持下载外部Flash）。
' _/ k7 y5 G2 h" \

( L4 u0 @6 c% V2 Q4 e5 F" }3 C2 C
点击Connect后效果如下：

8 P9 B8 }! L* i' F

在这里选择我们制作的下载算法：
& g- m0 o& M. h

5 i5 s# r& v  A( j$ B, B1 P1 @
任意加载个hex或者bin文件，并按照如下配置，然后点击Start Programming

4 |) g, t( e- J" S
5 |* ]7 ^) t$ X4 O6 z- Y下载完成后的效果如下：
: \/ T7 m9 K  G" b3 G; o
: X* A# Z7 m5 H

. z0 A8 j" I) w$ B
8 A7 c! C6 h# i$ `1 k" R8 R81.6.3 验证算法文件是否可以正常使用
8 }7 G( Q1 H: n+ {为了验证算法文件是否可以正常使用，大家可以运行本教程第82章或者83章配套的例子。也可以使用STM32CubeProg直接读取：
! j" s1 K! p" ~) z

81.7 实验例程说明
本章配套例子：V7-061_QSPI Flash的STM32CubeProg下载算法制作。

编译本章教程配套的例子，生成的算法文件位于此路径下：
" i! S  q. \; q6 B, T% r9 `
0 q! i, m$ `2 k9 X

81.8 总结
本章节就为大家讲解这么多，为了熟练掌握，大家可以尝试自己实现一个Flash下载算法。
+ d* N" t1 L  }2 T& {/ H* Y# S
5 ~3 s6 g1 y5 b1 t

, f2 P8 t( }6 B; C1 h: w