一、QSPI接口介绍
# k: f" m/ o) D0 J
" _- C% Z$ M& L" [8 f8 sQUADSPI 是一种专用的通信接口,连接单、双或四(条数据线)SPI Flash 存储介质。该接口可以在以下三种模式下工作:
" ]: u2 ^( l: y4 K, R9 [3 g0 Q7 d9 H. H8 t, L
间接模式:使用 QUADSPI 寄存器执行全部操作,支持对FALSH进行读、写、擦除、锁定等操作。) S, X/ y. P: K S: `) e4 F) r
0 {8 U, W! Y) P7 z 状态轮询模式:周期性读取外部 Flash 状态寄存器,而且标志位置 1 时会产生中断(如擦除或烧写完成,会产生中断)! i3 z& M% o4 P$ O# |0 O* w
7 B6 I. b9 l" ^* e4 m; J 内存映射模式:外部 Flash 映射到微控制器地址空间,从而系统将其视作内部存储器8 q3 Y* r. |% v+ ^( B) e3 y3 v
7 ?6 l( }7 s; m, r+ r6 ^6 @ D5 l采用双闪存模式时,将同时访问两个 Quad-SPI Flash,吞吐量和容量均可提高二倍。' x4 O2 [, ~: b( L8 D* R; P
: t! E* w# q+ s( w9 l3 Q2 }内存映射模式支持XIP,即可以将代码放在外部FLASH运行,缺点就是有延迟,没有内部运行速度快,且外部FALSH只能读,不能写入或擦除。/ L; x, ~3 q; {8 A' S c8 z$ f
6 N7 b1 F( h; T ~+ |7 N
内存映射模式下QUADSPI 外设若没有正确配置并使能,禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大,寻址空间也无法超过 256MB。, }& |: i+ e0 Z
, k2 m2 [3 C# p% b1 g; t
二、 STM32QSPI 功能框图# E7 n( N2 b% x" J. b' @4 ^
1 {4 n- H7 E3 i9 _/ M. F8 k
: z7 g( u1 X' y' G8 J/ p/ ^% t: N' l4 r7 G! E$ }; l; `
STM32F7系列支持双QSPI接口,可以接两个外部FLASH,本文只介绍接一个FALSH的情况。QSPI使用6根线通信,其中数据线4根,1根时钟线,1根片选线,但是程序里是可以配置工作在几线模式。
# l: c% J& q9 ]3 j5 X
$ q3 b( O6 I4 i% `三、QUADSPI 命令序列2 W4 x" a- z7 W c( S& w
" }, N1 }( W3 b$ g; zQUADSPI 通过命令与 Flash 通信 每条命令包括指令、地址、交替字节、空指令和数据这五+ Y V; p0 ]$ [6 U, L' J/ U& ~
个阶段,任一阶段均可跳过,但至少要包含指令、地址、交替字节或数据阶段之一。% {/ e7 s2 G- C0 r
nCS 在每条指令开始前下降,在每条指令完成后再次上升。
$ X$ z8 U! g, i# ]+ M+ y C. ^' U R; \2 A: h6 U
- g# U2 Y2 V7 A6 M, ?- [% @$ e8 H6 @0 ~2 _ c' T
上图清晰的展示了一次QSPI通信过程,它完整的包含了通信的5个阶段,但不是每次通信都需要包含这5个阶段.- W* f# {, x; x1 A8 ~/ B
; g5 E) x- j5 s+ l E$ B! a2 d
交替字节阶段,将 1-4 字节发送到 Flash,一般用于控制操作模式。|正常读写是不需要的,所以这个阶段可以省略(结构体中该参数置0);
& T$ N, s6 \6 P& G( K4 `& m) x0 r Z( r, @8 P* x' f
空指令周期阶段,给定的 1-31 个周期内不发送或接收任何数据,目的是当采用更高. t, m, U/ [+ ]& \( ~2 j
的时钟频率时,给 Flash 留出准备数据阶段的时间。! z& x, X$ E" d; {9 ~6 `
若 DummyCycles为零,则跳过空指令周期阶段,命令序列直接进入数据阶段(如果存在)。+ e2 K: v8 |( a& {6 i" Y
' U" J! ^& y* x( y2 g# a
此外,并不是每次通信都需要包含以上各个阶段,例如,打开写使能指令,只有指令阶段,其他阶段的参数都置0.再比如,读芯片ID,只有指令和数据阶段,具体包含哪些阶段需要参照芯片手册配置。
/ g( P" z; y- n9 d1 w- v3 l. D; D1 n! w: s5 L1 J
四、QUADSPI 信号接口协议模式* J0 j. L7 o5 n# E: y2 a, o, }$ G
' u. @# \! @2 z. @( o
下面提到的几线模式都是指数据线的根数( p4 X* L0 k A8 q
) a8 e' A5 f' d) R单线 SPI 模式(即普通SPI通信,等同于使用MISO、MOSI、CLK、CS方式通信):
" i9 W {" Z* |; Y传统 SPI 模式允许串行发送/接收单独的 1 位。在此模式下,数据通过 SO 信号(其 I/O 与
$ N9 z( A+ d/ }IO0 共享)发送到 Flash。从 Flash 接收到的数据通过 SI(其 I/O 与 IO1 共享)送达。2 L) ^! s/ {+ N$ V0 s; p
通过将(QUADSPI_CCR 中的)IMODE/ADMODE/ABMODE/DMODE 字段设置为 01,可
2 i4 _9 G( N1 f对不同的命令阶段分别进行配置,以使用此单个位模式。. ]. i2 j! Y9 }, y- T
在每个已配置为单线模式的阶段中:
' n1 N, A" R0 @5 H" w IO0 (SO) 处于输出模式$ i S+ E5 v- }
IO1 (SI) 处于输入模式(高阻抗)% _: A5 Q' Z* W8 d- z5 Z+ |8 b
IO2 处于输出模式并强制置“0”(以禁止“写保护”功能)3 Z; {4 S6 }% G0 H: I' h; u
IO3 处于输出模式并强制置“1”(以禁止“保持”功能)4 U) V2 E1 O) ~* T$ e( X- ]
; B7 k3 C! P9 C: i% D
双线 SPI 模式:
* A1 ]/ \. A& F4 W" x% v# I4 w* F5 Z在双线模式下,通过 IO0/IO1 信号同时发送/接收两位。
# B8 l' X' d; `/ K% O通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 10,可
/ V. ], s; x, v" |; d, E0 p& T" ~对不同的命令阶段分别进行配置,以使用双线 SPI 模式。' E. T/ I/ M, o$ z4 B
在每个已配置为双线模式的阶段中:
4 k2 C V& q( e c. n7 i6 \ IO0/IO1 在数据阶段进行读取操作时处于高阻态(输入),在其他情况下为输出6 P8 Q+ j& J+ f. m7 H. T3 K. L2 G! w
IO2 处于输出模式并强制置“0”
1 ? p) I$ f3 `0 k! U# _) w$ @3 W" [ IO3 处于输出模式并强制置“1”7 a2 w( h" s8 Y# S1 I
在空指令阶段,若 DMODE = 01,则 IO0/IO1 始终保持高阻态。+ f! z$ }* s- w. P D% D
: ?; Z1 X5 t' e* R6 H$ D
+ z. f* J. b1 Z: v R四线 SPI 模式:
& P3 J; F. u1 I4 l在四线模式下,通过 IO0/IO1/IO2/IO3 信号同时发送/接收四位。* y) M* o: A4 g4 o/ n: E6 L- l7 D
通过将 QUADSPI_CCR 寄存器的 IMODE/ADMODE/ABMODE/DMODE 字段设置为 11,可
6 E0 V6 I# d% i" d5 V对不同的命令阶段分别进行配置,以使用四线 SPI 模式。6 g! I. ?) K3 Z) e0 `9 B# _
在每个已配置为四线模式的阶段中,IO0/IO1/IO2/IO3 在数据阶段进行读取操作时均处于高
3 H7 C* I; M! Q( p阻态(输入),在其他情况下为输出。
* D4 j0 i: E; M! U" ]. @+ X: T在空指令阶段中,若 DMODE = 11,则 IO0/IO1/IO2/IO3 均为高阻态。4 x9 D( f1 c: o; _3 K3 P
IO2 和 IO3 仅用于 Quad SPI 模式 如果未配置任何阶段使用四线 SPI 模式,即使 QUADSPI
' K6 Z* C$ X6 P1 n激活,对应 IO2 和 IO3 的引脚也可用于其他功能。
. j/ Y2 t; e5 S& K/ _% x, W7 E9 n( p0 @/ M: }4 s
* \( y5 v. K6 R7 |+ ~* {4 sSDR 模式(默认工作模式)$ i& i) I: E! R4 w
默认情况下,QUADSPI 在单倍数据速率 (SDR) 模式下工作。4 Q t1 w( a9 R* G8 Q* Q/ b
在 SDR 模式下,当 QUADSPI 驱动 IO0/SO、IO1、IO2、IO3 信号时,这些信号仅在 CLK: i- F M) [/ S% e4 @0 ?
的下降沿发生转变。
- L. n( d; r$ @, f9 l6 `在 SDR 模式下接收数据时,QUADSPI 假定 Flash 也通过 CLK 的下降沿发送数据。默认情
, R/ T& k- V. H2 C: B况下 (SSHIFT = 0 时),将使用 CLK 后续的边沿(上升沿)对信号进行采样。
! \) g8 \0 D' k E7 G/ Y( a2 d' d: _, A0 B$ Y& c0 _: }2 C
8 {0 k. j, r0 Z+ X4 h* w- S
DDR 模式7 D: Q( d# Q# l0 Z$ t1 w8 x e
在 DDR 模式下,当 QUADSPI 在地址/交替字节/数据阶段驱动 IO0/SO、IO1、IO2、IO3 信
, v/ y2 D D. B( X+ s号时,将在 CLK 的每个上升沿和下降沿发送 1 位。
" |9 A& K+ X( W! s# _6 o- b" e指令阶段不受 DDRM 的影响。始终通过 CLK 的下降沿发送指令。
, g7 P, M% @/ T( R: V/ C在 DDR 模式下接收数据时,QUADSPI 假定 Flash 通过 CLK 的上升沿和下降沿均发送数: |2 D0 z2 W2 y, K. [* o( D6 @
据。若 DDRM = 1,固件必须清零 SSHIFT 位 (QUADSPI_CR[4])。因此,在半个 CLK 周期. O7 P0 \8 A2 x6 K. \2 z8 D
后(下一个反向边沿)对信号采样。
: c9 a {" D1 i# Q( J/ L% m
% X+ W# Q# e. a五、QSPI 配置(HAL库)
6 L" T' K, c$ X; K+ x) z* X
7 s. K0 P9 J$ C- ]& |* @0 o1.首先根据硬件电路,配置相关引脚,开启引脚和QSPI时钟* h* w6 c/ L. v! }! Q7 e" f# K q
# ]6 F: R! J8 \1 A3 K) E
. M: o# W) O- J! K1 x& Y
2 z. x% r- R1 _" B8 }7 t- void HAL_QSPI_MspInit(QSPI_HandleTypeDef* qspiHandle)
& h/ ]$ j+ H( X) K. b1 D( ~2 m - {
; |6 _: ]5 |3 V$ ]
+ v$ T# j" z3 J4 c- GPIO_InitTypeDef GPIO_InitStruct = {0};
# b- v$ T- G" d y% E - if(qspiHandle->Instance==QUADSPI)
/ U6 ~7 Y; a; b+ z& [; C. F - {
- ]6 G3 w" R1 W6 o8 p - /* USER CODE BEGIN QUADSPI_MspInit 0 */# s0 x( y% L4 ^; C t
- $ l5 x4 |! Q3 t
- /* USER CODE END QUADSPI_MspInit 0 */
) ~$ F- f0 v0 Q# x4 G ] - /* QUADSPI clock enable */0 l. Q" | }3 l9 `
- __HAL_RCC_QSPI_CLK_ENABLE();: b7 ?8 ]- G) a6 _4 u; s3 V% T
- 8 ?1 g9 E% g) ~. F. P
- __HAL_RCC_GPIOE_CLK_ENABLE();. U$ `& s+ ]0 Z4 |
- __HAL_RCC_GPIOB_CLK_ENABLE();( e8 y) F* L: i' Y
- __HAL_RCC_GPIOD_CLK_ENABLE();- @/ e6 O$ M- F" \
- /**QUADSPI GPIO Configuration
) `2 J+ ~$ P) x2 m* K9 T# F - PE2 ------> QUADSPI_BK1_IO2) v9 E! S1 q0 S4 u# d( M3 U3 g& h
- PB6 ------> QUADSPI_BK1_NCS
) P' k. m1 A0 Z4 `2 a6 u - PB2 ------> QUADSPI_CLK% c; Z6 f) J% Q/ ?- f
- PD12 ------> QUADSPI_BK1_IO18 \7 S& w5 {; A) v- T
- PD13 ------> QUADSPI_BK1_IO3
& U( [& p& i' d0 B - PD11 ------> QUADSPI_BK1_IO0 8 @ b+ V; u; c0 X2 N0 ~5 A
- */
, x" A* u" R% }1 Q* A6 A8 a% g - GPIO_InitStruct.Pin = GPIO_PIN_2;/ ]0 f! H' y( A' j
- GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
* Q9 Y5 F5 V) K* e - GPIO_InitStruct.Pull = GPIO_NOPULL;
4 ~9 h6 b+ z( ^% y - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;+ d" Q4 s9 c7 l3 e+ v4 R
- GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;' S- ~9 X2 V, X/ z9 ?
- HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
3 Z$ @* ~% h8 o' g$ \, K
- \+ b% r3 z6 [. I, u* e5 y( c" T" |- GPIO_InitStruct.Pin = GPIO_PIN_6;
$ [+ g r+ F' [2 j - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
$ A% h7 [0 T* V6 i& X, A7 e - GPIO_InitStruct.Pull = GPIO_NOPULL;
. o! b. |9 a3 o% i( o# J2 } - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
- Q, [% O* U1 _" i5 i6 m! s _ - GPIO_InitStruct.Alternate = GPIO_AF10_QUADSPI;
9 Q S/ a3 @- ~' p% K( e0 [7 s. _6 ^/ C - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);* |. i+ [8 x3 F6 [* @
- + x$ D v9 V9 ~: X3 I" _8 y
- GPIO_InitStruct.Pin = GPIO_PIN_2;
! m4 x r3 s2 \' J" y5 ^; x" v - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;5 Q6 |" K- E# b% {8 Z+ Z1 E
- GPIO_InitStruct.Pull = GPIO_NOPULL;
6 G: P8 |" x9 ^ - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
# L9 g6 M* a8 Q8 Y - GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
- e1 q0 s; G% |" m - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);0 [1 j) P1 w% W3 T5 {& r1 O) v( ~1 e
- # U, F0 B% h- h4 B- v! l
- GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_11;
" T, }/ a+ V7 Z; E - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
6 K2 R' B. V$ m1 k - GPIO_InitStruct.Pull = GPIO_NOPULL;8 V4 o4 C" k2 t3 c4 C
- GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
( g5 x- \+ U) t - GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;7 U0 m1 N3 T4 [7 i2 p5 M
- HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);+ {) `7 j+ N% g5 R8 H/ g. r- }0 G( w
# X7 F9 }+ O- M, o, I- /* USER CODE BEGIN QUADSPI_MspInit 1 */. g! W, g: f& i& ]6 A+ o
0 x* j3 i; q0 G9 d% i3 d/ N- /* USER CODE END QUADSPI_MspInit 1 */
0 O. b% K0 u; d9 b4 T9 v. y% e" O - }
- T C( [ E- N - }
复制代码 ; N5 u& l+ H/ @& n! ?: {
2.接着初始化SPI外设
{- N" o1 I) x' C5 D- W) `- / E7 [0 O6 O- S
- QSPI_HandleTypeDef hqspi;& d$ U+ G y6 }
- : q0 ~$ Y. a( J0 ^2 p0 g
- /* QUADSPI init function */- b/ M1 h- X4 Z. a! B. o- _2 s
- void MX_QUADSPI_Init(void), s2 I1 N4 q6 v- R; ?! S
- {5 A+ O# A' D- n3 F5 I6 L
- hqspi.Instance = QUADSPI;//QSPI外设2 u t4 _9 B8 N; B
- hqspi.Init.ClockPrescaler = 2;//QPSI分频比,N25Q128最大频率为104M,此处216/(2+1)=72M" ?3 P" c! _7 L) r. l& d
- hqspi.Init.FifoThreshold = 4;//FIFO阈值为4个字节( v; |8 G( ~( _! X4 L( a1 o' t- ?
- hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;//采样移位半个周期(DDR模式下,必须设置为0)
' z1 S l' \! X: }7 A1 M4 s9 C# i; { - hqspi.Init.FlashSize = POSITION_VAL(0X1000000)-1;//SPI FLASH大小,N25Q128大小为16M字节
* ^. b3 \; ?, Y! q - hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_6_CYCLE;//片选高电平时间为6个时钟(1/72*6=55.2ns),即手册里面的tSHSL参数" o& B/ A5 _1 r0 X
- hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;//时钟模式0
/ S* l4 S! t' d. x- D - hqspi.Init.FlashID = QSPI_FLASH_ID_1;//第一片flash
: m8 v' Q$ j a0 o* |. Y - hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;//禁止双FLASH模式
& N! p$ s% [3 _+ F - if (HAL_QSPI_Init(&hqspi) != HAL_OK)//初始化QSPI外设
3 q) Q8 w3 O6 S - {* w; b, i, A# k1 N) ]2 ?4 ?
- Error_Handler();/ x# d8 h/ S7 A' P; I
- }
: A% h* W. M0 o" p - }
复制代码
% J' a2 h3 x& y% b3.由于使用的是间接模式,我们对FLASH的所有操作都需要通过FLASH内部寄存器来完成,也就是通过向FALSH发送对应的指令来获得我们想要的结果,此时的FALSH就是一个普通的SPI协议外设,所以接下来所有对FALSH所有的操作都需要先发送相关指令,我们需要配置指令参数(指令类型、地址、数据宽度、地址宽度等等)。6 f# a) E1 U) Z( r$ n) N
Z6 W! V) Z; l' V, i! \我们首先需要配置下面的命令参数结构体:
Y; Y/ e+ d; D4 E# u' o+ P3 y& _, r& g
( X$ H3 r; W4 j) d$ a) b: |# f# t' w- ^2 v) c
Instruction:指令类型(读、写、擦除等等)
! e( p8 J; {7 C& X7 b8 W# ?6 X+ {( a- ]$ K- u- v$ e2 j
Address:需要读取或写入数据的起始地址! t7 ] J; t/ ]+ r( B1 e4 A8 r
8 ]1 v9 c6 |$ ?! i7 T
NbData:需要读取或写入数据的长度
! J8 J# T" Z: N0 |
0 y- d S5 z2 ZDataMode:数据传输模式,就是数据用几根线传输(1、2、4线可选),后面的AddreMode类似,就是用几根线传输地址,InstructionMode就是用几根线传输指令。
$ T7 ]* r% n% T
( Y6 J% t, s, R2 Z/ ]7 y5 @' }这三个参数都需要根据芯片数据手册来选择,手册上说明支持该模式才可以选择,否则会通信错误,另外,数据传输模式的不同,对应的指令类型也会不同,比如N25Q128 READ指令对应单线传输模式,Quad I/O Fast Read则对应四线传输模式,这些对应关系手册上都有详细说明!!!
8 T. Z [0 ^4 p. g; w5 d! s k+ D# t/ W* {
4.读取芯片JEDEC ID
# K" W/ |: H. a+ |+ i2 e) _, z0 f$ t9 v! C! y
首先查看手册上读取JEDEC ID的时序:6 m/ Y( s* h0 h z! v, Y
8 A; U: Q3 c) u6 ]9 @+ ?% O7 \$ C
7 W3 @. @9 H: b* z7 I; M4 Z, h( ?
可以看出,读ID这条指令是只有指令阶段和数据阶段,且都是单线传输模式,所以
3 ?- n% |0 B3 {7 ?
2 Q5 G+ |9 z6 a8 |0 ~9 e. ^, d6 bInstructionMode = QSPI_INSTRUCTION_1_LINE;//指令单线传输模式
! A. o5 ~) M3 I7 ~, q( G" h) U2 i4 B: p
DataMode = QSPI_DATA_1_LINE;//数据单线传输模式
5 i0 S+ P3 @- v; ]* }
p% Z% }2 l9 W" J% j( bAddress和AddressMode 这两个参数的值都置0,表示无地址。
* u5 r0 b# T0 W \: U; J8 P1 U K2 K$ g* @9 z3 j8 a" |$ S# H1 [
NbData :是想要读取的数据长度+1,ID是3个字节,这里令NbData=3
* m6 x/ T" O( x( @. V, l) ]' m9 C% V/ `+ @8 j( @! j+ `6 r
其他值和下面代码保持一致即可。
" f" e8 q; M4 J: r
- g, K5 F. G- I; ~4 `( j( R然后 使用HAL_QSPI_Command函数将读ID指令发送给FALSH,等待发送完成* B! l. X1 Y6 N* f; ?
% b8 K# A# P# g4 W* v
最后 调用HAL_QSPI_Receive,接受FALSH返回的数据,即芯片ID
; q2 m' o% K, g. o* @5 b3 B, |: ]9 ^8 b* @( `2 a+ i
- /**3 {( T" J- x/ f
- * @brief 读取FLASH ID# z( a8 H3 |4 Y9 j. y
- * @param 无
2 A& b" B; q: l3 H& N! C- L5 t - * @retval FLASH ID. @3 |( V9 M/ l
- */! x$ O' j0 G! u" n$ L& l
- uint32_t QSPI_FLASH_ReadID(void)
6 B! I/ a2 h, Z! F - {
) Y+ E/ `: F( P+ |" z! w! t/ O - QSPI_CommandTypeDef s_command;
8 D: K1 z2 t8 K - : a$ z7 {$ f9 v. Z2 I
- uint32_t Temp = 0;4 A- ^: d- d$ Q Y: x+ e ]0 | O
- ( f" o, |* g: s* q8 k
- uint8_t pData[3];6 [9 \1 `" o3 ]5 h( \
- 3 d0 c# h! y ~; g* W/ I
- /* 读取JEDEC ID */
4 Y3 n. K4 a& X* }
6 S \4 U6 ^$ C! o! `0 ~- s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;//指令阶段的操作模式,00:无指令;01:单线传输指令;10:双线传输指令;11:四线传输指令。+ u* S' O7 d& S. g, H. ~+ t
2 C; Z# S' U7 o. u3 V; A- s_command.Instruction = READ_JEDEC_ID_CMD;//读取芯片ID指令
. ]3 u( Z# p7 a
1 M7 P' J& h9 j; X7 Y2 f1 ]6 j2 @ N- s_command.AddressSize = QSPI_ADDRESS_24_BITS;//定义地址长度
1 l- j5 ~7 v( [* X; E+ l0 I e7 S: \
4 E9 |3 n U/ B8 l- s_command.DataMode = QSPI_DATA_1_LINE;//定义数据阶段的操作模式,00:无数据;01:单线传输数据;10:双线传输数据;11:四线传输数据。
7 d" n; K" U! I) y6 ]
( e, l; `( Y n7 B1 L- a9 o- s_command.AddressMode = 0;//地址阶段的操作模式,00:无地址;01:单线传输地址;10:双线传输地址;11:四线传输地址。4 m, \' g2 S) L/ i( |
-
# X/ R& e3 G- Z( ]8 z& I- J - s_command.Address = 0; . s0 h6 @8 l: {; P7 ^
- - |# v2 Z# }! Y. I
- s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;//交替字节长度
! F. V3 _) x/ Q% x! g+ y2 _2 F1 h - * {$ d t4 w+ P& _4 N
- s_command.DummyCycles = 0;//空指令阶段的持续时间,在 SDR 和 DDR 模式下,它指定 CLK 周期数 (0-31)。
4 N$ w/ G; z u/ [( q5 G, j# i
. H; b- r) V) `% A- s_command.NbData = 3;//设置数据长度,在间接模式和状态轮询模式下待检索的数据数量(值 + 1)。对状态轮询模式应使用不大于 3 的值(表示 4 字节)。5 ? p: z% f0 i. h
f& u' m6 [/ y% C- s_command.DdrMode = QSPI_DDR_MODE_DISABLE;//地址、交替字节和数据阶段设置 DDR 模式,0:禁止 DDR 模式;1:使能 DDR 模式。, o1 H* l- ~8 K9 a) z
& `; [7 y* q3 `, {' ^- s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;//设置DDR 模式下数据输出延迟 1/4 个 QUADSPI 输出时钟周期,0:使用模拟延迟来延迟数据输出;1:数据输出延迟 1/4 个 QUADSPI 输出时钟周期。1 f. h$ ?9 I6 q: Y) ?- V* n* H
- + m4 ~* ~# i; h6 t6 I, K+ c
- s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;//设置仅发送指令一次模式,。IMODE = 00 时,该位不起作用。0:在每个事务中发送指令;1:仅为第一条命令发送指令。
8 d+ p/ @! \- q I: { - - j4 F2 n# n. ]7 s! r' o' ^
- if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
9 f" P, r# a8 n4 k3 J - {
/ n6 r5 T" x' W5 m6 @ - #if QSPI_DEBUG8 T) V3 I9 Q2 l1 j
- printf("send read flash ID command error!\r\n");
8 ?2 E c6 }6 C4 b' V5 |3 f; u K - #endif L( O2 P2 w, g" N! B# H
- /* 用户可以在这里添加一些代码来处理这个错误 */9 k; t z8 s8 T, P1 P
- while (1) {}, y: q+ [6 d7 j0 D6 e/ R0 @
- }+ Y8 m. O; V. S5 i/ c
- if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK)
: f4 B) o; {/ I4 @* D - {
# g+ s4 Q2 k' L5 ~# y - #if QSPI_DEBUG
5 E! ?5 |6 S: H! R: S - printf("read qspi flash ID error!\r\n");
4 J4 P7 K1 S$ i) A - #endif
4 ?: W1 B" j2 |* H0 K: y1 O2 w" l - /* 用户可以在这里添加一些代码来处理这个错误 */
+ O0 m$ o4 D- `9 l) B - while (1) {}7 D( a& U+ i; [6 ~/ x& `
- }
7 \. y% j+ \4 D- K - Temp = ( pData[2] | pData[1]<<8 )| ( pData[0]<<16 );
1 O: O( p* T6 T7 c - return Temp;* i* Z- }1 ~7 x% x; @2 X' e8 `
- }
复制代码 0 H7 @# p# G7 b3 ~; Y
5.FALSH 写使能9 [ [$ c9 A1 ^% b
- b3 f/ ~/ ^* U4 v在对FALSH进行写之前,需要打开写使能开关(实际上就是发送写使能指令):
$ o* w6 b8 V! u3 b, g& G+ m4 p, |* n! o" d* I# m
类似的,需要查看芯片手册,写使能的时序
- W) h+ D3 e$ d9 @* `- U4 g- s! l% M* F3 j
. d. J$ M, E. N3 \# @& X
. G0 U# N& A& s4 S
可以看到这个指令时序更简单,仅仅有指令阶段,所以地址和数据的参数都应置0
( s" M/ {7 ~; Q% W7 ?
3 Q; }8 Z: n' h" t2 {8 C, E- /**# U1 ^) n7 L8 I3 u- T4 K, N" _) d
- * @brief QSPI FALSH写使能
# Z5 G* B8 [9 Q7 K/ j/ o - * @param None4 Q% H& ?8 i: H7 C
- * @retval HAL_OK
$ t% D$ O8 D% {/ I - */
# E9 w- }3 g% D7 A4 E" {9 Q* V* L - static HAL_StatusTypeDef QSPI_WriteEnable(void)2 x0 e- P1 P7 u% A/ g
- {
$ Q/ O. @* V8 D' R - QSPI_CommandTypeDef sCommand;4 i. a" d7 o \7 C4 M
- QSPI_AutoPollingTypeDef sConfig;' g, U5 @3 o! H6 z" y4 A# [
- 2 N0 b& C7 F) q+ K
- /* Enable write operations ------------------------------------------ */
# h4 z) ]* u P - sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;; F, Q% D$ p2 J m3 u6 Y* T
- sCommand.Instruction = WRITE_ENABLE_CMD;1 L* y/ C! Y$ a
- sCommand.AddressMode = QSPI_ADDRESS_NONE;; b/ _: s9 W8 i
- sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
0 t# F ]) d% M$ l0 J - sCommand.DataMode = QSPI_DATA_NONE;
) B3 I. W6 J" t* c# Y7 g - sCommand.DummyCycles = 0;2 r: \% c9 d, i
- sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
0 w! v# A. q8 D - sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
. a8 f, o) t* e2 p0 t5 K - sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;4 _5 A/ Y! I9 } h* Z) H: O/ x
5 T+ o+ ^. B T- if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
( B R( [! |4 |: `$ e n5 T9 C - {
: Z- f, q* I7 z- i, l# ]* W - return HAL_ERROR;
& r! t" E# ` C0 K - }- t/ t% _6 @' Y8 H
* ^1 y ?& s6 w$ s) E- /* Configure automatic polling mode to wait for write enabling ---- */ ) A. N) i/ \2 T# m# J$ j1 D7 a
- sConfig.Match = 0x02;+ |8 K/ `* s9 p. W
- sConfig.Mask = 0x02;) K+ r, b4 Q& O3 j5 I
- sConfig.MatchMode = QSPI_MATCH_MODE_AND;
# q1 L: j/ w+ \! J# Q7 F - sConfig.StatusBytesSize = 1;
' s- n4 H; s/ ]0 E. h3 J/ u - sConfig.Interval = 0x10;
" N7 |. I. E/ ?: h: K9 N+ t: j - sConfig.AutomaticStop = QSPI_AUTOMATIC_STOP_ENABLE;
' G$ k3 ^; p, Y0 O4 q) C% j - ; R# i v2 v, s7 s" \+ W
- sCommand.Instruction = READ_STATUS_REG1_CMD;
9 Z9 g; {% h1 C2 F9 s! p1 h3 ~' ^ - sCommand.DataMode = QSPI_DATA_1_LINE;
2 v9 M: D; s' V. p6 p V
8 e: s- ^1 S0 S5 S! R- if (HAL_QSPI_AutoPolling(&hqspi, &sCommand, &sConfig, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK), \ \4 I u3 a# C/ u/ T
- {# ?4 W# U) v. x9 C8 F
- return HAL_ERROR; 3 s5 E( u9 x$ p: ]" K
- }
9 n& n- o" a6 i/ y8 L, P+ N" t - return HAL_OK;
0 \8 p3 D7 k( l+ T- q2 s - }
复制代码 1 r2 Y/ Z/ [" z* Q5 Y, {) v
这里需要讲下 QUADSPI 状态标志轮询模式:+ i( i, L7 y7 n4 t: f
在自动轮询模式下,QUADSPI 周期性启动命令以读取一定数量的状态字节(最多 4 个)。. s/ s: r& v: x0 R$ }. w: A
可屏蔽接收的字节以隔离一些状态位,从而在所选的位具有定义的值时可产生中断。9 @! r+ S9 A; r) r! m
对 Flash 的访问最初与在间接读取模式下相同:如果不需要地址 (AMODE = 00),则在写入: r$ L0 V. n' x
QUADSPI_CCR 时即开始访问。否则,如果需要地址,则在写入 QUADSPI_AR 时开始第
7 j) O- `' m! ^& U1 g! U/ V一次访问。BUSY 在此时变为高电平,即使在周期性访问期间也保持不变。
/ v9 K+ u1 [" m$ y' F+ d在自动轮询模式下,MASK[31:0] (QUADSPI_PSMAR) 的内容用于屏蔽来自 Flash 的数据。
$ @0 ?1 N/ J7 _2 k- l! t+ L如果 MASK[n] = 0,则屏蔽结果的位 n,从而不考虑该位。如果 MASK[n] = 1 并且位 [n] 的内
& Z" t0 ]6 G4 t6 F容与 MATCH[n] (QUADSPI_PSMAR) 相同,说明存在位 n 匹配。+ D! Y9 u* N2 F3 s
如果轮询匹配模式位 (PMM, QUADSPI_CR[23]) 为 0,将激活“AND”匹配模式。这意味着+ f/ w( e8 y8 k+ ~* j" l4 K/ |
状态匹配标志 (SMF) 仅在全部未屏蔽位均存在匹配时置 1。! t& r, c4 q3 z* |& x7 }5 V" x# I
如果 PMM = 1,则激活“OR”匹配模式。这意味着 SMF 在任意未屏蔽位存在匹配时置 1。# a4 Q' ~8 e0 o' l. P
如果 SMIE = 1,则在 SMF 置 1 时调用一个中断。
! y0 g6 e" M/ c/ _; N% P2 `如果自动轮询模式停止 (APMS) 位置 1,则操作停止并且 BUSY 位在检测到匹配时清零。否; |% W5 ~" w6 n
则,BUSY 位保持为“1”,在发生中止或禁止 QUADSPI (EN = 0) 前继续进行周期性' Z' @6 ]# O- }2 R Q
访问。
D! h7 ?5 x% ?- ] B数据寄存器 (QUADSPI_DR) 包含最新接收的状态字节(FIFO 停用)。数据寄存器的内容不
" c- j' D3 G M- A) M i受匹配逻辑所用屏蔽方法的影响。FTF 状态位在新一次状态读取完成后置 1,并且 FTF 在数! _' U' ]: b8 l q
据读取后清零。
1 H0 C# R4 Q0 m% r+ M7 A, H& R( B0 ]: p5 J' S0 v
简单的说,就是CPU自动查询FALSH指定的标志位是否置位或清零,通过调用HAL_QSPI_AutoPolling函数,CPU将自动查询FALSH写使能标志位是否被置位,成功返回HAL_OK,否则返回HAL_ERROR,这样就省去了我们自己发读寄存器指令查询的麻烦了。
/ e) [6 p2 [4 N4 J, @! v. f+ D/ d8 g# F' O3 w4 @3 |4 t' u
6.读FALSH
y- j0 r$ f5 D9 u: u5 D/ X* N5 G0 r+ ?+ `: v1 H
这里仅介绍4线模式下的读FALSH流程,首先查看手册4线模式读时序
; X6 @/ T$ u+ ^6 @" ? q/ W: f8 c! O% |3 S6 x# Z
6 y& {5 }7 `( _, i! \
- k) O. K9 l* M% O( |从时序图可以看出,指令是1线模式,地址是4线模式,空周期(DummyCycles)为10,数据也是4线模式,还有此时的读指令是QUAD_INOUT_FAST_READ_CMD。所以相关参数配置如下:
0 g% r9 k0 y& J: P, |
- v+ c8 i% D3 g+ x/ Y- /**- \) j0 J: _; K6 l. W: |* k7 V: M8 r
- * @brief 从QSPI存储器中读取大量数据.' F8 x7 f- L0 L8 U
- * @param pData: 指向要读取的数据的指针
2 U9 I. V1 Y3 I* u, j* n - * @param ReadAddr: 读取起始地址
; G; \7 }: F: B8 u6 H - * @param Size: 要读取的数据大小
" x2 _5 ?' K# ]2 Y - * @retval QSPI存储器状态3 [4 @2 V& {( D v+ ^. k& r
- */( S+ W8 Q" ?% z5 Y6 G
- HAL_StatusTypeDef BSP_QSPI_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)8 d; {1 G. j% I# L- w5 P. X% U
- {4 m5 O/ \( I, C- B
- QSPI_CommandTypeDef s_command;% n' T6 W. ^9 _" [
- + R9 S" t2 w2 |6 i6 J! ~7 M
- /* 初始化读命令 *// @5 h( w0 F: w$ C' U+ Q
- # t. L7 X3 N& ^+ @
- s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;
- l3 M( Z/ L. l+ h
& o! m+ i) R/ ]& h( H% }- s_command.Instruction = QUAD_INOUT_FAST_READ_CMD;
m+ r( G# ~# g( u0 H
6 S/ o+ ?" G" y5 A0 P6 Y6 V+ K- s_command.AddressMode = QSPI_ADDRESS_4_LINES;
! ?/ @' Q+ S* \5 p2 r
* s1 D9 G7 @( H: H' ]) J. ^- s_command.AddressSize = QSPI_ADDRESS_24_BITS;
3 X7 ~! P, i& s! J$ E - . d; T# J6 O; y% r. N% ~" p
- s_command.Address = ReadAddr;
! D. F" s+ v E* ^) a$ A - 8 ]8 D X" `7 M+ G: i& o. N
- s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;1 H. K) W( K% c {9 g: L
3 [ Q2 B9 g/ [, w0 ~; k0 w8 N- s_command.DataMode = QSPI_DATA_4_LINES;
H3 @* V3 C& {' q9 Q- ?
/ b: Y) j3 [4 p* a" J- s_command.DummyCycles = 10;; q0 X, ]0 m D9 K% N; @) T
% V6 i! c. D) }4 @+ h) c, g$ d- s_command.NbData = Size;
+ s0 S5 ^. `1 W% Y0 p
% |) P6 g, ~; n" w- s_command.DdrMode = QSPI_DDR_MODE_DISABLE;
7 N/ \6 F. [! z& V) J - % ?! j5 Y2 D, K& g- ~& b0 d7 w
- s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
% ]: P B* O6 |% L7 `1 q
* }' [/ P4 l9 t9 D" q- s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
/ v' _; D' y6 X9 ]. I - /* 配置命令 */+ o6 p' _5 \8 W7 c; Z" T$ _
8 H; z ~9 W# k6 q. O7 P9 @3 F- if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
; p b7 ?6 u L" ^! [5 Z - {( {8 C9 U4 v4 P/ ]' X; G
- #if QSPI_DEBUG! m4 ?& n. e( I; r2 P1 _+ i
- printf("R-send read command error!\r\n");8 W' L& a' t- c% X) d5 _ X
- #endif% @8 e3 X' a/ } S# u
- return HAL_ERROR;3 y" v. f) Z8 j) R. |2 z
- }
" [0 y" p: Q/ }9 \0 {# u - /* 接收数据 */
" s+ ^3 H/ i0 w8 j# k/ t5 B6 i - if(HAL_QSPI_Receive(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE)!= HAL_OK) ! e7 V! E+ O& i( e
- {
" w/ d! h+ J; g& n% w' l' [. U - #if QSPI_DEBUG
. \1 J# e n# o6 k p) M - printf("R-read data error!\r\n");$ \) y2 ~8 N" G6 z" f! U
- #endif- a$ Z0 w* {' R6 R7 Q; n" z
- return HAL_ERROR;
7 c; `2 R; \2 T2 m2 ~# B - }
% k0 Q' }) X$ d6 l* C, Y, K! v - return HAL_OK;
' N2 k* s9 |( S. Z' j3 o - }
复制代码 & M" r: @5 U& R0 b6 q# l
本函数实现了从FALSH指定地址读取指定数量字节的功能1 ^4 o d. ]% m9 |
* d9 N8 k' Q/ f( [4 I
7.写FALSH
9 P+ E1 a& V+ B }- T7 ? B/ S' g* R' s2 N$ r" ]3 g
同读FALSH类似,我们需要在手册中找到4线写FALSH的时序:# P8 R& }* d) U) i
7 z( R" j5 b/ ~
- w6 G8 m3 O9 W
/ l$ _, E! t- s根据时序图配置如下:1线指令,1线地址,24bit地址,4线数据,没有空周期
! c& u. W. ^' @5 L; k9 K* y8 }& D& k. C! a
- /**
% H0 |) }5 h) l# b' D! K; Q2 `2 P$ ` - * @brief 将大量数据写入QSPI存储器
+ ^9 B5 H5 k* V0 I! [ - * @param pData: 指向要写入数据的指针
# G; y! v! H( g( Z/ i* k - * @param WriteAddr: 写起始地址
6 o2 V: ~' ?% O* E - * @param Size: 要写入的数据大小, C& _! ]7 Z3 v8 R& }1 i
- * @retval QSPI存储器状态& |/ w* O) G7 J, E p" D
- */8 v+ N. P+ b$ K$ n k8 O4 d4 B: [- Q
- HAL_StatusTypeDef BSP_QSPI_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)9 x9 T( l, I/ l* B9 w! ~% K
- {
9 Q1 `* E" m5 i/ N+ ` - QSPI_CommandTypeDef s_command;' n# s# m, J. N! d. a" W
- uint32_t end_addr, current_size, current_addr;
, O9 W% [( l$ N( l% {- y - unsigned char sector_start,sector_end,i;
' `7 a. b8 f4 T: w* }, J3 r- a -
* I; S' J; i1 J, D - /* 计算写入地址和页面末尾之间的大小 */4 c$ ?, }+ P( N9 v' o$ f
- current_addr = 0;2 A+ h) J n& T, X3 m! C- i; Z1 t
- 3 s- c l4 [# S
- while (current_addr <= WriteAddr) * Q3 ~ `, b& ~8 t# Q
- {' W) A, |4 f1 Q* V; V
- current_addr += N25Q128FV_PAGE_SIZE;
$ _) K1 ^$ w5 c$ b, ] - }$ C- [) U' u% i6 Z0 e
- current_size = current_addr - WriteAddr;
% d+ d& W$ R- G) X0 |6 q* W3 [5 H6 U- m - /* 检查数据的大小是否小于页面中的剩余位置 */
7 E& a* j, N5 a" M" [) m" S7 a0 g5 o - if (current_size > Size) : t2 F, {' E: t2 m/ C. ]6 K
- {
| s/ ]2 f) Z# `9 d - current_size = Size;
. F2 e& e8 z, @1 n - }
7 ? A) A+ ^6 k - /* 初始化地址变量 */
+ n {, |. z5 M9 {0 G - current_addr = WriteAddr;! f* `; ]+ W1 c5 \7 r' q
- end_addr = WriteAddr + Size;
$ }' ?: O& v2 J -
/ _6 e- t7 `* H' l& v - sector_start = current_addr >> 16;1 d2 f2 {+ N$ d# W7 z5 J7 P. k2 X% O
- sector_end = end_addr >> 16;" q3 N& b, I# q6 y: Q
- 9 h( v8 S2 o3 y2 x8 d
- for( i = sector_start; i<=sector_end ;i++)
6 x$ \( ?/ z/ m2 U5 V8 X8 a, G. _ - {
1 _% d) L7 j: e - BSP_QSPI_Erase_Block(i); //擦除对应删除
% m1 K9 q, u/ {5 @8 t L* m9 D - }
" K9 o2 I0 ~) A -
`( G0 r x1 n- M1 E% @/ p! G4 C - /* 初始化程序命令 */
' }0 p0 A! S8 ^4 H* n% F - s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;7 I5 Y9 ~1 P$ B/ u+ M3 H0 ^$ U+ D
# O( E# n3 m1 W4 }0 V- s_command.Instruction = QUAD_INPUT_PAGE_PROG_CMD;
- u5 l& V" B: @) H9 E; ^
* D- @7 S; W- s; ^" C; O2 g/ A/ p- s_command.AddressMode = QSPI_ADDRESS_1_LINE;
P: p. D2 A/ p9 Y8 [" S
9 l1 u1 r& N+ a" A y3 U- s_command.AddressSize = QSPI_ADDRESS_24_BITS;
; S- J0 [& m/ x Y- D - ' G- x5 c% s4 g2 r7 B- _) o
- s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;" Y8 f3 n7 N3 R( v% t G
P9 s9 n% g$ d" R6 J6 U- R$ j- s_command.DataMode = QSPI_DATA_4_LINES;
" U0 U# N7 y2 E- {
5 j; S k# g1 b6 Y- s_command.DummyCycles = 0;
J& J& X0 k% r0 _
% M$ p E9 |/ r0 O- s_command.DdrMode = QSPI_DDR_MODE_DISABLE;- a* ^5 t c% s5 @6 x
- 0 M( j! g7 [1 V/ w4 A, w) b. ~& |; b
- s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;1 y2 W# k0 W- P5 a4 ]1 J; O
1 K- v0 n1 X1 k$ U7 D* O- s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;" k& ?6 |# n, }( h! D o) g9 q
- 9 _8 m( h3 Q4 }2 l7 b$ }* I5 y
- /* 逐页执行写入 */( r D1 @ E* Q, }' D# y
- do {
- S9 r$ b+ i5 ^1 r \8 g - 1 M/ N% m# F5 t! ]* }. n% R4 V Q) u; v) G
- s_command.Address = current_addr;6 |$ p# X2 y$ ]! T$ W
- s_command.NbData = current_size;
3 x/ @5 [1 S4 N - /* 启用写操作 */7 ^+ Z3 q' E( e* _6 H
- H& k# g4 }6 Y. a9 Z% b, f7 T
- if (QSPI_WriteEnable() != HAL_OK)
, o) h. j9 ~- @) T - {" m6 E6 f4 k" O, c
- #if QSPI_DEBUG
0 p3 w% T2 e$ w+ R' Q) r2 k - printf("W-Qspi write enable error!\r\n");2 q2 N4 \& P6 Z! z4 {# L7 ^
- #endif
# t0 s9 ^5 Y6 h, e1 m. \4 n - return HAL_ERROR;
& Z+ s+ ?. s# ]3 l$ c - }! ?) x! J3 C2 ^* o: P
- /* 配置命令 */
- J0 j W q( q3 ] - if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
) h) o( X# Y e+ |/ _" M - {
+ C( p6 R+ R M - #if QSPI_DEBUG8 F+ G; F2 d4 [. u; K- z1 U
- printf("W-Qspi send Command error!\r\n");4 I9 I5 z ]7 j- G' ~- _
- #endif+ i* @1 t1 N" ?+ z* z- e# J# V
- return HAL_ERROR;
S* i, X5 Y2 o$ x& r$ B - }0 ?* y9 }& P- Z7 s* Q
- /* 传输数据 */( S: J. M5 t4 H: W" ~1 z
- if(HAL_QSPI_Transmit(&hqspi, pData, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) {: c3 [2 B8 F/ n( h
- {
1 r) ]% k: n2 `. I - #if QSPI_DEBUG
2 ~" Z( |+ Q. b R$ @ - printf("W-Qspi Transmit data error!\r\n");
" L7 K; [* C% @6 f - #endif
$ a- V( W. L' s0 k# [. r - return HAL_ERROR;/ N3 d" c. H4 r" }6 M$ A' R, f
- }
/ R2 q( ^; h7 `2 O0 b - /* 配置自动轮询模式等待程序结束 */
" x" B$ d8 o7 y8 {5 W% w8 m. ?/ E
' \8 O- w+ T+ R9 l+ j1 B- U5 G- if(QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
) C1 v H' E9 u' C j - {
7 Z# p* R( l) B! l6 y! p' _& {, p - #if QSPI_DEBUG
# c6 P3 p: R% }3 M4 Y - printf("W-AutoPollingMemReady error!\r\n");
0 q$ A' ]1 M4 J - #endif
9 |; h+ m3 W! R+ O1 D) l# n - return HAL_ERROR;) H) ?" |" P" r; L
- }3 l. {+ q, c3 l4 s9 A1 q8 F
- /* 更新下一页编程的地址和大小变量 */
: V6 e, L7 H/ c4 m - 1 _0 r+ K$ b1 g8 G
- current_addr += current_size;# y8 y# X) H6 B2 y+ k
- 6 P) A1 W% s/ b, k: [* b# l
- pData += current_size;! x% @" p3 j( V4 B6 P! o: u; [
- 1 y4 L6 j8 @ L* ]8 z
- current_size = ((current_addr + N25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr-current_addr) :
, ?# w8 Q9 B! C9 {
+ D! _( U+ K5 v- N25Q128FV_PAGE_SIZE;
3 K# H1 O$ I0 F0 S# e: e - # K. ?: ~& Z8 P4 W
- } while (current_addr < end_addr);1 b( Q. c( g% F) j7 m
- return HAL_OK;6 ]3 R/ g9 p1 Q& _
- }
复制代码
$ N$ b0 v6 f O7 t该函数实现从指定地址写入指定数量的字节。" Q9 Z! c5 C, y) N: k
) a& R9 e2 g% k3 ^8.擦除FALSH2 _7 k1 C. x/ a- S
2 I- n' m( a+ ~' V4 [' k, {+ @8 O1 q第一种情况是按扇区擦除,这也是N25Q128最小的擦除单位(N25Q128共有256个扇区,每个扇区64KB)
# o* e! n! R; @; W6 H( X7 T+ u) m: K! V" ^- \4 z
. P6 G- w R9 E4 M" p
1 ^+ y: J. r! f5 c4 ?4 C: t参数设置为1线指令 ,1线地址,24bit地址,无数据阶段' g! D! |/ O: r' Q
( B/ C6 G0 ^2 n9 N: G+ G- /**
1 x2 s# h* h6 N) J3 o - * @brief 擦除QSPI存储器的指定扇区; o6 E( Q+ j; {- g8 o b
- * @param BlockAddress: 需要擦除的扇区地址
6 F3 u9 y0 u2 a8 r: t8 M; S C - * @retval QSPI存储器状态 f2 m, d% c- @* M" |& O: x
- */" J2 t M2 u8 K( k! g/ T3 b' [
- HAL_StatusTypeDef BSP_QSPI_Erase_Sector(uint32_t Sector)0 B0 D; n/ m& R, Z5 B y
- {
" y$ c5 r7 O$ i% G - uint32_t SectorAddress=Sector << 16;//Sector*65535算出该扇区对应的地址4 B0 b0 o: ]" c
- / E* W) v- {2 T' N
- QSPI_CommandTypeDef s_command;
+ V$ c( p1 l( y( q5 n - /* 初始化擦除命令 */
, b1 d1 F( d" |$ x$ m, \) ~7 W -
& w& y6 C/ H9 p9 \& ^ - s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;
# q- D8 A9 p# t$ v1 s+ p: ` - % }$ b, E6 ~5 G/ S3 z. B& ^, X1 p
- s_command.Instruction = SECTOR_ERASE_CMD;//按扇区擦除
1 i. J2 S6 U) r! c& _
) \3 V' a+ ?9 E! k0 j& I- s_command.AddressMode = QSPI_ADDRESS_1_LINE;; \; D! H% ~; c- h/ C: U
$ z6 p% W0 s8 z7 w5 ^- s_command.AddressSize = QSPI_ADDRESS_24_BITS;+ z5 S! k; s. H
- , P% L2 Z6 n; l0 f# Z
- s_command.Address = SectorAddress;
x7 |% H% p4 ?+ D# z5 x - . t# P" c% q) U( u Y: ^5 [
- s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
$ l1 w1 D/ s2 S9 M - v' g8 m+ @# M5 Q1 l: O- [5 `
- s_command.DataMode = QSPI_DATA_NONE;! D9 f: R, U6 J# n3 @
- : b, P) ]! h! {3 m g: W
- s_command.DummyCycles = 0;
) j/ d- C6 n I1 f# A) U9 j
5 _4 U* j) [. Y" _6 K S. y3 L- s_command.DdrMode = QSPI_DDR_MODE_DISABLE;
: N0 R# V0 o9 @6 z2 e- `. |6 }" H - 3 e/ U. a" M3 A/ Q' a2 V) x
- s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
1 V9 \( I8 D+ M" G4 I. v - 1 D2 t9 }2 O5 O
- s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;( j7 Y- n* o% y9 Z s3 O' Y" x% H
- b9 B; E% V/ e0 [& K" Q0 w8 v; x- Y
- /* 启用写操作 */
, M; ~9 ]* w- r0 X, x p: h - 6 D1 g7 }! y# r- U
- if (QSPI_WriteEnable() != HAL_OK) : M/ t! q5 w2 U I1 o
- {
" _3 _- h4 D$ p/ C1 H1 q; Y. ^- `( O - return HAL_ERROR;& z7 h( t, Z7 A. o
- }
' K* Y# T" a% `. q/ j1 K4 w# @+ @ - /* 发送命令 */& h: C3 |, I, @2 i) w$ Y# E' Q
- if(HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) v5 \1 |7 k6 Y; _, `- b
- {
1 N4 j4 m5 q* b' W5 S9 t - return HAL_ERROR;; _" v, G- u: E- P! I
- } g. p/ G6 t( S9 Z
- /* 配置自动轮询模式等待擦除结束 */
7 j$ I" D& B, _+ c
. c) K' D4 t/ e- K5 B- if (QSPI_AutoPollingMemReady(HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)
7 b* A5 b- I3 D1 @; W& Y - {1 V4 l7 |9 [3 F) b e7 h
- #if QSPI_DEBUG
6 F- y( ~9 f, S1 |: r6 _% [& M - printf("erase sector error!\r\n");' b" F( h# T, O+ W- G
- #endif. M# A3 |3 |; a5 j
- return HAL_ERROR;
- M; L2 ~3 P; @6 `3 | - }
) X. p- C+ R: r7 w$ p( F - return HAL_OK;
. x" k9 m# f& S3 I3 ^ - }
复制代码 , B: M4 \) d7 d( @$ l
第二种情况是全片擦除,时序如下:
8 v( X2 ?0 `0 a2 l' W( {# T8 N8 ?5 t& x% o' h3 \1 C
4 l8 S1 |- H7 y0 s- Z+ @6 h
. ]/ H$ X" E- f' u O全片擦除仅包含指令阶段,对于N25Q128来说,全片擦除耗时可达48s。
/ k2 _2 V4 |4 j$ Y
! s" \# b2 B, m6 ?6 T" ~- /**
4 d" q1 ?. W* F+ z0 @7 Y* Z7 f# Z - * @brief 全片擦除 N25Q128全片擦除耗时48s% s: N3 |( _/ p( _- f' j
- * @retval QSPI memory status
( { H% @+ [+ F- ?5 N1 J - */3 r1 J5 s, D- J& H) }
- uint8_t BSP_QSPI_Erase_Chip(void)
8 p# b" Q! _% y7 ^# `; ^" o/ G$ k Y - {
" X& |" h( r1 u( F& X - QSPI_CommandTypeDef s_command;) d" q. Z* ?9 W
8 ?$ @3 o( s/ C9 A$ y- /* Initialize the erase command */
6 ^: ?! B* ?1 h" [- I - s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;9 G: u) N7 K! s# I' _
- s_command.Instruction = CHIP_ERASE_CMD;
( j: b7 t; n0 A - s_command.AddressMode = QSPI_ADDRESS_NONE;4 Z: C l$ ]2 y' D6 t. E
- s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; l: r! A/ X2 [4 I. x
- s_command.DataMode = QSPI_DATA_NONE;/ `$ O R3 Q" y+ E$ x. _4 J/ O
- s_command.DummyCycles = 0;
i# H/ ~6 k2 ?* [, z - s_command.DdrMode = QSPI_DDR_MODE_DISABLE;
2 s; }$ J+ H3 o+ ~/ E" P, f - s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;. J2 o) Y; {& F6 z; Y% R
- s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
; |3 e. d# i( j4 U( W( c7 @# | - ! F$ T# k; O& N8 n* p
- /* Enable write operations */
: g% g6 ~4 m7 {' [1 o8 d - if (QSPI_WriteEnable() != HAL_OK)! V+ i1 r& c7 k/ m! D
- {5 \: b8 p) v6 V+ @, o
- return HAL_ERROR;
+ K+ q" K1 V. Q9 k6 }: B - }& \3 u0 Z4 i( V o2 R4 X$ w
9 V: ^) f) |9 _3 W" v1 [- /* Send the command */
- k# U4 W0 N) }' S) M- |4 a5 S - if (HAL_QSPI_Command(&hqspi, &s_command, HAL_QPSI_TIMEOUT_DEFAULT_VALUE) != HAL_OK)3 U( n! k" h/ ^! n
- {
2 [7 R( a4 o* m) d/ ~9 w3 S - return HAL_ERROR;2 @$ b0 l2 U, R
- }
9 B; z. e* s3 w; m. u
7 X( w% Z$ `4 [& G6 a( k- /* Configure automatic polling mode to wait for end of erase */ 0 s/ [7 [+ Q% }% F- x2 s# u& I
- if (QSPI_AutoPollingMemReady(N25Q128A_BULK_ERASE_MAX_TIME) != HAL_OK)
: Y: H0 a P! H# p9 U - {3 f+ \% Z. L) m9 |+ l
- return HAL_ERROR;6 o2 I9 N* l- _' h1 S7 X
- }$ g( j. g0 Z R. ~
# B. Q' [- r5 m$ H4 a- return HAL_OK;7 W8 `% ?7 d* c% c! _+ g' }3 S8 {
- }
复制代码 ) }# I8 D. w$ a6 O3 T$ O
9.测试程序. K; {- Z) ^, `" V9 d( O5 C# U$ m8 f
1 K. ]6 g( v' ~* b测试芯片写入和读取是否成功,首先向0x1FFFF地址连续写入4096个字节,然后再读取出来,对比两次数据是否一致。
( w/ Q; a9 B, b4 N- V4 r6 X# g1 Y* d5 I) J- L
- unsigned char write[4096];
* K6 {% j/ g" G4 @) B" V - unsigned char read[4096]; 8 `! Y, O) W) R4 d2 L
- void N25Qxx_Test(void)
2 D+ t% W" M& @4 o" j5 \7 { - {
+ B7 _: j4 b7 X: X - uint32_t i = 0;
* C0 s6 {% z7 m9 u* _% p5 X( J
/ x% T" {$ j+ ]# ~! Z( X5 {+ y# W- for(i = 0;i<sizeof(write);i++)
8 M c4 g T/ A8 T3 @$ B+ ` - {# L7 E) |- j7 D1 ^5 ^* M0 s
- write=i;3 x, T$ G! h- \" w- x+ n9 B
- }
$ k6 h, `+ f+ ?8 n% H -
8 t+ `5 M9 n4 X7 L4 |& G% D - printf("write data:\r\n"); 5 L0 v( Z7 a g8 G
- for(i = 0;i<sizeof(write);i++)
3 R3 Q7 S c% Z5 m1 Q - {
# g3 \/ Z0 t& P, \1 F - printf("%d ",write);- W! F8 L7 Y$ y8 ?
- }4 O, e' x s. P; X0 @
- printf("\r\n");
. b7 Y4 f, ?5 {' _ - printf("\r\n");
0 n' }( [( b. M, {) W( d - printf("\r\n");$ M; G" H/ ?5 D3 t% f/ |* j
- 4 C' }4 I, W9 f3 l
- BSP_QSPI_Write(write,0x1FFFF,sizeof(write));
! V6 i0 O* {% `$ A r3 _7 } - BSP_QSPI_Read(read,0x1FFFF,sizeof(write));
; _; W- n0 G% Y/ Q# f- K - * {# m/ D3 j" [; J# o5 X4 Y
- printf("Read from QSPI:\r\n");
' ^' l0 O, \' @! B( ~1 J! c1 q - 0 @& c" |, {0 @
- for(i = 0;i<sizeof(read);i++)
: `- @7 Z, _9 _; z" }7 U3 b - {8 }4 T; P8 E+ k% R# q# Q0 a
- printf("%d ",read);
4 ^/ N& S9 r3 S* c8 t& h - }
3 m8 u% a4 r3 u4 T - printf("\r\n");7 {' H9 `- M$ N$ [; F& @
- }
复制代码 . Y& e2 k& ]% K" n" }2 _
写入的数据(部分截图):
' a- w. w; [3 }9 ^2 c& o0 w1 @# a2 n \2 A( S
4 ^; ]- m% G' l) ]5 [
: O+ u% T2 i4 {& J# W% N读取的数据(部分截图):: S, _4 I4 I; K5 m7 a5 p- f
0 Q1 |9 Y( B* b1 `# \
+ p9 U1 E5 Y3 h$ e3 E9 T0 i2 W& [9 J3 v
截取相同的部分,两次数据完全一致,写入和读取成功。3 g+ V8 q+ N/ o: B0 g2 A) \+ }
6 U: h" s0 Q* m1 c1 z6 I/ }; r' e最后,讲几点需要注意的地方:
# D& L6 C- g0 m9 i3 i |' m3 q5 J. ~9 G& D$ q+ ]9 f% s
1.N25Q128 与 W25Q128 有很多不同的地方,特别是4线模式下,二者很多地方不同,代码不可混用,比如W25Q128的很多指令都是支持4线的,但是N25Q128的指令阶段均不支持4线模式。; ^3 k1 S! e0 n0 r2 k6 ^" z
5 k, [: o# h0 h/ b/ G: M+ x4 w2.硬件上使用了4线SPI,但是仍然可以使用单线SPI操作,只是速度慢了点,其他的没什么影响。
* z' I. E. C! o8 D7 O+ d* D2 {1 k* Z" ?3 x8 H' {4 _+ W
3.N25Q128在配置为内存映射模式时,外部 SPI 器件被视为是内部存储器。QUADSPI 外设若没有正确配置并使能,禁止访问 QUADSPI Flash 的存储区域。即使 Flash 容量更大,寻址空间也无法超过 256MB。如果访问的地址超出 FSIZE 定义的范围但仍在 256MB 范围内,则生成 AHB 错误。此错误的影响具体取决于尝试进行访问的 AHB 主设备:
: @) Y/ I" {* d" A# X( _ 如果为 Cortex ® CPU,则生成硬性故障 (Hard fault) 中断
- ]" b& f2 y* J/ F9 N& w 如果为 DMA,则生成 DMA 传输错误,并自动禁用相应的 DMA 通道。
: s9 {! `9 `- s% N
" g3 U- ]% U0 k' f4.N25Q128包含248个主扇区,每个扇区64KB,还有8个64KB的启动扇区,这8个启动扇区又可分为128个子扇区,每个子扇区大小为4KB,所有的扇区擦除都可以按照一次64KB大小擦除,但是这8个启动扇区也可以按照4KB一次擦除(需要使用SUBSECTOR_ERASE_CMD指令擦除)。6 x" F5 ~( r' u ^% `0 ~4 r/ m
, b. S+ g2 L4 p- X7 C( Z5 M
5.N25Q128分TOP和Bottom架构,两种架构的区别就是启动扇区的位置不同,TOP架构的启动扇区是248~255(地址范围:F80000 ~FFFFFF),0~248为主扇区。Bottom架构的启动扇区是0~7(地址范围:0~7FFFF),8~255是主扇区。这两中架构可以通过完整的型号区分。$ b2 [ b" R' U
& d3 V) d K) o: O5 ~' U U* |
5 d: i v) G& i" `7 B I
& `' m0 s: O/ r" U6.N25Q128和W25Q128 不可以相互替换,除非使用单线SPI通信,且只能使用F80000 ~FFFFFF或者0~7FFFF范围内的内存。, Z6 |. z) n+ U: G+ Z0 z' o
. \# }2 L3 g+ H! B/ s7.N25Q128的指令在不同spi模式(单线、双线、四线)下有所不同,使用时一定要特别注意!!!; L& {1 o( m q! ]: S- t& U
s8 W3 W7 U: y" q7 ?
0 z! @& b* D8 l; C) V) r2 m, t8 I, f' J; ^" a8 Q6 }/ E3 u% }% K
|