81.1 初学者重要提示
  QSPI Flash的相关知识点可以看第78章和79章。
  QSPI Flash下载算法文件直接采用HAL库制作，方便大家自己修改。
$ k+ d2 K% Q7 N: ?' d: L/ g+ u  STM32CubeProg下载算法制作和MDK下载算法制作基本是一样
  本教程的第68章USB DFU和第69章串口IAP章节为大家介绍过STM32CubeProg的用法。
81.2 STM32CubeProg简介
* ]) s/ \, R! M) ?3 w6 ^STM32CubeProg，此软件实现了之前的 DfuSe，STLINK 小软件和 Flashloader 三合一，并且支持外部 EEPROM，NOR Flash，SPI Flash，NAND Flash 等烧写，也支持 OTA 编程。
* Y% a: i0 G" ]6 k" r' R' s8 U
  ~: [4 p' }) {# S: }8 A+ z3 b$ ]

+ h+ T* }! u7 h' s, L81.3 STM32CubeProg下载算法基础知识
STM32CubeProg下载算法是一种用于擦除应用程序或将应用程序下载到Flash的程序代码。ST自家的芯片都自带下载算法，存放在STM32CubeProg安装目录里面，但不支持的需要我们自己制作，本章教程为此而生。
8 _' F7 m# {- X+ X
81.3.1 程序能够通过下载算法下载到芯片的核心思想
6 L7 d* ?* f; }0 ?! X! O* O6 @1 F认识到这点很重要：通过IDE开发环境创建一批与地址信息无关的算法文件，实现的功能主要有初始化，擦除，编程，读取，校验等，然后STM32CubeProg下载阶段，会将算法文件加载到芯片的内部RAM里面，然后STM32CubeProg通过与这个算法文件的交互，实现程序下载，数据读取等操作。

, T8 \$ a4 O  U, g9 @81.3.2 算法程序中擦除操作执行流程
4 d! }, e4 n$ p1 m! @9 p% w9 x+ y注：下面是MDK的算法执行流程，STM32CubeProg是类似的。

: m6 o5 C, ^" b" y( y$ @擦除操作大致流程：
. z5 f/ I# M- |, L, e  r- s$ }
7 |# j  W: m% b4 K! \" q+ O- A

1 A' G- A# q" c  D% x
, a% v- M7 N" U1 M8 q  加载算法到芯片RAM。
  执行初始化函数Init。
  执行擦除操作，根据用户配置，这里可以选择整个芯片擦除或者扇区擦除。
# n2 k+ v" t; X  执行Uinit函数。
% Q! C6 i/ Q' t$ `2 ?" D2 k; V  操作完毕。
  D3 p" B( f2 k1 _+ o% i3 P81.3.3 算法程序中编程操作执行流程
9 U7 {  _5 B, g注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。
) m( A% S6 M2 k3 t- Q" U
编程操作大致流程：
' k$ e( {6 X( D- k0 l9 B# i
9 @9 z# A: l4 H2 N

  针对IDE生成的axf（elf）可执行文件做Init初始化，这个axf（elf）文件是指的大家自己创建应用程序生成的。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
  加载算法到RAM。
  执行Init函数。
: F8 u( R& q0 }) \/ a- j  加载用户到RAM缓冲。
/ M% c5 K& s! H- D  执行Program Page页编程函数。
# n6 m& G7 X" q% K1 d  执行Uninit函数。
  操作完毕。
! p4 j, d! W9 Q4 O: R* k81.3.4 算法程序中校验操作执行流程
- q4 e; G8 f# k" j% O, D5 G2 [注：下面是MDK的算法执行流程，STM32CubeProg是类似的（没有Unint函数）。
; y3 m2 [+ H6 \
7 M% `5 O8 j0 z, O! T校验操作大致流程：

! L2 i  t0 L* [' K4 S
( P- w5 U) [- K. M, F  校验要用到IDE生成的axf（elf）可执行文件。校验就是axf（elf）文件中下载到芯片的程序和实际下载的程序读出来做比较。
  查看Flash算法是否在FLM文件。如果没有在，操作失败。如果在：
  加载算法到RAM。
* x  ^& x- q' K4 P  执行Init函数。
  查看校验算法是否存在
6 R/ v; g; e/ P  如果有，加载应用程序到RAM并执行校验。
* V. Z6 M3 f: `2 r' d. c5 R- G  如果没有，执行计算CRC，将芯片中读取数据出来和RAM中加载应用计算输出的CRC值做比较。
$ h! Z3 }- @  \& y: d  执行Uninit函数。
. x6 K$ i5 q( t  L  替换BKPT（BreakPoint断点指令）为 B. 死循环指令。
  执行RecoverySupportStop，回复支持停止。
  执行DebugCoreStop，调试内核停止。
) e4 n/ O! M0 i" B8 R5 m  运行应用：
( z' q) X# A6 q0 ~$ a5 V  执行失败
( l. K0 k, U; S9 N! T9 I! U" a) k; {  执行成功，再执行硬件复位。
  操作完毕，停止调试端口。
. X8 H% H9 e7 `! y% i6 Z$ L/ v81.4 创建STM32CubeProg下载算法通用流程
下面是STM32CubeProg给的一种大致操作流程，不限制必须采用这种方法，自己创建也可以的。
( V) R0 q) P$ M" w' ?; f/ j, F
81.4.1 第1步，使用STM32CubeProg提供好的程序模板
位于路径：STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader

5 W3 m* f. g8 b. o4 @2 s& @
以M25P64为例（注，其余步骤就以这个为例子进行说明）：

81.4.2 第2步，修改工程名
STM32CubeProg提供的工程模板原始名字是M25P64_STM3210E-EVAL.uvproj，大家可以根据自己的需要做修改。比如修改为MyDevice.uvproj（MDK4的后缀）或者MyDevice.uvprojx（MDK5的后缀）。
/ e1 a% ^* b$ @8 d1 ?
81.4.3 第3步，修改使用的器件
: h7 `' S( z! B0 |* B在MDK的Option选项里面设置使用的器件。

8 M6 Z+ q+ [! h7 ~! Q0 U: q

81.4.4 第4步，修改输出算法文件的名字
这个名字是方便用户查看的，比如设置为stm32h7，那么输出的算法文件就是stm32h7.stldr。
  [( ^2 {1 D0 m
" D* U1 }2 k, W1 x1 g4 o, O4 S

注：STM32CubeProg软件里面别的文件名并不采用这个，而是由用户在文件Dev_Inf.c里面定义的：
3 n% i3 i; ~2 l5 U+ S

0 Z# [5 x2 f' @. _
' h* [+ U; v6 _* l7 Z7 P/ @81.4.5 第5步，修改使用的库文件和头文件路径
/ d' M8 ~$ c. q# L" x0 {+ d根据大家使用的主控芯片，添加相应的库文件和头文件路径。

81.4.6 第5步，修改编程算法文件Loader_Src.c
模板工程里面提供的是M25P64，部分代码如下：
+ X+ F5 F+ W4 s* \' o' J

1. /**
   
2.   * Description :
   
3.   * Initilize the MCU Clock, the GPIO Pins corresponding to the
   
4.   * device and initilize the FSMC with the chosen configuration
   / L( x1 r: X- c0 [+ ~
5.   * Inputs    :
   + R- Y# M0 F$ f; `& C$ l3 P! Q
6.   *      None
   8 b( M% N! ]. v9 A
7.   * outputs   :
   
8.   *      R0             : "1"             : Operation succeeded
   
9.   *               "0"             : Operation failure
   / U9 N, H% ]; |
10.   * Note: Mandatory for all types of device
    2 o9 r# R2 E6 K6 h
11.   */
    $ H0 o5 [# Y, }9 T' ^7 l: W# `; ^
12. int Init (void)
    
13. {  
    9 D! o: l+ @) b) i
14.   SystemInit();
    
15.   sFLASH_Init();
    / ]# }- ?* b1 X& @. V$ P- n- t
16.   return 1;
    - r5 j6 O! m; `
17. }
    
18. 
    ) }) m$ D5 }( O  G& ^' G+ N
19. 
    * {3 G  w! A, d
20. /**
    1 `3 V: ~& W/ r4 o: ^
21.   * Description :
    4 a$ ]! \+ o3 h% {/ _) S, K: Y- R
22.   * Read data from the device
    
23.   * Inputs    :
    
24.   *      Address       : Write location
    
25.   *      Size          : Length in bytes  
      B  T+ F7 j% r% t/ W
26.   *      buffer        : Address where to get the data to write
    
27.   * outputs   :
    / h( C5 u' L& f+ l" J" e( a2 m1 r
28.   *      R0             : "1"             : Operation succeeded
    
29.   *               "0"             : Operation failure
    8 f+ p9 F9 _5 A4 u# @# |# M1 `
30.   * Note: Mandatory for all types except SRAM and PSRAM   
    % z0 Y4 C+ m  f, _. ~
31.   */
    
32. int Read (uint32_t Address, uint32_t Size, uint8_t* buffer)
    2 x( d4 T, ^. \! J3 B
33. {
    0 D) f7 A4 x9 O) D
34.   sFLASH_ReadBuffer(buffer, Address, Size);
    
35.   return 1;
    
36. }
    
37. 
    7 n: C- i7 |  V" g5 C
38. 
    
39. /**
    
40.   * Description :
    
41.   * Write data from the device
      M/ `# |  e, r3 H9 {: R: u! p9 z
42.   * Inputs    :
    
43.   *      Address       : Write location
    
44.   *      Size          : Length in bytes  
    0 n) J0 T# q$ C; ]
45.   *      buffer        : Address where to get the data to write
    
46.   * outputs   :
    
47.   *      R0           : "1"             : Operation succeeded
    % p1 ~" X1 i5 o& j7 W& S" W
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. {
    0 C0 I/ }5 C5 x# |8 o7 z; j" Z: D
53.   sFLASH_WriteBuffer(buffer, Address, Size);
    6 n: h8 D" m* a6 I/ b: I9 b
54.   return 1;
    0 m- l5 q  P, g4 N/ i
55. }
    - T; l; E3 C) U* Q' ]1 E* y
56. 
    % d* ~) d* P( x
57. 
    
58. /**
    8 C4 ^- }: k& g' y4 d! R8 {/ `
59.   * Description :
    
60.   * Erase a full sector in the device
    
61.   * Inputs    :
    
62.   *     None
    ; Z: {  I' @# h% u9 Z  ?8 E+ Y
63.   * outputs   :
    
64.   *     R0             : "1" : Operation succeeded
    
65.   *              "0" : Operation failure
    7 V& \5 I7 h! ^( A; X
66.   * Note: Not Mandatory for SRAM PSRAM and NOR_FLASH
    * Y9 x) }, k& ?- m9 k
67.   */
    
68. int MassErase (void)
    
69. {  
    
70.   sFLASH_EraseBulk();
    
71.   return 1;   
    
72. }

复制代码

81.4.7 第6步，修改配置文件Dev_Inf.c
& }5 k' ]3 g- Z- ]" E5 v& f& z模板工程里面提供简单的配置说明：
, @3 `! @) T/ [- q4 i( Q3 |1 k3 h
, x$ J- \1 n9 B: }1 S+ Z

1. #if defined (__ICCARM__)
   
2. __root struct StorageInfo const StorageInfo  =  {
   
3. #else
   
4. struct StorageInfo const StorageInfo  =  {
   
5. #endif
   
6.    "M25P64_STM3210E-EVAL",           // Device Name + version number
   
7.    SPI_FLASH,                       // Device Type
   ) b9 M2 E5 t. w" P, w) L
8.    0x00000000,                     // Device Start Address
   ! v2 m2 N% g- N) t
9.    0x00800000,                      // Device Size in Bytes (8MBytes/64Mbits)
   1 X) X$ |) l5 |# j" T% W
10.    0x00000100,                      // Programming Page Size 16Bytes
    ( x' L, _9 m% j$ i* }. u5 S
11.    0xFF,                            // Initial Content of Erased Memory
    
12. // Specify Size and Address of Sectors (view example below)
    
13.    0x00000080, 0x00010000,          // Sector Num : 128 ,Sector Size: 64KBytes
    
14.    0x00000000, 0x00000000,
    2 q4 s9 Q- G$ \: ?2 ]
15. };

复制代码

: y5 r* N3 n9 a$ d注：名字M25P64_STM3210E-EVAL就是我们第4步所说的。STM32CubeProg会识别出这个名字。
! t! [' [6 T9 ~( x& d. l


81.4.8 第7步，保证生成的算法文件中RO和RW段的独立性，即与地址无关。
C和汇编的配置都勾选上：
6 P" ~1 A3 b& w6 C3 O

1 n5 }) D( ]) j2 }汇编：

9 u' D0 t( N% U, ~$ X

如果程序的所有只读段都与位置无关，则该程序为只读位置无关（ROPI, Read-only position independence）。ROPI段通常是位置无关代码（PIC,position-independent code），但可以是只读数据，也可以是PIC和只读数据的组合。选择“ ROPI”选项，可以避免不得不将代码加载到内存中的特定位置。这对于以下例程特别有用：

' d. q6 {4 z* E0 Q  K# n/ D（1）加载以响应运行事件。
9 [. f8 A2 F) K( F8 M- g8 h
（2）在不同情况下使用其他例程的不同组合加载到内存中。
: s, P' Y% W" l2 O8 X- s
# r1 X, y& K% j, c（3）在执行期间映射到不同的地址。
: {; z' `3 t8 h& r; }1 F
! ~. Q- R! b3 }& D+ h" w% X使用Read-Write position independence同理，表示的可读可写数据段。
$ y( B7 ^% r. M4 x
2 h: ^' s, N" ^3 ?: S. K) F7 F81.4.9 第8步，将程序可执行文件axf修改为stldr格式
/ K' [- _! Z* }/ C% a8 Z' [通过下面的命令就可以将生成的axf可执行文件修改为stldr。

7 M4 C$ ?( `$ d) p; u& Z

  X' j# H  ]- ?81.4.10   第9步，分散加载设置
我们这里的分散加载文件直接使用MDK模板工程里提供好的即可。

1 W' `* \- X9 f7 c) G

% F( K5 A# ~* B. R0 [6 C- h分散加载文件中的内容如下：

7 n+ ?; ]  E: E6 j4 a) b

1. FLASH_LOADER 0x20000004 PI   ; FlashLoader Functions
   9 L6 m# E1 v- {9 |  [; a
2. {
   % @# q) e7 f) Z. O& t4 W& K; S
3.   PrgCode +0           ; Code
   0 P2 C1 D$ |6 z: S: g0 h3 g
4.   {
   
5.     * (+RO)
   4 h& W5 ?; Q" O
6.   }
   ' Y* d* d5 z# l
7.   PrgData +0           ; Data
   
8.   {
   ' [8 S" p0 y3 n9 J- M1 o* F
9.     * (+RW,+ZI)
   
10.   }
    
11. }
    4 M$ Y2 Q3 ~1 Z
12. 
    
13. DEVICE_INFO +0               ; Device Info
    ' T  Q8 U$ H# V: y7 M$ Z' J
14. {
    , t6 V5 r7 V" D! g/ _4 _1 L
15.   DevInfo +0           ; Info structure
    
16.   {
    5 e. \' q% h5 t  x; d9 _! L
17.     dev_inf.o
    4 q6 A9 }3 g1 h4 o" R- g
18.   }
    
19. }

复制代码

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

--diag_suppress L6305用于屏蔽L6503类型警告信息。

! S! Q5 [2 f" d5 R0 K特别注意，设置了分散加载后，此处的配置就不再起作用了：

# J, ~. m) ?& `* ]

  }$ ^3 I7 P+ q2 M
* t$ m! h6 c$ h. ?9 l& k: z- n0 m81.5 QSPI Flash的STM32CubeProg下载算法制作
+ Z$ H4 E  r5 r下面将QSPI Flash算法制作过程中的几个关键点为大家做个说明。
# [$ {2 b0 @: \- t4 A: d& X; u
' Z# `) u. _. f. V  E) Z* ~81.5.1 第1步，制作前重要提示
! L$ j  b, m$ _5 S5 U% n这两点非常重要：

  程序里面不要开启任何中断，全部查询方式。
  HAL库里面各种时间基准相关的API全部处理掉。简单省事些，我们这里是直接注释，采用死等即可。无需做超时等待，因为超时后，已经意味着操作失败了，跟死等没有区别。
: {4 |/ }8 E. d" }" h. I81.5.2 第2步，准备一个工程模板
推荐大家直接使用我们本章工程准备好的模板即可，如果大家自己制作，注意一点，请使用当前最新的HAL库。

9 ~" x% ?. `/ j9 _8 \4 z

" B, A9 u7 x# \  `  b* A81.5.3 第3步，修改HAL库
" t: W; \) ?5 v5 P这一步比较重要，主要修改了以下三个文件：

7 ]: ~9 I+ D6 I0 |2 E5 W9 a

; |/ C* a5 b* `* {/ ]主要是修改了HAL库时间基准相关的几个API，并注释掉了一批无关的API。具体修改内容，大家可以找个比较软件，对比修改后的这个文件和CubeH7软件包V1.8.0（软件包里面的HAL库版本是V1.9.0）的差异即可。
' D9 K5 `' m5 ?5 c5 k& w
+ @* D& L7 ?6 {( V5 J81.5.4 第4步，时钟初始化
我们已经用不到滴答定时器了，直接在bsp.c文件里面对滴答初始化函数做重定向：

- @+ K: j" J* B0 s5 W0 {4 C. l

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: HAL_InitTick
   
4. *    功能说明: 重定向，不使用
   : s: J" C' e3 V$ E$ \8 _
5. *    形    参: TickPriority
   2 @; Z8 F- E' s0 E! s
6. *    返 回 值: 无
   . x+ R* v1 i, [; \" W
7. *********************************************************************************************************
   1 p7 O4 J2 x& Y4 u* ~) S) q
8. */
   
9. HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority)
   
10. {
      _( q; l/ Y6 g: {( v
11.     return HAL_OK;
    " f$ c9 u. e1 N- s
12. }

复制代码

8 z: }* u  P( y  Q. K然后就是HSE外置晶振的配置，大家根据自己的板子实际外挂晶振大小，修改stm32h7xx_hal_conf.h文件中HSE_VALUE大小，实际晶振多大，这里就修改为多大：

1. #if !defined  (HSE_VALUE)
   ! f7 E- {* N) \) Q* a0 z
2. #define HSE_VALUE    ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
   
3. #endif /* HSE_VALUE */

复制代码

2 V) ?. S/ m+ s5 A8 S/ {最后修改PLL：

) [$ ?/ B& y" `( z

1. /*
   
2. *********************************************************************************************************
   . R, `3 w" L5 A7 `' b8 S, a8 {
3. *    函 数 名: SystemClock_Config
   ; [$ u% I4 Y, u& \; ]  V' _
4. *    功能说明: 初始化系统时钟
   & L5 C& d9 v$ D. H( Z! n& Y
5. *                System Clock source            = PLL (HSE)
   & @/ S( I$ [6 W6 l
6. *                SYSCLK(Hz)                     = 400000000 (CPU Clock)
   
7. *               HCLK(Hz)                       = 200000000 (AXI and AHBs Clock)
   - _5 ~: A' ?1 V4 L
8. *                AHB Prescaler                  = 2
   
9. *                D1 APB3 Prescaler              = 2 (APB3 Clock  100MHz)
   
10. *                D2 APB1 Prescaler              = 2 (APB1 Clock  100MHz)
    + M8 y! d. j" X/ b1 V4 X# O( Q  V9 [
11. *                D2 APB2 Prescaler              = 2 (APB2 Clock  100MHz)
    & g6 U5 p* J4 t0 O
12. *                D3 APB4 Prescaler              = 2 (APB4 Clock  100MHz)
    
13. *                HSE Frequency(Hz)              = 25000000
    
14. *               PLL_M                          = 5
    * c; a5 Z, {- o' I: Q
15. *                PLL_N                          = 160
    ' S6 m0 J) R- ?7 m1 n! y
16. *                PLL_P                          = 2
    
17. *                PLL_Q                          = 4
    ' R1 H. V( R1 U# Z! p
18. *                PLL_R                          = 2
    
19. *                VDD(V)                         = 3.3
    
20. *                Flash Latency(WS)              = 4
    
21. *    形    参: 无
    
22. *    返 回 值: 1 表示失败，0 表示成功
    & D% r/ K- a3 ~; K( a
23. *********************************************************************************************************
    
24. */
    
25. int SystemClock_Config(void)
    5 ^1 t+ c0 s( u2 g
26. {
    
27.     RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    9 a4 G" p1 O& M5 P! D1 S
28.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    8 g6 U- p4 I: }1 ~7 `: G
29.     HAL_StatusTypeDef ret = HAL_OK;
    + U2 {$ G0 @: t0 [
30. 
    . F# A, P$ H8 g
31.     /* 锁住SCU(Supply configuration update) */
    
32.     MODIFY_REG(PWR->CR3, PWR_CR3_SCUEN, 0);
    3 \% q; f( `% i' `: Y
33. 
    
34.     /*

复制代码

2 b& C# `# v, [6 n" }$ M& {  X      1、芯片内部的LDO稳压器输出的电压范围，可选VOS1，VOS2和VOS3，不同范围对应不同的Flash读速度，
0 G- s5 d# s4 o" S* h3 M         详情看参考手册的Table 12的表格。
      2、这里选择使用VOS1，电压范围1.15V - 1.26V。
" B, j, [+ O7 D; n   

1. */
   * @$ N$ j) ~2 O; d
2.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
   
3. 
   , g+ t( A8 R9 d
4.     while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
   & h5 @1 g2 B/ s! g
5. 
   8 d! j0 D" x9 T; r5 o
6.     /* 使能HSE，并选择HSE作为PLL时钟源 */
   ! w% T7 w6 Y. k& W" S. M( y
7.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
   2 x4 t1 `5 H% C0 S" S
8.     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
   
9.     RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
   3 {; u+ E: B* _/ ~, T0 }
10.     RCC_OscInitStruct.CSIState = RCC_CSI_OFF;
    2 ?+ s$ s& v4 h2 i7 @! O" i' M5 Q
11.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    ) @8 I  }9 z! k# a. ^/ h) f' ^5 G
12.     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    $ c) v$ K" q5 D4 Z/ Q9 P* `( n
13. 
    
14.     RCC_OscInitStruct.PLL.PLLM = 5;
    5 U0 G& O5 t7 h9 i
15.     RCC_OscInitStruct.PLL.PLLN = 160;
    
16.     RCC_OscInitStruct.PLL.PLLP = 2;
      w% I+ I  `, Y' U2 N+ F7 w; A
17.     RCC_OscInitStruct.PLL.PLLR = 2;
    
18.     RCC_OscInitStruct.PLL.PLLQ = 4;        
    
19. 
    8 T( Q* O  [/ F2 [! \- B8 ~+ N
20.     RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
    $ D3 r4 a: e- F! ]3 V
21.     RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;   
    
22.     ret = HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
23.     if(ret != HAL_OK)
    ' ?) Y3 [+ L  q/ m5 d: V! ?! W
24.     {
    * l0 n! u( W% ]& T9 z$ J& Y/ c7 V9 X
25.         return 1;        
      h  c1 ]3 t% @6 z. A) i* d
26.     }
    - X% q4 `9 Y; x7 M: q8 e6 c: [6 y4 d0 @
27. 
    . w6 j: T6 t: G, n
28.     /*
    7 D# v( h( d4 s) }9 I1 Q
29.        选择PLL的输出作为系统时钟
    
30.        配置RCC_CLOCKTYPE_SYSCLK系统时钟
    
31.        配置RCC_CLOCKTYPE_HCLK 时钟，对应AHB1，AHB2，AHB3和AHB4总线
    - f% g# l" \0 _: O5 n! u( ~
32.        配置RCC_CLOCKTYPE_PCLK1时钟，对应APB1总线
    % k, X/ w" m* E, ^+ S
33.        配置RCC_CLOCKTYPE_PCLK2时钟，对应APB2总线
    : i/ L. ]7 P, O
34.        配置RCC_CLOCKTYPE_D1PCLK1时钟，对应APB3总线
    
35.        配置RCC_CLOCKTYPE_D3PCLK1时钟，对应APB4总线     
    
36.     */
    / l% F' j5 ]8 |( C* a6 a( M
37.     RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_D1PCLK1 | RCC_CLOCKTYPE_PCLK1 | \
    0 ~7 e9 Y2 e3 B% b, r8 r1 K6 t- J
38.                                  RCC_CLOCKTYPE_PCLK2  | RCC_CLOCKTYPE_D3PCLK1);
    9 M" u" D0 Y* Z8 s) b7 F$ x4 s9 D+ J# D1 F
39. 
    
40.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    8 V, g7 f$ V( c4 v
41.     RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
    6 R! M- g# J% l8 t: {6 m
42.     RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
    3 q( C/ F3 y+ @+ }( }) T& |) s
43.     RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;  
    0 j1 D: b2 B  J/ _4 w# l
44.     RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
    ! W5 O9 W2 \- v
45.     RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
    ' x( m) q% {' x* p9 {$ |
46.     RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
    4 g4 f3 x- {: Y  f# U# D
47. 
    ! G+ z( J+ h: }8 S. N+ k0 b3 I! B3 R
48.     /* 此函数会更新SystemCoreClock，并重新配置HAL_InitTick */
    ' x5 t7 g3 Z8 P7 H2 a4 ^; o9 v5 ~% t+ n: ?
49.     ret = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4);
    . j" W, e4 p) H
50.     if(ret != HAL_OK)
    " f7 p; h# N( F+ ~9 O6 s
51.     {
    
52.         return 1;
    
53.     }
    , X. Y. k5 T, z7 S+ `* }% `# ]1 k
54. 
    
55.     /*
    
56.       使用IO的高速模式，要使能IO补偿，即调用下面三个函数
    : t; F0 C1 J" Z" Y" |1 G3 L# [
57.       （1）使能CSI clock
    
58.       （2）使能SYSCFG clock
    
59.       （3）使能I/O补偿单元， 设置SYSCFG_CCCSR寄存器的bit0
    
60.     */
    
61.     __HAL_RCC_CSI_ENABLE() ;
    2 \; V4 W& q, m" I! V
62. 
    0 c8 b$ |0 t/ `0 @8 j, ^* w
63.     __HAL_RCC_SYSCFG_CLK_ENABLE() ;
    - i, m( c9 u( g( L1 N9 [4 B% o
64. 
    + _: W' L9 \( i
65.     HAL_EnableCompensationCell();
    
66. 
    ' ?* v$ m! |+ T% [3 {0 q
67.     __HAL_RCC_D2SRAM1_CLK_ENABLE();
    
68.     __HAL_RCC_D2SRAM2_CLK_ENABLE();
    
69.     __HAL_RCC_D2SRAM3_CLK_ENABLE();
    
70. 
    
71.     return 0;
    
72. }

复制代码

81.5.5 第5步，配置文件Dev_Inf.c的实现
* l! G9 Z/ M1 V' r  P  z4 N配置如下：

1. #if defined (__ICCARM__)
     s" [2 L& v' s' K7 G, \/ f
2. __root struct StorageInfo const StorageInfo  =  {
   $ a7 i1 i4 l, t2 a( |8 }7 n) f" A
3. #else
   1 |8 Y* u9 r0 P$ q
4. struct StorageInfo const StorageInfo =  {
   : ?" q( n5 p9 A5 E" v8 R" `
5. #endif
   
6.     "ARMFLY_STM32H7x_QSPI_W25Q256", /* 算法名，添加算法到STM32CubeProg安装目录会显示此名字 */
   9 q+ n0 f' F5 L  r3 T! s; h! @
7.     NOR_FLASH,                      /* 设备类型 */
   
8.     0x90000000,                     /* Flash起始地址 */
   3 x" U+ P# n! J  l3 O. g
9.     32 * 1024 * 1024,               /* Flash大小，32MB */
   # {0 m& N3 e2 `/ |
10.     4*1024,                         /* 编程页大小 */
    & ^( C$ q# s9 J! r4 K
11.     0xFF,                           /* 擦除后的数值 */
    * r0 |8 K  j. a" q' T+ Y
12.     512 , 64 * 1024,                /* 块个数和块大小 */
    / h9 I4 ]$ s. h6 B; b: C- u
13.     0x00000000, 0x00000000,
    7 P9 s0 N7 |. ?  B6 L  p3 @
14. };

复制代码

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

* R) T# \9 Q: s

5 T3 o- i4 R( |) P: b, R
0 [* ^  C( y0 ]  w; ~  f1 G81.5.6 第6步，编程文件Loader_Src.c的实现
下面将变成文件中实现的几个函数为大家做个说明：
  d5 V$ L  w# l5 W
  初始化函数Init
3 P4 e, B" g1 a

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: Init
   
4. *    功能说明: Flash编程初始化
   
5. *    形    参: 无
   
6. *    返 回 值: 0 表示失败， 1表示成功
   & y1 p4 F, l- _7 n
7. *********************************************************************************************************
   - F, ]9 e% Q: [$ F
8. */
   / L$ e% x) n: u. a, I" Q  }/ [
9. int Init(void)
   ! }* ~$ i- t8 ^  a7 |, T: _: y
10. {   
    
11.     int result = 1;
    ' c( a1 X. |1 k& P: D# G: E$ I3 X3 E
12. 
    
13.     /* 系统初始化 */
    7 g* c1 ]9 Z1 ?- Q- @* g8 j9 l
14.     SystemInit();
    ! g, `. H8 L- t4 h1 Y  h
15. 
    ' C7 Q" l" W3 ~) X3 q& ]
16.     /* 时钟初始化 */
    & p  M9 |$ Y# o. q8 D# \. g- O
17.     result = SystemClock_Config();
    % s3 _5 H- y& o5 P  D7 I2 `# `
18.     if (result == 1)
    
19.     {
    * X$ C; @7 T8 x% P$ c
20.         return 0;        
    
21.     }
    3 {% E7 @2 a* f; I# [
22. 
    ( N' v& ~( G! a% G9 V) N& z
23.     /* W25Q256初始化 */
    
24.     result = bsp_InitQSPI_W25Q256();
    " Q* j& [0 m& D4 E  g
25.     if (result == 1)
    3 F7 ^% ~9 P3 B0 [" X. j$ X
26.     {
    
27.         return 0;
    
28.     }
    5 v2 d  f  @; w; J& S2 ?
29. 
    
30.     /* 内存映射 */   
    9 M; @' l9 i# q3 d; E6 q
31.     result = QSPI_MemoryMapped();
    . K. r8 R  Z1 v
32.     if (result == 1)
    / j+ l% m) |, u( M9 f5 o1 i
33.     {
    # {5 a  [9 |+ C
34.         return 0;
    
35.     }
    7 \8 b# g( D3 q: ]
36. 
    
37.     return 1;
    % d) A- c* o+ T8 |! V+ r$ Y
38. }

复制代码

初始化完毕后将其设置为内存映射模式。

3 t" \; Z& W& b  整个芯片擦除函数MassErase
- P- P8 V7 _! z. W* ~/ U. r整个芯片的擦除实现如下：

( p7 a4 L7 Y, c1 t

1. /*
   / Q& G  b" t% u7 g! n9 I
2. *********************************************************************************************************
   0 X1 j; c- g) w1 Y, z7 F$ w
3. *    函 数 名: MassErase
   $ `  P6 L% U/ j
4. *    功能说明: 整个芯片擦除
   0 c5 W7 ]/ @0 u1 N  {4 W
5. *    形    参: 无
     o$ W! V' ~: r- G7 Q/ k
6. *    返 回 值: 1 表示成功，0表示失败
   6 V7 |6 a- h& h, N" m/ @
7. *********************************************************************************************************
   
8. */
   
9. int MassErase(void)
   ( \4 f  z; n1 \8 ~* j
10. {
    1 R6 c. D2 Y. o9 {( {  |
11.     int result = 1;
    ' {. P0 g- A. }: \4 e5 {6 ?
12. 
    1 N" S! L% y& n3 j/ l
13.     /* W25Q256初始化 */
    
14.     result = bsp_InitQSPI_W25Q256();
    0 @0 o- W7 T9 p% q* k7 Y0 a& ?* W
15.     if (result == 1)
    
16.     {
    
17.         return 0;
    ) Z: B* ?7 R2 l+ \" l- f- n
18.     }
    
19. 
    2 t8 c( g, T) _8 T- O. r
20.     result = QSPI_EraseChip();
    : b% [' b2 j) e
21.     if (result == 1)
    7 V' f! E% Y: C
22.     {
    
23.         return 0;
    : D0 D( S1 `$ H4 K
24.     }   
    & ~" h% W: r5 Z3 k3 n
25. 
    
26.     /* 内存映射 */   
    
27.     result = QSPI_MemoryMapped();
    
28.     if (result == 1)
    
29.     {
    
30.         return 0;
    / h- N9 _3 U7 R/ _, M) ^
31.     }
    , i( w: A9 I" D
32. 
    
33.     return result;         
    ; {: m, Y6 i; \& Y7 C" T
34. }

复制代码

2 e3 A* e! K  s$ ^  扇区擦除函数SectorErase
- L& u: [+ S6 ^( @; O$ X/ m- Z扇区擦除实现：

: M4 |9 X4 y1 q

1. /*
   7 Y* i, `6 D% a. r
2. *********************************************************************************************************
   
3. *    函 数 名: SectorErase
   
4. *    功能说明: EraseStartAddress 擦除起始地址
   " u6 k' ~- m0 j
5. *             EraseEndAddress   擦除结束地址
   6 O- H* }0 @' q0 M/ M1 i% r2 A
6. *    形    参: adr 擦除地址
   : w  t$ m$ h6 Z% Y/ g$ y
7. *    返 回 值: 1 表示成功，0表示失败
     F3 j5 U! v: m
8. *********************************************************************************************************
   3 f& a6 ]" c! ~  O
9. */
   
10. int SectorErase (uint32_t EraseStartAddress ,uint32_t EraseEndAddress)
    
11. {
    
12.     uint32_t BlockAddr, result;
    ) u8 X. u: N/ G* ]
13. 
    
14.     EraseStartAddress -= QSPI_FLASH_MEM_ADDR;
    ; Z8 \) m6 L# V3 u4 b
15.     EraseEndAddress -= QSPI_FLASH_MEM_ADDR;
    
16.     EraseStartAddress = EraseStartAddress -  EraseStartAddress % 0x10000; /* 64KB首地址 */
    
17. 
    ; y7 A* H5 Z2 c/ |# @- d
18.     /* W25Q256初始化 */
    
19.     result = bsp_InitQSPI_W25Q256();
    . `* m# F' d% ?8 H* f# d! z  x  K
20.     if (result == 1)
    
21.     {
    
22.         return 0;        
    
23.     }
    
24. 
    
25.     while (EraseEndAddress >= EraseStartAddress)
    
26.     {
    
27.         /* 防止超出256MB空间 */
    0 X0 u9 ]  G( l& Z1 O
28.         BlockAddr = EraseStartAddress & 0x0FFFFFFF;
    
29. 
    
30.         result = QSPI_EraseSector(BlockAddr);   
    
31.         if (result == 1)
    
32.         {
    
33.             QSPI_MemoryMapped();
    
34.             return 0;        
    & y9 h4 q, N& C2 l# Q8 }/ M
35.         }
    : Q$ l2 A2 o+ X3 k
36. 
    3 V! i6 m5 M) n+ |3 a. v
37.         EraseStartAddress += 0x10000;
    / U3 g7 P  ?2 z  d  Q3 `7 z
38.     }
    
39. 
    
40.     /* 内存映射 */   
    
41.     result = QSPI_MemoryMapped();
    
42.     if (result == 1)
    
43.     {
    
44.         return 0;
    + J+ [4 y( l0 @8 j
45.     }
    
46. 
    % O9 G6 @! F1 P, x6 a( ^' P' a
47.     return 1;
    
48. }

复制代码

这里要注意两点：

9 T, c/ y  s& E8 R（1）     程序里面的操作EraseStartAddress-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。
- M9 H, H5 ^3 {9 ~$ J# s$ h
（2）     这里执行的擦除大小要前面Dev_Inf.c文件中配置的扇区大小一致，这里是执行的64KB为扇区进行擦除。

: o7 t6 M8 y& m  页编程函数Write
- D+ Q8 }' H: D; o页编程函数实现如下：

1. int Write(uint32_t Address, uint32_t Size, uint8_t* buffer)
   
2. {
   
3.     int result = 0;
   * y& r/ C2 g4 |
4.     uint32_t end_addr, current_size, current_addr;
   % v. P. R+ Y0 Z" U
5. 
     }- n$ M# w: N1 }
6. 
   : _/ u: z8 G7 x
7.     if (Address < QSPI_FLASH_MEM_ADDR || Address >= QSPI_FLASH_MEM_ADDR + QSPI_FLASH_SIZES)
   ! [/ N: u6 p" y
8.     {
   
9.         return 0;
   
10.     }
      @4 f- W, S) g: M% g( ]
11. 
    7 Y! v9 H+ X: N! n8 J5 Y" f: y5 W2 ~
12.     Address -= QSPI_FLASH_MEM_ADDR;
    
13. 
    
14.     /* 计算写入地址和页末的字节大小 */
    6 {8 m- \. O4 W! n  r# s
15.     current_size = QSPI_PAGE_SIZE - (Address % QSPI_PAGE_SIZE);
    
16. 
    
17.     /* 检测页剩余空间是否够用 */
    
18.     if (current_size > Size)
    
19.     {
    4 }( I2 ]: L" e, U
20.         current_size = Size;
    5 ^1 x% F9 s" D/ c9 W8 I
21.     }
    ' ^/ E! C, w# Y' @" u
22. 
    
23.     /* W25Q256初始化 */
    ) n( b3 G. ]& }1 Z7 A
24.     result = bsp_InitQSPI_W25Q256();
    
25.     if (result == 1)
    . b! x6 ~% D5 L; p+ w  B
26.     {
    + `2 \3 O3 T( v2 f+ c( z4 j
27.         return 0;
    2 _- ]! O9 v. ?
28.     }
    
29. 
    5 z% d0 S9 r2 ?3 d+ N8 g" D
30.     current_addr = Address;
    8 g. Q* M/ n3 ]/ K3 v( x
31.     end_addr = Address + Size;
    7 W. a7 {3 B6 N5 y7 e; s
32. 
    
33.     do{
    
34.         if (QSPI_WriteBuffer(buffer, current_addr, current_size) == 1)
    2 R9 W& S0 Y2 V" s+ H9 Y7 p, n
35.         {
    
36.             QSPI_MemoryMapped();  
    
37.             return 0;  
    4 G$ h. O/ T5 t. h; r" ?
38.         }
    6 I8 A3 k" @- I0 L' c; ^3 B  P
39. 
    
40.         /* 更新地址 */
    
41.         current_addr += current_size;
    " q  }8 O! V5 q2 G& o/ N( s7 ]1 b# Q
42.         buffer += current_size;
    
43.         current_size = ((current_addr + QSPI_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : QSPI_PAGE_SIZE;
    
44. 
    : g' _! v. y+ [; c( r
45.     }while(current_addr < end_addr);
    0 u0 T; g' ]5 [, l% j, W2 x
46. 
    1 C0 z0 w: V5 r+ @
47.     /* 内存映射 */   
    % {  x% z+ v, J. k! i
48.     result = QSPI_MemoryMapped();
    , M  f8 }1 a5 |! p
49.     if (result == 1)
    3 y9 s$ s& C, d# Z
50.     {
    ! @. s3 H3 T( h! F: Y
51.         return 0;
    6 ]3 D" D6 f9 F0 K" P
52.     }
    : r! p& M$ s% _
53. 
    
54.     return (1);  
    . K4 D- l* m1 f  u
55. }

复制代码

这里注意两点：
7 J4 Q$ g) ]) d  p
) [$ ?1 `; X: Z% D（1）     W25Q256的页大小是256字节，前面FlashDev.c中将页编程大小设置为4096字节，所以此程序要做处理。
0 ?+ Q# N* S0 g1 h% Q2 q
（2）     程序里面的操作Address-= QSPI_FLASH_MEM_ADDR，实际传递进来的地址是带了首地址的，即0x90000000。

  读取和校验函数
我们程序中未做读取和校验函数。

（1）     如果程序中未做读取函数，那么STM32CubeProg会以总线方式进行读取，这也是为什么每个函数执行完毕都设置为内存映射模式的原因。
) B/ U% U9 P) W% I$ Z
9 Q8 w3 Y9 I$ K, r: ?5 C+ h（2）     如果程序中未做校验函数，那么STM32CubeProg会读取数据做校验。

81.5.7 第7步，修改QSPI Flash驱动文件（引脚，命令等）
- C$ Z+ E+ _) T: c4 L$ b4 g' A最后一步就是QSPI Flash（W25Q256）的驱动修改，大家可以根据自己的需求做修改。使用的引脚定义在文件bsp_qspi_w25q256.c（做了条件编译，包含了H7-TOOL和STM32-V7板子）：

' J3 k. f, d& o

1. /*
   
2.     STM32-V7开发板接线
   $ G! X: p- X2 V4 N$ k
3. 
   3 f3 f. {9 E) P1 ?
4.     PG6/QUADSPI_BK1_NCS     AF10
     J) u# R) X) b7 v/ q9 C7 }& Z
5.     PF10/QUADSPI_CLK        AF9
   
6.     PF8/QUADSPI_BK1_IO0     AF10
   
7.     PF9/QUADSPI_BK1_IO1     AF10
   0 q: R; ^8 R1 o8 u: J  W7 x
8.     PF7/QUADSPI_BK1_IO2     AF9
   " [* C$ j+ E" ^2 s# X" b) N0 Y: z7 d
9.     PF6/QUADSPI_BK1_IO3     AF9
   
10. 
    
11.     W25Q256JV有512块，每块有16个扇区，每个扇区Sector有16页，每页有256字节，共计32MB
    
12. 
    
13.     H7-TOOL开发板接线
    
14. 
    
15.     PG6/QUADSPI_BK1_NCS     AF10
    
16.     PB2/QUADSPI_CLK         AF9
    / j& S3 o) o! j" {5 P
17.     PD11/QUADSPI_BK1_IO0    AF10
    4 A( P- t8 r) E8 ]9 N: A
18.     PD12/QUADSPI_BK1_IO1    AF10
    
19.     PF7/QUADSPI_BK1_IO2     AF9
    
20.     PD13/QUADSPI_BK1_IO3    AF9
    ' {# E3 v+ ~1 a5 b
21. */
    
22. 
      M  p* L3 C1 k, c
23. /* QSPI引脚和时钟相关配置宏定义 */
    
24. #if 0
    
25. #define QSPI_CLK_ENABLE()               __HAL_RCC_QSPI_CLK_ENABLE()
    
26. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    & r4 `( p2 v1 ?# @, q. A5 o& p( h
27. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    + F5 r2 h% M$ e$ l0 c+ {
28. #define QSPI_CLK_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOB_CLK_ENABLE()
    ( n6 S1 ?6 A! f4 J8 C1 D9 @
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()
    0 Y, U+ ~0 ]1 K5 I- a* D6 J
31. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    $ L4 w- J( k/ Q
32. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOD_CLK_ENABLE()
    
33. 
    * s& e# G% ^2 R/ L4 Q
34. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    3 m% q7 ]( L' K2 _. i( X1 \# ]8 N) X
35. #define QSPI_FORCE_RESET()              __HAL_RCC_QSPI_FORCE_RESET()
    
36. #define QSPI_RELEASE_RESET()            __HAL_RCC_QSPI_RELEASE_RESET()
    . j/ }) [7 E8 f- y
37. 
    ' H" A% G: s. |& l$ O+ r; w
38. #define QSPI_CS_PIN                     GPIO_PIN_6
    
39. #define QSPI_CS_GPIO_PORT               GPIOG
    ' k, N, y# ?% q! y0 F% Q2 r3 h
40. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    3 k' Z' v2 |3 |/ d  n+ {
41. 
    
42. #define QSPI_CLK_PIN                    GPIO_PIN_2
    
43. #define QSPI_CLK_GPIO_PORT              GPIOB
    , F- q" A* |; z  B, C8 ~2 c
44. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    ! j* }( T' z, d3 X! K+ I9 `
45. 
    7 {# n# h1 p5 E; T8 F* f1 ?
46. #define QSPI_BK1_D0_PIN                 GPIO_PIN_11
    ; w5 \1 Y& b, g0 ]5 P+ y
47. #define QSPI_BK1_D0_GPIO_PORT           GPIOD
    
48. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF9_QUADSPI
    8 P( t: m; c; J' j3 _
49. 
    + J5 G& a2 C3 X7 g
50. #define QSPI_BK1_D1_PIN                 GPIO_PIN_12
    
51. #define QSPI_BK1_D1_GPIO_PORT           GPIOD
    ) j2 G0 K( |0 r
52. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF9_QUADSPI
    0 V+ r# ]6 Y/ K% O9 p
53. 
    
54. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    
55. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    ' W2 M% [) M$ s: Q
56. #define QSPI_BK1_D2_GPIO_AF             GPIO_AF9_QUADSPI
    
57. 
    , K- F; E# W# ?; d0 Q
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()
    
63. #define QSPI_CLK_DISABLE()              __HAL_RCC_QSPI_CLK_DISABLE()
    
64. #define QSPI_CS_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOG_CLK_ENABLE()
    + j0 w1 l1 ?' m2 W9 p
65. #define QSPI_CLK_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOF_CLK_ENABLE()
    9 j5 k* L3 e; o3 e9 ~3 w- p
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()
    - y+ Z/ j5 J  J2 [! M, ]% w% D3 {
68. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    7 r, t( J! G- I! c
69. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOF_CLK_ENABLE()
    
70. 
    & ~# [( M! Q& w8 ~- a+ i
71. #define QSPI_MDMA_CLK_ENABLE()          __HAL_RCC_MDMA_CLK_ENABLE()
    
72. #define QSPI_FORCE_RESET()              __HAL_RCC_QSPI_FORCE_RESET()
    1 S3 D7 h3 ^, S& k' h$ w
73. #define QSPI_RELEASE_RESET()            __HAL_RCC_QSPI_RELEASE_RESET()
    1 j$ `( O7 Z8 o
74. 
    + q5 W3 ^4 p, V" G+ q, ~. R
75. #define QSPI_CS_PIN                     GPIO_PIN_6
    + P- C  q/ v8 m$ `) l+ `* c  F! C
76. #define QSPI_CS_GPIO_PORT               GPIOG
    
77. #define QSPI_CS_GPIO_AF                 GPIO_AF10_QUADSPI
    1 g# f+ {4 g5 S; }( K6 ]
78. 
    # T. B% _' n( w; c
79. #define QSPI_CLK_PIN                    GPIO_PIN_10
    0 t' N% Y+ w' V% h0 D
80. #define QSPI_CLK_GPIO_PORT              GPIOF
    ! Z: ^' F, I& n+ Y" T( i# U
81. #define QSPI_CLK_GPIO_AF                GPIO_AF9_QUADSPI
    8 k8 Y9 X: ]5 u8 d
82. 
    / c& Q! c& V& V4 t$ O4 B/ z
83. #define QSPI_BK1_D0_PIN                 GPIO_PIN_8
    
84. #define QSPI_BK1_D0_GPIO_PORT           GPIOF
    " ^( o, m1 n) J$ v; G/ M1 h
85. #define QSPI_BK1_D0_GPIO_AF             GPIO_AF10_QUADSPI
    ! D/ g3 a3 ^4 N6 X+ @0 K
86. 
    
87. #define QSPI_BK1_D1_PIN                 GPIO_PIN_9
    0 S5 U) O- Y1 R2 W- _' M
88. #define QSPI_BK1_D1_GPIO_PORT           GPIOF
    1 W# W1 A- I% e/ J) n* C$ |
89. #define QSPI_BK1_D1_GPIO_AF             GPIO_AF10_QUADSPI
    
90. 
    ! Y1 G9 f* U8 W. K# u! w0 t
91. #define QSPI_BK1_D2_PIN                 GPIO_PIN_7
    
92. #define QSPI_BK1_D2_GPIO_PORT           GPIOF
    
93. #define QSPI_BK1_D2_GPIO_AF             GPIO_AF9_QUADSPI
    
94. 
    
95. #define QSPI_BK1_D3_PIN                 GPIO_PIN_6
    # ?  w) P) h& i" }& h9 R/ A8 o
96. #define QSPI_BK1_D3_GPIO_PORT           GPIOF
    & r0 ^' Y2 |* k( c% Q
97. #define QSPI_BK1_D3_GPIO_AF             GPIO_AF9_QUADSPI
    ) [$ Y* g# C$ _! B
98. #endif

复制代码

% {8 }5 d( p+ e9 {7 _硬件设置了之后，剩下就是QSPI Flash相关的几个配置，在文件bsp_qspi_w25q256.h：
  L$ |3 {% I/ G+ U6 c$ }% Q
主要是下面这几个：

1. #define QSPI_FLASH_MEM_ADDR         0x90000000
   $ a/ C. G" m4 h% o6 H
2. 
   
3. /* W25Q256JV基本信息 */
   8 }/ K7 h' M7 V' Q$ P
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)  /* 末尾地址 */
   " n' t9 x- _1 d' Z- f1 n# H  s- X
8. #define QSPI_FLASH_SIZES    32 * 1024 * 1024         /* Flash大小，2^25 = 32MB*/
   " ?$ O! y5 H: i
9. 
   . [; c) |) u! R9 x8 k
10. /* W25Q256JV相关命令 */
    
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 */
    $ J4 q% l; h+ ~- m& a
15. #define QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD       0x34    /* 32bit地址的4线快速写入命令 */
    : H/ Y9 e) t- ?% j$ J6 y6 z/ p
16. #define QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD    0xEC    /* 32bit地址的4线快速读取命令 */
    / r! k/ g3 S7 F( D
17. 
    
18. #define BLOCK_ERASE_64K_4_BYTE_ADDR_CMD         0xDC    /* 4字节地址，64K扇区 */
    
19. 
    % g. [+ W& L( ?$ `
20. #define BULK_ERASE_CMD                          0xC7    /* 整片擦除 */

复制代码

+ \% X. g* }+ l- x" S7 M81.6 QSPI Flash的STM32CubeProg下载算法使用方法
编译本章教程配套的例子，生成的算法文件位于此路径下：
/ y4 x$ d6 J8 e- B
8 w4 [: K. L/ n( v/ L0 B; ~

( @( h4 y; Y$ v; u0 ~4 O5 }
5 ?3 F) u9 H) Y$ N. R( C81.6.1 下载算法存放位置
生成此文件后，需要大家将其存放到STM32CubeProg安装目录路径：
" L2 T$ }; ?- @; k. d
\STMicroelectronics\STM32Cube\STM32CubeProgrammer\bin\ExternalLoader

81.6.2 STM32CubeProg下载配置
- d- V; y0 S, l/ B# ^: {8 F8 ]$ |我们这里以STLINK连接开发板为例进行说明（USB DFU或者串口方式不支持下载外部Flash）。

7 S! C6 _3 c2 D) F9 C* N' x4 h; j& C

3 [8 N, P/ @1 r$ H# w; o: v点击Connect后效果如下：
, K" |* P. o# A; v# `  v

3 O+ b7 l' W6 A
' u- k  H5 F( Y# ~/ T在这里选择我们制作的下载算法：

; ]( s) Z3 Q8 l+ }. q) W

; ~- r" y4 p8 E- Z, F! ?
任意加载个hex或者bin文件，并按照如下配置，然后点击Start Programming

* k+ h. S& y1 T% S$ d下载完成后的效果如下：

6 g" a7 y6 U' ~7 u, c: O  n3 ~
81.6.3 验证算法文件是否可以正常使用
为了验证算法文件是否可以正常使用，大家可以运行本教程第82章或者83章配套的例子。也可以使用STM32CubeProg直接读取：

( \5 u: E! `# n, \
1 V  E2 K2 q) p# Q- r# _81.7 实验例程说明
本章配套例子：V7-061_QSPI Flash的STM32CubeProg下载算法制作。
* s6 R0 u" @/ m& `, O8 P' q
编译本章教程配套的例子，生成的算法文件位于此路径下：

81.8 总结
4 l0 e, ?+ a8 ]6 o6 @' M4 O本章节就为大家讲解这么多，为了熟练掌握，大家可以尝试自己实现一个Flash下载算法。