一、QSPI接口介绍

QUADSPI 是一种专用的通信接口，连接单、双或四（条数据线）SPI Flash 存储介质。该接口可以在以下三种模式下工作：
! ^3 ?( `; |7 K' n# m! m' H0 @# n
 间接模式：使用 QUADSPI 寄存器执行全部操作，支持对FALSH进行读、写、擦除、锁定等操作。

 状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）

6 ]" S$ V: q( k 内存映射模式：外部 Flash 映射到微控制器地址空间，从而系统将其视作内部存储器

" H6 a/ I5 J1 t( w2 O采用双闪存模式时，将同时访问两个 Quad-SPI Flash，吞吐量和容量均可提高二倍。

内存映射模式支持XIP，即可以将代码放在外部FLASH运行，缺点就是有延迟，没有内部运行速度快，且外部FALSH只能读，不能写入或擦除。
& S. E" t* ^/ x/ d& q$ C3 N
# K4 |& G3 I9 X6 {& ^内存映射模式下QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。
7 B7 V, L, G) ^. t
二、 STM32QSPI 功能框图

8 @1 f4 H: R! I# G& j

# f* t$ X1 j2 s+ i, N6 M8 m
STM32F7系列支持双QSPI接口，可以接两个外部FLASH，本文只介绍接一个FALSH的情况。QSPI使用6根线通信，其中数据线4根，1根时钟线，1根片选线，但是程序里是可以配置工作在几线模式。

三、QUADSPI  命令序列

0 V4 q* ?( S+ w2 h9 aQUADSPI 通过命令与 Flash 通信 每条命令包括指令、地址、交替字节、空指令和数据这五
  _& b. b/ p. M个阶段，任一阶段均可跳过，但至少要包含指令、地址、交替字节或数据阶段之一。
nCS 在每条指令开始前下降，在每条指令完成后再次上升。
! e$ @3 r$ s- _  A0 f/ c4 O

- Q7 B3 d: X& Q8 g上图清晰的展示了一次QSPI通信过程，它完整的包含了通信的5个阶段，但不是每次通信都需要包含这5个阶段.
$ y2 F. ^, \( c/ `, Q2 Y
交替字节阶段，将 1-4 字节发送到 Flash，一般用于控制操作模式。|正常读写是不需要的，所以这个阶段可以省略（结构体中该参数置0）；
) ?1 I7 e5 o: O' e$ W
空指令周期阶段，给定的 1-31 个周期内不发送或接收任何数据，目的是当采用更高
的时钟频率时，给 Flash 留出准备数据阶段的时间。
若 DummyCycles为零，则跳过空指令周期阶段，命令序列直接进入数据阶段（如果存在）。

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

/ n( N9 B" c( N7 h: ?四、QUADSPI  信号接口协议模式
8 @1 k# b- b# x0 l8 C5 ^
下面提到的几线模式都是指数据线的根数
7 v3 v+ w3 U* B( n1 e  S! O9 \
单线 SPI  模式（即普通SPI通信，等同于使用MISO、MOSI、CLK、CS方式通信）:
5 q4 C8 h! X" s2 D# f: g* W传统 SPI 模式允许串行发送/接收单独的 1 位。在此模式下，数据通过 SO 信号（其 I/O 与
" u! g0 q! _; d# BIO0 共享）发送到 Flash。从 Flash 接收到的数据通过 SI（其 I/O 与 IO1 共享）送达。
% G+ T6 C& S' \7 r9 V通过将（QUADSPI_CCR 中的）IMODE/ADMODE/ABMODE/DMODE 字段设置为 01，可
对不同的命令阶段分别进行配置，以使用此单个位模式。
在每个已配置为单线模式的阶段中：
 IO0 (SO) 处于输出模式
 IO1 (SI) 处于输入模式（高阻抗）
6 y: T7 S- g% s: @" R! N0 H IO2 处于输出模式并强制置“0”（以禁止“写保护”功能）
 IO3 处于输出模式并强制置“1”（以禁止“保持”功能）

, A% b3 t; H. w* e" o0 l: f& p7 m& x双线 SPI  模式：
在双线模式下，通过 IO0/IO1 信号同时发送/接收两位。
通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 10，可
- c9 R4 s* g" ^$ p, Z2 z对不同的命令阶段分别进行配置，以使用双线 SPI 模式。
在每个已配置为双线模式的阶段中：
 IO0/IO1 在数据阶段进行读取操作时处于高阻态（输入），在其他情况下为输出
2 K; \/ d. Y" ? IO2 处于输出模式并强制置“0”
# ^5 O4 [8 J$ l8 [' r$ X8 o( ` IO3 处于输出模式并强制置“1”
7 f: H2 }* l2 i  l0 g8 F# W* Q在空指令阶段，若 DMODE = 01，则 IO0/IO1 始终保持高阻态。

' u) n  S) L5 Y$ k; W# T9 }0 x
! Y* F1 B6 l) n: D四线 SPI  模式:
在四线模式下，通过 IO0/IO1/IO2/IO3 信号同时发送/接收四位。
通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 11，可
  l- r) X- Q& z( }1 B" [* L对不同的命令阶段分别进行配置，以使用四线 SPI 模式。
! ?/ ~9 }5 \7 m9 @- ^- ^在每个已配置为四线模式的阶段中，IO0/IO1/IO2/IO3 在数据阶段进行读取操作时均处于高
  C% ?9 y5 ~7 E5 a1 f' B阻态（输入），在其他情况下为输出。
在空指令阶段中，若 DMODE = 11，则 IO0/IO1/IO2/IO3 均为高阻态。
IO2 和 IO3 仅用于 Quad SPI 模式 如果未配置任何阶段使用四线 SPI 模式，即使 QUADSPI
, c: u6 j* `5 Y+ }+ P  i激活，对应 IO2 和 IO3 的引脚也可用于其他功能。
1 P8 v, P( I: }+ t6 h
8 u: G" q* H2 Q  C# C6 X4 L+ H% N
SDR  模式(默认工作模式)
3 R6 C/ \) l2 g( C  A4 P默认情况下，QUADSPI 在单倍数据速率 (SDR) 模式下工作。
在 SDR 模式下，当 QUADSPI 驱动 IO0/SO、IO1、IO2、IO3 信号时，这些信号仅在 CLK
的下降沿发生转变。
( V8 R6 V( `$ a7 y5 W/ B: k在 SDR 模式下接收数据时，QUADSPI 假定 Flash 也通过 CLK 的下降沿发送数据。默认情
# ?4 N6 [$ n! M, u9 R+ l况下 (SSHIFT = 0 时)，将使用 CLK 后续的边沿（上升沿）对信号进行采样。
3 U9 g& y5 Z, q* m! n' q8 }
8 L# v6 U! Z# B3 i% h7 X
DDR  模式
在 DDR 模式下，当 QUADSPI 在地址/交替字节/数据阶段驱动 IO0/SO、IO1、IO2、IO3 信
号时，将在 CLK 的每个上升沿和下降沿发送 1 位。
指令阶段不受 DDRM 的影响。始终通过 CLK 的下降沿发送指令。
% G/ A( W9 }: M- o2 r, x在 DDR 模式下接收数据时，QUADSPI 假定 Flash 通过 CLK 的上升沿和下降沿均发送数
据。若 DDRM = 1，固件必须清零 SSHIFT 位 (QUADSPI_CR[4])。因此，在半个 CLK 周期
后（下一个反向边沿）对信号采样。
# X1 N# T* Q3 J4 l  q2 j
五、QSPI 配置（HAL库）
7 [# y, B+ d4 d/ Q3 S1 P9 v- _& e
5 x' H+ q7 n# |& c1.首先根据硬件电路，配置相关引脚，开启引脚和QSPI时钟

- E% N9 L! b2 |

& T  ~/ Q; U* @& I8 ^# Z

1. void HAL_QSPI_MspInit(QSPI_HandleTypeDef* qspiHandle)
   
2. {
   ) S1 D" ^/ e3 y) R1 |4 K
3. 
   4 z5 v- @8 C$ j: j- z! n
4.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   
5.   if(qspiHandle->Instance==QUADSPI)
   
6.   {
   ) ?5 F$ i3 _0 c; Y
7.   /* USER CODE BEGIN QUADSPI_MspInit 0 */
   3 e1 X$ X! j. m1 K
8. 
   
9.   /* USER CODE END QUADSPI_MspInit 0 */
   2 T" P+ E* G4 b; d4 U2 s5 }2 w) R
10.     /* QUADSPI clock enable */
    
11.     __HAL_RCC_QSPI_CLK_ENABLE();
    $ u$ c( q7 l, P* T# A$ l$ q
12. 
    , X+ A. `5 [( c1 A. w- G  \
13.     __HAL_RCC_GPIOE_CLK_ENABLE();
    
14.     __HAL_RCC_GPIOB_CLK_ENABLE();
    + n1 q8 y. F# B# X7 W2 y# ]
15.     __HAL_RCC_GPIOD_CLK_ENABLE();
    
16.     /**QUADSPI GPIO Configuration   
      ?3 }+ E9 @* E/ ^- _( A- a
17.     PE2     ------> QUADSPI_BK1_IO2
    
18.     PB6     ------> QUADSPI_BK1_NCS
    
19.     PB2     ------> QUADSPI_CLK
    
20.     PD12     ------> QUADSPI_BK1_IO1
    7 _2 w! N; _" w9 T5 r" O
21.     PD13     ------> QUADSPI_BK1_IO3
    % B: |) I" |9 O9 K
22.     PD11     ------> QUADSPI_BK1_IO0
    0 s+ j+ b3 F% G7 Y
23.     */
    
24.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
25.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
26.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
27.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    1 ?. J$ {" }9 E1 W5 ]
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;
      I! V( G) A# C; L; {. _
33.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
34.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
35.     GPIO_InitStruct.Alternate = GPIO_AF10_QUADSPI;
    $ {. s, U& y7 {% g' m* h6 w
36.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    0 Q9 r7 Q( r* Y" s* g8 S$ H
37. 
    $ e' v4 ]5 b  Y$ Y" Z
38.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
39.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ) E/ E* L1 v! y+ K% T
40.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    / p5 W( L2 Z% S( {! }# u
41.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
42.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    
43.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
44. 
    
45.     GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_11;
    ; D. Z  V( w/ @
46.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
47.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    $ X, T. b; b# I. X+ M7 L. \
49.     GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
    
50.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    : s4 ?! y9 ?& y8 U
51. 
    $ u( d( _2 A  G
52.   /* USER CODE BEGIN QUADSPI_MspInit 1 */
    ( B5 d' I( o- i$ M
53. 
    : l7 R( D) a$ h, G: A
54.   /* USER CODE END QUADSPI_MspInit 1 */
    8 {. G" S! X2 i& P7 c
55.   }
    
56. }

复制代码

2.接着初始化SPI外设

1. 
   
2. QSPI_HandleTypeDef hqspi;
   * t2 |" ~* k2 ]
3. 
   * P" C' Y- t3 X
4. /* QUADSPI init function */
   & n6 ]* S% t( X5 V
5. void MX_QUADSPI_Init(void)
   
6. {
   7 s$ y" n1 B3 s9 w
7.   hqspi.Instance = QUADSPI;//QSPI外设
   
8.   hqspi.Init.ClockPrescaler = 2;//QPSI分频比，N25Q128最大频率为104M，此处216/(2+1)=72M
     |3 C( `: E4 E# N" ~4 D/ Y: ]
9.   hqspi.Init.FifoThreshold = 4;//FIFO阈值为4个字节
   
10.   hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;//采样移位半个周期(DDR模式下,必须设置为0)
    / t' Q% B4 b0 i( B( N
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
    # Q  ^! |( n0 v$ @2 j' n  e4 v, o0 A
15.   hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;//禁止双FLASH模式
    
16.   if (HAL_QSPI_Init(&hqspi) != HAL_OK)//初始化QSPI外设
    
17.   {
    
18.     Error_Handler();
    
19.   }
    
20. }

复制代码

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

. M! V& [6 O8 e  d8 W6 y( _" z我们首先需要配置下面的命令参数结构体：

0 {9 r% @3 g9 p9 v

* P6 v3 S9 y5 Z# f8 }
Instruction:指令类型（读、写、擦除等等）
/ m- X0 ?9 D) R6 Q
Address:需要读取或写入数据的起始地址

/ t8 Y+ p* Q6 oNbData:需要读取或写入数据的长度

DataMode：数据传输模式，就是数据用几根线传输（1、2、4线可选），后面的AddreMode类似，就是用几根线传输地址，InstructionMode就是用几根线传输指令。
8 T1 M6 n0 p$ \( t) R3 m; M5 w& o
$ ?3 @! a' y* y- h1 r' z2 Y这三个参数都需要根据芯片数据手册来选择，手册上说明支持该模式才可以选择，否则会通信错误，另外，数据传输模式的不同，对应的指令类型也会不同，比如N25Q128 READ指令对应单线传输模式，Quad I/O Fast Read则对应四线传输模式，这些对应关系手册上都有详细说明！！！
1 {% \! G! M' G( K
4.读取芯片JEDEC ID
; X  S" R" R! z8 J, R) @8 l
首先查看手册上读取JEDEC ID的时序：

+ ]2 f  K/ O+ R

4 j; v& ^; {2 e$ q& J3 y/ w( T
可以看出，读ID这条指令是只有指令阶段和数据阶段，且都是单线传输模式，所以
& A3 n' I+ F5 k; j9 d/ b
9 z1 A. U* ?! P8 k: o: f  dInstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令单线传输模式
5 l4 @, A; E  n% B0 l7 b" B
DataMode = QSPI_DATA_1_LINE；//数据单线传输模式

! Y( L2 ]+ k4 Q* k( [5 q" GAddress和AddressMode 这两个参数的值都置0，表示无地址。

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

3 i. |! w2 O9 w6 O4 A+ x其他值和下面代码保持一致即可。
* z. l) [3 v2 m3 V. N
3 X2 q" f& F6 b然后 使用HAL_QSPI_Command函数将读ID指令发送给FALSH，等待发送完成

最后 调用HAL_QSPI_Receive，接受FALSH返回的数据，即芯片ID
- e4 G# _. d( W+ ]& [

1. /**
   / q; {' v4 U) b4 J! e4 g) n2 Y# G
2. * @brief  读取FLASH ID
   * m" [$ W$ e9 |4 F# e
3. * @param   无
   
4. * @retval FLASH ID
   * i! q3 i, c3 C% f4 P
5. */
   " W1 x& _3 Z: w* o) J/ _
6. uint32_t QSPI_FLASH_ReadID(void)
   8 A: z% N% M+ v4 X- _+ b  y
7. {
   
8.      QSPI_CommandTypeDef s_command;
   
9. 
   ( H' c, }' K9 z$ T, n) y4 w
10.      uint32_t Temp = 0;
    , \$ ?. J' e" `- {: B4 i  n, E% z
11. 
    
12.      uint8_t pData[3];
    
13. 
    
14.      /* 读取JEDEC ID */
    
15. 
    5 w3 w7 G  ?  Z) B2 F
16.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;//指令阶段的操作模式，00：无指令；01：单线传输指令；10：双线传输指令；11：四线传输指令。
    3 [0 J0 ?1 |' x% v% b, H0 W! u9 V
17. 
    7 y/ j: _  {; S5 O7 f; ^9 e
18.      s_command.Instruction       = READ_JEDEC_ID_CMD;//读取芯片ID指令
    
19. 
    
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;//定义地址长度
    / J* \! S* z+ c- g) L# E
21. 
    6 N& e0 h7 C1 j
22.      s_command.DataMode          = QSPI_DATA_1_LINE;//定义数据阶段的操作模式，00：无数据；01：单线传输数据；10：双线传输数据；11：四线传输数据。
    5 Y" h2 P- }3 R9 I+ s. G* J5 j
23. 
    
24.      s_command.AddressMode       = 0;//地址阶段的操作模式，00：无地址；01：单线传输地址；10：双线传输地址；11：四线传输地址。
    
25.          
    - r7 f# z0 r" p% ?) z, w
26.      s_command.Address           = 0;   
    * i$ \2 H% R) b& z- q+ Z% p2 `0 b
27.         
    ) w/ y+ O7 V+ ?6 t) E, A' C8 A
28.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;//交替字节长度
    
29. 
    & I8 n  ]! W* }8 a0 m  P+ g
30.      s_command.DummyCycles       = 0;//空指令阶段的持续时间，在 SDR 和 DDR 模式下，它指定 CLK 周期数 (0-31)。
    0 W+ S: w, y& C2 t3 x8 g
31. 
    + j: W6 n0 K$ R0 Y
32.      s_command.NbData            = 3;//设置数据长度，在间接模式和状态轮询模式下待检索的数据数量（值 + 1）。对状态轮询模式应使用不大于 3 的值（表示 4 字节）。
    
33. 
    
34.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;//地址、交替字节和数据阶段设置 DDR 模式，0：禁止 DDR 模式；1：使能 DDR 模式。
    
35. 
    
36.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;//设置DDR 模式下数据输出延迟 1/4 个 QUADSPI 输出时钟周期，0：使用模拟延迟来延迟数据输出；1：数据输出延迟 1/4 个 QUADSPI 输出时钟周期。
    
37.                  
    / ?9 H* S+ e: A: S/ z& z
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)
    . Y* _' {7 I% K6 _* B* E. t
41.                  {
    9 I% r/ W# \) i3 o9 C4 M
42.          #if  QSPI_DEBUG
    3 r! N' p  ]/ U" |) S  |9 l2 F9 U
43.                      printf("send read flash ID command error!\r\n");
    
44.                #endif
    
45.          /* 用户可以在这里添加一些代码来处理这个错误 */
    
46.          while (1) {}
    % u4 E4 y- f# `+ @% ~" U' O/ C
47.      }
    4 S# Y4 o; N. Z) o- w' W
48.      if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    
49.                  {
    5 _" l% h2 a0 w8 u3 ~
50.          #if  QSPI_DEBUG
    
51.                      printf("read qspi flash ID error!\r\n");
      \4 Y/ s9 r1 v$ t; S
52.                #endif
    
53.          /* 用户可以在这里添加一些代码来处理这个错误 */
    
54.          while (1) {}
    
55.      }
    
56.      Temp = ( pData[2] | pData[1]<<8 )| ( pData[0]<<16 );
    
57.      return Temp;
    3 [* s6 \5 X5 t1 W4 m
58. }

复制代码

) T) p! j( l9 F 5.FALSH 写使能
0 [, N; x8 J9 u! W: }
6 e- K: P# S" C$ H7 c/ j在对FALSH进行写之前，需要打开写使能开关（实际上就是发送写使能指令）：
) e2 U& p6 E% j
类似的，需要查看芯片手册，写使能的时序

可以看到这个指令时序更简单，仅仅有指令阶段，所以地址和数据的参数都应置0

1. /**
   / \& N+ p, V: h( {, S2 @% g6 v  J8 l
2.   * @brief  QSPI FALSH写使能
   5 s7 @) j4 U: O: e
3.   * @param  None
   . m/ a+ ?; K0 L1 G5 ?
4.   * @retval HAL_OK
   ( {; o, E0 e, A* D- o4 W/ {# {
5. */
   0 O3 |8 }! l; L  q
6. static HAL_StatusTypeDef QSPI_WriteEnable(void)
   
7. {
   : P2 T( _8 f! v, U4 B  V* w( E' u
8.   QSPI_CommandTypeDef     sCommand;
   
9.   QSPI_AutoPollingTypeDef sConfig;
   
10. 
    
11.   /* Enable write operations ------------------------------------------ */
    . l3 h& r+ T6 W" B6 `! W6 ~
12.   sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    2 K3 I6 I. L+ j# I
13.   sCommand.Instruction       = WRITE_ENABLE_CMD;
    
14.   sCommand.AddressMode       = QSPI_ADDRESS_NONE;
      k5 T5 f. l( Y3 m( N  W8 n! y; w
15.   sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    , `% }' |( Y0 V8 u/ f5 L
16.   sCommand.DataMode          = QSPI_DATA_NONE;
    & x/ o" B+ e+ V+ r& r: W1 a
17.   sCommand.DummyCycles       = 0;
    
18.   sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;
    
19.   sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    / w( B9 i4 Q8 {6 g% ^
20.   sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    + T2 [1 `4 X. t( ]
21. 
    
22.   if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    ( H4 c) ?5 C; B
23.   {
    3 Y5 j1 `$ s5 s
24.     return HAL_ERROR;
    1 p- T# q( k, F) |/ Z- y$ }
25.   }
    ( M2 a$ |. A. }
26. 
    
27.   /* Configure automatic polling mode to wait for write enabling ---- */  
    ! s. W+ B  ]- }! M
28.   sConfig.Match           = 0x02;
    1 A  K( K0 O9 W5 f- i1 Q
29.   sConfig.Mask            = 0x02;
    + n- L) T, r6 e! G8 ^( ?" S4 D2 L
30.   sConfig.MatchMode       = QSPI_MATCH_MODE_AND;
    ( }8 N& R2 _; S1 v/ F1 p8 K8 j7 @
31.   sConfig.StatusBytesSize = 1;
    
32.   sConfig.Interval        = 0x10;
    
33.   sConfig.AutomaticStop   = QSPI_AUTOMATIC_STOP_ENABLE;
    + y1 W- z5 H: n" m5 u% U
34. 
    
35.   sCommand.Instruction    = READ_STATUS_REG1_CMD;
    
36.   sCommand.DataMode       = QSPI_DATA_1_LINE;
    
37. 
    1 t" ?5 d8 i: U
38.   if (HAL_QSPI_AutoPolling(&hqspi, &sCommand, &sConfig, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    ) z- F# f# J/ @1 ~8 j3 V# T
39.   {
    
40.                 return HAL_ERROR;        
    , n0 y2 S0 P( @5 A  H, ~
41.   }
    1 E, Z: [  |% z; d
42.         return HAL_OK;
    
43. }

复制代码

这里需要讲下 QUADSPI  状态标志轮询模式：
在自动轮询模式下，QUADSPI 周期性启动命令以读取一定数量的状态字节（最多 4 个）。
可屏蔽接收的字节以隔离一些状态位，从而在所选的位具有定义的值时可产生中断。
对 Flash 的访问最初与在间接读取模式下相同：如果不需要地址 (AMODE = 00)，则在写入
QUADSPI_CCR 时即开始访问。否则，如果需要地址，则在写入 QUADSPI_AR 时开始第
$ t* T- i$ e1 C' o2 `4 w一次访问。BUSY 在此时变为高电平，即使在周期性访问期间也保持不变。
! X2 ?& O0 ~8 u! n) A. d在自动轮询模式下，MASK[31:0] (QUADSPI_PSMAR) 的内容用于屏蔽来自 Flash 的数据。
2 B( f7 D# |% V) e. S" u5 F如果 MASK[n] = 0，则屏蔽结果的位 n，从而不考虑该位。如果 MASK[n] = 1 并且位 [n] 的内
* G) a; I% f; [& n( }容与 MATCH[n] (QUADSPI_PSMAR) 相同，说明存在位 n 匹配。
如果轮询匹配模式位 (PMM, QUADSPI_CR[23]) 为 0，将激活“AND”匹配模式。这意味着
状态匹配标志 (SMF) 仅在全部未屏蔽位均存在匹配时置 1。
如果 PMM = 1，则激活“OR”匹配模式。这意味着 SMF 在任意未屏蔽位存在匹配时置 1。
如果 SMIE = 1，则在 SMF 置 1 时调用一个中断。
如果自动轮询模式停止 (APMS) 位置 1，则操作停止并且 BUSY 位在检测到匹配时清零。否
+ f  F) y6 e/ G1 @8 c/ Z则，BUSY 位保持为“1”，在发生中止或禁止 QUADSPI (EN = 0) 前继续进行周期性
访问。
数据寄存器 (QUADSPI_DR) 包含最新接收的状态字节（FIFO 停用）。数据寄存器的内容不
受匹配逻辑所用屏蔽方法的影响。FTF 状态位在新一次状态读取完成后置 1，并且 FTF 在数
据读取后清零。

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

6.读FALSH
- [* Y$ V0 {) \9 W& j
9 n6 m3 I- ]% [/ r( a$ |* W这里仅介绍4线模式下的读FALSH流程，首先查看手册4线模式读时序

从时序图可以看出，指令是1线模式，地址是4线模式，空周期（DummyCycles）为10，数据也是4线模式，还有此时的读指令是QUAD_INOUT_FAST_READ_CMD。所以相关参数配置如下：
# j: k5 Q( Z1 Z  q& }( W4 _* }
8 L: h6 T0 F( ^% W. Z( _! k- S: x" y- e

1. /**
   + V+ ^5 [) z  j# _& N- b9 l
2. * @brief  从QSPI存储器中读取大量数据.
   
3. * @param  pData: 指向要读取的数据的指针
   ; K: X/ [; K! E
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. {
   % l& z$ M. g7 v+ c; H7 e: s
10.      QSPI_CommandTypeDef s_command;
    
11. 
    
12.      /* 初始化读命令 */
    
13. 
    
14.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
15. 
    4 u8 T7 o  g0 k1 P% _8 P+ J
16.      s_command.Instruction       = QUAD_INOUT_FAST_READ_CMD;
    
17. 
    ! R+ n+ _1 A3 _3 d  q
18.      s_command.AddressMode       = QSPI_ADDRESS_4_LINES;
    , b: h+ R. B: \! e) T3 E9 k
19. 
    
20.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    
21. 
    
22.      s_command.Address           = ReadAddr;
    9 m. x% Y8 l4 o; G* n+ ]
23. 
    8 ^) o* W0 v; h  B8 B3 h
24.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
25. 
    
26.      s_command.DataMode          = QSPI_DATA_4_LINES;
    
27. 
    & i, y5 r* M9 J5 ]  J) P. l
28.      s_command.DummyCycles       = 10;
    . e" e+ d. h3 Y. ~
29. 
    
30.      s_command.NbData            = Size;
    
31. 
    
32.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    , c- N% f$ B. z, R% S2 v
33. 
    
34.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
35. 
    
36.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    9 l) S* _5 c* T! ?0 x3 m1 D% L; g
37.      /* 配置命令 */
    
38. 
    
39.    if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    4 X5 d4 f* }$ f! Z) f* Y; ?* U" \
40.          {
    
41.                 #if  QSPI_DEBUG
      \% Q8 f! }+ s, M  Y8 q
42.                 printf("R-send read command error!\r\n");
    
43.           #endif
    2 C& f# q8 T) z$ V0 k, z9 n1 \
44.     return HAL_ERROR;
    
45.    }  
    
46.    /* 接收数据 */
    
47.    if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
    
48.          {
    / T0 k; d( K9 Y  o7 t
49.                 #if  QSPI_DEBUG
    
50.                 printf("R-read data error!\r\n");
    
51.           #endif
    
52.     return HAL_ERROR;
    . J1 k! y' c4 T: ?2 {- H
53.    }
    
54.    return HAL_OK;
    & m* a# e3 f3 \4 ^8 T+ I( p
55. }

复制代码

本函数实现了从FALSH指定地址读取指定数量字节的功能
9 z. O3 B  u4 U: ~( _
' ~4 c, R3 M6 f8 s8 e 7.写FALSH
' U  e, D5 ^8 \- c2 E6 [6 u1 P
同读FALSH类似，我们需要在手册中找到4线写FALSH的时序：

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

8 N6 @6 z+ ]3 I) y' M) u& B

1. /**
   $ a2 D2 G0 G9 S, D9 Y8 Z( f
2. * @brief  将大量数据写入QSPI存储器
   ; D# `  b( L/ k# q' _
3. * @param  pData: 指向要写入数据的指针
   # a: c  r* r( a
4. * @param  WriteAddr: 写起始地址
   
5. * @param  Size: 要写入的数据大小
   
6. * @retval QSPI存储器状态
   8 V$ g* o7 ]( b0 p1 ?# E; i) z7 e. q
7. */
   0 l2 j3 @3 F9 j! Q
8. HAL_StatusTypeDef BSP_QSPI_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
   ( \0 i5 f( }/ b
9. {
   
10.                         QSPI_CommandTypeDef s_command;
    
11.                         uint32_t end_addr, current_size, current_addr;
    
12.             unsigned char sector_start,sector_end,i;
    8 ]" N& I+ H% t& n
13.         
    
14.                         /* 计算写入地址和页面末尾之间的大小 */
    
15.                         current_addr = 0;
    , j+ Y: Y) w( C" B$ Z* |& ?* C  _
16.         
    
17.                         while (current_addr <= WriteAddr)
    - Q6 M* |9 J8 A" p
18.                         {
    : J$ n$ U, c& s$ [" }" ~" C
19.                                         current_addr += N25Q128FV_PAGE_SIZE;
    
20.                         }
    
21.                   current_size = current_addr - WriteAddr;
    $ ?. R* P3 I2 \% L5 f' K7 J9 y4 F
22.      /* 检查数据的大小是否小于页面中的剩余位置 */
    
23.      if (current_size > Size)
    
24.                  {
    2 V  d8 Z+ y1 Y! L
25.          current_size = Size;
    
26.      }
    
27.      /* 初始化地址变量 */
    
28.      current_addr = WriteAddr;
    
29.      end_addr = WriteAddr + Size;
    ; O$ o9 l" b) g4 w, f( {! ]
30.                  
    1 ?6 p# k* L1 M: t7 J1 B
31.                  sector_start = current_addr >> 16;
    
32.                  sector_end = end_addr >> 16;
    
33.                  
    / u$ w7 F# u- J
34.                  for( i = sector_start; i<=sector_end ;i++)
    
35.                  {
    " ]& o" N" ?' q2 G9 P3 w! R& B
36.                     BSP_QSPI_Erase_Block(i); //擦除对应删除
    3 f6 j+ s7 z" U
37.                  }
    . Q) }$ Q3 ^5 d/ N5 B
38.                  
    
39.      /* 初始化程序命令 */
    
40.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
      s: Q+ N5 Q9 g& [- L; t
41. 
    7 i; Z  w* i3 m( o
42.      s_command.Instruction       = QUAD_INPUT_PAGE_PROG_CMD;
    
43. 
    
44.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    
45. 
    
46.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
    0 f. h9 p# T" G  d) P' \
47. 
    & I* Q/ f' \. M
48.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
49. 
    % }; H; N# i0 j. b  |' P
50.      s_command.DataMode          = QSPI_DATA_4_LINES;
    
51. 
    0 y9 P$ f+ g, I9 M' W
52.      s_command.DummyCycles       = 0;
    , c; h$ e* X' z1 ~2 k
53. 
    
54.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    + P- g" C+ _; `& |- L4 g. n
55. 
    
56.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    & U. o: X- N3 t" H. a
57. 
    6 }  O4 r8 f4 I( p+ j! Y# `
58.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    6 S2 a. c- }6 n) X
59. 
    
60.      /* 逐页执行写入 */
    
61.      do {
    
62. 
    ( _8 p& p4 V8 B% [& t1 b
63.          s_command.Address = current_addr;
    
64.          s_command.NbData  = current_size;
    
65.          /* 启用写操作 */
    
66. 
    
67.          if (QSPI_WriteEnable() != HAL_OK)
    
68.                                  {
    
69.                                                 #if  QSPI_DEBUG
    
70.                                                 printf("W-Qspi write enable error!\r\n");
    
71.                                                 #endif
    
72.             return HAL_ERROR;
    
73.          }
    0 T1 v7 G/ a$ y/ [1 u- S
74.          /* 配置命令 */
    
75.         if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
76.                 {                                 
    0 L- g7 h% G- t2 {( W) Q) r7 X2 b7 r+ ~
77.                                           #if  QSPI_DEBUG
    1 \5 C: `. B7 e" o* r
78.                                                 printf("W-Qspi send Command error!\r\n");
    
79.                                                 #endif
    $ c7 |4 `# g1 @5 G$ D0 g- W/ i. Q
80.             return HAL_ERROR;
    
81.          }
      l- s1 \6 V- U5 g5 X9 z1 T
82.          /* 传输数据 */
    % ?1 f* R# ~3 z0 `: I
83.          if(HAL_QSPI_Transmit(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
84.                                  {
    
85.                                           #if  QSPI_DEBUG
    
86.                                                 printf("W-Qspi Transmit data error!\r\n");
    $ h6 b/ \% E5 \$ y  K! A+ d* ?4 Y
87.                                                 #endif
    
88.             return HAL_ERROR;
    8 C4 w8 g5 Y3 g5 [0 P$ a5 d( ~5 U
89.          }
    $ L. q  R/ w" K0 D. z0 G
90.          /* 配置自动轮询模式等待程序结束 */
    
91. 
    
92.          if(QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
93.                                  {                                         
    
94.                                                 #if  QSPI_DEBUG
    
95.                                                 printf("W-AutoPollingMemReady error!\r\n");
    
96.                                                 #endif
    4 h) p$ k% s* f5 g& h4 i
97.             return HAL_ERROR;
    & w, d3 x; M: w* _4 ^& s
98.          }
    $ M2 _" S( c/ `; D, W+ w8 N
99.          /* 更新下一页编程的地址和大小变量 */
    . `0 ?- N8 B; o- r
100. 
     : d% L% E; m; z. F% K" K: _' ?
101.          current_addr += current_size;
     
102. 
     8 E: u7 D0 ^$ g$ a
103.          pData += current_size;
     0 T7 ~- Y# O* O. i! g
104. 
     
105.          current_size = ((current_addr + N25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr-current_addr) :
     * Y1 ?# \; F* G8 ^4 I3 g
106. 
     8 ?* E! C4 G3 E- G2 A% Z. Z/ `8 ^
107.                         N25Q128FV_PAGE_SIZE;
     . `- J% M, R1 M
108. 
     ; i, f" C; @: v8 k6 v/ @# t
109.      } while (current_addr < end_addr);
     0 p" V) B- X$ _4 L4 c6 f
110.      return HAL_OK;
     ( o5 s) V# q1 u$ V
111. }

复制代码

该函数实现从指定地址写入指定数量的字节。
; Z+ ]: X: T9 u- `3 b+ j; i3 ^
8.擦除FALSH

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

; R5 X1 w3 n! Y
9 V$ g1 j. w5 @- w/ m( J# N参数设置为1线指令 ，1线地址，24bit地址，无数据阶段
6 _( m4 n. ?8 ^5 \6 A0 U4 ?+ B# I$ I

1. /**
   . [+ \( N0 B) K, Z. `: s' [
2. * @brief  擦除QSPI存储器的指定扇区
   
3. * @param  BlockAddress: 需要擦除的扇区地址
   
4. * @retval QSPI存储器状态
   / x8 A& b. x1 w
5. */
   - U7 {, b- s8 }  \
6. HAL_StatusTypeDef BSP_QSPI_Erase_Sector(uint32_t Sector)
   
7. {
   % ^- W0 K- _: W* G, o! Z
8.            uint32_t SectorAddress=Sector << 16;//Sector*65535算出该扇区对应的地址
   
9.         
   
10.      QSPI_CommandTypeDef s_command;
    
11.      /* 初始化擦除命令 */
      S2 R! ~6 ^) A% Z
12.         
    
13.      s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    # J+ W4 T$ [6 q5 D) E1 |( {  M
14. 
    8 J; s0 h. y$ ~' w! }0 O9 G
15.      s_command.Instruction       = SECTOR_ERASE_CMD;//按扇区擦除
    
16. 
    
17.      s_command.AddressMode       = QSPI_ADDRESS_1_LINE;
    
18. 
    
19.      s_command.AddressSize       = QSPI_ADDRESS_24_BITS;
      j. y; W6 {- q5 B
20. 
    
21.      s_command.Address           = SectorAddress;
    
22. 
    
23.      s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    
24. 
    
25.      s_command.DataMode          = QSPI_DATA_NONE;
    0 I0 u  F! n' _
26. 
    7 F& ^! w8 w0 P8 r  C4 C
27.      s_command.DummyCycles       = 0;
    7 `+ W4 \+ n! g$ t3 ^" P$ e2 O
28. 
    
29.      s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    
30. 
    , `2 r* e1 y% ^! D4 U4 j* P
31.      s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
32. 
    ( |& E5 n4 ^/ i, r6 r( u7 t
33.      s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    . z1 K! o% y! K+ A) M
34. 
    & O, U9 a  N9 Z6 i5 ]
35.      /* 启用写操作 */
    
36. 
    ! {3 v% W; I" c6 H" U$ l$ }
37.      if (QSPI_WriteEnable() != HAL_OK)
    
38.                  {
    
39.          return HAL_ERROR;
    . b, w# b1 T! E5 \2 K" `( \
40.      }
    
41.      /* 发送命令 */
    ; p( H8 T& \: V! k
42.      if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    $ y' y0 D" D8 z. |' |: m# E
43.      {
    9 q& O5 j  A) T+ U4 c) G9 k) T
44.          return HAL_ERROR;
    
45.      }
    
46.      /* 配置自动轮询模式等待擦除结束 */
    
47. 
    1 E# G6 o2 c; }/ A/ t
48.      if (QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    " q6 @/ U# @2 y  d; |8 {
49.      {
    . z& _8 I5 T9 }" K$ t# u% m
50.                                 #if  QSPI_DEBUG
    
51.                                 printf("erase sector error!\r\n");
    6 x. ?9 _9 @9 k: P) `
52.                                 #endif
    5 i( C3 C3 C- l" r; r4 c$ S
53.         return HAL_ERROR;
    2 {* L& ^' X% d3 x$ T6 I" q
54.      }
    - k& |+ X! B6 l- h
55.     return HAL_OK;
    % ^5 O9 Y6 v; q% C1 H+ e
56. }

复制代码

. a; [" ]% |* C% z第二种情况是全片擦除，时序如下：
# S( E: w5 o* J' U: I. @

# D, I: H' k" M! c# o
全片擦除仅包含指令阶段，对于N25Q128来说，全片擦除耗时可达48s。

  i( c% B9 x8 w1 L5 ^# m7 D" X

1. /**
   
2.   * @brief  全片擦除  N25Q128全片擦除耗时48s
   
3.   * @retval QSPI memory status
   
4.   */
   0 ^. N2 K' Q, f) x( n
5. uint8_t BSP_QSPI_Erase_Chip(void)
   
6. {
   
7.   QSPI_CommandTypeDef s_command;
   
8. 
   
9.   /* Initialize the erase command */
   8 I; p- E6 I3 Y: E! H% a3 i, a% J
10.   s_command.InstructionMode   = QSPI_INSTRUCTION_1_LINE;
    
11.   s_command.Instruction       = CHIP_ERASE_CMD;
    6 g' p3 k8 p, S0 i; {
12.   s_command.AddressMode       = QSPI_ADDRESS_NONE;
    : T8 z1 _% y% r; b
13.   s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    $ Q% [, S3 c, {8 P; t3 t
14.   s_command.DataMode          = QSPI_DATA_NONE;
    
15.   s_command.DummyCycles       = 0;
    
16.   s_command.DdrMode           = QSPI_DDR_MODE_DISABLE;
    6 J. }/ S; d% q# v. L
17.   s_command.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;
    
18.   s_command.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;
    
19. 
    & L2 Q! h! L/ W  T+ u- y
20.   /* Enable write operations */
    - j2 @! q  I. k7 x
21.   if (QSPI_WriteEnable() != HAL_OK)
    + E! U' C" w3 c5 a
22.   {
    4 C3 A$ L" M; o4 K; N  j% q
23.     return HAL_ERROR;
    ) q. k$ [' F1 I! ]" v7 h# F- q
24.   }
    
25. 
    2 [; N' }' G" u; t+ s
26.   /* Send the command */
    
27.   if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
    
28.   {
    ; I; w2 R% |0 F2 j  q/ `
29.     return HAL_ERROR;
    * t: O! f2 ?. v% j& n2 M* K3 E
30.   }
    + Q1 O* g- g7 `, ?3 @
31. 
    6 M. }, {% P8 j0 ^5 u$ _
32.   /* Configure automatic polling mode to wait for end of erase */  
    
33.   if (QSPI_AutoPollingMemReady(N25Q128A_BULK_ERASE_MAX_TIME) != HAL_OK)
    0 R5 k" X/ T3 @/ G
34.   {
    
35.     return HAL_ERROR;
    
36.   }
    
37. 
    % B, b7 k. u& d3 s1 C4 p
38.   return HAL_OK;
    5 f3 E  @6 y- ~, Z: d5 h3 A
39. }

复制代码

9.测试程序

& z5 z% X  j' ^: K/ y4 O5 ~/ s6 i3 I测试芯片写入和读取是否成功，首先向0x1FFFF地址连续写入4096个字节，然后再读取出来，对比两次数据是否一致。

1. unsigned char write[4096];
   + S! l6 u/ e" X. F' W2 ]# B
2. unsigned char read[4096];   
   
3. void N25Qxx_Test(void)
   
4. {
   $ T, q6 G. X. X. d9 X# W
5.   uint32_t i = 0;
   , ^5 n, L/ I; ]& r( s: S# t; g
6. 
   
7.         for(i = 0;i<sizeof(write);i++)
   
8.         {
   
9.     write=i;
   $ ?& b& ~$ j5 M
10.         }
    
11.         
    
12.         printf("write data:\r\n");        
    
13.   for(i = 0;i<sizeof(write);i++)
    7 I3 j+ m6 n# V/ Y  A
14.         {
    
15.                 printf("%d ",write);
    
16.         }
    
17.   printf("\r\n");
    6 _; _" k5 c7 ~7 E! `9 k  ]
18.         printf("\r\n");
    : {0 F( W9 m: C  w  \+ c3 a
19.         printf("\r\n");
    
20.         
    ! j8 T  O/ |2 Y1 L2 g% ~1 x
21.         BSP_QSPI_Write(write,0x1FFFF,sizeof(write));
    1 @4 S3 {2 @6 a$ v
22.   BSP_QSPI_Read(read,0x1FFFF,sizeof(write));        
    
23.         
    
24.         printf("Read from QSPI:\r\n");
    " O& ^' N1 b4 e1 X' R8 e( l5 G
25.         
    8 k- P  [% M- D; t; j4 v
26.   for(i = 0;i<sizeof(read);i++)
    ! T( a7 Y+ X1 R0 Z
27.         {
    ) X& N2 q( s! S9 l: z2 m+ L, \/ L
28.                 printf("%d ",read);
    
29.         }
    + m* o" p8 k9 [
30.   printf("\r\n");
    
31. }

复制代码

9 l8 X" S" M8 C; f& Z写入的数据（部分截图）：
5 o6 j& _5 `, l* w
" N0 a* P0 R; \9 Q9 y. t3 [+ j

读取的数据（部分截图）：

9 j$ V0 `: S8 A. _: K
截取相同的部分，两次数据完全一致，写入和读取成功。

/ R) m4 N3 I0 P# ~$ \最后，讲几点需要注意的地方：

# R2 E% Q' N" |+ P4 u1.N25Q128 与  W25Q128 有很多不同的地方，特别是4线模式下，二者很多地方不同，代码不可混用，比如W25Q128的很多指令都是支持4线的，但是N25Q128的指令阶段均不支持4线模式。
8 b% |: H- [7 R
5 I% k" z7 ?2 {2.硬件上使用了4线SPI，但是仍然可以使用单线SPI操作，只是速度慢了点，其他的没什么影响。

2 P3 u9 S0 s" \" H; }3.N25Q128在配置为内存映射模式时，外部 SPI 器件被视为是内部存储器。QUADSPI 外设若没有正确配置并使能，禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大，寻址空间也无法超过 256MB。如果访问的地址超出 FSIZE 定义的范围但仍在 256MB 范围内，则生成 AHB 错误。此错误的影响具体取决于尝试进行访问的 AHB 主设备：
 如果为 Cortex ® CPU，则生成硬性故障 (Hard fault) 中断
% P4 j6 d; R! c1 [% ?# X! ? 如果为 DMA，则生成 DMA 传输错误，并自动禁用相应的 DMA 通道。
& o6 M; m# O# }; I
4.N25Q128包含248个主扇区，每个扇区64KB,还有8个64KB的启动扇区，这8个启动扇区又可分为128个子扇区，每个子扇区大小为4KB，所有的扇区擦除都可以按照一次64KB大小擦除，但是这8个启动扇区也可以按照4KB一次擦除（需要使用SUBSECTOR_ERASE_CMD指令擦除）。
$ q9 W7 R" ?1 w/ a
5.N25Q128分TOP和Bottom架构，两种架构的区别就是启动扇区的位置不同，TOP架构的启动扇区是248~255（地址范围：F80000 ~FFFFFF），0~248为主扇区。Bottom架构的启动扇区是0~7（地址范围：0~7FFFF），8~255是主扇区。这两中架构可以通过完整的型号区分。

$ }7 K$ |0 ~- Z5 [3 w7 B! ]7 C" F/ Q

* f& _% N+ I  e& l8 F* H# ^9 D6.N25Q128和W25Q128 不可以相互替换，除非使用单线SPI通信，且只能使用F80000 ~FFFFFF或者0~7FFFF范围内的内存。
4 [! k5 W0 u4 I3 ]# J( D/ F5 Q9 f
7.N25Q128的指令在不同spi模式（单线、双线、四线）下有所不同，使用时一定要特别注意！！！
1 p1 _; {: a& ^4 n2 P
+ `' E; F$ S. H- j