一、QSPI接口介绍

QUADSPI 是一种专用的通信接口，连接单、双或四（条数据线）SPI Flash 存储介质。该接口可以在以下三种模式下工作：

% i! j( E# d4 L, ]1 U- s 间接模式：使用 QUADSPI 寄存器执行全部操作，支持对FALSH进行读、写、擦除、锁定等操作。

 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）
" l3 l* O' l( K% ~
* Q2 P9 k' i, s 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器
3 f! ]: h( ]- I3 s* r: Q' G
! S0 z) [4 @* L采用双闪存模式时，将同时访问两个 Quad-SPI Flash，吞吐量和容量均可提高二倍。

+ {- v3 t$ F' O6 ]2 F& r. y6 M( k内存映射模式支持XIP，即可以将代码放在外部FLASH运行，缺点就是有延迟，没有内部运行速度快，且外部FALSH只能读，不能写入或擦除。

内存映射模式下QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。

二、 STM32QSPI 功能框图

STM32F7系列支持双QSPI接口，可以接两个外部FLASH，本文只介绍接一个FALSH的情况。QSPI使用6根线通信，其中数据线4根，1根时钟线，1根片选线，但是程序里是可以配置工作在几线模式。
4 F- M$ f" q# I& J  _. m
三、QUADSPI  命令序列
% M; b, n4 v  @7 ]
QUADSPI 通过命令与 Flash 通信 每条命令包括指令、地址、交替字节、空指令和数据这五
个阶段，任一阶段均可跳过，但至少要包含指令、地址、交替字节或数据阶段之一。
" G; c- @: z, @. ^nCS 在每条指令开始前下降，在每条指令完成后再次上升。
- r7 J. x9 P* s+ o

) \) D  L! ?  o# W3 x9 _* C2 i7 g9 `2 w) r上图清晰的展示了一次QSPI通信过程，它完整的包含了通信的5个阶段，但不是每次通信都需要包含这5个阶段.

交替字节阶段，将 1-4 字节发送到 Flash，一般用于控制操作模式。|正常读写是不需要的，所以这个阶段可以省略（结构体中该参数置0）；

空指令周期阶段，给定的 1-31 个周期内不发送或接收任何数据，目的是当采用更高
- e0 ]( F1 q. k7 {$ ^$ a6 S+ R* q的时钟频率时，给 Flash 留出准备数据阶段的时间。
# l6 [8 C# J2 A+ K9 Y  a) [若 DummyCycles为零，则跳过空指令周期阶段，命令序列直接进入数据阶段（如果存在）。

此外，并不是每次通信都需要包含以上各个阶段，例如，打开写使能指令，只有指令阶段，其他阶段的参数都置0.再比如，读芯片ID，只有指令和数据阶段，具体包含哪些阶段需要参照芯片手册配置。

四、QUADSPI  信号接口协议模式

下面提到的几线模式都是指数据线的根数
: p3 R- w' |1 b0 w  M  j
单线 SPI  模式（即普通SPI通信，等同于使用MISO、MOSI、CLK、CS方式通信）:
1 V: F" i$ Z  b! Z& V/ {' S7 P传统 SPI 模式允许串行发送/接收单独的 1 位。在此模式下，数据通过 SO 信号（其 I/O 与
IO0 共享）发送到 Flash。从 Flash 接收到的数据通过 SI（其 I/O 与 IO1 共享）送达。
通过将（QUADSPI_CCR 中的）IMODE/ADMODE/ABMODE/DMODE 字段设置为 01，可
对不同的命令阶段分别进行配置，以使用此单个位模式。
在每个已配置为单线模式的阶段中：
 IO0 (SO) 处于输出模式
 IO1 (SI) 处于输入模式（高阻抗）
 IO2 处于输出模式并强制置“0”（以禁止“写保护”功能）
( `! @& d7 X2 H4 H9 O/ i IO3 处于输出模式并强制置“1”（以禁止“保持”功能）
9 s8 L: s4 v0 @2 p
5 c) K5 b6 `( ]* }" L$ Q0 ~$ _双线 SPI  模式：
: T2 i) f6 ^, J/ Q- Z在双线模式下，通过 IO0/IO1 信号同时发送/接收两位。
通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 10，可
对不同的命令阶段分别进行配置，以使用双线 SPI 模式。
在每个已配置为双线模式的阶段中：
0 X! J- Y( o2 E  o# l: L( e6 {+ Z IO0/IO1 在数据阶段进行读取操作时处于高阻态（输入），在其他情况下为输出
 IO2 处于输出模式并强制置“0”
+ R( K8 }( M( l( G2 a. } IO3 处于输出模式并强制置“1”
# Y: T: ~/ D# Z在空指令阶段，若 DMODE = 01，则 IO0/IO1 始终保持高阻态。

% f+ ^. ^: p5 u- q5 L
4 K% `8 v5 a2 x0 m四线 SPI  模式:
- a, h3 }5 ~. M* ~2 w在四线模式下，通过 IO0/IO1/IO2/IO3 信号同时发送/接收四位。
. E% W2 f" @- l/ m# X/ l通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 11，可
对不同的命令阶段分别进行配置，以使用四线 SPI 模式。
在每个已配置为四线模式的阶段中，IO0/IO1/IO2/IO3 在数据阶段进行读取操作时均处于高
! h9 N! @  I) n8 X8 b阻态（输入），在其他情况下为输出。
在空指令阶段中，若 DMODE = 11，则 IO0/IO1/IO2/IO3 均为高阻态。
9 e# E+ c0 g  b7 DIO2 和 IO3 仅用于 Quad SPI 模式 如果未配置任何阶段使用四线 SPI 模式，即使 QUADSPI
激活，对应 IO2 和 IO3 的引脚也可用于其他功能。


, h6 s! \& ^/ VSDR  模式(默认工作模式)
3 O1 l  ^: t7 I2 `, K默认情况下，QUADSPI 在单倍数据速率 (SDR) 模式下工作。
在 SDR 模式下，当 QUADSPI 驱动 IO0/SO、IO1、IO2、IO3 信号时，这些信号仅在 CLK
的下降沿发生转变。
2 z6 y# R' G/ ]/ e+ K在 SDR 模式下接收数据时，QUADSPI 假定 Flash 也通过 CLK 的下降沿发送数据。默认情
况下 (SSHIFT = 0 时)，将使用 CLK 后续的边沿（上升沿）对信号进行采样。
* ~8 Q7 x* p; |$ H5 ?) p, t

DDR  模式
# Z1 b/ _8 [5 |/ V5 a. l4 d7 `9 X  Q在 DDR 模式下，当 QUADSPI 在地址/交替字节/数据阶段驱动 IO0/SO、IO1、IO2、IO3 信
6 d$ L7 U+ n8 t0 |& R! @号时，将在 CLK 的每个上升沿和下降沿发送 1 位。
指令阶段不受 DDRM 的影响。始终通过 CLK 的下降沿发送指令。
/ M  c8 O1 @6 Q3 ?在 DDR 模式下接收数据时，QUADSPI 假定 Flash 通过 CLK 的上升沿和下降沿均发送数
据。若 DDRM = 1，固件必须清零 SSHIFT 位 (QUADSPI_CR[4])。因此，在半个 CLK 周期
后（下一个反向边沿）对信号采样。

五、QSPI 配置（HAL库）

, q3 N4 h& k; e- Y0 K9 A- i# ]1.首先根据硬件电路，配置相关引脚，开启引脚和QSPI时钟
( ]' w4 g* k/ V8 }& o% r: j

5 ?& x" j" B3 P) p

1. void HAL_QSPI_MspInit(QSPI_HandleTypeDef* qspiHandle)
     D1 h: T2 h/ V0 s; ?. ~" [4 V
2. {
   1 H8 V. q- l+ n, I) D/ i
3. 
   * C  l1 E7 \& |  {4 |" A- A
4.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   ( c" p- v  Z( G; f. g; m- c5 A8 Q
5.   if(qspiHandle->Instance==QUADSPI)
   4 ]6 k2 l% {/ ^4 Y
6.   {
   
7.   /* USER CODE BEGIN QUADSPI_MspInit 0 */
   1 X4 \/ H1 i+ q% `$ Q& m& A0 f
8. 
   
9.   /* USER CODE END QUADSPI_MspInit 0 */
   
10.     /* QUADSPI clock enable */
    : ?% i8 d6 }* r: ?3 o5 `
11.     __HAL_RCC_QSPI_CLK_ENABLE();
    
12. 
    8 d0 [  u+ s$ J) W% ~+ k
13.     __HAL_RCC_GPIOE_CLK_ENABLE();
    
14.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
15.     __HAL_RCC_GPIOD_CLK_ENABLE();
    # l3 \  P1 u3 X! _( K, S5 c( z: s
16.     /**QUADSPI GPIO Configuration   
    
17.     PE2     ------> QUADSPI_BK1_IO2
    . |" A7 ^5 N. g
18.     PB6     ------> QUADSPI_BK1_NCS
    
19.     PB2     ------> QUADSPI_CLK
    
20.     PD12     ------> QUADSPI_BK1_IO1
    
21.     PD13     ------> QUADSPI_BK1_IO3
    
22.     PD11     ------> QUADSPI_BK1_IO0
    7 Q! M) s# Q# `, ~
23.     */
    # @. e5 k" u7 W) V' G6 D" J3 E: x% r
24.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    & g' ]; @# E: M2 H( G
25.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
26.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
27.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    ( y* Z2 S" ^0 L4 f$ Z
28.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    + z' k0 d  S: F
29.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
    , F& G4 R' P3 X" H* }
30. 
    
31.     GPIO_InitStruct.Pin = GPIO_PIN_6;
    * _8 P4 u/ P; T3 Z. C) K3 k$ I( g
32.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
33.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    $ |  v0 i3 C# M
34.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    # D. H# m- q" D. o0 P% `
35.     GPIO_InitStruct.Alternate = GPIO_AF10_QUADSPI;
    
36.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
37. 
    
38.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    , T" t4 w& ]- m8 I8 m/ N5 Q1 B
39.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    5 v$ A/ _6 W0 z- f6 D  _2 w
40.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    2 K$ ^8 l7 S& _2 u( C. T  w1 \
41.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    0 ^4 k2 V9 X6 T$ P1 k1 V: K
42.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    
43.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    + S7 e; [" K7 q- W7 f0 }3 V
44. 
    7 x: {" D6 x- T' |. B7 J  {
45.     GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_11;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
47.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    & k& F# J  Q! d
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    6 O: D' ]  A$ d" C
49.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    
50.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    , X0 Q, u2 W2 ^" x
51. 
    ! T. N8 ^4 A2 X/ W3 h2 V! E
52.   /* USER CODE BEGIN QUADSPI_MspInit 1 */
    
53. 
    
54.   /* USER CODE END QUADSPI_MspInit 1 */
    
55.   }
    
56. }

复制代码

2.接着初始化SPI外设

1. 
   
2. QSPI_HandleTypeDef hqspi;
   & s7 @6 e3 ]8 {$ }
3. 
   
4. /* QUADSPI init function */
   
5. void MX_QUADSPI_Init(void)
   
6. {
   2 p; c7 V$ U0 U4 @5 P# k* U
7.   hqspi.Instance = QUADSPI;//QSPI外设
   # }4 m; S7 M7 s% I. `! w
8.   hqspi.Init.ClockPrescaler = 2;//QPSI分频比，N25Q128最大频率为104M，此处216/(2+1)=72M
   0 m, X! W7 S" |6 \0 G6 T6 Y& W, M
9.   hqspi.Init.FifoThreshold = 4;//FIFO阈值为4个字节
   4 S, O( T* N6 i) z# k) {1 |! {
10.   hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;//采样移位半个周期(DDR模式下,必须设置为0)
    8 S( z& V5 g- J1 D! a  L
11.   hqspi.Init.FlashSize = POSITION_VAL(0X1000000)-1;//SPI FLASH大小，N25Q128大小为16M字节
    2 E1 x7 s- C& r9 s4 j
12.   hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_6_CYCLE;//片选高电平时间为6个时钟(1/72*6=55.2ns),即手册里面的tSHSL参数
    
13.   hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;//时钟模式0
    
14.   hqspi.Init.FlashID = QSPI_FLASH_ID_1;//第一片flash
    3 T$ R. b# U9 C$ l! e
15.   hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;//禁止双FLASH模式
    
16.   if (HAL_QSPI_Init(&hqspi) != HAL_OK)//初始化QSPI外设
    : ~8 ~" R8 X: d2 x' y
17.   {
    ! |3 G5 ^1 c% y1 h' u/ O
18.     Error_Handler();
    / s# i" I% J; A) a3 m
19.   }
    
20. }

复制代码

3.由于使用的是间接模式，我们对FLASH的所有操作都需要通过FLASH内部寄存器来完成，也就是通过向FALSH发送对应的指令来获得我们想要的结果，此时的FALSH就是一个普通的SPI协议外设，所以接下来所有对FALSH所有的操作都需要先发送相关指令，我们需要配置指令参数（指令类型、地址、数据宽度、地址宽度等等）。
3 }) r  F/ Q( ~" s5 ]4 ~' \$ V* P
我们首先需要配置下面的命令参数结构体：
: l+ \2 e+ c# I7 j7 {' w7 `" i

# a* Z. ?  i  \6 t6 Q3 Y; H
* \! u  n. K0 p" O2 N' ^/ d9 l! SInstruction:指令类型（读、写、擦除等等）

Address:需要读取或写入数据的起始地址
0 E- z% C! q0 M' L2 b
NbData:需要读取或写入数据的长度
( v  N; F$ b2 ?2 S5 {" Y
DataMode：数据传输模式，就是数据用几根线传输（1、2、4线可选），后面的AddreMode类似，就是用几根线传输地址，InstructionMode就是用几根线传输指令。
5 n6 d" V( w* r  B  B% l
3 n" w) p* f* P这三个参数都需要根据芯片数据手册来选择，手册上说明支持该模式才可以选择，否则会通信错误，另外，数据传输模式的不同，对应的指令类型也会不同，比如N25Q128 READ指令对应单线传输模式，Quad I/O Fast Read则对应四线传输模式，这些对应关系手册上都有详细说明！！！
* t5 N8 k) D! d* @3 ?2 J5 g0 x
+ F6 \  j' O4 y4 T7 y7 ? 4.读取芯片JEDEC ID

首先查看手册上读取JEDEC ID的时序：

5 A& g0 n2 ]# g0 b: F& Z& a
可以看出，读ID这条指令是只有指令阶段和数据阶段，且都是单线传输模式，所以

InstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令单线传输模式
; {( }  q# G" W+ m9 g* x$ U
5 R( t* l+ J) y. V9 O3 \+ GDataMode = QSPI_DATA_1_LINE；//数据单线传输模式
" m8 T% [, ]' q7 Q
Address和AddressMode 这两个参数的值都置0，表示无地址。
. B4 Q) ^/ P: p% j9 k* J$ `2 Z/ K
8 Y; s& G3 y: _3 \. Z) I0 DNbData ：是想要读取的数据长度+1，ID是3个字节，这里令NbData=3

其他值和下面代码保持一致即可。

. |! X% V0 b$ T$ D然后 使用HAL_QSPI_Command函数将读ID指令发送给FALSH，等待发送完成

% ?$ N$ Y" g; ~+ F( ^( X+ A最后 调用HAL_QSPI_Receive，接受FALSH返回的数据，即芯片ID

1. /**
   # d+ [# x7 z5 K. w) \
2. * @brief  读取FLASH ID
   1 ]0 V; M+ G& c1 }+ m5 l& }. q: }
3. * @param   无
   
4. * @retval FLASH ID
   
5. */
   
6. uint32_t QSPI_FLASH_ReadID(void)
   
7. {
   4 z7 \) ^9 g  F: {- J8 D7 X1 M
8.      QSPI_CommandTypeDef s_command;
   9 {* s1 v* B: Z% \
9. 
   2 z& [4 ?" K  _+ L) q
10.      uint32_t Temp = 0;
    
11. 
    ! Q- J1 k: |5 r+ Y. ]( i0 D# s
12.      uint8_t pData[3];
    ( G5 T9 |; j" [  F, Z: y
13. 
    
14.      /* 读取JEDEC ID */
    ; e; V2 U- ^% p- @- B
15. 
    . u$ q4 u, ]1 E  ]6 i6 ^
16.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令阶段的操作模式，00：无指令；01：单线传输指令；10：双线传输指令；11：四线传输指令。
    
17. 
    2 q/ U% |: F2 R; F
18.      s_command.Instruction       = READ_JEDEC_ID_CMD;//读取芯片ID指令
    9 z( M9 Z+ X$ K$ d6 q  ?: m% O: u1 F
19. 
    7 e" D, G' S5 W5 U3 S5 u
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;//定义地址长度
    ; K& C* X* g2 ]) Q; U) \2 P, H& L  u
21. 
    
22.      s_command.DataMode          = QSPI_DATA_1_LINE;//定义数据阶段的操作模式，00：无数据；01：单线传输数据；10：双线传输数据；11：四线传输数据。
    
23. 
    , I( Z% q9 m% K, i# ^2 _8 p; x
24.      s_command.AddressMode       = 0;//地址阶段的操作模式，00：无地址；01：单线传输地址；10：双线传输地址；11：四线传输地址。
    5 s5 A3 h% _: I- ]
25.          
    
26.      s_command.Address           = 0;   
    
27.         
    ) c+ }0 r: [5 ~2 y
28.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;//交替字节长度
    ! o  G4 G4 ~. ^9 M
29. 
    % q8 z3 K8 Q/ {5 a
30.      s_command.DummyCycles       = 0;//空指令阶段的持续时间，在 SDR 和 DDR 模式下，它指定 CLK 周期数 (0-31)。
    ( V7 W8 e  ^2 [, O8 C7 o. L2 r
31. 
    1 K5 q, K/ r6 @6 C  ~
32.      s_command.NbData            = 3;//设置数据长度，在间接模式和状态轮询模式下待检索的数据数量（值 + 1）。对状态轮询模式应使用不大于 3 的值（表示 4 字节）。
    + |( j, j2 ~5 ~! m4 C% _- @' C
33. 
    
34.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;//地址、交替字节和数据阶段设置 DDR 模式，0：禁止 DDR 模式；1：使能 DDR 模式。
    
35. 
    - P+ h& I, C2 }5 M
36.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;//设置DDR 模式下数据输出延迟 1/4 个 QUADSPI 输出时钟周期，0：使用模拟延迟来延迟数据输出；1：数据输出延迟 1/4 个 QUADSPI 输出时钟周期。
    
37.                  
    4 @  x& g2 W# e* r1 }# c
38.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;//设置仅发送指令一次模式，。IMODE = 00 时，该位不起作用。0：在每个事务中发送指令；1：仅为第一条命令发送指令。
    
39. 
    
40.      if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
41.                  {
      b, k# @8 @+ C: ~- n( D  {) L
42.          #if  QSPI_DEBUG
    . `9 E4 v7 l' E7 _2 \( `: M0 z
43.                      printf("send read flash ID command error!\r\n");
    * d) U/ q: E, a$ u; P: U3 o
44.                #endif
    
45.          /* 用户可以在这里添加一些代码来处理这个错误 */
    
46.          while (1) {}
    0 C! q: n; _& ]' K- M
47.      }
    + z% h3 J6 D* o# S) j
48.      if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    
49.                  {
    8 \' E0 j5 |) @
50.          #if  QSPI_DEBUG
    : f9 O# W+ ]1 t6 I; |7 N# M
51.                      printf("read qspi flash ID error!\r\n");
    
52.                #endif
    % ]$ ?3 H2 `" F- W1 Z( b
53.          /* 用户可以在这里添加一些代码来处理这个错误 */
    
54.          while (1) {}
    ; b8 |8 n2 z  u( _# B7 j# C9 C
55.      }
    
56.      Temp = ( pData[2] | pData[1]<<8 )| ( pData[0]<<16 );
    ( D7 ]# w: |# J  b- m
57.      return Temp;
    . Z4 Z* ?1 ~! i" u3 x( I
58. }

复制代码

5.FALSH 写使能
( h- a& Q- Z: H0 ~) n- c  r# U
在对FALSH进行写之前，需要打开写使能开关（实际上就是发送写使能指令）：

类似的，需要查看芯片手册，写使能的时序

4 {+ \- C& q, X

: ~0 k0 `9 [8 I- d; b) Z4 C可以看到这个指令时序更简单，仅仅有指令阶段，所以地址和数据的参数都应置0
0 L/ o( K7 X7 |0 E

1. /**
   : ^: s$ Q3 C/ C$ ~
2.   * @brief  QSPI FALSH写使能
   
3.   * @param  None
   " p8 ?6 K2 E9 U& T; ^7 |
4.   * @retval HAL_OK
   
5. */
   
6. static HAL_StatusTypeDef QSPI_WriteEnable(void)
   - ?: r0 }' u3 J# b  q, G
7. {
   - g5 J: T  J" f4 r" G9 g8 |) G
8.   QSPI_CommandTypeDef     sCommand;
   
9.   QSPI_AutoPollingTypeDef sConfig;
   
10. 
    9 u1 A1 J) i5 A2 Q4 Q& P4 |
11.   /* Enable write operations ------------------------------------------ */
    
12.   sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    1 \! G- M+ u, p/ a. j& l! i% B
13.   sCommand.Instruction       = WRITE_ENABLE_CMD;
    8 I$ p+ ^' H4 m4 T
14.   sCommand.AddressMode       = QSPI_ADDRESS_NONE;
    
15.   sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    6 f/ S, b9 c; x7 E7 \: B
16.   sCommand.DataMode          = QSPI_DATA_NONE;
    / [0 z  ?1 r; c% v1 ~
17.   sCommand.DummyCycles       = 0;
    ) C+ N  Z# d6 A" S
18.   sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;
    % e7 U% I$ G! r/ j$ g+ |
19.   sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
20.   sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
21. 
    
22.   if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
23.   {
    
24.     return HAL_ERROR;
    3 i8 H7 z' f6 i& i8 @1 Q/ u
25.   }
    9 O& k9 _9 c, @6 V5 r" K
26. 
    
27.   /* Configure automatic polling mode to wait for write enabling ---- */  
    
28.   sConfig.Match           = 0x02;
    ; g8 ^5 j! J9 b9 Z
29.   sConfig.Mask            = 0x02;
    * {3 B5 q/ e( l
30.   sConfig.MatchMode       = QSPI_MATCH_MODE_AND;
    
31.   sConfig.StatusBytesSize = 1;
    
32.   sConfig.Interval        = 0x10;
    
33.   sConfig.AutomaticStop   = QSPI_AUTOMATIC_STOP_ENABLE;
    9 x9 n# c" C0 d2 c0 t/ ~
34. 
    ; N0 z+ q( X+ j, ~) m+ F  s6 U6 O% J
35.   sCommand.Instruction    = READ_STATUS_REG1_CMD;
    1 B* q$ M1 F- n# O2 B' i9 t" M
36.   sCommand.DataMode       = QSPI_DATA_1_LINE;
    9 L* _; r9 H* }; H2 t
37. 
    
38.   if (HAL_QSPI_AutoPolling(&hqspi, &sCommand, &sConfig, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    # p5 b6 q% z; i7 ~( [, Z+ p. e' @
39.   {
    
40.                 return HAL_ERROR;        
    ' d( r, j5 R4 @  w# W/ L
41.   }
    
42.         return HAL_OK;
    + w  q( ^' F. @6 O8 F0 G
43. }

复制代码

这里需要讲下 QUADSPI  状态标志轮询模式：
6 \  |' m5 G0 B5 `; P. M/ ]在自动轮询模式下，QUADSPI 周期性启动命令以读取一定数量的状态字节（最多 4 个）。
! W/ N. k$ {( x/ L% @% @可屏蔽接收的字节以隔离一些状态位，从而在所选的位具有定义的值时可产生中断。
7 e0 x4 E) ~3 c7 m( }; J, U对 Flash 的访问最初与在间接读取模式下相同：如果不需要地址 (AMODE = 00)，则在写入
QUADSPI_CCR 时即开始访问。否则，如果需要地址，则在写入 QUADSPI_AR 时开始第
! E- Z6 P  _" Y一次访问。BUSY 在此时变为高电平，即使在周期性访问期间也保持不变。
- r& V0 ^% ]* L6 b7 {* E1 d在自动轮询模式下，MASK[31:0] (QUADSPI_PSMAR) 的内容用于屏蔽来自 Flash 的数据。
如果 MASK[n] = 0，则屏蔽结果的位 n，从而不考虑该位。如果 MASK[n] = 1 并且位 [n] 的内
7 M1 G, v5 K  b+ z% i容与 MATCH[n] (QUADSPI_PSMAR) 相同，说明存在位 n 匹配。
0 `4 U: l9 Q! o( }' q* b如果轮询匹配模式位 (PMM, QUADSPI_CR[23]) 为 0，将激活“AND”匹配模式。这意味着
状态匹配标志 (SMF) 仅在全部未屏蔽位均存在匹配时置 1。
如果 PMM = 1，则激活“OR”匹配模式。这意味着 SMF 在任意未屏蔽位存在匹配时置 1。
如果 SMIE = 1，则在 SMF 置 1 时调用一个中断。
如果自动轮询模式停止 (APMS) 位置 1，则操作停止并且 BUSY 位在检测到匹配时清零。否
$ E& E' c$ \* o  ^: b则，BUSY 位保持为“1”，在发生中止或禁止 QUADSPI (EN = 0) 前继续进行周期性
访问。
' K3 T! q% S: W8 C& y% M0 l数据寄存器 (QUADSPI_DR) 包含最新接收的状态字节（FIFO 停用）。数据寄存器的内容不
9 C. `" m- u0 b$ `受匹配逻辑所用屏蔽方法的影响。FTF 状态位在新一次状态读取完成后置 1，并且 FTF 在数
- R; Z- |( i" N  t- W据读取后清零。
3 t* g8 o: J2 C- t. _
简单的说，就是CPU自动查询FALSH指定的标志位是否置位或清零，通过调用HAL_QSPI_AutoPolling函数，CPU将自动查询FALSH写使能标志位是否被置位，成功返回HAL_OK,否则返回HAL_ERROR，这样就省去了我们自己发读寄存器指令查询的麻烦了。
8 W/ g6 P2 e7 k2 }
, c8 O% `% w0 g9 Y6.读FALSH

0 V, T$ B% ?. ?这里仅介绍4线模式下的读FALSH流程，首先查看手册4线模式读时序

' b$ L1 p- I0 u- m9 ?, q( g( k+ o从时序图可以看出，指令是1线模式，地址是4线模式，空周期（DummyCycles）为10，数据也是4线模式，还有此时的读指令是QUAD_INOUT_FAST_READ_CMD。所以相关参数配置如下：
5 y2 b' W! w0 ^/ ^! q' _
) G. C) m2 |9 b# E+ U4 F8 j5 C

1. /**
   * C% E. a0 G# a: ~
2. * @brief  从QSPI存储器中读取大量数据.
   $ G% Y& Y, H+ d3 \9 [
3. * @param  pData: 指向要读取的数据的指针
   
4. * @param  ReadAddr: 读取起始地址
   
5. * @param  Size: 要读取的数据大小
   
6. * @retval QSPI存储器状态
   
7. */
   
8. HAL_StatusTypeDef BSP_QSPI_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)
   
9. {
   4 j# a! b. V9 P
10.      QSPI_CommandTypeDef s_command;
    ; q$ F) u6 j6 Z! h
11. 
    
12.      /* 初始化读命令 */
    ' g* F) n7 z/ ?* R. ^2 G
13. 
    
14.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
15. 
    ; j; r5 k4 R: W  @: P; l
16.      s_command.Instruction       = QUAD_INOUT_FAST_READ_CMD;
    
17. 
    
18.      s_command.AddressMode       = QSPI_ADDRESS_4_LINES;
    , P5 i  _  T4 I8 E& [; c" Z
19. 
    
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    
21. 
    $ d8 Z+ Z8 t4 W% k/ H7 L( i# V
22.      s_command.Address           = ReadAddr;
    
23. 
    ( x: V" S+ T6 z. E! q+ y+ d
24.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    6 l- b9 B' k: c# v' O' d
25. 
    / }9 g3 N6 {# d; @: K0 W1 d
26.      s_command.DataMode          = QSPI_DATA_4_LINES;
    3 A8 L" J/ Y; t& ?7 U; ~& G
27. 
    
28.      s_command.DummyCycles       = 10;
    6 w; r+ t+ W7 B) A9 h7 E2 B
29. 
    
30.      s_command.NbData            = Size;
    ; `! [' U- Y, [5 N& ]
31. 
    4 E9 Z7 ?7 n" V4 {; w" b+ R
32.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    * K- u5 \& d8 R/ R, h% N, p
33. 
    
34.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    2 A( s& h* r+ d% @( D
35. 
    
36.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
37.      /* 配置命令 */
    * r1 c/ Y4 ~3 b  H
38. 
    
39.    if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    . p& }0 i, B: A/ x* B
40.          {
    : L! `( t) C2 }  m
41.                 #if  QSPI_DEBUG
    . u/ b; O6 V& i( ^" o$ k0 f
42.                 printf("R-send read command error!\r\n");
    
43.           #endif
    
44.     return HAL_ERROR;
    
45.    }  
    
46.    /* 接收数据 */
    & `$ T3 v' q3 {, D8 e% ], e  [; x
47.    if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    * U, A. R2 E' Z4 h0 h# Q
48.          {
    - M3 h; W( D3 E* f+ q2 C
49.                 #if  QSPI_DEBUG
    
50.                 printf("R-read data error!\r\n");
    
51.           #endif
    
52.     return HAL_ERROR;
    # Y8 W1 _& c, B) E7 O
53.    }
    , t0 C# I7 s0 s+ a( _  M+ c
54.    return HAL_OK;
    ; D  X4 t. R  U8 ^5 R+ c5 T4 Q
55. }

复制代码

8 {  T& j, i. X& M9 n本函数实现了从FALSH指定地址读取指定数量字节的功能

; Z2 s! ?6 Y+ @3 Q4 | 7.写FALSH

同读FALSH类似，我们需要在手册中找到4线写FALSH的时序：

9 Y$ s% D! ^$ r7 K根据时序图配置如下：1线指令，1线地址，24bit地址，4线数据，没有空周期
, B) O% d& ]1 [5 ~

1. /**
   ; X$ j; z! m( k. C
2. * @brief  将大量数据写入QSPI存储器
   
3. * @param  pData: 指向要写入数据的指针
   
4. * @param  WriteAddr: 写起始地址
   + ^" u# Z5 o' J: {7 {
5. * @param  Size: 要写入的数据大小
   ) O' G* L) U) \" o' E5 Q) r
6. * @retval QSPI存储器状态
   
7. */
   - Y' p, e$ |1 w( D! P
8. HAL_StatusTypeDef BSP_QSPI_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
   + J6 B3 [: i  m  u8 o$ P
9. {
   
10.                         QSPI_CommandTypeDef s_command;
    
11.                         uint32_t end_addr, current_size, current_addr;
    
12.             unsigned char sector_start,sector_end,i;
    
13.         
    
14.                         /* 计算写入地址和页面末尾之间的大小 */
    * z2 H! T5 v1 I2 f+ P  {
15.                         current_addr = 0;
    % Q% |$ w8 u' Q% z
16.         
    
17.                         while (current_addr <= WriteAddr)
    3 k( k& t5 o: u' B4 y7 B2 X( K! n; C
18.                         {
    
19.                                         current_addr += N25Q128FV_PAGE_SIZE;
    
20.                         }
    
21.                   current_size = current_addr - WriteAddr;
    - L! ?. K3 B( }
22.      /* 检查数据的大小是否小于页面中的剩余位置 */
    3 m. t0 R, g5 T. S& c
23.      if (current_size > Size)
    
24.                  {
    
25.          current_size = Size;
    
26.      }
    2 p" ^: S& l/ [' u
27.      /* 初始化地址变量 */
    
28.      current_addr = WriteAddr;
    % O" g0 t2 u+ ?! I  z
29.      end_addr = WriteAddr + Size;
    
30.                  
    
31.                  sector_start = current_addr >> 16;
    
32.                  sector_end = end_addr >> 16;
    + L! m+ a4 G" N  o/ d, @
33.                  
    $ a' j, `  X# s9 C! w2 S- ^4 ^
34.                  for( i = sector_start; i<=sector_end ;i++)
    
35.                  {
    
36.                     BSP_QSPI_Erase_Block(i); //擦除对应删除
    
37.                  }
    ) t  U) F$ c) Q' U! Q
38.                  
    
39.      /* 初始化程序命令 */
    
40.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
41. 
    9 T0 C4 Q% ]; l1 D' k* Y$ N
42.      s_command.Instruction       = QUAD_INPUT_PAGE_PROG_CMD;
    
43. 
    
44.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    , C, ^! k, `3 T% s3 T4 ]
45. 
    
46.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    
47. 
    
48.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
49. 
    
50.      s_command.DataMode          = QSPI_DATA_4_LINES;
    
51. 
    
52.      s_command.DummyCycles       = 0;
    
53. 
    + P* E3 H$ e. g: l6 [
54.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    " r' ?9 F1 _! I+ Y
55. 
    
56.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
57. 
    
58.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
59. 
    
60.      /* 逐页执行写入 */
    $ a! _6 Z+ @, H$ g% ^
61.      do {
    
62. 
    
63.          s_command.Address = current_addr;
    , o) o, q7 S2 C1 I! x: K+ P" i
64.          s_command.NbData  = current_size;
    " g$ H+ v; A; u1 o
65.          /* 启用写操作 */
    " ]1 I0 I1 P" \! o, d% Y) U
66. 
    
67.          if (QSPI_WriteEnable() != HAL_OK)
    + y( u  p  O/ U2 L. t+ Y
68.                                  {
    
69.                                                 #if  QSPI_DEBUG
    
70.                                                 printf("W-Qspi write enable error!\r\n");
    
71.                                                 #endif
    
72.             return HAL_ERROR;
    
73.          }
    
74.          /* 配置命令 */
    % |0 k$ Z3 j3 X0 h7 I! y
75.         if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    . m. C, C- g: R( O
76.                 {                                 
    7 t* ^" A. S8 L3 F4 D
77.                                           #if  QSPI_DEBUG
    - {/ ^1 ^  o* d7 ^% P4 n
78.                                                 printf("W-Qspi send Command error!\r\n");
    + g6 g% R( L3 {5 U
79.                                                 #endif
    
80.             return HAL_ERROR;
    
81.          }
    8 a, A' w/ a! j, A# O) F: L
82.          /* 传输数据 */
    
83.          if(HAL_QSPI_Transmit(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
84.                                  {
    ) z3 h' K% O+ V. }
85.                                           #if  QSPI_DEBUG
    
86.                                                 printf("W-Qspi Transmit data error!\r\n");
    5 s( u3 t( k7 I: l/ P
87.                                                 #endif
    
88.             return HAL_ERROR;
    
89.          }
    
90.          /* 配置自动轮询模式等待程序结束 */
    
91. 
    $ x) I4 v( y% D& I# r/ X- m5 _
92.          if(QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    1 X( f2 h4 k) ?: f  G" W# ]
93.                                  {                                         
    ( ~8 h- @; E: J
94.                                                 #if  QSPI_DEBUG
    
95.                                                 printf("W-AutoPollingMemReady error!\r\n");
    
96.                                                 #endif
    7 r' }& w$ P* @6 B
97.             return HAL_ERROR;
    9 W# t3 h$ Y* G; @
98.          }
    
99.          /* 更新下一页编程的地址和大小变量 */
    1 p% d5 \) o) R3 n
100. 
     
101.          current_addr += current_size;
     ; o9 e0 \' j+ s2 T6 G
102. 
     4 `+ w" Q  G' c8 ]2 M7 D1 m" C
103.          pData += current_size;
     - y2 Q' p1 D. c- E( Q
104. 
     7 e; {  L% c! l' K" [! d
105.          current_size = ((current_addr + N25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr-current_addr) :
     
106. 
     
107.                         N25Q128FV_PAGE_SIZE;
     
108. 
     
109.      } while (current_addr < end_addr);
     ! P2 p, i- ~' t9 @. G1 l. |
110.      return HAL_OK;
     / h. p; j8 {" c' w% K- ~
111. }

复制代码

! U  u0 W! A2 [- }7 o该函数实现从指定地址写入指定数量的字节。

, Y! D" H! ~. n9 }' F6 ]. m. w8.擦除FALSH
2 W; U/ o1 C# c7 o: b
' C/ S# g6 d+ R/ r第一种情况是按扇区擦除，这也是N25Q128最小的擦除单位（N25Q128共有256个扇区，每个扇区64KB）
9 j3 F5 Y9 R( E$ u+ f- D# I

2 _+ d0 H3 \+ V) T6 l. o/ ^+ }
参数设置为1线指令 ，1线地址，24bit地址，无数据阶段

# [! n! p& j9 x# V) Q: j

1. /**
   7 z2 h3 R4 ?% c5 [/ D1 Q6 n
2. * @brief  擦除QSPI存储器的指定扇区
   
3. * @param  BlockAddress: 需要擦除的扇区地址
   3 g  A; a4 |; j
4. * @retval QSPI存储器状态
   
5. */
   
6. HAL_StatusTypeDef BSP_QSPI_Erase_Sector(uint32_t Sector)
   " B5 ~; K' B* v9 s0 B( J) r
7. {
   0 o& ^* k. k* p" f3 m9 x8 E
8.            uint32_t SectorAddress=Sector << 16;//Sector*65535算出该扇区对应的地址
   . K( i" Q( L2 W% s) Q& j1 Y: L& y6 g
9.         
   ' B9 A+ m% f' [7 d* g4 g0 Y  d
10.      QSPI_CommandTypeDef s_command;
    * ?9 ^7 @0 J, y
11.      /* 初始化擦除命令 */
    6 |1 H, J5 D& k* X) e+ u, Z# E
12.         
    
13.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
14. 
    0 u& }3 r$ Z0 }: ?7 e! e
15.      s_command.Instruction       = SECTOR_ERASE_CMD;//按扇区擦除
    4 n* H$ S1 [' A" h0 R" |" V' p
16. 
    2 r" X  f# H" E/ t5 `
17.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    7 {8 ~, z9 d  ?8 E/ c$ n
18. 
    
19.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    / U  T0 R1 l! m' h3 |) o
20. 
    2 c7 X; \( m+ K( a) p; w) U
21.      s_command.Address           = SectorAddress;
    
22. 
    
23.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    * ]9 K" H3 {1 N  N' J- @! l
24. 
    - l+ h8 p* D" d- f& n- v7 o
25.      s_command.DataMode          = QSPI_DATA_NONE;
    & e/ x; H5 M0 g/ N' {2 ^
26. 
    
27.      s_command.DummyCycles       = 0;
    7 j+ d3 _, J9 v/ B
28. 
    7 t! M& ?$ [% I0 {, B
29.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    8 U1 p+ J4 O2 U; a2 V. l
30. 
    ) u; Z& P" D6 |
31.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    0 D- X, v" X, e! n. }( u
32. 
    - ~2 Q( F3 ]+ \/ j
33.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
34. 
    
35.      /* 启用写操作 */
    3 ~+ F$ \1 A) Q  A
36. 
    
37.      if (QSPI_WriteEnable() != HAL_OK)
    9 [+ G- }* F7 l" ^
38.                  {
    . ]! p7 `3 G& |2 A
39.          return HAL_ERROR;
    
40.      }
    
41.      /* 发送命令 */
    7 d3 m% F$ H) K
42.      if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    4 ?; b$ \' h. Q* L5 k/ a2 k
43.      {
    
44.          return HAL_ERROR;
    
45.      }
    
46.      /* 配置自动轮询模式等待擦除结束 */
    9 b, J2 q. l7 ?# c( t6 l, c3 A6 W. P
47. 
    
48.      if (QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
49.      {
    
50.                                 #if  QSPI_DEBUG
    
51.                                 printf("erase sector error!\r\n");
    
52.                                 #endif
    
53.         return HAL_ERROR;
    & h* d5 j, N- i# L' Q% K
54.      }
    . T5 j, O# j) j8 h  Q: n
55.     return HAL_OK;
    
56. }

复制代码

% D' u( `! X& N& d8 N第二种情况是全片擦除，时序如下：
) E1 w9 g" \# |# t1 j8 n
6 E1 n, d7 ~9 o) N; K

" F- l: u* I" z& |# ?+ P全片擦除仅包含指令阶段，对于N25Q128来说，全片擦除耗时可达48s。

1 @; a5 b  S9 |, \% [

1. /**
   
2.   * @brief  全片擦除  N25Q128全片擦除耗时48s
   + R8 A7 v/ l& S# d1 T; {: l
3.   * @retval QSPI memory status
   
4.   */
   
5. uint8_t BSP_QSPI_Erase_Chip(void)
   ' `& O1 s2 P! C& H& a
6. {
   
7.   QSPI_CommandTypeDef s_command;
   
8. 
   
9.   /* Initialize the erase command */
   # B5 d) j, n  _
10.   s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
11.   s_command.Instruction       = CHIP_ERASE_CMD;
    
12.   s_command.AddressMode       = QSPI_ADDRESS_NONE;
    
13.   s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    + D' P1 Y1 f4 k3 H) V" D; E; C  U/ }/ P
14.   s_command.DataMode          = QSPI_DATA_NONE;
    , l( ]+ T' }  Y: I0 ~
15.   s_command.DummyCycles       = 0;
    
16.   s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    
17.   s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    * z* e, Z5 w8 v7 T3 X
18.   s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
19. 
    
20.   /* Enable write operations */
    3 ^" @, V1 m3 `  I& J
21.   if (QSPI_WriteEnable() != HAL_OK)
    - f  r) a4 h* f/ N! X
22.   {
    ' T0 Z, m8 r& z9 I
23.     return HAL_ERROR;
    
24.   }
    
25. 
    4 \( ]9 g# m( x: j. Z
26.   /* Send the command */
    
27.   if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    " j/ k' e4 c* m
28.   {
    - |( S3 Y+ ~, L7 a3 F+ s+ j# f
29.     return HAL_ERROR;
    # o, w' p' q  y; T" Y& O% H
30.   }
    * b2 ]  K9 G! L% J" K) Z8 j
31. 
    
32.   /* Configure automatic polling mode to wait for end of erase */  
    + z6 G4 y5 ]) _9 R0 J5 J3 \8 s
33.   if (QSPI_AutoPollingMemReady(N25Q128A_BULK_ERASE_MAX_TIME) != HAL_OK)
    1 _3 A4 u0 s. r& [" U; h+ V
34.   {
    
35.     return HAL_ERROR;
    
36.   }
    
37. 
    
38.   return HAL_OK;
    
39. }

复制代码

9.测试程序
! W6 B1 O# a$ @$ I! ?1 ?
# H  A, e7 [3 q$ Y; O$ _+ b- [测试芯片写入和读取是否成功，首先向0x1FFFF地址连续写入4096个字节，然后再读取出来，对比两次数据是否一致。
. A: C7 T' O% ?* |5 j

1. unsigned char write[4096];
   
2. unsigned char read[4096];   
     v6 l7 D" l1 i& T  j7 E, `
3. void N25Qxx_Test(void)
   - y  [9 o; [3 `7 H* g
4. {
   2 V) v' X8 e: b# U
5.   uint32_t i = 0;
   
6. 
   3 e% b- }: S/ X% O  I: O1 j. k& ^
7.         for(i = 0;i<sizeof(write);i++)
   3 t& @; Y3 ^; r6 x* t1 B
8.         {
   
9.     write=i;
   " W% i5 @% Z8 E
10.         }
    * d4 [: E  x; @; ^4 P: U* W
11.         
    ) p6 _, I" R6 _) P& f3 ?( @) b
12.         printf("write data:\r\n");        
    0 m* N5 F" b7 N1 z. U
13.   for(i = 0;i<sizeof(write);i++)
    
14.         {
    
15.                 printf("%d ",write);
    
16.         }
    
17.   printf("\r\n");
    
18.         printf("\r\n");
    
19.         printf("\r\n");
    . B( H+ }  y7 J4 A' z* v
20.         
    
21.         BSP_QSPI_Write(write,0x1FFFF,sizeof(write));
    1 G0 s" o* {2 _/ I- L+ @, m& R. L2 v
22.   BSP_QSPI_Read(read,0x1FFFF,sizeof(write));        
    
23.         
    
24.         printf("Read from QSPI:\r\n");
    
25.         
    
26.   for(i = 0;i<sizeof(read);i++)
    . }7 G  |% d8 d6 J
27.         {
    
28.                 printf("%d ",read);
    
29.         }
    7 g& N" x! ^" ^$ \9 i2 ?
30.   printf("\r\n");
    # n0 o, H2 [- G6 f& Z( @. f# p
31. }

复制代码

  |' c; X  R$ k0 E写入的数据（部分截图）：

读取的数据（部分截图）：
8 s1 O# x8 l: k) ~% {3 w( U9 |
8 L* A( y4 Y, w+ w  j. \3 i

截取相同的部分，两次数据完全一致，写入和读取成功。

& b7 {0 v  o" a( r3 n/ F最后，讲几点需要注意的地方：

( Q$ k* h6 a/ R6 C4 V% ?; b1 V- |1.N25Q128 与  W25Q128 有很多不同的地方，特别是4线模式下，二者很多地方不同，代码不可混用，比如W25Q128的很多指令都是支持4线的，但是N25Q128的指令阶段均不支持4线模式。
% l2 g6 \- ~0 C
2.硬件上使用了4线SPI，但是仍然可以使用单线SPI操作，只是速度慢了点，其他的没什么影响。
/ J8 p+ p2 m$ j; U. H9 p
3.N25Q128在配置为内存映射模式时，外部 SPI 器件被视为是内部存储器。QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。如果访问的地址超出 FSIZE 定义的范围但仍在 256MB 范围内，则生成 AHB 错误。此错误的影响具体取决于尝试进行访问的 AHB 主设备：
5 U" N0 e4 e. u6 W* K 如果为 Cortex ® CPU，则生成硬性故障 (Hard fault) 中断
9 `" Y, _& [( H/ h2 F( k8 t# f 如果为 DMA，则生成 DMA 传输错误，并自动禁用相应的 DMA 通道。

4.N25Q128包含248个主扇区，每个扇区64KB,还有8个64KB的启动扇区，这8个启动扇区又可分为128个子扇区，每个子扇区大小为4KB，所有的扇区擦除都可以按照一次64KB大小擦除，但是这8个启动扇区也可以按照4KB一次擦除（需要使用SUBSECTOR_ERASE_CMD指令擦除）。
; x' M0 w" [9 q
5.N25Q128分TOP和Bottom架构，两种架构的区别就是启动扇区的位置不同，TOP架构的启动扇区是248~255（地址范围：F80000 ~FFFFFF），0~248为主扇区。Bottom架构的启动扇区是0~7（地址范围：0~7FFFF），8~255是主扇区。这两中架构可以通过完整的型号区分。

) _% s) \: i& {* ~# v7 ~4 E0 U

. }# J2 h# t* Y& V. N
6.N25Q128和W25Q128 不可以相互替换，除非使用单线SPI通信，且只能使用F80000 ~FFFFFF或者0~7FFFF范围内的内存。

7.N25Q128的指令在不同spi模式（单线、双线、四线）下有所不同，使用时一定要特别注意！！！


1 w0 f8 O0 a6 E/ Z
4 U! F, D5 h4 e$ K5 I