一、QSPI接口介绍
4 w/ g" Y0 o5 @- j
QUADSPI 是一种专用的通信接口，连接单、双或四（条数据线）SPI Flash 存储介质。该接口可以在以下三种模式下工作：
( `# T$ b# r/ v2 Y! l3 q5 I; C0 L- M5 e
( {8 j  V0 e' D9 e% Y' d 间接模式：使用 QUADSPI 寄存器执行全部操作，支持对FALSH进行读、写、擦除、锁定等操作。
6 ~$ ^: g+ z# T
 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）

 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器

+ u& [( \' h3 q$ J/ N: Q, Y- L采用双闪存模式时，将同时访问两个 Quad-SPI Flash，吞吐量和容量均可提高二倍。
8 C0 m. o, M" O& ?) E% t4 {' E% P
内存映射模式支持XIP，即可以将代码放在外部FLASH运行，缺点就是有延迟，没有内部运行速度快，且外部FALSH只能读，不能写入或擦除。
! o; L5 m& X) T7 p+ _
内存映射模式下QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。
0 a5 t, E2 P3 B; o
二、 STM32QSPI 功能框图
6 d# i" o- x( J3 \; M9 U  {, I! g4 \

: g+ M+ D. ]( z6 [5 x8 z
STM32F7系列支持双QSPI接口，可以接两个外部FLASH，本文只介绍接一个FALSH的情况。QSPI使用6根线通信，其中数据线4根，1根时钟线，1根片选线，但是程序里是可以配置工作在几线模式。
1 `! G" M7 P" Q) s& N/ Q
6 s  H, ~* ]' I! F三、QUADSPI  命令序列

- B1 x) `2 l4 T5 f: Y* oQUADSPI 通过命令与 Flash 通信 每条命令包括指令、地址、交替字节、空指令和数据这五
- O2 v: k4 U" E; p个阶段，任一阶段均可跳过，但至少要包含指令、地址、交替字节或数据阶段之一。
8 K; Q1 r5 |3 r  {! qnCS 在每条指令开始前下降，在每条指令完成后再次上升。
0 f' d- r% O6 L% [
  Q$ Q8 A, O2 n) K4 X, {3 S  q

3 ^! F( r6 a' N; t
上图清晰的展示了一次QSPI通信过程，它完整的包含了通信的5个阶段，但不是每次通信都需要包含这5个阶段.

) I/ T6 z$ c$ n/ n3 h: B交替字节阶段，将 1-4 字节发送到 Flash，一般用于控制操作模式。|正常读写是不需要的，所以这个阶段可以省略（结构体中该参数置0）；
& h- V' Y, K: Z3 s
4 g! W# {" C; d( P8 G5 A2 A空指令周期阶段，给定的 1-31 个周期内不发送或接收任何数据，目的是当采用更高
的时钟频率时，给 Flash 留出准备数据阶段的时间。
. e, u. h7 O5 |1 ?1 ]0 d若 DummyCycles为零，则跳过空指令周期阶段，命令序列直接进入数据阶段（如果存在）。
, H$ h# F8 `. C- ^
9 s0 O) h* Y/ {8 ]  D! M) \4 T% V此外，并不是每次通信都需要包含以上各个阶段，例如，打开写使能指令，只有指令阶段，其他阶段的参数都置0.再比如，读芯片ID，只有指令和数据阶段，具体包含哪些阶段需要参照芯片手册配置。

四、QUADSPI  信号接口协议模式
' Z; W  i0 T5 S0 a0 L8 c2 c
, l) k; n# X/ [/ G7 P  |下面提到的几线模式都是指数据线的根数
# [# O8 o2 D& \6 l
单线 SPI  模式（即普通SPI通信，等同于使用MISO、MOSI、CLK、CS方式通信）:
传统 SPI 模式允许串行发送/接收单独的 1 位。在此模式下，数据通过 SO 信号（其 I/O 与
IO0 共享）发送到 Flash。从 Flash 接收到的数据通过 SI（其 I/O 与 IO1 共享）送达。
通过将（QUADSPI_CCR 中的）IMODE/ADMODE/ABMODE/DMODE 字段设置为 01，可
# O$ W- H$ n; b) b* l6 O" @对不同的命令阶段分别进行配置，以使用此单个位模式。
在每个已配置为单线模式的阶段中：
) E! k0 @# A! V# } IO0 (SO) 处于输出模式
, R0 G, v; _2 v' U  Y IO1 (SI) 处于输入模式（高阻抗）
6 s6 j2 u; L" J IO2 处于输出模式并强制置“0”（以禁止“写保护”功能）
 IO3 处于输出模式并强制置“1”（以禁止“保持”功能）

双线 SPI  模式：
在双线模式下，通过 IO0/IO1 信号同时发送/接收两位。
通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 10，可
对不同的命令阶段分别进行配置，以使用双线 SPI 模式。
在每个已配置为双线模式的阶段中：
( Y% X& k& N+ ]4 Z IO0/IO1 在数据阶段进行读取操作时处于高阻态（输入），在其他情况下为输出
+ ?% U6 X: X" ~" Q2 C) ~ IO2 处于输出模式并强制置“0”
 IO3 处于输出模式并强制置“1”
在空指令阶段，若 DMODE = 01，则 IO0/IO1 始终保持高阻态。
. v$ K: A; d8 g% t9 A/ {0 Q% K
2 N2 l4 K$ O3 e  N' l* U6 I- N
  _5 r: S! N6 a4 K四线 SPI  模式:
& r4 s' w6 E% [) K4 Z. I在四线模式下，通过 IO0/IO1/IO2/IO3 信号同时发送/接收四位。
% f% _0 R4 j! k+ `  ~通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 11，可
0 \0 S/ a  e' U8 n- X+ t对不同的命令阶段分别进行配置，以使用四线 SPI 模式。
9 w9 m8 E' ~5 ?9 W4 u- X2 N在每个已配置为四线模式的阶段中，IO0/IO1/IO2/IO3 在数据阶段进行读取操作时均处于高
阻态（输入），在其他情况下为输出。
在空指令阶段中，若 DMODE = 11，则 IO0/IO1/IO2/IO3 均为高阻态。
! z# R9 y8 S& ]% ^0 z" y  @IO2 和 IO3 仅用于 Quad SPI 模式 如果未配置任何阶段使用四线 SPI 模式，即使 QUADSPI
激活，对应 IO2 和 IO3 的引脚也可用于其他功能。
+ e9 k' a( V4 g: B/ g
$ O1 r3 \6 F$ m* \4 a+ E
2 H/ i/ ]1 F% R& d) rSDR  模式(默认工作模式)
. q. N/ z2 l$ I) l默认情况下，QUADSPI 在单倍数据速率 (SDR) 模式下工作。
" v7 s" k; O. \( Y) ?; `9 z5 ~在 SDR 模式下，当 QUADSPI 驱动 IO0/SO、IO1、IO2、IO3 信号时，这些信号仅在 CLK
的下降沿发生转变。
在 SDR 模式下接收数据时，QUADSPI 假定 Flash 也通过 CLK 的下降沿发送数据。默认情
, P& J) A: F5 E9 `+ r况下 (SSHIFT = 0 时)，将使用 CLK 后续的边沿（上升沿）对信号进行采样。
5 H' h: f; n* V& Z1 X
& g& ~5 H- k0 n! X0 `
DDR  模式
8 V" {& C/ h; W$ F4 Q& z4 v0 Q9 A在 DDR 模式下，当 QUADSPI 在地址/交替字节/数据阶段驱动 IO0/SO、IO1、IO2、IO3 信
# G3 y+ A0 s! {' F6 u5 ]( V号时，将在 CLK 的每个上升沿和下降沿发送 1 位。
- K  C1 }. V, ~1 }: N: T指令阶段不受 DDRM 的影响。始终通过 CLK 的下降沿发送指令。
在 DDR 模式下接收数据时，QUADSPI 假定 Flash 通过 CLK 的上升沿和下降沿均发送数
1 z) K* \; j' b据。若 DDRM = 1，固件必须清零 SSHIFT 位 (QUADSPI_CR[4])。因此，在半个 CLK 周期
后（下一个反向边沿）对信号采样。
, A5 Q- U, e) o& y
! s  U4 x. o" C9 Z6 X! M6 G9 i五、QSPI 配置（HAL库）

1.首先根据硬件电路，配置相关引脚，开启引脚和QSPI时钟

; P) U% J( M0 ^5 R

- @' n. [' B' c, C9 J

1. void HAL_QSPI_MspInit(QSPI_HandleTypeDef* qspiHandle)
   9 ~; Y* C) i7 [/ Y& X; E, P
2. {
   
3. 
   
4.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   
5.   if(qspiHandle->Instance==QUADSPI)
   # }0 @8 z1 V  c1 d3 A8 Q
6.   {
   
7.   /* USER CODE BEGIN QUADSPI_MspInit 0 */
   
8. 
   * c' c' _4 I# R0 x% x/ Y
9.   /* USER CODE END QUADSPI_MspInit 0 */
   9 Y% d9 g* x. X$ j
10.     /* QUADSPI clock enable */
    
11.     __HAL_RCC_QSPI_CLK_ENABLE();
    - V+ C( s1 i3 E* A/ V
12. 
    # l! F$ C! r8 c2 `
13.     __HAL_RCC_GPIOE_CLK_ENABLE();
    
14.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
15.     __HAL_RCC_GPIOD_CLK_ENABLE();
    
16.     /**QUADSPI GPIO Configuration   
    
17.     PE2     ------> QUADSPI_BK1_IO2
    $ }: t8 m( f' K9 d9 Z0 X
18.     PB6     ------> QUADSPI_BK1_NCS
    ; T; x; e/ Z3 Z& n) l8 w3 l
19.     PB2     ------> QUADSPI_CLK
    
20.     PD12     ------> QUADSPI_BK1_IO1
    
21.     PD13     ------> QUADSPI_BK1_IO3
    ; I% N3 c5 g8 ]+ G0 Q5 K' |
22.     PD11     ------> QUADSPI_BK1_IO0
    
23.     */
    
24.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    % f2 J; E; V4 c7 ^, ^, Z; u9 f
25.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
26.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
27.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    0 y, r2 A0 |% c% _% Q! d" @
28.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    
29.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
    
30. 
    
31.     GPIO_InitStruct.Pin = GPIO_PIN_6;
    
32.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
33.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
34.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
35.     GPIO_InitStruct.Alternate = GPIO_AF10_QUADSPI;
    0 a# }- p% ^' j
36.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    7 i( Z8 l* d" ]; S
37. 
    
38.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
39.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    , _5 p! I; {. N  K' u! k
40.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
41.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
42.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    
43.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
44. 
    - W7 ~9 ~" W5 q5 ^# n" D
45.     GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_11;
    . F) |6 X  N9 F, I( U
46.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ; H. ^# d# ]; H! ^. ~+ R4 x4 C
47.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
49.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    
50.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    
51. 
    
52.   /* USER CODE BEGIN QUADSPI_MspInit 1 */
    ! C- C! W' s$ [) N% h
53. 
    
54.   /* USER CODE END QUADSPI_MspInit 1 */
    
55.   }
    
56. }

复制代码

2.接着初始化SPI外设

1. 
   7 ^: Z4 Q9 }" V. D
2. QSPI_HandleTypeDef hqspi;
   7 v& t* K  j! A2 ?1 z3 L
3. 
   " a! W$ \0 J& d' ^# G9 e1 f
4. /* QUADSPI init function */
   
5. void MX_QUADSPI_Init(void)
   * g8 S0 x' {6 E5 I1 [4 j/ D
6. {
   3 [+ [  W( M' J: Y. h
7.   hqspi.Instance = QUADSPI;//QSPI外设
   + G/ [5 t% ]5 D! ]
8.   hqspi.Init.ClockPrescaler = 2;//QPSI分频比，N25Q128最大频率为104M，此处216/(2+1)=72M
   " b: @' G3 Y. j' I2 v
9.   hqspi.Init.FifoThreshold = 4;//FIFO阈值为4个字节
   7 @) \- _: e; o% u8 T
10.   hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;//采样移位半个周期(DDR模式下,必须设置为0)
    
11.   hqspi.Init.FlashSize = POSITION_VAL(0X1000000)-1;//SPI FLASH大小，N25Q128大小为16M字节
    $ J8 j  ~0 R7 n/ R
12.   hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_6_CYCLE;//片选高电平时间为6个时钟(1/72*6=55.2ns),即手册里面的tSHSL参数
    * n' @/ j" a) F( u
13.   hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;//时钟模式0
    
14.   hqspi.Init.FlashID = QSPI_FLASH_ID_1;//第一片flash
    - R0 n! Z. a9 Q( S4 t1 G
15.   hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;//禁止双FLASH模式
    
16.   if (HAL_QSPI_Init(&hqspi) != HAL_OK)//初始化QSPI外设
    
17.   {
    9 _8 n9 B6 ~* y* W! \9 C4 U9 O/ b8 @, n
18.     Error_Handler();
    
19.   }
    
20. }

复制代码

3.由于使用的是间接模式，我们对FLASH的所有操作都需要通过FLASH内部寄存器来完成，也就是通过向FALSH发送对应的指令来获得我们想要的结果，此时的FALSH就是一个普通的SPI协议外设，所以接下来所有对FALSH所有的操作都需要先发送相关指令，我们需要配置指令参数（指令类型、地址、数据宽度、地址宽度等等）。
7 @/ m0 O2 v* H* B4 R$ b
我们首先需要配置下面的命令参数结构体：
8 A9 t* I+ n' G6 s, J

Instruction:指令类型（读、写、擦除等等）

Address:需要读取或写入数据的起始地址
8 e! z2 z& |  o5 H& _
" t& F9 @6 M& d* WNbData:需要读取或写入数据的长度
' E8 Z' D& ?- ]' w$ e4 ]8 ^
" O0 s7 F2 ~# ?( g% E* uDataMode：数据传输模式，就是数据用几根线传输（1、2、4线可选），后面的AddreMode类似，就是用几根线传输地址，InstructionMode就是用几根线传输指令。
2 l8 ?  b6 k1 }% j$ b4 v% I
; n3 r+ I0 Q- B; A3 r% b" f: x1 W这三个参数都需要根据芯片数据手册来选择，手册上说明支持该模式才可以选择，否则会通信错误，另外，数据传输模式的不同，对应的指令类型也会不同，比如N25Q128 READ指令对应单线传输模式，Quad I/O Fast Read则对应四线传输模式，这些对应关系手册上都有详细说明！！！

4.读取芯片JEDEC ID
2 K; X5 f8 V! @
. T6 e% p4 v3 R3 h% l9 E首先查看手册上读取JEDEC ID的时序：
# L9 e. H$ L2 E: w7 N! P( h) N

( _3 C0 N2 o3 U# E- f
可以看出，读ID这条指令是只有指令阶段和数据阶段，且都是单线传输模式，所以

InstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令单线传输模式
, E4 \0 w, t# R0 H
DataMode = QSPI_DATA_1_LINE；//数据单线传输模式

9 g: [. n# x7 P6 P$ V7 i: i$ DAddress和AddressMode 这两个参数的值都置0，表示无地址。

NbData ：是想要读取的数据长度+1，ID是3个字节，这里令NbData=3

! C2 A$ l3 u  _1 }其他值和下面代码保持一致即可。
6 V+ H3 L3 D) K( u3 j+ V7 ?
$ g# m' _# ]2 C7 [, {! _/ M+ u. r6 h然后 使用HAL_QSPI_Command函数将读ID指令发送给FALSH，等待发送完成
5 `7 c, Z* [' d+ Z/ j* `/ R
: _. O  w8 d! D1 j最后 调用HAL_QSPI_Receive，接受FALSH返回的数据，即芯片ID
% S& ^. J  D$ N' E4 `) c. |

1. /**
   , K4 ~) k9 x8 M. w0 V
2. * @brief  读取FLASH ID
   $ H, O6 R) e" F5 K+ Y6 H& E) h, ^: ^
3. * @param   无
   3 K  R+ L. Y! K  M1 T% }
4. * @retval FLASH ID
   . F! u' @. v, i, y
5. */
   
6. uint32_t QSPI_FLASH_ReadID(void)
   
7. {
   , N. ^9 Y! H; S) k/ c" Y& n7 u
8.      QSPI_CommandTypeDef s_command;
   
9. 
   
10.      uint32_t Temp = 0;
    " {( X" l3 j! m3 P0 d
11. 
      }9 a1 Y" s3 J9 l# Q8 h. c# Z2 R
12.      uint8_t pData[3];
    
13. 
    
14.      /* 读取JEDEC ID */
    $ p! c( C. Q! U& t+ \$ x2 `
15. 
    
16.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令阶段的操作模式，00：无指令；01：单线传输指令；10：双线传输指令；11：四线传输指令。
    1 N% |/ ~9 ]5 N: B
17. 
    " V7 g5 U' n- l4 p. J
18.      s_command.Instruction       = READ_JEDEC_ID_CMD;//读取芯片ID指令
    # B0 B# j1 }# {  C: u% b/ a0 ?* q: y
19. 
    
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;//定义地址长度
    + o: F/ F7 |! ?- _$ @% P
21. 
    ) Z" r+ f, E8 q( S9 d0 [
22.      s_command.DataMode          = QSPI_DATA_1_LINE;//定义数据阶段的操作模式，00：无数据；01：单线传输数据；10：双线传输数据；11：四线传输数据。
    5 ^4 G$ h" @+ T+ q, R6 x( y: ]6 D) O
23. 
    " Z# a9 ?: q- e+ o' P
24.      s_command.AddressMode       = 0;//地址阶段的操作模式，00：无地址；01：单线传输地址；10：双线传输地址；11：四线传输地址。
    
25.          
    
26.      s_command.Address           = 0;   
    $ \' |; d4 p5 w: \' `' i
27.         
    , H# l* n, H' O2 |
28.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;//交替字节长度
    
29. 
    
30.      s_command.DummyCycles       = 0;//空指令阶段的持续时间，在 SDR 和 DDR 模式下，它指定 CLK 周期数 (0-31)。
    
31. 
    & P4 Q+ o5 u, h7 J: ~
32.      s_command.NbData            = 3;//设置数据长度，在间接模式和状态轮询模式下待检索的数据数量（值 + 1）。对状态轮询模式应使用不大于 3 的值（表示 4 字节）。
    
33. 
      Q1 o5 T2 u5 {0 t
34.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;//地址、交替字节和数据阶段设置 DDR 模式，0：禁止 DDR 模式；1：使能 DDR 模式。
    1 \& U3 o  `; s+ n
35. 
    
36.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;//设置DDR 模式下数据输出延迟 1/4 个 QUADSPI 输出时钟周期，0：使用模拟延迟来延迟数据输出；1：数据输出延迟 1/4 个 QUADSPI 输出时钟周期。
    
37.                  
    
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.                  {
    
42.          #if  QSPI_DEBUG
    - o" M, T* D2 C9 j. S! R
43.                      printf("send read flash ID command error!\r\n");
    
44.                #endif
    ; F* l6 ]' g) q4 E6 @% h
45.          /* 用户可以在这里添加一些代码来处理这个错误 */
    
46.          while (1) {}
    
47.      }
    
48.      if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    
49.                  {
    
50.          #if  QSPI_DEBUG
    
51.                      printf("read qspi flash ID error!\r\n");
    
52.                #endif
    2 j  N/ `8 i3 `& ~# R
53.          /* 用户可以在这里添加一些代码来处理这个错误 */
    . K3 u: ^# D, `4 Y* ^/ D% A
54.          while (1) {}
    
55.      }
    ) C" l1 u7 A$ b. P, @" f
56.      Temp = ( pData[2] | pData[1]<<8 )| ( pData[0]<<16 );
    
57.      return Temp;
    ( G# @4 b* S( W  E! w# }% K
58. }

复制代码

- W! V0 m4 z, [3 L3 ? 5.FALSH 写使能
/ Y. M0 S) K8 C; ]6 F& g
' K3 x% x% ~0 B. \# H$ q8 T在对FALSH进行写之前，需要打开写使能开关（实际上就是发送写使能指令）：
; w  ?% B6 F& j2 N4 i9 j
类似的，需要查看芯片手册，写使能的时序

( f2 k$ _5 l5 N可以看到这个指令时序更简单，仅仅有指令阶段，所以地址和数据的参数都应置0
: k& \) @: e& Q5 @" e! Y) g4 f

1. /**
   
2.   * @brief  QSPI FALSH写使能
   
3.   * @param  None
   2 |- ^- V& k6 }$ O! l3 @. V) i! C# `
4.   * @retval HAL_OK
   + \/ ~! S4 H) G  G
5. */
   
6. static HAL_StatusTypeDef QSPI_WriteEnable(void)
   6 u/ e4 ~* K# K! x  N% y: N5 a
7. {
   8 @9 Y  b; t. U$ L0 C; q/ z& L' Q4 o4 U
8.   QSPI_CommandTypeDef     sCommand;
   # f( k8 s' ]3 I' A
9.   QSPI_AutoPollingTypeDef sConfig;
   
10. 
    ) `9 P3 d6 x- W' t2 C1 r. f' s
11.   /* Enable write operations ------------------------------------------ */
    . E( ^, D7 D* o9 }
12.   sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    6 J7 W" q4 O7 j
13.   sCommand.Instruction       = WRITE_ENABLE_CMD;
    9 _! v& c0 v2 s4 O* H5 t: y
14.   sCommand.AddressMode       = QSPI_ADDRESS_NONE;
    
15.   sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
16.   sCommand.DataMode          = QSPI_DATA_NONE;
    
17.   sCommand.DummyCycles       = 0;
    7 H. D0 }2 t, J) G+ w7 W
18.   sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;
    % E* m' v- j8 T* a: Q( G/ r! f, E* K
19.   sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
20.   sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
21. 
    & b0 \* Z, j/ ?
22.   if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    7 q0 q/ c. O  Q- k6 d+ w9 ~
23.   {
    
24.     return HAL_ERROR;
    
25.   }
    
26. 
    * ^1 L4 `& M8 B; t) Z
27.   /* Configure automatic polling mode to wait for write enabling ---- */  
    ) T/ I* h3 a& |6 V) A; Q/ ^
28.   sConfig.Match           = 0x02;
    / O" k# r; N+ G0 j9 G& X; ^1 x
29.   sConfig.Mask            = 0x02;
    * ]4 P$ i$ l! F7 i; ~/ t
30.   sConfig.MatchMode       = QSPI_MATCH_MODE_AND;
    
31.   sConfig.StatusBytesSize = 1;
    
32.   sConfig.Interval        = 0x10;
    ! A5 g3 J- v2 n/ o* i
33.   sConfig.AutomaticStop   = QSPI_AUTOMATIC_STOP_ENABLE;
    7 s8 R1 p9 {# i( ]( t
34. 
    
35.   sCommand.Instruction    = READ_STATUS_REG1_CMD;
    
36.   sCommand.DataMode       = QSPI_DATA_1_LINE;
    ' y; ~, W, E( Q+ j* I6 Z
37. 
    ) D0 P! @( f! ]% q
38.   if (HAL_QSPI_AutoPolling(&hqspi, &sCommand, &sConfig, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    + x9 u; j5 T/ n# B( E
39.   {
    : s7 U- ~. S' m
40.                 return HAL_ERROR;        
    - Q' l  @6 l( z) p+ m+ x0 ~3 W
41.   }
    9 L. c7 q* L7 s* I+ t
42.         return HAL_OK;
    
43. }

复制代码

这里需要讲下 QUADSPI  状态标志轮询模式：
在自动轮询模式下，QUADSPI 周期性启动命令以读取一定数量的状态字节（最多 4 个）。
可屏蔽接收的字节以隔离一些状态位，从而在所选的位具有定义的值时可产生中断。
对 Flash 的访问最初与在间接读取模式下相同：如果不需要地址 (AMODE = 00)，则在写入
QUADSPI_CCR 时即开始访问。否则，如果需要地址，则在写入 QUADSPI_AR 时开始第
' R4 E- q1 b, Q# L0 q一次访问。BUSY 在此时变为高电平，即使在周期性访问期间也保持不变。
7 J: E4 B+ Q; @; _; j- R- f在自动轮询模式下，MASK[31:0] (QUADSPI_PSMAR) 的内容用于屏蔽来自 Flash 的数据。
如果 MASK[n] = 0，则屏蔽结果的位 n，从而不考虑该位。如果 MASK[n] = 1 并且位 [n] 的内
( x- p7 L: ]& R0 d6 w$ f; [/ A/ V容与 MATCH[n] (QUADSPI_PSMAR) 相同，说明存在位 n 匹配。
' N" z/ }. [# {7 `如果轮询匹配模式位 (PMM, QUADSPI_CR[23]) 为 0，将激活“AND”匹配模式。这意味着
% C( z3 U1 q. D8 N状态匹配标志 (SMF) 仅在全部未屏蔽位均存在匹配时置 1。
如果 PMM = 1，则激活“OR”匹配模式。这意味着 SMF 在任意未屏蔽位存在匹配时置 1。
- @/ q$ O6 V2 A( o' D; j4 ~/ Q如果 SMIE = 1，则在 SMF 置 1 时调用一个中断。
如果自动轮询模式停止 (APMS) 位置 1，则操作停止并且 BUSY 位在检测到匹配时清零。否
( X8 @2 ]! X9 F/ [( U2 M2 N则，BUSY 位保持为“1”，在发生中止或禁止 QUADSPI (EN = 0) 前继续进行周期性
访问。
数据寄存器 (QUADSPI_DR) 包含最新接收的状态字节（FIFO 停用）。数据寄存器的内容不
; O2 z$ `: w- q, t, F" N! v受匹配逻辑所用屏蔽方法的影响。FTF 状态位在新一次状态读取完成后置 1，并且 FTF 在数
据读取后清零。

简单的说，就是CPU自动查询FALSH指定的标志位是否置位或清零，通过调用HAL_QSPI_AutoPolling函数，CPU将自动查询FALSH写使能标志位是否被置位，成功返回HAL_OK,否则返回HAL_ERROR，这样就省去了我们自己发读寄存器指令查询的麻烦了。

6.读FALSH
+ {) D+ C- h/ T, i5 \* l
这里仅介绍4线模式下的读FALSH流程，首先查看手册4线模式读时序

% b) }8 G. {" p0 \1 h

从时序图可以看出，指令是1线模式，地址是4线模式，空周期（DummyCycles）为10，数据也是4线模式，还有此时的读指令是QUAD_INOUT_FAST_READ_CMD。所以相关参数配置如下：

1. /**
   
2. * @brief  从QSPI存储器中读取大量数据.
   
3. * @param  pData: 指向要读取的数据的指针
   $ ^& f: V( R3 D
4. * @param  ReadAddr: 读取起始地址
   
5. * @param  Size: 要读取的数据大小
   
6. * @retval QSPI存储器状态
   
7. */
     }( K1 ^% r& m8 h9 [5 U9 \
8. HAL_StatusTypeDef BSP_QSPI_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)
   , V1 O( @: }+ v" `/ S
9. {
   
10.      QSPI_CommandTypeDef s_command;
    ' s; s; c# `& k: ~$ @
11. 
    % T3 G. U; R/ R  p1 ^6 y6 C+ t2 r
12.      /* 初始化读命令 */
    
13. 
    
14.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
15. 
    
16.      s_command.Instruction       = QUAD_INOUT_FAST_READ_CMD;
    
17. 
    
18.      s_command.AddressMode       = QSPI_ADDRESS_4_LINES;
    ( }! ^8 a- d) B7 D$ Q0 K& C) g
19. 
    ) q( o0 |! ^7 Q8 X4 ?8 d" w/ }
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    ( c7 t" K! l  W- p  x
21. 
    6 D! T) H! O8 z& m
22.      s_command.Address           = ReadAddr;
    
23. 
    " R' g3 O' C8 P0 F4 R  @+ K
24.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    ' G# s; t4 {, u$ k% K
25. 
    + ~9 v' C. r: e* _
26.      s_command.DataMode          = QSPI_DATA_4_LINES;
    
27. 
    % Z5 v1 J, \( [4 \: M7 e. k7 h
28.      s_command.DummyCycles       = 10;
    8 X9 `" [+ B3 L# f/ j6 P; C
29. 
    
30.      s_command.NbData            = Size;
    
31. 
    " a) N7 r' V2 i. f3 b$ R2 U+ S6 s5 S
32.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    7 b9 _- _  p; ]# ?5 ?) u6 r
33. 
    8 C& r- V4 z' f. L+ [4 E$ L9 T
34.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
35. 
    , m0 H3 _9 R8 Y" r0 Z* H. A
36.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    0 J6 d: m8 ^) [) O
37.      /* 配置命令 */
    
38. 
    
39.    if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    " N! C2 e# m/ c1 @( Z
40.          {
    ! z! s: H; u3 s/ [( \, R9 |
41.                 #if  QSPI_DEBUG
    . |4 W  H' V' `* ?' o
42.                 printf("R-send read command error!\r\n");
    
43.           #endif
    ! r- C* k+ f) B& p4 K: y
44.     return HAL_ERROR;
    0 s- s9 G( C3 S: f
45.    }  
    
46.    /* 接收数据 */
    
47.    if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    ) [" X. Z+ Y* w( P8 _" J
48.          {
      k: G$ X% r! B" y
49.                 #if  QSPI_DEBUG
    
50.                 printf("R-read data error!\r\n");
    
51.           #endif
    
52.     return HAL_ERROR;
    
53.    }
    
54.    return HAL_OK;
    ( l! P$ b- e. e% m
55. }

复制代码

本函数实现了从FALSH指定地址读取指定数量字节的功能

7.写FALSH
0 s  N- Y4 z2 u$ o% ]% N; c
同读FALSH类似，我们需要在手册中找到4线写FALSH的时序：

' |, ]& w7 {) P( i' M. [  J根据时序图配置如下：1线指令，1线地址，24bit地址，4线数据，没有空周期
  p4 k4 D/ k6 H& D2 _1 M" c4 h+ @
7 X, Z! O. K- x( e) F/ J

1. /**
   . p5 E2 B+ D4 y- N6 K; e7 `. h: F
2. * @brief  将大量数据写入QSPI存储器
   $ h$ R2 X8 T7 z: I0 o# v
3. * @param  pData: 指向要写入数据的指针
   
4. * @param  WriteAddr: 写起始地址
   & G; T' [6 F1 I* g5 }5 l- R
5. * @param  Size: 要写入的数据大小
   * H& D  X2 a& I$ u) d, l
6. * @retval QSPI存储器状态
   
7. */
   
8. HAL_StatusTypeDef BSP_QSPI_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
   0 _/ Y) q  d: p0 `+ N) k& b+ Z
9. {
   + e$ d; M  l5 b- k% r1 s8 G
10.                         QSPI_CommandTypeDef s_command;
    
11.                         uint32_t end_addr, current_size, current_addr;
    
12.             unsigned char sector_start,sector_end,i;
    * l: A9 a6 c4 U* I$ U
13.         
    $ u& i& _% b. Z6 z5 l
14.                         /* 计算写入地址和页面末尾之间的大小 */
    ( l1 k; d, Z* ]0 S' [7 q! L
15.                         current_addr = 0;
    0 H' O. A# |& i/ M3 c6 T7 _
16.         
    % @# O* V% r1 m( c
17.                         while (current_addr <= WriteAddr)
    ) |' G2 c! S% m# n5 N+ Z/ @
18.                         {
    
19.                                         current_addr += N25Q128FV_PAGE_SIZE;
    
20.                         }
    ; X: C. u3 t0 @! Y$ L+ k
21.                   current_size = current_addr - WriteAddr;
    - _$ A8 H! v; ^) D9 ]+ y; \, Z
22.      /* 检查数据的大小是否小于页面中的剩余位置 */
    7 m; h5 u: j* R/ Z" u* c) e
23.      if (current_size > Size)
    1 h3 D+ {9 d  A: r( L! {
24.                  {
    
25.          current_size = Size;
    , S- I/ Q' i* t
26.      }
    
27.      /* 初始化地址变量 */
    9 }/ [% W3 a4 \3 i6 e
28.      current_addr = WriteAddr;
    
29.      end_addr = WriteAddr + Size;
    $ N5 [9 i9 Z; Q/ i& T, U! M
30.                  
    , P2 y8 c# L6 E
31.                  sector_start = current_addr >> 16;
    
32.                  sector_end = end_addr >> 16;
    
33.                  
    8 G2 ~$ z, Q8 k
34.                  for( i = sector_start; i<=sector_end ;i++)
    . s. S) |0 q( x# _3 V9 K# B- ?
35.                  {
    
36.                     BSP_QSPI_Erase_Block(i); //擦除对应删除
    3 A2 V& S( \" x0 m8 X: d; t- d
37.                  }
    ( g" @5 N8 D3 @. H. Z* z0 H
38.                  
    & c- G% x4 f; Z) {, F
39.      /* 初始化程序命令 */
    ( v  s2 G' x; V) ~2 O( m
40.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    2 b* M2 L! ~! Y( r# X' E
41. 
    6 T8 f+ h  s. h9 \' \' {
42.      s_command.Instruction       = QUAD_INPUT_PAGE_PROG_CMD;
    
43. 
    
44.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    
45. 
    + Y' {% U, B/ d2 a# M
46.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    + x# m+ N$ G" [$ F1 ^  _
47. 
    
48.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
49. 
    6 ?: m- f0 A- G' [
50.      s_command.DataMode          = QSPI_DATA_4_LINES;
    
51. 
    7 A- Y& _) @' P7 ?% M, J' G0 T. c  V
52.      s_command.DummyCycles       = 0;
    ' `8 @: i2 S; O1 P' A- ]
53. 
    
54.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    : u( t1 ?# B8 Z0 S' k/ e
55. 
    
56.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
      m' u! s) y5 M
57. 
    
58.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    2 ?. j& @# T( G# [; b8 c7 V4 H9 j
59. 
    $ J! F3 n6 l& ^! y
60.      /* 逐页执行写入 */
    
61.      do {
    5 \* v4 u! k7 B+ z3 R
62. 
    2 L% B1 D0 P6 ]* k: s
63.          s_command.Address = current_addr;
    
64.          s_command.NbData  = current_size;
    / a, }* r1 T* {% m
65.          /* 启用写操作 */
    
66. 
    , r" J# F7 w/ O- T
67.          if (QSPI_WriteEnable() != HAL_OK)
    , W9 a1 g& ~$ A9 F- {
68.                                  {
      ?6 ?( P: i1 @0 [/ h& d: D; V
69.                                                 #if  QSPI_DEBUG
    * ~* {) H7 X+ m" }  O: V/ o
70.                                                 printf("W-Qspi write enable error!\r\n");
    5 B$ q1 o  x* [7 H
71.                                                 #endif
    
72.             return HAL_ERROR;
    
73.          }
    , e, u3 B2 {- O9 I9 H5 J
74.          /* 配置命令 */
    * L) E. u" N5 l  x+ M, s+ U: j% [: p
75.         if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    & `% a3 o0 A" r) Y$ X
76.                 {                                 
    % q. m) P" z+ d/ c2 `# A
77.                                           #if  QSPI_DEBUG
    
78.                                                 printf("W-Qspi send Command error!\r\n");
    
79.                                                 #endif
    
80.             return HAL_ERROR;
    
81.          }
    / }1 [. ?) r3 n4 g2 s
82.          /* 传输数据 */
    
83.          if(HAL_QSPI_Transmit(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    % R" t. F. y: y/ _7 y- U
84.                                  {
    4 M# }4 S5 T; M( [: B% H7 D
85.                                           #if  QSPI_DEBUG
    * V- d" ^% g$ g8 @7 R
86.                                                 printf("W-Qspi Transmit data error!\r\n");
    
87.                                                 #endif
    
88.             return HAL_ERROR;
    3 }) F1 L! C& z4 D, b! c/ k  a
89.          }
    ! E+ g  b  g5 Y! s
90.          /* 配置自动轮询模式等待程序结束 */
    
91. 
    
92.          if(QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    . `* }+ p2 E) l0 o; \  a
93.                                  {                                         
    
94.                                                 #if  QSPI_DEBUG
    ) ^, C( l# R$ M( q% \
95.                                                 printf("W-AutoPollingMemReady error!\r\n");
    ! I- ^, s  n# L8 G6 H
96.                                                 #endif
    8 r" X+ x6 l# L. t* G
97.             return HAL_ERROR;
    
98.          }
    $ Y4 Y, e) T- D: F( f
99.          /* 更新下一页编程的地址和大小变量 */
    
100. 
     1 M/ Z; {2 o3 _7 I
101.          current_addr += current_size;
     2 ~* n, n- X8 g: b" P
102. 
     0 ^8 c. H. b0 T
103.          pData += current_size;
     ( g8 f( E; k2 d
104. 
     
105.          current_size = ((current_addr + N25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr-current_addr) :
     
106. 
     ( l" @2 G) I) ^; O" S% j- Q' ]& D
107.                         N25Q128FV_PAGE_SIZE;
     : Z- r" k1 P$ u& m1 F$ s
108. 
     
109.      } while (current_addr < end_addr);
     " N8 J& r# {1 ?. N  y
110.      return HAL_OK;
     
111. }

复制代码

该函数实现从指定地址写入指定数量的字节。

8.擦除FALSH

第一种情况是按扇区擦除，这也是N25Q128最小的擦除单位（N25Q128共有256个扇区，每个扇区64KB）

/ Y  [/ s7 b0 ~2 z) x+ ]. S' X5 h

+ R( z9 ^9 w  ?* X3 ?" \4 n' ]
# D9 h% @0 ?/ D: v4 Q参数设置为1线指令 ，1线地址，24bit地址，无数据阶段
/ j) [9 @& @5 o3 f0 i2 c
3 Q. j9 c0 ?* L$ `- E' A* u7 {

1. /**
   
2. * @brief  擦除QSPI存储器的指定扇区
   2 Q4 e1 k3 U% ^6 j" r- v5 J
3. * @param  BlockAddress: 需要擦除的扇区地址
   
4. * @retval QSPI存储器状态
   3 A# b: c2 K9 r( G: v
5. */
   
6. HAL_StatusTypeDef BSP_QSPI_Erase_Sector(uint32_t Sector)
   
7. {
   
8.            uint32_t SectorAddress=Sector << 16;//Sector*65535算出该扇区对应的地址
   ; a- V7 X& I# I7 X" W
9.         
   6 W% d2 }* v" s  b
10.      QSPI_CommandTypeDef s_command;
    
11.      /* 初始化擦除命令 */
    
12.         
    . [& c9 Q+ c8 \/ Z. _" w
13.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    0 G9 q/ V& f; e; V$ T. a( H0 I
14. 
    
15.      s_command.Instruction       = SECTOR_ERASE_CMD;//按扇区擦除
    
16. 
    ( G' m3 ?- W2 @9 Y# ]
17.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    % y1 F: |6 P+ }) i7 N
18. 
    
19.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    6 S# D5 D) }. u# o2 F
20. 
    ) e9 u  `4 z' i4 c" |
21.      s_command.Address           = SectorAddress;
    * ?# @& t  ?9 v5 B
22. 
    
23.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    . n1 a4 A3 Y1 u$ W. M. ^8 Q) Q
24. 
    4 U1 j8 X' N( z% `/ i
25.      s_command.DataMode          = QSPI_DATA_NONE;
    # c3 Y1 |8 y4 q& A, C7 B
26. 
    
27.      s_command.DummyCycles       = 0;
    & y& a" ^2 B4 g5 n2 [, A
28. 
    4 }- D7 T$ W: y3 l/ n+ ?% D
29.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    + ~9 J0 _, b1 n
30. 
    
31.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    " R- S9 W7 n+ w; c+ d" T9 z
32. 
    
33.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
34. 
    
35.      /* 启用写操作 */
    - @  w; [6 q% J0 m
36. 
    & C. o) L! M( }% I) ?+ n1 i( |
37.      if (QSPI_WriteEnable() != HAL_OK)
    6 ^  G8 G$ |2 [. H! W+ V
38.                  {
    
39.          return HAL_ERROR;
    # a; s' C$ {; {0 k' C
40.      }
    " m& |1 t/ z6 W! m& ?
41.      /* 发送命令 */
    
42.      if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
      w/ j- O& K6 T% \/ \" s
43.      {
    2 t9 j, [. b% q3 H: e9 g
44.          return HAL_ERROR;
    " \( C2 D+ r- M# L# K% I2 P3 N4 J
45.      }
    
46.      /* 配置自动轮询模式等待擦除结束 */
    
47. 
    # I4 p& ]6 v, J4 ~* x, a7 [  Y$ k/ f
48.      if (QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    " R* Z. w7 ~  ]6 v! [
49.      {
    3 x7 M  E' H- Z* d' }: x
50.                                 #if  QSPI_DEBUG
    
51.                                 printf("erase sector error!\r\n");
    4 y$ M+ X% q" U
52.                                 #endif
    
53.         return HAL_ERROR;
    
54.      }
    
55.     return HAL_OK;
    
56. }

复制代码

第二种情况是全片擦除，时序如下：

* z1 y+ M, Z) a8 [2 M: d

1 Y- {' ^( @' X. D  w6 C6 p
全片擦除仅包含指令阶段，对于N25Q128来说，全片擦除耗时可达48s。
% @9 F- Z' ^; ]9 ^4 p, ?. t7 T

1. /**
   ) ?- s: b: J5 ]6 l+ `( x
2.   * @brief  全片擦除  N25Q128全片擦除耗时48s
   ) X! @# L) U  e$ l2 O6 a: I3 i4 e% E8 I
3.   * @retval QSPI memory status
   3 l2 d( ?, f6 I
4.   */
   
5. uint8_t BSP_QSPI_Erase_Chip(void)
   5 ~$ N% O' d3 T: W2 \- M
6. {
   
7.   QSPI_CommandTypeDef s_command;
   
8. 
   
9.   /* Initialize the erase command */
   7 ]4 N2 O  U: Y- o) S, s
10.   s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
11.   s_command.Instruction       = CHIP_ERASE_CMD;
    ) a0 W6 Z, t' h# e* ?
12.   s_command.AddressMode       = QSPI_ADDRESS_NONE;
    ; U# A. z- f, i
13.   s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    & H) R6 D: C: l- S4 Y
14.   s_command.DataMode          = QSPI_DATA_NONE;
    ' l" L9 `8 K8 X
15.   s_command.DummyCycles       = 0;
    
16.   s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    
17.   s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    % |0 o' g7 d  s( E
18.   s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    1 R) Y# Z' S+ y6 A+ d7 \- j, M! e
19. 
    $ k/ Z( Z3 p3 n# C, }
20.   /* Enable write operations */
    7 t: V1 [- q1 r  v' r$ b8 y& m
21.   if (QSPI_WriteEnable() != HAL_OK)
    
22.   {
    
23.     return HAL_ERROR;
    + ]7 g# `0 n$ w9 O, M9 b) J
24.   }
    . _' T8 E* g7 s) A3 I( T
25. 
    - Q. C/ g% Y, S# ?% \3 s
26.   /* Send the command */
    
27.   if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
28.   {
    9 t5 w3 `; U$ f$ S
29.     return HAL_ERROR;
    
30.   }
    
31. 
    
32.   /* Configure automatic polling mode to wait for end of erase */  
    
33.   if (QSPI_AutoPollingMemReady(N25Q128A_BULK_ERASE_MAX_TIME) != HAL_OK)
    & @0 ?) N7 Z, G* c) p5 n3 E2 \; w
34.   {
    
35.     return HAL_ERROR;
    + p6 y5 l& X, {
36.   }
    3 H9 k& Z& W  c& _; y! F
37. 
    & ]% h$ a( S" s0 V$ l
38.   return HAL_OK;
    5 u: s- J. H* |. a
39. }

复制代码

9.测试程序
! w4 `8 U9 z! j% a
7 k) Z) I8 X) ~( [0 J0 n" a测试芯片写入和读取是否成功，首先向0x1FFFF地址连续写入4096个字节，然后再读取出来，对比两次数据是否一致。
3 B$ V; b) S5 ~& y( @8 {9 T- A
7 _7 ?: m5 S: r

1. unsigned char write[4096];
   
2. unsigned char read[4096];   
   
3. void N25Qxx_Test(void)
   ' m5 J1 r8 Z% F0 i+ \
4. {
   ' A9 r, a2 r0 w; {3 {  S
5.   uint32_t i = 0;
   / k, f. e; v5 G& H0 B0 S& a9 f
6. 
   
7.         for(i = 0;i<sizeof(write);i++)
   
8.         {
   ' l' w1 r0 [5 a8 E9 x
9.     write=i;
   
10.         }
    9 Z" O1 Z9 W4 L
11.         
    6 {! L5 S  z, M" ]# }
12.         printf("write data:\r\n");        
    
13.   for(i = 0;i<sizeof(write);i++)
    % b7 b  M$ e7 r/ ]/ Q
14.         {
    : H3 ]7 I6 r. P# U5 k8 o: @
15.                 printf("%d ",write);
    
16.         }
    
17.   printf("\r\n");
    
18.         printf("\r\n");
    6 n6 W% _8 V, p2 q6 D  V( l
19.         printf("\r\n");
    
20.         
    
21.         BSP_QSPI_Write(write,0x1FFFF,sizeof(write));
    . m3 l# o- x' S
22.   BSP_QSPI_Read(read,0x1FFFF,sizeof(write));        
    4 n% a/ K9 }. Y# x  w+ A0 c
23.         
    ; n' h. l* B# [7 q
24.         printf("Read from QSPI:\r\n");
    
25.         
    9 ]/ M: ]6 b' F9 |+ v: E% C
26.   for(i = 0;i<sizeof(read);i++)
    
27.         {
    
28.                 printf("%d ",read);
    0 l" _, f/ w7 U: l5 Y2 R
29.         }
    
30.   printf("\r\n");
    
31. }

复制代码

( E! v& V1 q2 ?) w写入的数据（部分截图）：
  R9 m6 L# [! V/ B5 X$ s8 D

# |- {9 Y6 c( e7 H& h/ F, ^+ y
读取的数据（部分截图）：

5 O2 e; u8 v3 ]* k6 M& J$ _/ d截取相同的部分，两次数据完全一致，写入和读取成功。
$ D' y. @7 H" O
最后，讲几点需要注意的地方：
0 ~$ ~, S9 D* o' B0 U' b) m+ ~* o6 I
1 M! F! z; N$ Q7 N# j! x! z1.N25Q128 与  W25Q128 有很多不同的地方，特别是4线模式下，二者很多地方不同，代码不可混用，比如W25Q128的很多指令都是支持4线的，但是N25Q128的指令阶段均不支持4线模式。
6 M* b/ o: M8 V% F- Y
2.硬件上使用了4线SPI，但是仍然可以使用单线SPI操作，只是速度慢了点，其他的没什么影响。

3.N25Q128在配置为内存映射模式时，外部 SPI 器件被视为是内部存储器。QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。如果访问的地址超出 FSIZE 定义的范围但仍在 256MB 范围内，则生成 AHB 错误。此错误的影响具体取决于尝试进行访问的 AHB 主设备：
 如果为 Cortex ® CPU，则生成硬性故障 (Hard fault) 中断
 如果为 DMA，则生成 DMA 传输错误，并自动禁用相应的 DMA 通道。
+ ]1 z  l' K, u, K. a
: J' e4 J$ s3 n) v& X2 J; f( }4.N25Q128包含248个主扇区，每个扇区64KB,还有8个64KB的启动扇区，这8个启动扇区又可分为128个子扇区，每个子扇区大小为4KB，所有的扇区擦除都可以按照一次64KB大小擦除，但是这8个启动扇区也可以按照4KB一次擦除（需要使用SUBSECTOR_ERASE_CMD指令擦除）。
+ h4 n. u2 J! z1 K5 y) H, C
5.N25Q128分TOP和Bottom架构，两种架构的区别就是启动扇区的位置不同，TOP架构的启动扇区是248~255（地址范围：F80000 ~FFFFFF），0~248为主扇区。Bottom架构的启动扇区是0~7（地址范围：0~7FFFF），8~255是主扇区。这两中架构可以通过完整的型号区分。
! f0 |) C2 a  m3 P) \5 }, L

/ q( w* L; T+ M- u
6.N25Q128和W25Q128 不可以相互替换，除非使用单线SPI通信，且只能使用F80000 ~FFFFFF或者0~7FFFF范围内的内存。
; Z3 {0 f" q" g4 a0 I
$ h, O. H/ k) B0 `, i& \7.N25Q128的指令在不同spi模式（单线、双线、四线）下有所不同，使用时一定要特别注意！！！


% l1 L# u" U; Y' e% j
; u6 Q7 k2 n& r" V