81.1 初学者重要提示
7 m5 A# T# s+ `5 F  QSPI Flash的相关知识点可以看第78章和79章。
  QSPI Flash下载算法文件直接采用HAL库制作，方便大家自己修改。
1 w  G7 |& R" x* u  i6 e/ i  STM32CubeProg下载算法制作和MDK下载算法制作基本是一样
  本教程的第68章USB DFU和第69章串口IAP章节为大家介绍过STM32CubeProg的用法。
81.2 STM32CubeProg简介
STM32CubeProg，此软件实现了之前的 DfuSe，STLINK 小软件和 Flashloader 三合一，并且支持外部 EEPROM，NOR Flash，SPI Flash，NAND Flash 等烧写，也支持 OTA 编程。
) e' ~# j1 E6 W' h
$ _2 k  W- \  z5 W0 T' x7 I

( u) [3 y) {% i; n
81.3 STM32CubeProg下载算法基础知识
1 D* l5 }# {3 l+ k2 G6 YSTM32CubeProg下载算法是一种用于擦除应用程序或将应用程序下载到Flash的程序代码。ST自家的芯片都自带下载算法，存放在STM32CubeProg安装目录里面，但不支持的需要我们自己制作，本章教程为此而生。

81.3.1 程序能够通过下载算法下载到芯片的核心思想
8 d, q3 p* I* D* G认识到这点很重要：通过IDE开发环境创建一批与地址信息无关的算法文件，实现的功能主要有初始化，擦除，编程，读取，校验等，然后STM32CubeProg下载阶段，会将算法文件加载到芯片的内部RAM里面，然后STM32CubeProg通过与这个算法文件的交互，实现程序下载，数据读取等操作。
; f, g% L0 S* e* A5 \8 r& ^9 |% u2 ?
& T- D1 Y- g7 X  L  k# @81.3.2 算法程序中擦除操作执行流程
注：下面是MDK的算法执行流程，STM32CubeProg是类似的。

' Y7 t0 s  J, x  p擦除操作大致流程：

8 j) N& C" c. d  R8 d$ a1 P
0 h( [, K; ?# M- j  加载算法到芯片RAM。
1 K6 u3 r; i  \, ~$ Y  执行初始化函数Init。
  执行擦除操作，根据用户配置，这里可以选择整个芯片擦除或者扇区擦除。
  执行Uinit函数。
  操作完毕。
81.3.3 算法程序中编程操作执行流程
注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。
% T5 J+ G. J6 b2 j, m3 ?
编程操作大致流程：

5 h( k) Y- V# G) Z: z4 _& W8 A
( ?. M- Y. b9 t# ~2 ~. T  针对IDE生成的axf（elf）可执行文件做Init初始化，这个axf（elf）文件是指的大家自己创建应用程序生成的。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
: S( d, `; z; L0 g2 O  加载算法到RAM。
  执行Init函数。
, Q6 W* ~1 g3 ?3 R' B6 C  加载用户到RAM缓冲。
  执行Program Page页编程函数。
4 I# Z3 f0 M$ K) N4 s; f' T9 h  执行Uninit函数。
% j0 n* E( v$ b7 E  操作完毕。
81.3.4 算法程序中校验操作执行流程
注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。
. r' L+ q; T4 C; n$ m
校验操作大致流程：

% k$ X9 f, O; t% x+ e2 d
  校验要用到IDE生成的axf（elf）可执行文件。校验就是axf（elf）文件中下载到芯片的程序和实际下载的程序读出来做比较。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
7 U' L5 ?1 Z7 Z9 C  加载算法到RAM。
  执行Init函数。
8 W! s; i( I6 t$ I+ k! ^  查看校验算法是否存在
  如果有，加载应用程序到RAM并执行校验。
  如果没有，执行计算CRC，将芯片中读取数据出来和RAM中加载应用计算输出的CRC值做比较。
& A/ o0 J( o2 V8 S+ ?$ a5 \  执行Uninit函数。
  替换BKPT（BreakPoint断点指令）为 B. 死循环指令。
  执行RecoverySupportStop，回复支持停止。
: a* B* R4 z. h7 h% e( ?9 b( Y7 ^/ Z  执行DebugCoreStop，调试内核停止。
  运行应用：
3 J+ ^' L9 M7 Q  执行失败
2 Y5 p& o# f  e6 g1 g' z2 v; q1 i7 ]  执行成功，再执行硬件复位。
  操作完毕，停止调试端口。
; e! n, v' `/ f; J: p81.4 创建STM32CubeProg下载算法通用流程
* o* _$ H2 {  S, q5 U下面是STM32CubeProg给的一种大致操作流程，不限制必须采用这种方法，自己创建也可以的。
! w2 r2 s$ a9 B/ p. `
9 H% Y  g! W  V& m, h; n81.4.1 第1步，使用STM32CubeProg提供好的程序模板
- E; d0 K9 s) ^; F8 N( N; l位于路径：STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader

+ d6 C: r5 P+ S
以M25P64为例（注，其余步骤就以这个为例子进行说明）：
: l9 n5 i! u+ E- }5 u' q
$ [( z) |: ^$ `% d

81.4.2 第2步，修改工程名
STM32CubeProg提供的工程模板原始名字是M25P64_STM3210E-EVAL.uvproj，大家可以根据自己的需要做修改。比如修改为MyDevice.uvproj（MDK4的后缀）或者MyDevice.uvprojx（MDK5的后缀）。

# J9 n; y" R& e% J( P. B81.4.3 第3步，修改使用的器件
在MDK的Option选项里面设置使用的器件。

, o6 i% H5 Z6 h$ a$ T( z. ^81.4.4 第4步，修改输出算法文件的名字
这个名字是方便用户查看的，比如设置为stm32h7，那么输出的算法文件就是stm32h7.stldr。
. b  c; q9 @, {, W" [
# C* C9 x1 e: T9 N

  A, ^9 O0 C- f. H2 a
' ]& i# Q9 F0 h9 l9 ~注：STM32CubeProg软件里面别的文件名并不采用这个，而是由用户在文件Dev_Inf.c里面定义的：

0 z" S1 ?" |. H2 J( V: ~: l
- W" X8 h- T$ H81.4.5 第5步，修改使用的库文件和头文件路径
% R, i+ L* [7 y. B, p+ l2 ]根据大家使用的主控芯片，添加相应的库文件和头文件路径。

81.4.6 第5步，修改编程算法文件Loader_Src.c
模板工程里面提供的是M25P64，部分代码如下：
: J- O( C& Z# A* M! {" {3 Q

1. /**
   # n& Y  @( Q$ d2 u# P4 U' u
2.   * Description :
   * N5 [; i5 x6 A! R; Q
3.   * Initilize the MCU Clock, the GPIO Pins corresponding to the
   
4.   * device and initilize the FSMC with the chosen configuration
   ; ]5 }( _' m4 m  i2 Q6 g
5.   * Inputs    :
     ?' z/ o: I( s$ I$ m! u
6.   *      None
   
7.   * outputs   :
   
8.   *      R0             : "1"             : Operation succeeded
   ( _- w. b7 a% z: X6 X1 }# M
9.   *               "0"             : Operation failure
   6 U6 v# a! X; @
10.   * Note: Mandatory for all types of device
    
11.   */
    4 n7 ^, K) |- q" x3 O2 V
12. int Init (void)
    $ u! \# S3 L+ Z* L8 b3 G
13. {  
    
14.   SystemInit();
    
15.   sFLASH_Init();
    
16.   return 1;
    
17. }
    
18. 
    
19. 
    
20. /**
    
21.   * Description :
    + i7 [1 u5 w7 a3 c
22.   * Read data from the device
    6 f3 Z) Y( N( V3 l1 _
23.   * Inputs    :
    
24.   *      Address       : Write location
    
25.   *      Size          : Length in bytes  
    3 `5 v0 u" o  n/ [+ o( x4 U
26.   *      buffer        : Address where to get the data to write
      f' N2 S( N. h, K' Z3 @, ?6 ]- m3 }  Y, F
27.   * outputs   :
    
28.   *      R0             : "1"             : Operation succeeded
    
29.   *               "0"             : Operation failure
    & v' S! _- b3 V
30.   * Note: Mandatory for all types except SRAM and PSRAM   
    2 Y9 E, v, W8 p# X) [. f4 U
31.   */
    
32. int Read (uint32_t Address, uint32_t Size, uint8_t* buffer)
    
33. {
    
34.   sFLASH_ReadBuffer(buffer, Address, Size);
    
35.   return 1;
    + n& @2 M8 ^& c8 _8 e) r9 {, Y1 k7 F
36. }
    
37. 
    
38. 
    
39. /**
    6 z' A+ S0 F8 r% O! l- a8 q2 m1 Q
40.   * Description :
    
41.   * Write data from the device
    4 ~4 _/ i$ e* t9 Z
42.   * Inputs    :
    6 U* s4 U5 Q5 g6 p0 B4 L) O
43.   *      Address       : Write location
    7 o5 `5 P" B7 o9 A6 B2 K9 R8 j
44.   *      Size          : Length in bytes  
      g: i6 ]9 r  m
45.   *      buffer        : Address where to get the data to write
    
46.   * outputs   :
    
47.   *      R0           : "1"             : Operation succeeded
    
48.   *                     "0"             : Operation failure
    
49.   * Note: Mandatory for all types except SRAM and PSRAM   
    
50.   */
    
51. int Write (uint32_t Address, uint32_t Size, uint8_t* buffer)
    
52. {
    + w5 z6 X) u1 \
53.   sFLASH_WriteBuffer(buffer, Address, Size);
    % d6 S6 I* q6 p' R
54.   return 1;
    9 v* S6 `$ R& @2 t0 O
55. }
    
56. 
    : Q! P0 w9 Q9 {4 K) l
57. 
    
58. /**
    
59.   * Description :
    $ l. V) v; E, b' F6 K
60.   * Erase a full sector in the device
    
61.   * Inputs    :
    , _$ }; W/ t/ S2 S/ t/ a. A/ ~
62.   *     None
    
63.   * outputs   :
    / N- B# G) \! h0 d
64.   *     R0             : "1" : Operation succeeded
    
65.   *              "0" : Operation failure
    
66.   * Note: Not Mandatory for SRAM PSRAM and NOR_FLASH
    * D8 _" [5 W; ^
67.   */
    ! n5 e6 r9 w" t, f2 Z
68. int MassErase (void)
    
69. {  
    & i5 n" Y' K) E( ^0 C
70.   sFLASH_EraseBulk();
    
71.   return 1;   
    
72. }

复制代码

. m7 E2 r' w) w) q* s; U- @81.4.7 第6步，修改配置文件Dev_Inf.c
模板工程里面提供简单的配置说明：
: Q8 |6 A  V! U  y

1. #if defined (__ICCARM__)
   6 V  Y; ~  N; K+ q. @+ X, X
2. __root struct StorageInfo const StorageInfo  =  {
   ) `& V1 |% [- h: ~  Z! E
3. #else
   
4. struct StorageInfo const StorageInfo  =  {
   # M4 j8 {- T1 i
5. #endif
   & B3 z4 S0 q% I. s$ M1 S5 z2 |* @0 ?# d
6.    "M25P64_STM3210E-EVAL",           // Device Name + version number
   9 D8 J( Y% P: |( |8 G/ a3 G: W* N" x
7.    SPI_FLASH,                       // Device Type
   
8.    0x00000000,                     // Device Start Address
   - }' u5 `% j7 u, V
9.    0x00800000,                      // Device Size in Bytes (8MBytes/64Mbits)
   
10.    0x00000100,                      // Programming Page Size 16Bytes
    
11.    0xFF,                            // Initial Content of Erased Memory
      K. T% `8 y. O$ W
12. // Specify Size and Address of Sectors (view example below)
    1 c" b* g! e$ C' h! }# a
13.    0x00000080, 0x00010000,          // Sector Num : 128 ,Sector Size: 64KBytes
    
14.    0x00000000, 0x00000000,
    9 J9 k4 Z" _  r
15. };

复制代码

! N. V8 E& ]4 U& O, D/ i注：名字M25P64_STM3210E-EVAL就是我们第4步所说的。STM32CubeProg会识别出这个名字。
, O9 D& ]% m+ k+ J5 D! r8 x
3 @2 r# k' B8 M& J8 }

81.4.8 第7步，保证生成的算法文件中RO和RW段的独立性，即与地址无关。
% k4 ]. x( s! F+ K$ wC和汇编的配置都勾选上：

8 W& J  m! _( \) F& I' w
汇编：
' @3 j: r' Z" H% M* |' Y9 z, A

3 e3 ^3 v0 y" Y! I- r如果程序的所有只读段都与位置无关，则该程序为只读位置无关（ROPI, Read-only position independence）。ROPI段通常是位置无关代码（PIC,position-independent code），但可以是只读数据，也可以是PIC和只读数据的组合。选择“ ROPI”选项，可以避免不得不将代码加载到内存中的特定位置。这对于以下例程特别有用：
; x, n  M: N5 t
4 ?* B7 @5 c8 w+ |& H; U（1）加载以响应运行事件。
3 C9 z$ F8 c: L5 ]9 M% ^8 e
& e  D3 d  e3 e' z7 }; a8 ^（2）在不同情况下使用其他例程的不同组合加载到内存中。
. U6 U( }) n, F0 p" R
（3）在执行期间映射到不同的地址。
/ X6 Z3 s9 q3 u0 U1 G3 I* ]- X
/ @" C( P. M7 m使用Read-Write position independence同理，表示的可读可写数据段。

. d2 J. p4 _9 B1 ], d81.4.9 第8步，将程序可执行文件axf修改为stldr格式
2 ?6 Q. R- l5 p- Q( C: A- J- v通过下面的命令就可以将生成的axf可执行文件修改为stldr。

$ c8 s) E: M1 z; o1 d$ D, j% p# ~9 Q
81.4.10   第9步，分散加载设置
1 E, V4 I+ x8 @, }1 q7 u2 b我们这里的分散加载文件直接使用MDK模板工程里提供好的即可。

分散加载文件中的内容如下：
4 l% Q, p5 u& Z7 ~
3 R1 K$ F' G! ]7 R' d: Z0 @  h# h# v% a- f

1. FLASH_LOADER 0x20000004 PI   ; FlashLoader Functions
   ! R+ Z  T0 z4 ?/ s; q
2. {
   5 \( w3 q, C. H# |0 u1 \
3.   PrgCode +0           ; Code
   
4.   {
   + K& ~- X! L3 I1 z9 o' F, x
5.     * (+RO)
   
6.   }
   7 c7 C4 T( P* G
7.   PrgData +0           ; Data
   & Z2 K) J- V% h# l( u* Q# N
8.   {
   
9.     * (+RW,+ZI)
   
10.   }
    - M' r8 d! c6 g; f) d; I% H
11. }
    
12. 
    # c! U  ?0 h  |; ]+ U
13. DEVICE_INFO +0               ; Device Info
    # h& L  m2 z/ K; a+ P$ U, Z
14. {
    
15.   DevInfo +0           ; Info structure
    , B" k4 {* H4 o" S9 h8 _1 O- n
16.   {
    
17.     dev_inf.o
    
18.   }
    * \( J0 O9 `2 I
19. }

复制代码

8 O) L+ s; v3 }; C( S6 S+ F. }这里要修改下Flash算法加载地址，将0x20000004修改为STM32H7的RAM地址，任何RAM块地址均可，只要够存储Flash算法。推荐设置为AXI SRAM地址0x24000004，因为空间够大，有512KB。
3 b' r7 I, o5 ?  i" e  s: L
--diag_suppress L6305用于屏蔽L6503类型警告信息。

特别注意，设置了分散加载后，此处的配置就不再起作用了：
/ ~( m5 Z, n# R) e' ^

7 I: a% y# \& Z! {- ?, ^
81.5 QSPI Flash的STM32CubeProg下载算法制作
下面将QSPI Flash算法制作过程中的几个关键点为大家做个说明。

1 G  P! I, @- Y/ }- u! `81.5.1 第1步，制作前重要提示
$ J8 @/ f+ v! s: T$ U/ r) [) r这两点非常重要：
" n* d) j, S) L+ }0 C! W& h
  程序里面不要开启任何中断，全部查询方式。
4 @2 K  n* ~$ \7 w  HAL库里面各种时间基准相关的API全部处理掉。简单省事些，我们这里是直接注释，采用死等即可。无需做超时等待，因为超时后，已经意味着操作失败了，跟死等没有区别。
81.5.2 第2步，准备一个工程模板
推荐大家直接使用我们本章工程准备好的模板即可，如果大家自己制作，注意一点，请使用当前最新的HAL库。
$ E- s6 Y6 z3 Z/ E  [3 K

9 [" J, ~5 [4 z) u" s# A81.5.3 第3步，修改HAL库
这一步比较重要，主要修改了以下三个文件：

8 L, I  u; z0 g8 \; K! w: X

主要是修改了HAL库时间基准相关的几个API，并注释掉了一批无关的API。具体修改内容，大家可以找个比较软件，对比修改后的这个文件和CubeH7软件包V1.8.0（软件包里面的HAL库版本是V1.9.0）的差异即可。
/ q1 g8 E/ l% P  L' J  A+ P
* U7 g! N0 D3 |( u, W8 @4 {4 k/ x81.5.4 第4步，时钟初始化
我们已经用不到滴答定时器了，直接在bsp.c文件里面对滴答初始化函数做重定向：

1. /*
   3 J0 @9 ?' u$ |
2. *********************************************************************************************************
   . j" N- v+ I3 p' E7 f' _7 i% \
3. *    函 数 名: HAL_InitTick
   
4. *    功能说明: 重定向，不使用
   ' S) W% W) X0 S) Z1 h! r
5. *    形    参: TickPriority
   
6. *    返 回 值: 无
   % ~! t& J! G. R( ^
7. *********************************************************************************************************
   
8. */
   ! F" M/ g4 a7 z% C7 [. f. g
9. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
   
10. {
    9 L3 ]! }( T  w3 c0 B0 ~: c  N6 @
11.     return HAL_OK;
    / L& r9 T  R4 }% C0 W3 F
12. }

复制代码

然后就是HSE外置晶振的配置，大家根据自己的板子实际外挂晶振大小，修改stm32h7xx_hal_conf.h文件中HSE_VALUE大小，实际晶振多大，这里就修改为多大：
: t; {% E. T1 p; o
0 V% D0 F# q# ~" w6 F9 f& A* M- {

1. #if !defined  (HSE_VALUE)
   
2. #define HSE_VALUE    ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
   & v" t7 k1 g7 u4 P: C: s( s
3. #endif /* HSE_VALUE */

复制代码

4 i: H+ `% ]3 Y$ ^( X最后修改PLL：
  G( x' g7 d" n3 ]

1. /*
   
2. *********************************************************************************************************
   ) J7 ?3 z. _7 V' B- |6 C; O" }7 `
3. *    函 数 名: SystemClock_Config
   
4. *    功能说明: 初始化系统时钟
   7 \" }9 w. p. ^% H1 ]
5. *                System Clock source            = PLL (HSE)
   
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)
   
10. *                D2 APB1 Prescaler              = 2 (APB1 Clock  100MHz)
    
11. *                D2 APB2 Prescaler              = 2 (APB2 Clock  100MHz)
    # E( L# u$ S; j* w
12. *                D3 APB4 Prescaler              = 2 (APB4 Clock  100MHz)
    ( x6 W& J& ~! w+ m3 u/ P$ W
13. *                HSE Frequency(Hz)              = 25000000
    9 k3 Y$ E4 e. ^
14. *               PLL_M                          = 5
    " b7 I* [# W3 w) t$ O- C0 R8 l
15. *                PLL_N                          = 160
    
16. *                PLL_P                          = 2
    
17. *                PLL_Q                          = 4
    
18. *                PLL_R                          = 2
    + h7 K- n- r4 N/ X
19. *                VDD(V)                         = 3.3
    4 q* |$ b- W1 I/ I2 M2 ]
20. *                Flash Latency(WS)              = 4
    
21. *    形    参: 无
    
22. *    返 回 值: 1 表示失败，0 表示成功
    
23. *********************************************************************************************************
    
24. */
    ' L% D1 ^+ B& a* m# ~( L- D. b- d$ \
25. int SystemClock_Config(void)
    8 ?3 O* \! g. E" Y6 R! `2 J
26. {
    
27.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    
28.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
29.     HAL_StatusTypeDef ret = HAL_OK;
    ) A3 w% H- y5 p* y
30. 
    0 W4 E$ P. y7 X, p" H, f
31.     /* 锁住SCU(Supply configuration update) */
    
32.     MODIFY_REG(PWR->CR3, PWR_CR3_SCUEN, 0);
    ! r- v2 q; R- A
33. 
    
34.     /*

复制代码

/ g' |4 |- x" T2 [5 ^+ o$ N      1、芯片内部的LDO稳压器输出的电压范围，可选VOS1，VOS2和VOS3，不同范围对应不同的Flash读速度，
" U6 `+ x9 a2 u& u         详情看参考手册的Table 12的表格。
      2、这里选择使用VOS1，电压范围1.15V - 1.26V。
+ u5 A  L- M" u' F8 |9 U; M   

1. */
   
2.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
   
3. 
   
4.     while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
   
5. 
   
6.     /* 使能HSE，并选择HSE作为PLL时钟源 */
   
7.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   2 Z4 x8 f* z" D$ J* a
8.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
   : c# ^+ A; ~+ @& p; q  a9 ]$ d
9.     RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
   ( m+ E6 ~) [0 P  f; }
10.     RCC_OscInitStruct.CSIState = RCC_CSI_OFF;
    , M$ z0 D9 q, m4 ]3 L' @6 E% p
11.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    7 R& j1 [& J1 e" N( F5 [& p
12.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    
13. 
    
14.     RCC_OscInitStruct.PLL.PLLM = 5;
    & ~6 ~3 h/ {0 u: p
15.     RCC_OscInitStruct.PLL.PLLN = 160;
    
16.     RCC_OscInitStruct.PLL.PLLP = 2;
    
17.     RCC_OscInitStruct.PLL.PLLR = 2;
    
18.     RCC_OscInitStruct.PLL.PLLQ = 4;        
    
19. 
    ( _- w  y" s8 o4 o, n( Z+ @  v9 Q0 Q' f% S
20.     RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
    $ y- N  J% O0 A3 n& N1 r
21.     RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;   
    : s1 h6 _3 e! r; B9 d
22.     ret = HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
23.     if(ret != HAL_OK)
    2 ~7 Z% N$ ?: c- \6 u
24.     {
    
25.         return 1;        
    # A) ?. A. a* _1 J  {8 s1 T
26.     }
    
27. 
    
28.     /*
    5 \2 c, d  x. }( B/ \; g+ L
29.        选择PLL的输出作为系统时钟
    $ F4 `5 T( t7 R. Y
30.        配置RCC_CLOCKTYPE_SYSCLK系统时钟
    - c( T1 l0 a) e  \3 a
31.        配置RCC_CLOCKTYPE_HCLK 时钟，对应AHB1，AHB2，AHB3和AHB4总线
    
32.        配置RCC_CLOCKTYPE_PCLK1时钟，对应APB1总线
    ) q0 ?& i# b. ?
33.        配置RCC_CLOCKTYPE_PCLK2时钟，对应APB2总线
      f! }/ O. V9 l3 x" h$ j3 C" n. j
34.        配置RCC_CLOCKTYPE_D1PCLK1时钟，对应APB3总线
    9 A6 ^2 B1 c. S
35.        配置RCC_CLOCKTYPE_D3PCLK1时钟，对应APB4总线     
    
36.     */
    
37.     RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_D1PCLK1 | RCC_CLOCKTYPE_PCLK1 | \
    4 ^1 w6 }- I+ e& l- Z: R, H; V
38.                                  RCC_CLOCKTYPE_PCLK2  | RCC_CLOCKTYPE_D3PCLK1);
    
39. 
    * M$ A& r) s5 K) p  o% ]1 q8 r
40.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    
41.     RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
    & R$ E* }( k4 C7 K" l3 k
42.     RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
    - f- o/ J+ I1 G8 s
43.     RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;  
    - ?8 ?# y: p! n4 v2 j: S, B
44.     RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
    + D! I9 d/ a, E6 ?$ d: x% D
45.     RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
    : V; i9 u% ^) U' p
46.     RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
    
47. 
    
48.     /* 此函数会更新SystemCoreClock，并重新配置HAL_InitTick */
    
49.     ret = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4);
      I8 \. u, ]3 V: S% T
50.     if(ret != HAL_OK)
    " n: {$ _' D: l4 x
51.     {
    9 w0 Q$ w( P5 K, V
52.         return 1;
    7 I# \3 m+ ~) B% _
53.     }
    ) D! O, |8 E- D8 q7 d
54. 
    ; A) E* \) N; t4 l$ Z
55.     /*
    
56.       使用IO的高速模式，要使能IO补偿，即调用下面三个函数
    6 [7 B; m+ M, u/ z  ~, J/ B/ J
57.       （1）使能CSI clock
    1 B2 u& N3 p8 b' u
58.       （2）使能SYSCFG clock
    ( z  \6 X% g; K% z% D: x
59.       （3）使能I/O补偿单元， 设置SYSCFG_CCCSR寄存器的bit0
    
60.     */
    
61.     __HAL_RCC_CSI_ENABLE() ;
    
62. 
    
63.     __HAL_RCC_SYSCFG_CLK_ENABLE() ;
    ( @" x$ p  Z- o6 x" i
64. 
    # Q6 ~* f. W6 R8 R' d+ A
65.     HAL_EnableCompensationCell();
    0 F' a, \( H; c! ~- K/ ?$ r9 `
66. 
    
67.     __HAL_RCC_D2SRAM1_CLK_ENABLE();
    : Z! C( G9 f, k, Z* Y: ^% V
68.     __HAL_RCC_D2SRAM2_CLK_ENABLE();
    
69.     __HAL_RCC_D2SRAM3_CLK_ENABLE();
    * K) ]4 |# X' c9 Q  O7 l
70. 
    
71.     return 0;
    & @6 K" v% Q. A+ t8 J. j7 g
72. }

复制代码

8 ]4 a4 ^4 r! \81.5.5 第5步，配置文件Dev_Inf.c的实现
% k, h) L& a' a& }配置如下：

) n" R- ^) W% ~1 r! P

1. #if defined (__ICCARM__)
   
2. __root struct StorageInfo const StorageInfo  =  {
   
3. #else
   
4. struct StorageInfo const StorageInfo =  {
   
5. #endif
   % h0 Z* k! a# L+ K
6.     "ARMFLY_STM32H7x_QSPI_W25Q256", /* 算法名，添加算法到STM32CubeProg安装目录会显示此名字 */
   0 X( D$ a" u% r9 i1 @; l" _
7.     NOR_FLASH,                      /* 设备类型 */
   
8.     0x90000000,                     /* Flash起始地址 */
   
9.     32 * 1024 * 1024,               /* Flash大小，32MB */
   3 F; r5 |" P  d; f% e
10.     4*1024,                         /* 编程页大小 */
    
11.     0xFF,                           /* 擦除后的数值 */
    
12.     512 , 64 * 1024,                /* 块个数和块大小 */
    
13.     0x00000000, 0x00000000,
    ; e% q) \. e. [  a6 c% M! z1 u7 o
14. };

复制代码

1 j1 g$ O2 I. P% ?注释已经比较详细，大家根据自己的需要做修改即可。注意一点，算法名ARMFLY_STM32H7x_QSPI_W25Q256会反馈到这个地方：
' L& e7 ]. l8 T1 B! J0 ^9 @

1 {/ L2 b' t+ m81.5.6 第6步，编程文件Loader_Src.c的实现
: S. y2 Y- N& M下面将变成文件中实现的几个函数为大家做个说明：
& o3 s: d: r" M$ T( r9 `- v" Z/ ^
) Z. [; w+ l1 }; L  初始化函数Init
+ g" J. T4 L9 Z1 d6 L8 C

1. /*
   
2. *********************************************************************************************************
   2 v# C: ^# l; i3 [% A9 ~
3. *    函 数 名: Init
   
4. *    功能说明: Flash编程初始化
   ! u' t0 V- G. a
5. *    形    参: 无
   ) ?3 s4 ]. M0 j% L/ r/ V  g  {
6. *    返 回 值: 0 表示失败， 1表示成功
   
7. *********************************************************************************************************
   ) ^$ m4 U2 F$ \8 U  \6 ^
8. */
   4 y5 p4 F& M1 {3 X! v# }+ b0 _
9. int Init(void)
   
10. {   
    4 `+ }2 J' N+ H- w5 Q: s
11.     int result = 1;
    % N+ _# `# {4 a* J( I  j$ D/ X
12. 
    
13.     /* 系统初始化 */
    
14.     SystemInit();
    ; y5 ]1 n) \/ W/ A! _
15. 
    
16.     /* 时钟初始化 */
    + g/ V7 m) D5 u1 k
17.     result = SystemClock_Config();
    7 Y: K6 Z+ V+ X: H
18.     if (result == 1)
    ( `7 I4 q7 N+ I' J8 r' P
19.     {
    + A, I1 O! }; R1 k
20.         return 0;        
    2 d) Y* p0 l- J! u' j# A/ S2 ^
21.     }
    ' d3 Z7 S, h, D* x3 I' x$ I+ O' i1 N
22. 
    ! K" j; p1 l* \! H9 G+ V) A
23.     /* W25Q256初始化 */
    / {3 D9 J! A2 m4 \
24.     result = bsp_InitQSPI_W25Q256();
    
25.     if (result == 1)
    
26.     {
    $ S8 y9 Z5 W* V  O& M" X5 a: e
27.         return 0;
    ! r* S" s& `5 _, w. i1 K
28.     }
    % M5 H8 H6 q1 f- P
29. 
    
30.     /* 内存映射 */   
    ) M2 Z7 }* u) I
31.     result = QSPI_MemoryMapped();
    
32.     if (result == 1)
    1 s8 n5 N6 a9 H4 i- f+ S
33.     {
    
34.         return 0;
    $ H) l  e* l# o4 N; k, P4 W
35.     }
    . |; l0 S: [! ?+ y% [$ K# A
36. 
    - n( b/ g9 U. p, m
37.     return 1;
    
38. }

复制代码

! g% Q8 a; u8 m6 P0 e4 C. u初始化完毕后将其设置为内存映射模式。
  R2 {/ ~* t! N
  整个芯片擦除函数MassErase
整个芯片的擦除实现如下：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MassErase
   # N2 W  ]: W  b1 L
4. *    功能说明: 整个芯片擦除
   6 D( k4 `, a2 _$ _) w+ A8 R7 N9 ~
5. *    形    参: 无
   
6. *    返 回 值: 1 表示成功，0表示失败
   " s# N# M% K, O9 K  f
7. *********************************************************************************************************
   
8. */
   # R$ E) u0 W# c( t
9. int MassErase(void)
   . N& x! L# X$ m+ e
10. {
    2 b. r  z( {- {+ v9 l1 q4 a
11.     int result = 1;
    
12. 
    : S2 s+ g1 `# H2 I+ W
13.     /* W25Q256初始化 */
    ! u/ d' g  O% m+ k! h2 \0 _9 W
14.     result = bsp_InitQSPI_W25Q256();
    
15.     if (result == 1)
    
16.     {
    
17.         return 0;
    
18.     }
    " u% ^  \; C( d+ e4 }
19. 
    
20.     result = QSPI_EraseChip();
      p$ m4 _, ?+ @  D
21.     if (result == 1)
    6 k6 E8 L4 g, j- H: A
22.     {
    
23.         return 0;
    
24.     }   
    
25. 
    / B& e2 g/ a, I7 H9 @0 ^6 I8 Q
26.     /* 内存映射 */   
    
27.     result = QSPI_MemoryMapped();
    ! A; f- X) ]! I
28.     if (result == 1)
    
29.     {
    
30.         return 0;
    
31.     }
    3 t! \; {# I3 U# X1 x
32. 
    
33.     return result;         
    0 e" B& \" i  e3 G* b% V+ T
34. }

复制代码

/ R4 l5 @; F4 B0 n' B6 c% O) n  扇区擦除函数SectorErase
4 L; `- A# j+ {- s' |( `! r扇区擦除实现：

( G3 I4 ^+ X5 `; t

1. /*
   . M# ~- _& g9 g2 q* e
2. *********************************************************************************************************
   ' q) l& t3 ?9 X$ s- m
3. *    函 数 名: SectorErase
   
4. *    功能说明: EraseStartAddress 擦除起始地址
   . A; m- E  Y: B+ ]. B
5. *             EraseEndAddress   擦除结束地址
   5 i& o: ]3 J" j' o! x. G8 \; }
6. *    形    参: adr 擦除地址
   : L& u' `' W5 F0 w, f( g: y: E' ^
7. *    返 回 值: 1 表示成功，0表示失败
   
8. *********************************************************************************************************
   / Q- J! k+ C  c& F
9. */
   8 ~6 T7 t. l% _
10. int SectorErase (uint32_t EraseStartAddress ,uint32_t EraseEndAddress)
    8 ~$ e* ~, `+ v+ X4 |3 n
11. {
    
12.     uint32_t BlockAddr, result;
    
13. 
    ' w8 d$ R  E+ \3 V+ O/ s
14.     EraseStartAddress -= QSPI_FLASH_MEM_ADDR;
    
15.     EraseEndAddress -= QSPI_FLASH_MEM_ADDR;
    1 J7 ]5 U& A: N/ T+ F  j# M
16.     EraseStartAddress = EraseStartAddress -  EraseStartAddress % 0x10000; /* 64KB首地址 */
    
17. 
    
18.     /* W25Q256初始化 */
    
19.     result = bsp_InitQSPI_W25Q256();
    
20.     if (result == 1)
    9 f$ g- C6 ?6 D. T! C$ t0 t. X
21.     {
    
22.         return 0;        
    
23.     }
    ; [% E4 [5 j" ~) f
24. 
    
25.     while (EraseEndAddress >= EraseStartAddress)
    9 o% l2 t, V8 l" N( o- d0 |
26.     {
    
27.         /* 防止超出256MB空间 */
    , L( k; d+ M5 T
28.         BlockAddr = EraseStartAddress & 0x0FFFFFFF;
    
29. 
    
30.         result = QSPI_EraseSector(BlockAddr);   
      l' ]  Q+ \% e7 u
31.         if (result == 1)
    
32.         {
    9 P4 S8 |- W7 W. k  {  S; g
33.             QSPI_MemoryMapped();
    1 \4 I( t3 T% c9 N9 W
34.             return 0;        
    ! B* |1 r! B1 s/ g
35.         }
    2 k9 @1 A+ ]* V0 @
36. 
    ) |) ?- i. s4 ?& C+ h1 U. D
37.         EraseStartAddress += 0x10000;
    
38.     }
    1 V# a( o* z7 {% O
39. 
    
40.     /* 内存映射 */   
    2 T, D; n: e. L% W2 m! J
41.     result = QSPI_MemoryMapped();
    ; v0 @# E( w7 C! C( m* O9 E
42.     if (result == 1)
    
43.     {
    
44.         return 0;
    
45.     }
    ' `% o' p% R* S' t+ T5 u
46. 
    
47.     return 1;
    
48. }

复制代码

这里要注意两点：
- B9 j# R$ @8 K. ?% ~$ S
（1）     程序里面的操作EraseStartAddress-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。

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

  页编程函数Write
页编程函数实现如下：

1. int Write(uint32_t Address, uint32_t Size, uint8_t* buffer)
   6 Q( Z+ d2 ~' c9 q0 N1 `2 e
2. {
   
3.     int result = 0;
   " {: A) J  b4 V& s0 T* b5 A
4.     uint32_t end_addr, current_size, current_addr;
   : }; Z7 W7 {. S& M
5. 
   . X/ i9 D6 K2 g0 `; p
6. 
   
7.     if (Address < QSPI_FLASH_MEM_ADDR || Address >= QSPI_FLASH_MEM_ADDR + QSPI_FLASH_SIZES)
   
8.     {
   
9.         return 0;
   
10.     }
    $ q7 v+ |- W% _& Y2 o+ F9 F  Z
11. 
    
12.     Address -= QSPI_FLASH_MEM_ADDR;
    
13. 
    " S( p1 l1 Z2 ~0 I; ^2 W
14.     /* 计算写入地址和页末的字节大小 */
    
15.     current_size = QSPI_PAGE_SIZE - (Address % QSPI_PAGE_SIZE);
    1 z$ ^- A. H/ e9 E" \7 A6 ^
16. 
    
17.     /* 检测页剩余空间是否够用 */
    0 ^4 E6 ^. O, A
18.     if (current_size > Size)
    6 o2 ]" t- l5 s. l1 i
19.     {
    8 h& c( n/ Z+ h+ V
20.         current_size = Size;
    
21.     }
    
22. 
    / a. X9 ~, u. u' A' c3 y" _
23.     /* W25Q256初始化 */
    9 p8 W% {: R) G
24.     result = bsp_InitQSPI_W25Q256();
    " K* O; h6 a) T. L! @) R
25.     if (result == 1)
    0 f' p6 ^- @0 D. @* \
26.     {
    0 y+ X; e: @$ ~! a7 B' ~% p
27.         return 0;
    " {8 I: z8 J1 k' I1 ?3 ^
28.     }
    
29. 
    
30.     current_addr = Address;
    
31.     end_addr = Address + Size;
    - f3 K4 W7 }0 N5 s/ g) A7 H
32. 
    
33.     do{
    : j' ]& ^% |/ ^4 L) w
34.         if (QSPI_WriteBuffer(buffer, current_addr, current_size) == 1)
    ; c# `  L$ d$ s! A7 g& p5 i
35.         {
    8 y2 A5 {3 ~/ d) E
36.             QSPI_MemoryMapped();  
    - v0 E5 k7 ~* ~5 m, L! Y
37.             return 0;  
    
38.         }
    6 |7 ?0 [0 \- ]* W4 p8 D/ _
39. 
    / a' [. r5 l- {( p
40.         /* 更新地址 */
    / o: M! ?* g8 s; R
41.         current_addr += current_size;
    
42.         buffer += current_size;
    $ i8 {" f9 j' ^/ s& A7 B, i( }
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. 
    
47.     /* 内存映射 */   
    * v* w- U& I7 s' n" \) G
48.     result = QSPI_MemoryMapped();
    $ N. \$ x, r9 o; [: N' M* @
49.     if (result == 1)
    
50.     {
    / C1 z4 T1 M+ [- e0 H. M3 O
51.         return 0;
    ( U' ?, u+ @5 ~
52.     }
    
53. 
    
54.     return (1);  
    
55. }

复制代码

这里注意两点：
  ?% n! s/ `2 f8 g4 c# E! ~
, p& O% B& i0 e7 O( M0 T/ I（1）     W25Q256的页大小是256字节，前面FlashDev.c中将页编程大小设置为4096字节，所以此程序要做处理。

/ }( N) H1 Q) S  g（2）     程序里面的操作Address-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。
4 M7 E* c" a/ p  x: w$ ^6 R
- H4 C* K# Y7 h' b! k( Z4 w' ~  读取和校验函数
我们程序中未做读取和校验函数。

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

: ]% C/ O$ ~9 n; u! J8 Z* Z9 _（2）     如果程序中未做校验函数，那么STM32CubeProg会读取数据做校验。
3 `6 A) V# _+ w4 v+ e0 y
81.5.7 第7步，修改QSPI Flash驱动文件（引脚，命令等）
最后一步就是QSPI Flash（W25Q256）的驱动修改，大家可以根据自己的需求做修改。使用的引脚定义在文件bsp_qspi_w25q256.c（做了条件编译，包含了H7-TOOL和STM32-V7板子）：

* N( l. [! y4 G1 t

1. /*
   + x  U- B2 A' U; K2 u. f6 h2 I& C
2.     STM32-V7开发板接线
   
3. 
   " o  S, z- n. [; U, G
4.     PG6/QUADSPI_BK1_NCS     AF10
   5 a+ D9 f4 P* T+ B; I' p
5.     PF10/QUADSPI_CLK        AF9
   5 G' L- |2 W  o8 P- ]3 G
6.     PF8/QUADSPI_BK1_IO0     AF10
   
7.     PF9/QUADSPI_BK1_IO1     AF10
   & }$ f: Q/ E5 p* a1 q- n2 d
8.     PF7/QUADSPI_BK1_IO2     AF9
   
9.     PF6/QUADSPI_BK1_IO3     AF9
   
10. 
    
11.     W25Q256JV有512块，每块有16个扇区，每个扇区Sector有16页，每页有256字节，共计32MB
    " E& R* p: I- \- |5 b
12. 
    8 W- h9 z3 j# a! G
13.     H7-TOOL开发板接线
    
14. 
    
15.     PG6/QUADSPI_BK1_NCS     AF10
    ! V; C+ g0 S3 P$ G
16.     PB2/QUADSPI_CLK         AF9
    . Y/ e: H" _* n. w! T, N# D$ K
17.     PD11/QUADSPI_BK1_IO0    AF10
    
18.     PD12/QUADSPI_BK1_IO1    AF10
    
19.     PF7/QUADSPI_BK1_IO2     AF9
    . N& ~9 c2 Z  f0 E
20.     PD13/QUADSPI_BK1_IO3    AF9
    
21. */
    , Z6 d, z& k2 X- ^$ B0 l" h
22. 
    # e# D* C! z: ^5 C; k
23. /* QSPI引脚和时钟相关配置宏定义 */
    
24. #if 0
    " w7 W5 O; C* x5 z
25. #define QSPI_CLK_ENABLE()               __HAL_RCC_QSPI_CLK_ENABLE()
    & B5 {7 ?" s" Z$ F) M. }* I
26. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    ; E& C9 m: t2 i( n
27. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    ; R6 ^3 W/ ?0 f& I) @) n+ f, n! x
28. #define QSPI_CLK_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOB_CLK_ENABLE()
    ; X- ~# t0 x% }3 s9 f
29. #define QSPI_BK1_D0_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOD_CLK_ENABLE()
    + G, S) n2 d3 O% K
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()
    6 B7 U. _0 N& a3 c5 W
32. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOD_CLK_ENABLE()
    
33. 
    ; z6 m8 D! R& j) g, c; q
34. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    
35. #define QSPI_FORCE_RESET()              __HAL_RCC_QSPI_FORCE_RESET()
    6 T! _5 [, D3 K
36. #define QSPI_RELEASE_RESET()            __HAL_RCC_QSPI_RELEASE_RESET()
    
37. 
    : {- @3 @+ ^% }0 \8 d9 w& D8 w
38. #define QSPI_CS_PIN                     GPIO_PIN_6
    
39. #define QSPI_CS_GPIO_PORT               GPIOG
    # ~& k+ F$ h" I5 S" T) J% y/ e
40. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    
41. 
    
42. #define QSPI_CLK_PIN                    GPIO_PIN_2
    ( }3 h) [) i, i2 a  g+ o+ `8 H
43. #define QSPI_CLK_GPIO_PORT              GPIOB
    3 T/ _, ~$ o8 A7 Z" g; Z
44. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    
45. 
    
46. #define QSPI_BK1_D0_PIN                 GPIO_PIN_11
    5 [) t2 d9 d# {7 p
47. #define QSPI_BK1_D0_GPIO_PORT           GPIOD
    
48. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF9_QUADSPI
    
49. 
      B# N2 F6 S, V, u+ \
50. #define QSPI_BK1_D1_PIN                 GPIO_PIN_12
    % _" D1 E: J) T; m4 `* B, |( I
51. #define QSPI_BK1_D1_GPIO_PORT           GPIOD
    " j+ `; m( F$ g4 w
52. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF9_QUADSPI
    
53. 
    
54. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    ' ^6 O8 H: O3 o# U4 B
55. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    / v, c" l( b8 f$ i0 o
56. #define QSPI_BK1_D2_GPIO_AF             GPIO_AF9_QUADSPI
    
57. 
    9 ], T+ i  r6 Y3 p
58. #define QSPI_BK1_D3_PIN                 GPIO_PIN_13
    0 e& ?, {- C$ i" N3 E7 y& I
59. #define QSPI_BK1_D3_GPIO_PORT           GPIOD
    7 E( t9 N% x+ O5 m, N0 L9 |
60. #define QSPI_BK1_D3_GPIO_AF             GPIO_AF9_QUADSPI
    5 v$ r7 [2 b0 S' R. a
61. #else
    
62. #define QSPI_CLK_ENABLE()               __HAL_RCC_QSPI_CLK_ENABLE()
    
63. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    8 g5 g1 r$ P$ I
64. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    3 {. D' V& a) @  G
65. #define QSPI_CLK_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOF_CLK_ENABLE()
    0 Y* X( N. M: g' }5 ~' l0 `4 w
66. #define QSPI_BK1_D0_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    / @. N2 b' k1 `' t& ^; F! x
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()
    ! p( Y) t5 j5 N$ s+ M% g
70. 
    , o5 n& ^  V5 l( ?+ g5 f' a
71. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    & R/ p: C/ B, T
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
    * T  X& z# l4 b; }* }
76. #define QSPI_CS_GPIO_PORT               GPIOG
    
77. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    5 X: @! _) n+ B: Z5 n
78. 
    
79. #define QSPI_CLK_PIN                    GPIO_PIN_10
    
80. #define QSPI_CLK_GPIO_PORT              GPIOF
    : V/ g; ^2 V6 d- K7 ^; [* p
81. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    ' s- z7 z5 o7 \
82. 
    " W+ {  d  F" ~
83. #define QSPI_BK1_D0_PIN                 GPIO_PIN_8
    
84. #define QSPI_BK1_D0_GPIO_PORT           GPIOF
    
85. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF10_QUADSPI
    ) J: h8 u/ K! }
86. 
    
87. #define QSPI_BK1_D1_PIN                 GPIO_PIN_9
    + q  E4 a& Z; B! `, T
88. #define QSPI_BK1_D1_GPIO_PORT           GPIOF
    
89. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF10_QUADSPI
    + @8 z& m3 B" M9 f# i* _9 W
90. 
    , i  A" d# e# s" e5 d6 B; X
91. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    0 H. u. F* R. ?6 {
92. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    
93. #define QSPI_BK1_D2_GPIO_AF             GPIO_AF9_QUADSPI
    9 R% |- u& l" y: Q- ~
94. 
    2 F8 N  e& F- Y  T9 R
95. #define QSPI_BK1_D3_PIN                 GPIO_PIN_6
    8 m. Q" A2 H' h
96. #define QSPI_BK1_D3_GPIO_PORT           GPIOF
    6 }+ R* l; V% h0 B0 p2 F: Z
97. #define QSPI_BK1_D3_GPIO_AF             GPIO_AF9_QUADSPI
    ' ~7 C0 C: B' }1 O2 A! I$ x' ]
98. #endif

复制代码

/ a4 S7 F: W, x- r+ U' C硬件设置了之后，剩下就是QSPI Flash相关的几个配置，在文件bsp_qspi_w25q256.h：

; c' L$ w5 m* p* l4 h主要是下面这几个：

1. #define QSPI_FLASH_MEM_ADDR         0x90000000
   
2. 
   . x  C4 \( _. h, x. @, @
3. /* W25Q256JV基本信息 */
   * K, k+ x/ N3 A3 D# I; M5 i3 F
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字节 */
   
7. #define QSPI_END_ADDR       (1 << QSPI_FLASH_SIZE)  /* 末尾地址 */
   
8. #define QSPI_FLASH_SIZES    32 * 1024 * 1024         /* Flash大小，2^25 = 32MB*/
   1 {: B; C2 D6 p# ^
9. 
   % `! Z' @) ?, D
10. /* W25Q256JV相关命令 */
    
11. #define WRITE_ENABLE_CMD                        0x06    /* 写使能指令 */
    8 V( K( p9 g# r: [1 [3 w
12. #define READ_ID_CMD2                            0x9F    /* 读取ID命令 */
    
13. #define READ_STATUS_REG_CMD                     0x05    /* 读取状态命令 */
    $ ^, s5 ~; V; L5 @
14. #define SUBSECTOR_ERASE_4_BYTE_ADDR_CMD         0x21    /* 32bit地址扇区擦除指令, 4KB */
    $ L' j& s6 @, @' l0 \" H
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. 
    
18. #define BLOCK_ERASE_64K_4_BYTE_ADDR_CMD         0xDC    /* 4字节地址，64K扇区 */
    7 X% }( B. e; j3 s
19. 
    
20. #define BULK_ERASE_CMD                          0xC7    /* 整片擦除 */

复制代码

0 B6 N% W8 X6 V; S( k81.6 QSPI Flash的STM32CubeProg下载算法使用方法
+ k$ N" }0 ?2 ~6 o8 L% x1 L编译本章教程配套的例子，生成的算法文件位于此路径下：
+ ?2 O5 W( i/ M; ]. V  d0 l1 ^
' z, Z9 D+ j& {) J

2 f7 [% d9 W; T( ~% i" _
81.6.1 下载算法存放位置
3 R7 X3 L; {% B, N生成此文件后，需要大家将其存放到STM32CubeProg安装目录路径：
% t0 f* O% d* K3 B! f8 @  t2 h
\STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader

, p6 ^3 @9 d2 I
0 Q& I) _% K8 D5 z1 r% Y* w81.6.2 STM32CubeProg下载配置
我们这里以STLINK连接开发板为例进行说明（USB DFU或者串口方式不支持下载外部Flash）。
# T: m5 K) p, }# Y
& l+ o' N5 M% [3 l: E: k

3 W& F& W/ _" ^) O! t点击Connect后效果如下：
  j8 w$ M: J( F' P, }& P& F4 Y

, L% x# I/ G6 f# n3 S* j: B
3 @; {6 {: ^. {" W1 ]在这里选择我们制作的下载算法：

7 Y. ^+ _* w- F

2 y( w! S) I& D8 Q7 h" y: i" u
/ ?/ I, y2 _! H! S# Y0 I任意加载个hex或者bin文件，并按照如下配置，然后点击Start Programming
4 H9 f/ H/ ~1 q0 i1 A; x# E3 G% i

9 |+ a) X" y/ A下载完成后的效果如下：

) b' r4 Z9 n5 K  G6 T# c# g81.6.3 验证算法文件是否可以正常使用
1 t0 V3 r( J! X: C# C8 P为了验证算法文件是否可以正常使用，大家可以运行本教程第82章或者83章配套的例子。也可以使用STM32CubeProg直接读取：

* c1 `6 F* g& Q# }+ ^1 W

/ ^3 e3 n% s6 ^7 F! G8 y81.7 实验例程说明
本章配套例子：V7-061_QSPI Flash的STM32CubeProg下载算法制作。

4 S# l2 m6 q9 a& V8 M编译本章教程配套的例子，生成的算法文件位于此路径下：
+ O( m! {. [; i

. h- B- w# N" j7 P. L- \7 L8 B81.8 总结
0 I: N: |) C' Y  d  ?本章节就为大家讲解这么多，为了熟练掌握，大家可以尝试自己实现一个Flash下载算法。


% l: ~7 l# o, q2 }