一、QSPI接口介绍

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

- r* r" \% t  G7 r: p" U 间接模式：使用 QUADSPI 寄存器执行全部操作，支持对FALSH进行读、写、擦除、锁定等操作。
7 c, }- a( \) ^! d8 H& X
 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）

- `" [' U5 D# H 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器
" Z( f8 B# X" B% E4 b) C2 W+ s6 }6 q
采用双闪存模式时，将同时访问两个 Quad-SPI Flash，吞吐量和容量均可提高二倍。
, Z: a. |# m* F: t, H
) H, @8 z% a4 e$ f内存映射模式支持XIP，即可以将代码放在外部FLASH运行，缺点就是有延迟，没有内部运行速度快，且外部FALSH只能读，不能写入或擦除。
( O, F/ r* F0 n7 Q( _
内存映射模式下QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。
5 M/ L3 P7 R( r8 `+ l/ _
二、 STM32QSPI 功能框图

5 }* R6 A% Z" l3 Z

. G+ ^% ~% q+ O. ~/ Y
( I% \! R5 y- W% r) t* TSTM32F7系列支持双QSPI接口，可以接两个外部FLASH，本文只介绍接一个FALSH的情况。QSPI使用6根线通信，其中数据线4根，1根时钟线，1根片选线，但是程序里是可以配置工作在几线模式。
. P$ |5 Q5 H+ T
' W: e2 c" r% F' t9 k: C三、QUADSPI  命令序列
( X) @% t) h  {  k
QUADSPI 通过命令与 Flash 通信 每条命令包括指令、地址、交替字节、空指令和数据这五
/ t" m! W' N8 x1 X( z) D个阶段，任一阶段均可跳过，但至少要包含指令、地址、交替字节或数据阶段之一。
8 P% t: N3 \7 R# n7 unCS 在每条指令开始前下降，在每条指令完成后再次上升。

" p5 u) e% P4 J/ `# M6 ?- j

上图清晰的展示了一次QSPI通信过程，它完整的包含了通信的5个阶段，但不是每次通信都需要包含这5个阶段.
2 }( G! E" Q1 J% `  _" ~- f
) k0 D5 C, m/ A7 S交替字节阶段，将 1-4 字节发送到 Flash，一般用于控制操作模式。|正常读写是不需要的，所以这个阶段可以省略（结构体中该参数置0）；
9 |4 ]: R* Q( ~; s3 `' N4 x; j
空指令周期阶段，给定的 1-31 个周期内不发送或接收任何数据，目的是当采用更高
# D) Q) k  {2 K4 m2 {, ~& L+ w+ T的时钟频率时，给 Flash 留出准备数据阶段的时间。
9 [: p! m; M8 R! R1 b' o! z. n$ T若 DummyCycles为零，则跳过空指令周期阶段，命令序列直接进入数据阶段（如果存在）。

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

四、QUADSPI  信号接口协议模式
9 c  G7 K, v/ f: `7 a; e) M
下面提到的几线模式都是指数据线的根数

单线 SPI  模式（即普通SPI通信，等同于使用MISO、MOSI、CLK、CS方式通信）:
- m" c" I( M4 \3 c$ i0 m8 s传统 SPI 模式允许串行发送/接收单独的 1 位。在此模式下，数据通过 SO 信号（其 I/O 与
IO0 共享）发送到 Flash。从 Flash 接收到的数据通过 SI（其 I/O 与 IO1 共享）送达。
通过将（QUADSPI_CCR 中的）IMODE/ADMODE/ABMODE/DMODE 字段设置为 01，可
对不同的命令阶段分别进行配置，以使用此单个位模式。
% c. c3 o: J" Y; W$ x5 P) i& p在每个已配置为单线模式的阶段中：
0 v& L) I4 L; T- V  b IO0 (SO) 处于输出模式
0 y0 e0 p/ ]1 K0 } IO1 (SI) 处于输入模式（高阻抗）
; T5 c# K. G5 U IO2 处于输出模式并强制置“0”（以禁止“写保护”功能）
 IO3 处于输出模式并强制置“1”（以禁止“保持”功能）
1 s& _0 H/ F, |4 U
: {4 }, O8 H* S7 J' E双线 SPI  模式：
3 ]! y- Z: R' ~: |! \在双线模式下，通过 IO0/IO1 信号同时发送/接收两位。
通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 10，可
对不同的命令阶段分别进行配置，以使用双线 SPI 模式。
5 f5 u- V9 l& u5 B$ A1 B( L在每个已配置为双线模式的阶段中：
 IO0/IO1 在数据阶段进行读取操作时处于高阻态（输入），在其他情况下为输出
 IO2 处于输出模式并强制置“0”
, l9 @9 O6 Q; [" j7 O IO3 处于输出模式并强制置“1”
8 j2 B$ z) {" U8 l在空指令阶段，若 DMODE = 01，则 IO0/IO1 始终保持高阻态。


% c: B; F: H6 o7 j8 W# j四线 SPI  模式:
在四线模式下，通过 IO0/IO1/IO2/IO3 信号同时发送/接收四位。
通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 11，可
对不同的命令阶段分别进行配置，以使用四线 SPI 模式。
在每个已配置为四线模式的阶段中，IO0/IO1/IO2/IO3 在数据阶段进行读取操作时均处于高
阻态（输入），在其他情况下为输出。
; [+ A. g. i) U. C9 S! y1 T在空指令阶段中，若 DMODE = 11，则 IO0/IO1/IO2/IO3 均为高阻态。
* b5 J9 d) Y) k* eIO2 和 IO3 仅用于 Quad SPI 模式 如果未配置任何阶段使用四线 SPI 模式，即使 QUADSPI
激活，对应 IO2 和 IO3 的引脚也可用于其他功能。


SDR  模式(默认工作模式)
- v  Z  ]3 W% \6 V& W2 w默认情况下，QUADSPI 在单倍数据速率 (SDR) 模式下工作。
5 `+ T9 C$ k! g在 SDR 模式下，当 QUADSPI 驱动 IO0/SO、IO1、IO2、IO3 信号时，这些信号仅在 CLK
) P0 G+ E# F$ X' p3 d: P的下降沿发生转变。
在 SDR 模式下接收数据时，QUADSPI 假定 Flash 也通过 CLK 的下降沿发送数据。默认情
* v! B( D! k) A况下 (SSHIFT = 0 时)，将使用 CLK 后续的边沿（上升沿）对信号进行采样。
6 P! z7 H* ~2 w" m5 }# \

DDR  模式
0 n8 }- k! ^. B" J5 t9 [' g在 DDR 模式下，当 QUADSPI 在地址/交替字节/数据阶段驱动 IO0/SO、IO1、IO2、IO3 信
号时，将在 CLK 的每个上升沿和下降沿发送 1 位。
指令阶段不受 DDRM 的影响。始终通过 CLK 的下降沿发送指令。
在 DDR 模式下接收数据时，QUADSPI 假定 Flash 通过 CLK 的上升沿和下降沿均发送数
据。若 DDRM = 1，固件必须清零 SSHIFT 位 (QUADSPI_CR[4])。因此，在半个 CLK 周期
! U  j) X# s+ f& u. I后（下一个反向边沿）对信号采样。

- B/ P$ q! b0 U" r, m五、QSPI 配置（HAL库）
- n3 e1 Y8 x4 v
3 {. U3 ~. q7 U$ a! o1.首先根据硬件电路，配置相关引脚，开启引脚和QSPI时钟
) J1 Z9 k! D7 u3 z

; l" E; ~! c; p* Z1 N

1. void HAL_QSPI_MspInit(QSPI_HandleTypeDef* qspiHandle)
   ; b. U" T9 f" X: B% y7 j
2. {
   - Y0 U* x1 u  m( i6 e7 T* J5 Y4 m
3. 
   
4.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   
5.   if(qspiHandle->Instance==QUADSPI)
   % C% P: Y4 W" r& B7 m) G2 L5 {, k
6.   {
   
7.   /* USER CODE BEGIN QUADSPI_MspInit 0 */
   
8. 
   ; P) h  [8 O- \% C
9.   /* USER CODE END QUADSPI_MspInit 0 */
   
10.     /* QUADSPI clock enable */
    ! v2 d; W7 J% a
11.     __HAL_RCC_QSPI_CLK_ENABLE();
    
12. 
    
13.     __HAL_RCC_GPIOE_CLK_ENABLE();
    
14.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
15.     __HAL_RCC_GPIOD_CLK_ENABLE();
    
16.     /**QUADSPI GPIO Configuration   
    * h4 f9 a- a0 {8 Z! [
17.     PE2     ------> QUADSPI_BK1_IO2
    
18.     PB6     ------> QUADSPI_BK1_NCS
    
19.     PB2     ------> QUADSPI_CLK
    
20.     PD12     ------> QUADSPI_BK1_IO1
    ; i2 v/ X! r4 N0 |
21.     PD13     ------> QUADSPI_BK1_IO3
    
22.     PD11     ------> QUADSPI_BK1_IO0
    
23.     */
    ) Q6 @  i  Q3 q+ V3 {
24.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
25.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
26.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    0 f7 h- v5 a" C/ F7 M" m
27.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
28.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    % u, [1 B% ?3 H; l3 K* a
29.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
    + R$ T- z% h: Z. m  b8 C5 w* A4 r% r
30. 
    
31.     GPIO_InitStruct.Pin = GPIO_PIN_6;
    
32.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    : R, h, `4 B/ p. n4 o
33.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    # [; O, t( ~; Y. S9 Z! i
34.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
35.     GPIO_InitStruct.Alternate = GPIO_AF10_QUADSPI;
    
36.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
37. 
    
38.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
39.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    * q$ E! }9 g& j% T* x. k& D: w6 W
40.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
41.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
42.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    5 G- J/ [5 Q6 @3 J
43.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    . N1 D9 e$ D' ?" H7 [
44. 
    
45.     GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_11;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    % b# s7 X5 M3 D1 W6 j( g  o7 Y1 W
47.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
      Y5 b# @+ V1 t+ e8 s
49.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    ) I& y: E) X' t' @
50.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    ' E/ U4 \: W( x  i5 W
51. 
    
52.   /* USER CODE BEGIN QUADSPI_MspInit 1 */
    
53. 
    . n  Z' H$ r* g
54.   /* USER CODE END QUADSPI_MspInit 1 */
    3 ^% d1 m) ?8 s1 }" v" t3 r
55.   }
    3 V6 S& j" x  k; F* k7 p0 R
56. }

复制代码

7 q* Z7 Z* z  U) O9 Z7 d2.接着初始化SPI外设
% S9 V) G2 D  B. z

1. 
   ( d0 M. U0 k* q% R
2. QSPI_HandleTypeDef hqspi;
   
3. 
   
4. /* QUADSPI init function */
   + H1 L; j( O; z8 x; R# N! F
5. void MX_QUADSPI_Init(void)
   
6. {
   " a. _1 q0 l; Z: n' G8 H
7.   hqspi.Instance = QUADSPI;//QSPI外设
   - p) q) b/ `+ P
8.   hqspi.Init.ClockPrescaler = 2;//QPSI分频比，N25Q128最大频率为104M，此处216/(2+1)=72M
   0 J3 i$ O# s. T
9.   hqspi.Init.FifoThreshold = 4;//FIFO阈值为4个字节
   / x9 B( H3 D5 w1 w7 f. ~/ Y9 G$ i
10.   hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;//采样移位半个周期(DDR模式下,必须设置为0)
    - V6 `+ D- Z1 i6 I1 \! U
11.   hqspi.Init.FlashSize = POSITION_VAL(0X1000000)-1;//SPI FLASH大小，N25Q128大小为16M字节
    
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
    / x  Z5 e0 @+ n& y; H1 e' I  Z7 C
15.   hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;//禁止双FLASH模式
    
16.   if (HAL_QSPI_Init(&hqspi) != HAL_OK)//初始化QSPI外设
    
17.   {
    
18.     Error_Handler();
    # D7 N( ^* E# C! x0 Q
19.   }
    
20. }

复制代码

3.由于使用的是间接模式，我们对FLASH的所有操作都需要通过FLASH内部寄存器来完成，也就是通过向FALSH发送对应的指令来获得我们想要的结果，此时的FALSH就是一个普通的SPI协议外设，所以接下来所有对FALSH所有的操作都需要先发送相关指令，我们需要配置指令参数（指令类型、地址、数据宽度、地址宽度等等）。

& O" K5 D7 C4 h0 j我们首先需要配置下面的命令参数结构体：

7 H0 {: C1 Q, F# [6 z- K- b3 ?, W' g

3 L- @# T; w% n  H0 ^/ o; h* WInstruction:指令类型（读、写、擦除等等）

$ b/ a. Y  W1 {+ hAddress:需要读取或写入数据的起始地址
) z+ _. j# H8 o% D" T/ k. b; ~& T
NbData:需要读取或写入数据的长度

' f! t' O+ w6 t; z9 WDataMode：数据传输模式，就是数据用几根线传输（1、2、4线可选），后面的AddreMode类似，就是用几根线传输地址，InstructionMode就是用几根线传输指令。

5 t' g1 v# h5 E这三个参数都需要根据芯片数据手册来选择，手册上说明支持该模式才可以选择，否则会通信错误，另外，数据传输模式的不同，对应的指令类型也会不同，比如N25Q128 READ指令对应单线传输模式，Quad I/O Fast Read则对应四线传输模式，这些对应关系手册上都有详细说明！！！
3 |$ Q1 f# O( A& p3 y
4.读取芯片JEDEC ID
2 `- W  [  Q2 N4 z
首先查看手册上读取JEDEC ID的时序：
: {, x0 T$ v* y, X1 }/ ~
3 R8 @) i& \2 B2 h9 b0 x

, {+ ^8 A  z$ i( z& J& y1 S" N可以看出，读ID这条指令是只有指令阶段和数据阶段，且都是单线传输模式，所以
& b8 W4 }" ?, ^* Z
/ m% G; y; [  p. ~0 V7 D, d2 ~InstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令单线传输模式
4 x- d6 x& n3 E- \2 i6 K7 j5 c
DataMode = QSPI_DATA_1_LINE；//数据单线传输模式

Address和AddressMode 这两个参数的值都置0，表示无地址。

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

/ a- v  f1 V; N4 W0 P. ~- ?, ?其他值和下面代码保持一致即可。

/ D- E% p6 |" O9 @! \* o然后 使用HAL_QSPI_Command函数将读ID指令发送给FALSH，等待发送完成

! P$ T) P9 H$ ?5 R1 i5 j/ e4 Y最后 调用HAL_QSPI_Receive，接受FALSH返回的数据，即芯片ID

1. /**
   
2. * @brief  读取FLASH ID
   
3. * @param   无
   # g) I! h4 V9 q, a+ v
4. * @retval FLASH ID
   3 A/ z& V! {/ V/ q) \# r% P
5. */
   
6. uint32_t QSPI_FLASH_ReadID(void)
   
7. {
   
8.      QSPI_CommandTypeDef s_command;
   
9. 
   / }$ \& x" M0 p7 H1 t
10.      uint32_t Temp = 0;
    
11. 
    7 T" ]9 n( l* ^7 v
12.      uint8_t pData[3];
    
13. 
    
14.      /* 读取JEDEC ID */
    $ ?7 g6 W- x6 f: E) v$ Z6 o" h
15. 
    ) J$ C. l6 w- M/ ]1 X
16.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令阶段的操作模式，00：无指令；01：单线传输指令；10：双线传输指令；11：四线传输指令。
    ; Q! h% ?8 H3 e$ D! B* C) c
17. 
    ! x, D( I9 ^6 Y; ~; i* h
18.      s_command.Instruction       = READ_JEDEC_ID_CMD;//读取芯片ID指令
    5 ]" q: T) }  J
19. 
    
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;//定义地址长度
    ! c: g+ L# N- l# `0 T& z. y
21. 
    
22.      s_command.DataMode          = QSPI_DATA_1_LINE;//定义数据阶段的操作模式，00：无数据；01：单线传输数据；10：双线传输数据；11：四线传输数据。
    8 k3 \/ Q% _5 e3 g+ \) P
23. 
    2 z9 d7 Q$ C9 Q( j$ V
24.      s_command.AddressMode       = 0;//地址阶段的操作模式，00：无地址；01：单线传输地址；10：双线传输地址；11：四线传输地址。
    
25.          
    
26.      s_command.Address           = 0;   
    
27.         
    
28.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;//交替字节长度
    
29. 
    6 i: x* T3 H' e- {
30.      s_command.DummyCycles       = 0;//空指令阶段的持续时间，在 SDR 和 DDR 模式下，它指定 CLK 周期数 (0-31)。
    ( n. }5 R- A+ C  r
31. 
    
32.      s_command.NbData            = 3;//设置数据长度，在间接模式和状态轮询模式下待检索的数据数量（值 + 1）。对状态轮询模式应使用不大于 3 的值（表示 4 字节）。
    $ z' v3 R& z1 T: r
33. 
    
34.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;//地址、交替字节和数据阶段设置 DDR 模式，0：禁止 DDR 模式；1：使能 DDR 模式。
    
35. 
    ( h1 _! H( [1 Q# d, E# w1 y
36.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;//设置DDR 模式下数据输出延迟 1/4 个 QUADSPI 输出时钟周期，0：使用模拟延迟来延迟数据输出；1：数据输出延迟 1/4 个 QUADSPI 输出时钟周期。
    7 v3 G+ |8 ?1 l+ c
37.                  
    
38.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;//设置仅发送指令一次模式，。IMODE = 00 时，该位不起作用。0：在每个事务中发送指令；1：仅为第一条命令发送指令。
    9 K7 V7 p  b+ g' P) {. H- |
39. 
    5 b! H5 W' H4 D; Z+ w9 o
40.      if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
41.                  {
    
42.          #if  QSPI_DEBUG
    
43.                      printf("send read flash ID command error!\r\n");
    
44.                #endif
    
45.          /* 用户可以在这里添加一些代码来处理这个错误 */
    
46.          while (1) {}
    
47.      }
    
48.      if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    
49.                  {
    
50.          #if  QSPI_DEBUG
    ; [; [. d3 @9 d  s! D' _: l& [
51.                      printf("read qspi flash ID error!\r\n");
    
52.                #endif
    ) e9 p/ _& E9 b) r) P0 O; X
53.          /* 用户可以在这里添加一些代码来处理这个错误 */
    & A- v/ T1 R8 D" B& e4 \; |8 `" q
54.          while (1) {}
    
55.      }
    
56.      Temp = ( pData[2] | pData[1]<<8 )| ( pData[0]<<16 );
    
57.      return Temp;
    
58. }

复制代码

5.FALSH 写使能
' T3 K) a$ q# }: K; U0 y8 ^, |7 S
, T' Z. C8 H7 r- A) e在对FALSH进行写之前，需要打开写使能开关（实际上就是发送写使能指令）：

类似的，需要查看芯片手册，写使能的时序
( K# T- @0 D% G/ O. c

2 M8 I$ y) {& q" r9 I, a可以看到这个指令时序更简单，仅仅有指令阶段，所以地址和数据的参数都应置0

1. /**
   
2.   * @brief  QSPI FALSH写使能
   ) z3 W$ G9 i, A* \4 I+ F
3.   * @param  None
   
4.   * @retval HAL_OK
   
5. */
   
6. static HAL_StatusTypeDef QSPI_WriteEnable(void)
   
7. {
   ' ^# ~+ Y- ?- I* @5 c" U& C+ G
8.   QSPI_CommandTypeDef     sCommand;
   9 Q5 \' r4 J! }( m1 H  x
9.   QSPI_AutoPollingTypeDef sConfig;
   9 Z3 p2 g( o- \/ O* L7 b
10. 
    
11.   /* Enable write operations ------------------------------------------ */
    3 g: [* @( l2 k5 _: p
12.   sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
13.   sCommand.Instruction       = WRITE_ENABLE_CMD;
    
14.   sCommand.AddressMode       = QSPI_ADDRESS_NONE;
    1 y9 P0 h4 {- W; L
15.   sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
16.   sCommand.DataMode          = QSPI_DATA_NONE;
    
17.   sCommand.DummyCycles       = 0;
    
18.   sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;
    
19.   sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    2 R, ]6 G4 q) j7 h' x- f
20.   sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    ) w8 m  L! I! |3 M& R
21. 
    " W7 x+ _+ K- A. }0 L1 X" Y
22.   if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    7 i* I0 g5 Y5 m3 G) f! Z7 `
23.   {
    
24.     return HAL_ERROR;
    : D* y% v' `. C# t
25.   }
    
26. 
    $ f0 y9 Q3 k9 V4 w
27.   /* Configure automatic polling mode to wait for write enabling ---- */  
    6 L% e! \* A. K. \  A! R
28.   sConfig.Match           = 0x02;
    6 m3 q# Y( b0 c& @$ [" I
29.   sConfig.Mask            = 0x02;
    
30.   sConfig.MatchMode       = QSPI_MATCH_MODE_AND;
    ) K6 b3 ^+ k3 S* \" I7 X1 b
31.   sConfig.StatusBytesSize = 1;
    
32.   sConfig.Interval        = 0x10;
    
33.   sConfig.AutomaticStop   = QSPI_AUTOMATIC_STOP_ENABLE;
    
34. 
    
35.   sCommand.Instruction    = READ_STATUS_REG1_CMD;
    
36.   sCommand.DataMode       = QSPI_DATA_1_LINE;
    
37. 
    7 m( H, i; F4 N6 s3 \
38.   if (HAL_QSPI_AutoPolling(&hqspi, &sCommand, &sConfig, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    ' P8 l% t9 k" \4 u
39.   {
    
40.                 return HAL_ERROR;        
    6 f# V) `% e( b: J- I) {
41.   }
    + ]9 D9 N1 F7 _" j
42.         return HAL_OK;
    
43. }

复制代码

& a7 s' A' }$ L7 e) e( r这里需要讲下 QUADSPI  状态标志轮询模式：
在自动轮询模式下，QUADSPI 周期性启动命令以读取一定数量的状态字节（最多 4 个）。
$ ~1 w5 M4 d* `2 K1 `$ R8 w9 ^可屏蔽接收的字节以隔离一些状态位，从而在所选的位具有定义的值时可产生中断。
对 Flash 的访问最初与在间接读取模式下相同：如果不需要地址 (AMODE = 00)，则在写入
QUADSPI_CCR 时即开始访问。否则，如果需要地址，则在写入 QUADSPI_AR 时开始第
% ?6 V5 W! b/ L1 |$ z一次访问。BUSY 在此时变为高电平，即使在周期性访问期间也保持不变。
在自动轮询模式下，MASK[31:0] (QUADSPI_PSMAR) 的内容用于屏蔽来自 Flash 的数据。
) f/ [6 k, Z8 m+ h: k5 F如果 MASK[n] = 0，则屏蔽结果的位 n，从而不考虑该位。如果 MASK[n] = 1 并且位 [n] 的内
: j( p/ [. J" ?' b# k, N容与 MATCH[n] (QUADSPI_PSMAR) 相同，说明存在位 n 匹配。
4 U$ o# l% Q6 E! f0 r8 S0 A如果轮询匹配模式位 (PMM, QUADSPI_CR[23]) 为 0，将激活“AND”匹配模式。这意味着
状态匹配标志 (SMF) 仅在全部未屏蔽位均存在匹配时置 1。
如果 PMM = 1，则激活“OR”匹配模式。这意味着 SMF 在任意未屏蔽位存在匹配时置 1。
如果 SMIE = 1，则在 SMF 置 1 时调用一个中断。
( z2 M$ k: x. m如果自动轮询模式停止 (APMS) 位置 1，则操作停止并且 BUSY 位在检测到匹配时清零。否
则，BUSY 位保持为“1”，在发生中止或禁止 QUADSPI (EN = 0) 前继续进行周期性
: M4 S& s( y) Z% ?9 @访问。
数据寄存器 (QUADSPI_DR) 包含最新接收的状态字节（FIFO 停用）。数据寄存器的内容不
9 p5 K( Q: k4 C8 m' R- m7 s/ e受匹配逻辑所用屏蔽方法的影响。FTF 状态位在新一次状态读取完成后置 1，并且 FTF 在数
8 M& w: D4 u9 X+ z: p/ V据读取后清零。
4 @. x6 I3 Y+ x8 s- A
简单的说，就是CPU自动查询FALSH指定的标志位是否置位或清零，通过调用HAL_QSPI_AutoPolling函数，CPU将自动查询FALSH写使能标志位是否被置位，成功返回HAL_OK,否则返回HAL_ERROR，这样就省去了我们自己发读寄存器指令查询的麻烦了。
0 [( p2 C* R$ `; o. p  I9 N
$ p' k. ]# T" W2 H4 U% h8 H6.读FALSH

  f6 l/ o' K- n这里仅介绍4线模式下的读FALSH流程，首先查看手册4线模式读时序

6 N# j5 n" |/ E
& s9 b* i: Z3 G) C# R从时序图可以看出，指令是1线模式，地址是4线模式，空周期（DummyCycles）为10，数据也是4线模式，还有此时的读指令是QUAD_INOUT_FAST_READ_CMD。所以相关参数配置如下：
3 j  [6 E9 q" a9 l0 J. V

1. /**
   
2. * @brief  从QSPI存储器中读取大量数据.
   
3. * @param  pData: 指向要读取的数据的指针
   & i6 C8 l0 m: @' q% g6 E
4. * @param  ReadAddr: 读取起始地址
   
5. * @param  Size: 要读取的数据大小
   * l) n; P  F2 w! W: Q# C3 y
6. * @retval QSPI存储器状态
   
7. */
   7 X% d1 N5 @# r' ?: @5 I
8. HAL_StatusTypeDef BSP_QSPI_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)
   
9. {
   % M+ e3 l8 i6 L# W, ~; K# C% X4 }& ^& |+ [
10.      QSPI_CommandTypeDef s_command;
    - ~0 n+ B8 o4 x
11. 
    
12.      /* 初始化读命令 */
      i4 E2 G9 o% @$ R3 b; y
13. 
    
14.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    & ?% T2 C: Q9 M" ]; ^
15. 
    : \1 d- j! C% v0 q
16.      s_command.Instruction       = QUAD_INOUT_FAST_READ_CMD;
    4 ?) [7 N/ g8 n0 D6 X. d
17. 
    
18.      s_command.AddressMode       = QSPI_ADDRESS_4_LINES;
    
19. 
    
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    / a7 b0 K5 z$ D* `! `
21. 
    
22.      s_command.Address           = ReadAddr;
    
23. 
    2 K; g, I, V" s, w3 G7 o9 g
24.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    4 A% e' E+ N9 x  F  S& W
25. 
    
26.      s_command.DataMode          = QSPI_DATA_4_LINES;
    - E& {' q( [; k7 t% F: H
27. 
    7 [; t0 B/ f3 `$ \
28.      s_command.DummyCycles       = 10;
    
29. 
    
30.      s_command.NbData            = Size;
    8 b% s( F7 c) b1 p7 T5 r
31. 
    
32.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    6 E3 U6 x: T# N6 H9 ^' j4 L  Z. D
33. 
    % ?  G% h$ Z( t" l
34.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
35. 
    + l# }4 I# _! K2 K* s7 H
36.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
37.      /* 配置命令 */
    9 k8 f, F0 ]9 ?- s6 u- O
38. 
    
39.    if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    6 f7 [( ^7 E, E. ?( v% P
40.          {
    ( A! M, ^. Y) }! o% H. i; h
41.                 #if  QSPI_DEBUG
    
42.                 printf("R-send read command error!\r\n");
    7 Z7 ~$ M5 n. \9 e3 Z/ U
43.           #endif
    & p0 i5 X$ M5 ^
44.     return HAL_ERROR;
    7 B/ [" p. l# K# D0 c. I& n
45.    }  
    8 e. [! o+ t8 L; x7 R, n. ?2 i
46.    /* 接收数据 */
    + Q' ?! U5 B# Y/ j
47.    if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    
48.          {
    
49.                 #if  QSPI_DEBUG
    / C5 b5 [8 F! H' N2 [) i
50.                 printf("R-read data error!\r\n");
    6 ~7 |- v) _  @& Z
51.           #endif
    % T8 t! ?- |. d' E( j' T
52.     return HAL_ERROR;
    . r% {( A- j6 d
53.    }
    
54.    return HAL_OK;
    
55. }

复制代码

本函数实现了从FALSH指定地址读取指定数量字节的功能
0 T% H0 Z) S; {' T. U  O
7.写FALSH

3 M6 B, S$ E/ y6 m' y同读FALSH类似，我们需要在手册中找到4线写FALSH的时序：
* F4 m( c+ I" r- O
7 [4 b2 o/ p. C0 I8 g8 h

根据时序图配置如下：1线指令，1线地址，24bit地址，4线数据，没有空周期

1. /**
   
2. * @brief  将大量数据写入QSPI存储器
   
3. * @param  pData: 指向要写入数据的指针
   
4. * @param  WriteAddr: 写起始地址
   
5. * @param  Size: 要写入的数据大小
   
6. * @retval QSPI存储器状态
   
7. */
   % ]" v. M" u3 i' _! w
8. HAL_StatusTypeDef BSP_QSPI_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
   
9. {
   . _) n8 d1 [4 s
10.                         QSPI_CommandTypeDef s_command;
    
11.                         uint32_t end_addr, current_size, current_addr;
    
12.             unsigned char sector_start,sector_end,i;
    8 {$ F/ \& r' n7 Z
13.         
    % l7 Z' e3 v# n- _' g' r
14.                         /* 计算写入地址和页面末尾之间的大小 */
    
15.                         current_addr = 0;
    
16.         
    
17.                         while (current_addr <= WriteAddr)
    . l& S- S8 C, M
18.                         {
    , g% r  K  R$ ^4 p  H# T
19.                                         current_addr += N25Q128FV_PAGE_SIZE;
    
20.                         }
    
21.                   current_size = current_addr - WriteAddr;
    
22.      /* 检查数据的大小是否小于页面中的剩余位置 */
    
23.      if (current_size > Size)
    & d& T- e# M7 J8 t, {# R
24.                  {
    5 i; \5 `5 `2 x4 h
25.          current_size = Size;
    : `7 x* b* l1 h- c$ j+ f) A8 |
26.      }
    4 _1 G( K7 Y% H; y. h: K
27.      /* 初始化地址变量 */
    
28.      current_addr = WriteAddr;
    9 }: A7 ]; U9 N# B! s6 d
29.      end_addr = WriteAddr + Size;
    ) |1 K# j, `5 x: [# \
30.                  
    
31.                  sector_start = current_addr >> 16;
    1 m! O! ~; I4 Y6 I0 a
32.                  sector_end = end_addr >> 16;
    
33.                  
    $ ^4 p" f& \& \2 |
34.                  for( i = sector_start; i<=sector_end ;i++)
    6 \- W- O# t, B* r2 F9 e/ F
35.                  {
    # m* P0 f# Q. ]2 |0 @
36.                     BSP_QSPI_Erase_Block(i); //擦除对应删除
    / v5 i2 j' s) \# S/ @! a
37.                  }
    * a6 d- K' X1 H
38.                  
    
39.      /* 初始化程序命令 */
    
40.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
41. 
    
42.      s_command.Instruction       = QUAD_INPUT_PAGE_PROG_CMD;
    3 s* l  G3 T* g" H' r
43. 
    
44.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    
45. 
    
46.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    ) ], R; h# B' ^' W% w8 T" \7 N( a
47. 
    
48.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    1 W+ y7 j( z9 U8 M
49. 
    ' |' F+ d8 P- C8 X
50.      s_command.DataMode          = QSPI_DATA_4_LINES;
    / o# t  D6 Z: O) L
51. 
    & t4 J- A3 c3 N& m3 Y7 c
52.      s_command.DummyCycles       = 0;
    % ^: A9 l$ {; e( {( l/ a! j
53. 
    
54.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    9 n: g5 z; [5 R, \
55. 
    
56.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
57. 
    / C; J1 E) M. _0 N1 h0 j: s6 Y5 `
58.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
59. 
    # a& ~  E1 D- D% f
60.      /* 逐页执行写入 */
    6 q; ]: f8 l% f/ ^% Z4 }. I
61.      do {
    7 _) G3 ?# g7 U' X* W. @
62. 
    
63.          s_command.Address = current_addr;
    
64.          s_command.NbData  = current_size;
    
65.          /* 启用写操作 */
    
66. 
    / D$ a5 n+ r. K
67.          if (QSPI_WriteEnable() != HAL_OK)
    
68.                                  {
    ( y7 }* J) f1 ~5 d
69.                                                 #if  QSPI_DEBUG
    - k9 f; U) |7 P7 v( R1 [, B
70.                                                 printf("W-Qspi write enable error!\r\n");
    / G& F( X' ?3 l# Y5 n, h2 B' d# J5 R1 X
71.                                                 #endif
    
72.             return HAL_ERROR;
    
73.          }
    
74.          /* 配置命令 */
    
75.         if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    ! u* Q4 f% h. D
76.                 {                                 
    
77.                                           #if  QSPI_DEBUG
    
78.                                                 printf("W-Qspi send Command error!\r\n");
    
79.                                                 #endif
    
80.             return HAL_ERROR;
    4 |) [8 w! b( e8 f: K6 d) R; g9 p
81.          }
    / N+ S9 q4 n. Y5 d1 T9 V3 Y
82.          /* 传输数据 */
    ) H" d- l1 W% _% `
83.          if(HAL_QSPI_Transmit(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    0 X, O+ z4 r, n( |
84.                                  {
    
85.                                           #if  QSPI_DEBUG
    # v1 U, Y  }8 ~# g8 Q9 i% u! N
86.                                                 printf("W-Qspi Transmit data error!\r\n");
    
87.                                                 #endif
      P) M7 j4 W7 \9 c7 J% K0 S
88.             return HAL_ERROR;
    - {& G+ _# f0 Q5 s% e+ @
89.          }
    . T: X1 l7 m4 o; m8 N8 n% `
90.          /* 配置自动轮询模式等待程序结束 */
    / h: X9 V( c  z7 v$ \
91. 
    
92.          if(QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
93.                                  {                                         
    % N, k+ J- \0 h2 U% R" S( D
94.                                                 #if  QSPI_DEBUG
    
95.                                                 printf("W-AutoPollingMemReady error!\r\n");
    
96.                                                 #endif
    
97.             return HAL_ERROR;
    
98.          }
    
99.          /* 更新下一页编程的地址和大小变量 */
    8 k' o* m# Q' T  T" t$ X
100. 
     
101.          current_addr += current_size;
     
102. 
     ; [; C( c% h9 `6 i; n. J% p
103.          pData += current_size;
     
104. 
     
105.          current_size = ((current_addr + N25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr-current_addr) :
       L: L3 u) X! X
106. 
     7 [9 ~8 z( s$ l7 }, \
107.                         N25Q128FV_PAGE_SIZE;
     0 M! l, t( W5 r1 G6 V
108. 
     0 C# P( h( }+ @' {
109.      } while (current_addr < end_addr);
     5 ^$ m( X- o8 n( G
110.      return HAL_OK;
     
111. }

复制代码

该函数实现从指定地址写入指定数量的字节。
- H+ I6 l/ J2 b/ x; k; o' Q) @! |+ g9 k
6 ^6 C+ }' o  F; T8.擦除FALSH

第一种情况是按扇区擦除，这也是N25Q128最小的擦除单位（N25Q128共有256个扇区，每个扇区64KB）
3 _* C/ N2 {& r# v5 V9 X' P

参数设置为1线指令 ，1线地址，24bit地址，无数据阶段
  N0 w; f! h. C. @2 l) b
) g( L5 p/ `! x9 J' R9 q9 Z

1. /**
   
2. * @brief  擦除QSPI存储器的指定扇区
   
3. * @param  BlockAddress: 需要擦除的扇区地址
   # A4 P2 Y2 r, q5 U# E
4. * @retval QSPI存储器状态
   
5. */
   
6. HAL_StatusTypeDef BSP_QSPI_Erase_Sector(uint32_t Sector)
   
7. {
   
8.            uint32_t SectorAddress=Sector << 16;//Sector*65535算出该扇区对应的地址
   
9.         
   
10.      QSPI_CommandTypeDef s_command;
    
11.      /* 初始化擦除命令 */
    3 R0 r7 R  W% D% s& M$ K0 o; m
12.         
      U# x! x0 l  D# `( |
13.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
14. 
    2 S, [0 Q  d# R
15.      s_command.Instruction       = SECTOR_ERASE_CMD;//按扇区擦除
    " Y4 j9 A  S$ J5 O5 T( w
16. 
    
17.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    
18. 
    
19.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    
20. 
    
21.      s_command.Address           = SectorAddress;
    $ H5 x# K. g( _
22. 
      z  f% y6 K- _9 v2 V+ _+ _% n' S8 O1 c
23.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
24. 
    
25.      s_command.DataMode          = QSPI_DATA_NONE;
    
26. 
    
27.      s_command.DummyCycles       = 0;
    9 B& k( b  P1 j% X( G
28. 
    5 Y3 s5 A$ B. a/ g  \/ B
29.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    4 H6 |  W! M3 O1 Y& T
30. 
    6 g5 m- h/ r0 u6 N; \( g
31.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    8 X$ {# C/ g" K) ]) d
32. 
    
33.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
34. 
    
35.      /* 启用写操作 */
    
36. 
    
37.      if (QSPI_WriteEnable() != HAL_OK)
    
38.                  {
    8 f3 d& p* m) @3 t- Y5 d
39.          return HAL_ERROR;
    
40.      }
    
41.      /* 发送命令 */
    
42.      if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    : }# s( J4 Y! m- o+ X
43.      {
    
44.          return HAL_ERROR;
    / i5 U! E+ G( x
45.      }
    % U; T( Z. ~; D" j
46.      /* 配置自动轮询模式等待擦除结束 */
    / a: F" ~- [( N5 J$ F# X) S
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
    2 O: U& M$ _  v3 p6 y
53.         return HAL_ERROR;
    ! t9 T+ _1 t  U$ R
54.      }
    9 P2 P; g$ h7 [; {
55.     return HAL_OK;
    
56. }

复制代码

& c- ]( \6 A; T; g第二种情况是全片擦除，时序如下：

* f  k0 J* S  l, a. ^/ n8 I0 f全片擦除仅包含指令阶段，对于N25Q128来说，全片擦除耗时可达48s。

0 ]1 w) U! g8 e

1. /**
   
2.   * @brief  全片擦除  N25Q128全片擦除耗时48s
   
3.   * @retval QSPI memory status
   
4.   */
   
5. uint8_t BSP_QSPI_Erase_Chip(void)
   ) E( B- s1 [2 h! Q# s$ e/ N2 n
6. {
   - }% `: O' U7 S
7.   QSPI_CommandTypeDef s_command;
   5 |! o7 W2 T) p! v( }
8. 
   ' W! H$ L) R; U1 F' c) \
9.   /* Initialize the erase command */
   
10.   s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    ! e% `5 U' u6 l  h4 S% P
11.   s_command.Instruction       = CHIP_ERASE_CMD;
    
12.   s_command.AddressMode       = QSPI_ADDRESS_NONE;
    . B8 O% ?: i2 U  b" b
13.   s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
14.   s_command.DataMode          = QSPI_DATA_NONE;
    
15.   s_command.DummyCycles       = 0;
    
16.   s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    4 m* B4 y2 |; p$ q: x
17.   s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
18.   s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    7 T2 H& q( C- \; J' o4 F
19. 
    / b5 u  }+ K* L6 N( S
20.   /* Enable write operations */
    
21.   if (QSPI_WriteEnable() != HAL_OK)
    
22.   {
    
23.     return HAL_ERROR;
    + r5 }/ r# D' O3 u. Z- Q
24.   }
    4 ?( M$ C/ U2 P. G9 ~- m% r# L1 I
25. 
    6 i  |6 v1 {5 Z& l7 m4 S
26.   /* Send the command */
    / U$ r. a( l) P8 q
27.   if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
28.   {
    - y* w; Z: J  t# p5 f
29.     return HAL_ERROR;
    
30.   }
    
31. 
    
32.   /* Configure automatic polling mode to wait for end of erase */  
    # h0 g2 @2 S7 U5 W. u9 c9 _0 S" i
33.   if (QSPI_AutoPollingMemReady(N25Q128A_BULK_ERASE_MAX_TIME) != HAL_OK)
    9 n% K# o2 \# @" _6 ^, ^
34.   {
    
35.     return HAL_ERROR;
    ; h  v5 T2 Z, [' X
36.   }
    
37. 
    
38.   return HAL_OK;
    
39. }

复制代码

9.测试程序

测试芯片写入和读取是否成功，首先向0x1FFFF地址连续写入4096个字节，然后再读取出来，对比两次数据是否一致。
! w/ ?0 e% ^4 j0 a! o

1. unsigned char write[4096];
   
2. unsigned char read[4096];   
   
3. void N25Qxx_Test(void)
   
4. {
   % c. E* y. Q/ y# w8 x2 b
5.   uint32_t i = 0;
   
6. 
   
7.         for(i = 0;i<sizeof(write);i++)
   * @  o% l" D7 R% k! @3 o
8.         {
   1 W5 A3 ]4 X/ z3 s
9.     write=i;
   
10.         }
    
11.         
    $ d+ p1 T( `7 j: t
12.         printf("write data:\r\n");        
    
13.   for(i = 0;i<sizeof(write);i++)
    
14.         {
    0 s; v0 h6 a6 T; j
15.                 printf("%d ",write);
    " S+ V  D7 c! C! Q  v
16.         }
    
17.   printf("\r\n");
    
18.         printf("\r\n");
    1 b& N: Q4 A+ x4 g
19.         printf("\r\n");
    ' n6 H' m" I8 q, L, K2 ?7 W! w' }
20.         
    
21.         BSP_QSPI_Write(write,0x1FFFF,sizeof(write));
    7 W4 P2 q9 M4 F& l
22.   BSP_QSPI_Read(read,0x1FFFF,sizeof(write));        
    ) _5 k+ B" {: g) z
23.         
    
24.         printf("Read from QSPI:\r\n");
    # v  O: ^% x% M. s$ Q
25.         
    
26.   for(i = 0;i<sizeof(read);i++)
    & s9 b! x; B  a/ k+ X- B' z/ ^7 i
27.         {
    - {* w# K( C* M% U8 q2 S+ x
28.                 printf("%d ",read);
    
29.         }
    - M( y$ ]* a; i6 Z
30.   printf("\r\n");
    " M! V- _& C  v! G
31. }

复制代码

* z, v, j! C3 w1 f+ F写入的数据（部分截图）：
  r4 ^$ x7 C% u
% D6 m4 \3 h2 @! X# U' Z# v

: v8 o6 U$ P8 y; s* ~$ l! b
8 P/ B) k. M# ~( I  ^/ d6 [读取的数据（部分截图）：

- e# C2 V8 @+ U) e0 u
& M$ j( Q3 R. P截取相同的部分，两次数据完全一致，写入和读取成功。

最后，讲几点需要注意的地方：

7 O1 f7 F' f2 e9 q2 f, x" I2 h1.N25Q128 与  W25Q128 有很多不同的地方，特别是4线模式下，二者很多地方不同，代码不可混用，比如W25Q128的很多指令都是支持4线的，但是N25Q128的指令阶段均不支持4线模式。
% A4 Q+ |1 w3 r& B, c0 [
2.硬件上使用了4线SPI，但是仍然可以使用单线SPI操作，只是速度慢了点，其他的没什么影响。
3 \7 }$ e" S" k1 Q- v! H/ e
, e- O0 x- h* c3.N25Q128在配置为内存映射模式时，外部 SPI 器件被视为是内部存储器。QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。如果访问的地址超出 FSIZE 定义的范围但仍在 256MB 范围内，则生成 AHB 错误。此错误的影响具体取决于尝试进行访问的 AHB 主设备：
 如果为 Cortex ® CPU，则生成硬性故障 (Hard fault) 中断
 如果为 DMA，则生成 DMA 传输错误，并自动禁用相应的 DMA 通道。
% l0 b) A2 L! w1 i9 ]
: j2 E. _6 q5 K- P& V" j8 g4.N25Q128包含248个主扇区，每个扇区64KB,还有8个64KB的启动扇区，这8个启动扇区又可分为128个子扇区，每个子扇区大小为4KB，所有的扇区擦除都可以按照一次64KB大小擦除，但是这8个启动扇区也可以按照4KB一次擦除（需要使用SUBSECTOR_ERASE_CMD指令擦除）。

  o0 t, H5 F. v' c5.N25Q128分TOP和Bottom架构，两种架构的区别就是启动扇区的位置不同，TOP架构的启动扇区是248~255（地址范围：F80000 ~FFFFFF），0~248为主扇区。Bottom架构的启动扇区是0~7（地址范围：0~7FFFF），8~255是主扇区。这两中架构可以通过完整的型号区分。
9 V5 O6 P+ I% E7 n: I- D2 f

6.N25Q128和W25Q128 不可以相互替换，除非使用单线SPI通信，且只能使用F80000 ~FFFFFF或者0~7FFFF范围内的内存。
  N4 z) Z+ G1 b( i; f
. X  W, {4 z. h4 J( k: x" L7.N25Q128的指令在不同spi模式（单线、双线、四线）下有所不同，使用时一定要特别注意！！！
" v5 B" }6 C0 ?6 G