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