79.1 初学者重要提示
5 u0 Z) I6 A5 C! U5 l 1、 学习本章节前，务必优先学习第79章。

2、 W25Q256JV属于NOR型Flash存储芯片。
  S2 n7 b, |: L
& d+ U+ R: @! N. f- ^. w/ a* r 3、 W25Q256JV手册下载地址。

4 ~3 |- ^& {0 \2 P: ?; M$ c4 |
: p. i; u2 M, h. g  G4 O 4、 本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。

/ t; |* r0 O7 k 5、 对QSPI Flash W25Q256JV的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。

6、 W25Q256JV最高支持133MHz。
: q+ i. N2 B8 D: y5 L) ]
7、 STM32H7驱动QSPI Flash的4线DMA模式，读速度48MB/S左右。

) `; D/ `- D" @! Q 8、 内存映射模式下，最后一个字节无法正常读取的解决办法。

9、 本章配套例子的DMA是采用性能最强的MDMA。
# u+ T2 t! c1 M1 f  l* m) F. b/ \% R
79.2 W25QXX硬件设计
; `' `  Y6 Z% B8 q* ^4 xSTM32H7驱动W25Q256JV的硬件设计如下：
6 S8 V2 W) E, g, S1 j+ B! T7 V- G$ ^

9 V! v5 z# t( M
关于这个原理图，要了解到以下几个知识：

# Y& [/ e: ]& l  V7开发板实际外接的芯片是W25Q256JV。
  CS片选最好接上拉电阻，防止意外操作。
9 B; ^; m6 ]  d- ]# a3 j! y9 i( a  W25Q256的WP引脚用于写保护，低电平有效性，当前是将其作为4方式的IO2。
1 a* m: G0 x$ [* ~  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。当前是将其作为4线方式的IO3。
79.3 W25QXX关键知识点整理（重要）
/ y9 q- [8 M! P2 h6 E. Y5 d4 }驱动W25QXX前要先了解下这个芯片的相关信息。
: J, f2 ^5 D- @* F

2 l8 Y* h, c+ t. @& i( M
79.3.1 W25QXX基础信息
, v5 I6 G# P) \+ |- k; K) P  W25Q256JV是32MB（256Mbit）。
! r' k" M+ e. L! J  W25Q256JV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
支持两线SPI，用到引脚CLK、CS、IO0、IO1 。
( R$ |9 t0 g3 U9 v3 t: r- q
: L  S4 O. I) \5 O" |9 f0 u' q支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。

; d% Y- I4 d% t/ L4 w  r* `/ m（注：这里几线的意思是几个数据线）。
. r. w: l( Y* _
5 G& t1 H, h& ]  W25Q256JV支持的最高时钟是133MHz。
3 u& }- o1 w- n- ~  每个扇区最少支持10万次擦写，可以保存20年数据。
5 x6 l+ Q: y5 N6 S  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
整体框图如下：

( ]3 C4 \+ C! ~
! L3 d/ @5 c6 n7 q/ A( u& tW25Q256JV：
& ~, B) E$ A9 g0 b( O/ C4 R( ^
9 ?0 x- G+ B  M. |  有512个Block，每个Block大小64KB。
6 Q% S! ]9 X! T1 n$ n  每个Block有16个Sector，每个Sector大小4KB。
) [# |( a- T8 L$ A  S. q  每个Sector有16个Page，每个Page大小是256字节。
3 P. v8 `0 \, s7 |% [0 U79.3.2 W25QXX命令
1 |3 m" ^% i1 Z) s3 ]/ \0 a使用W25Q256的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的QSPI，即4线SPI，并且用的4字节地址模式，使用的命令如下：
' h/ r) P, W; d. ?  X8 m! n9 D" l
* m8 h; U8 Z/ c/ {* k

" B) d9 M2 W/ H

/ s5 a0 F3 U% ]
当前主要用到如下几个命令：
+ g, c  F2 ^7 k! s' O$ t' W; P2 R
* R+ R+ P  A- E" X- s2 s* z

1. #define WRITE_ENABLE_CMD      0x06         /* 写使能指令 */  
   
2. #define READ_ID_CMD2          0x9F         /* 读取ID命令 */  
   
3. #define READ_STATUS_REG_CMD   0x05         /* 读取状态命令 */
   
4. #define BULK_ERASE_CMD        0xC7         /* 整个芯片擦除命令 */
   
5. #define SUBSECTOR_ERASE_4_BYTE_ADDR_CMD      0x21    /* 32bit地址扇区擦除指令, 4KB */
   & p* B$ N' W7 F; ?6 J' {# x
6. #define QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD    0x34    /* 32bit地址的4线快速写入命令 */
   
7. #define QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD 0xEC    /* 32bit地址的4线快速读取命令 */

复制代码

7 G" \! X- B9 f6 [79.3.3 W25QXX页编程和页回卷
! X* U4 C  P  Y7 `% Y! {" KSPI Flash仅支持页编程（页大小256字节），所有其它大批量数据的写入都是以页为单位。这里注意所说的页编程含义，页编程分为以下三步（伪代码）：
0 q1 r+ p- ]- |9 A5 b' p
/ T3 b, v& ~$ B8 r. k3 M+ {

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   6 b. r& m; K; l6 P) i& `; v# B
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   ) U% p- e5 r% Z& y8 x
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   
5. 
   6 y7 f% g* B$ P  I1 Z# G0 i- R6 K
6.     for (i = 0; i < _usSize; i++)
   
7.     {
   " T9 g" G4 T1 `' E; c1 H: R+ m" w
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   8 o9 `6 }3 I: n( h; j9 Z4 l3 e/ Y
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   / q: Q2 E5 D- f9 Z' Q) q
10.     }

复制代码

- l- F8 H9 `& L. H( J页编程的含义恰恰就体现在第3步了，如果用户设置的“起始地址+数据长度”所确定的地址范围超过了此起始地址所在的页，地址自增不会超过页范围，而是重新回到了此页的首地进行编写。这一点要特别的注意。如果用户不需要使用地址自增效果，那么直接指定地址进行编写即可。可以任意指定地址进行编写，编写前一定要进行擦除。

: q, o  ?- w) D$ B比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：
1 L2 @: U% ?# x  N' P1 u/ R
0 }* j+ `1 u) n9 \, n/ F7 a

1. uint8_t tempbuf[10] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00};
   
2. uint8_t temp1 = 0x10, temp2 = 0x29, temp3 = 0x48;

复制代码

) i( S' I9 B% L: u' A) d  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
& q+ c# W1 r( n+ ]  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。

79.3.4 W25QXX扇区擦除
SPI Flash的擦除支持扇区擦除（4KB），块擦除（32KB或者64KB）以及整个芯片擦除。对于扇区擦除和块擦除，使用的时候要注意一点，一般情况下，只需用户给出扇区或者块的首地址即可。

如果给的不是扇区或者块的首地址也没有关系的，只要此地址是在扇区或者块的范围内，此扇区或者块也可以被正确擦除。不过建议使用时给首地址，方便管理。

79.3.5 W25QXX规格参数
这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：

! @* T- d, E& p3 ]
. Q+ G+ g. s2 @1 m" n$ m
  页编程时间：典型值0.4ms，最大值3ms。
* P( U( B  U5 C9 P  扇区擦除时间（4KB）：典型值50ms，最大值400ms。
  块擦除时间（32KB）：典型值120ms，最大值1600ms。
6 ]% D& B$ }1 O8 p  块擦除时间（64KB）：典型值150ms，最大值2000ms。
  整个芯片擦除时间：典型值80s，最大值400s。
2 g, @& O- N3 z
支持的速度参数如下：
4 t/ X  ?- k3 x( Q* M' m0 C

可以看到最高支持的读时钟（使用命令03H）速度是50MHz，其它命令速度可以做到133MHz。

" w+ C3 N: W* r$ S+ W79.4 W25QXX驱动设计
6 f7 B- B& @5 `% D8 V- ~W25QXX的程序驱动框架设计如下：

) D! K# i! V7 }% F+ M( @
有了这个框图，程序设计就比较好理解了。
0 S" X6 J- {( o4 P  }6 @
2 m! t* T" V4 N/ v; ]; c- F79.4.1 第1步：QSPI总线配置
QSPI总线配置如下：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_InitQSPI_W25Q256
   
4. *    功能说明: QSPI Flash硬件初始化，配置基本参数
   ' ^0 |2 B$ G0 x- L4 A* ?
5. *    形    参: 无
   + h9 e2 H0 w% h1 N, b
6. *    返 回 值: 无
   ( X& \1 I% E' C: o
7. *********************************************************************************************************
   $ O. o! v3 V; Y
8. */
   
9. void bsp_InitQSPI_W25Q256(void)
   5 N  H6 ~8 I2 y3 D9 F4 _
10. {
    
11.     /* 复位QSPI */
    8 _- j9 q6 G+ B/ B8 v+ J- r
12.     QSPIHandle.Instance = QUADSPI;
    6 [2 h( Z- a( Z8 C+ v
13.     if (HAL_QSPI_DeInit(&QSPIHandle) != HAL_OK)
      L3 Q+ h: o% m2 U- ]  }
14.     {
    4 {% i8 W2 `# a9 p% _3 B$ o
15.         Error_Handler(__FILE__, __LINE__);
    & q$ x8 L( Q5 P# l
16.     }
    
17. 
    
18.     /* 设置时钟速度，QSPI clock = 200MHz / (ClockPrescaler+1) = 100MHz */
    
19.     QSPIHandle.Init.ClockPrescaler  = 1;  
    
20. 
    . [* ^/ Q$ p8 S
21.     /* 设置FIFO阀值，范围1 - 32 */
    5 s- q; n8 V6 ~* k! q, O
22.     QSPIHandle.Init.FifoThreshold   = 32;
    
23. 
    
24.     /*
      {( ~0 n; ^! n  m, E6 y# l" S- Z
25.         QUADSPI在FLASH驱动信号后过半个CLK周期才对FLASH驱动的数据采样。
    
26.         在外部信号延迟时，这有利于推迟数据采样。
    # E+ W/ ^2 E$ ^2 j' x% F
27.     */
    
28.     QSPIHandle.Init.SampleShifting  = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
    6 ?3 D4 B! T! a; `' l% _! y
29. 
    
30.     /*Flash大小是2^(FlashSize + 1) = 2^25 = 32MB */
    
31.     //QSPI_FLASH_SIZE - 1; 需要扩大一倍，否则内存映射方位最后1个地址时，会异常。
    
32.     QSPIHandle.Init.FlashSize       = QSPI_FLASH_SIZE;
    
33. 
    0 N  T7 V, u( a8 M
34.     /* 命令之间的CS片选至少保持2个时钟周期的高电平 */
    $ M$ Q2 q3 s* F; [' _' V) E) t
35.     QSPIHandle.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_2_CYCLE;
      X+ o: s8 Q! H4 F. x2 R. c
36. 
    
37.     /*
    
38.        MODE0: 表示片选信号空闲期间，CLK时钟信号是低电平
    
39.        MODE3: 表示片选信号空闲期间，CLK时钟信号是高电平
    
40.     */
    - X" A6 L2 E" I* f3 l9 D
41.     QSPIHandle.Init.ClockMode = QSPI_CLOCK_MODE_0;
    
42. 
    
43.     /* QSPI有两个BANK，这里使用的BANK1 */
    1 a. C7 w& y, z7 o
44.     QSPIHandle.Init.FlashID   = QSPI_FLASH_ID_1;
    
45. 
    9 b9 s: A, P) n9 [( ~& G" w
46.     /* V7开发板仅使用了BANK1，这里是禁止双BANK */
    / x0 k3 j* J0 W- i$ A# a5 e
47.     QSPIHandle.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
    5 p/ v' A5 z. j- d2 I& g0 s4 @
48. 
    $ H. i' S( V7 W, c+ v* y6 y
49.     /* 初始化配置QSPI */
    $ d* P. ~% r" V
50.     if (HAL_QSPI_Init(&QSPIHandle) != HAL_OK)
    
51.     {
    
52.         Error_Handler(__FILE__, __LINE__);
    
53.     }   
    
54. }

复制代码

QSPI这部分配置，要特别注意Flash大小的设置，这里做了特别处理，本来是应该填入QSPI_FLASH_SIZE-1，而我们实际上填入的是QSPI_FLASH_SIZE，主要是因为内存映射模式下，最后一个字节访问有问题。

79.4.2 第2步：QSPI总线的查询和MDMA方式设置
* E9 m1 m! @9 L) x! T本章提供了QSPI Flash的查询和MDMA两种方式的例子，驱动的区别是调用的API不同，查询方式调用的API是HAL_QSPI_Transmit和HAL_QSPI_Receive，而DMA方式使用的API是HAL_QSPI_Transmit_DMA和HAL_QSPI_Receive_DMA。

0 m! X6 d9 ?  v& T79.4.3 第3步：W25QXX的读取实现
注：这里以查询方式的API进行说明，DMA方式是一样的。

( W% b: m# l  z; I  y. `W25QXX的读取功能是发送的4线快速读取指令0xEC，设置任意地址都可以读取数据，只要不超过芯片容量即可（如果采用的DMA方式，限制每次最大读取65536字节）。
: H1 o5 a8 d+ B8 _/ r5 w

1. /*
   / b: ~; Q4 d5 A/ V9 K7 ]- N& m- Y
2. *********************************************************************************************************
   % a6 J% B0 X) q- w
3. *    函 数 名: QSPI_ReadBuffer
   : i0 N6 B- {8 }7 `7 u
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   
5. *    形    参: _pBuf : 数据源缓冲区。
   
6. *              _uiReadAddr ：起始地址。
   5 _! A7 f. w6 d/ d
7. *              _usSize ：数据个数, 可以大于PAGE_SIZE, 但是不能超出芯片总容量。
   
8. *    返 回 值: 无
   " d% u, M) ~* G% L  x/ Y  {
9. *********************************************************************************************************
   
10. */
    
11. void QSPI_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    / S8 Z# h. H( U# N
12. {
    5 b2 N! O! [# t# ]5 v$ x- b. e
13. 
    
14.     QSPI_CommandTypeDef sCommand = {0};
    
15. 
    3 O& [; t& @* M3 f5 |
16. 
    
17.     /* 基本配置 */
    , s/ }8 \! Z8 Q  j2 [. ^/ _% _; N
18.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;        /* 1线方式发送指令 */
    $ T3 Y, ~% i% C) ?2 Y, U
19.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;          /* 32位地址 */
    
20.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;      /* 无交替字节 */
    . F! r; q/ `! }& D0 Y7 Y" @; @8 O
21.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;          /* W25Q256JV不支持DDR */
    ( n- ~* |6 R2 p+ C6 y! r
22.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;      /* DDR模式，数据输出延迟 */
    
23.     sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;        /* 每次传输要发指令 */   
    ! k1 |! }) T, @' W6 i) i
24. 
    2 o/ ?- _$ I/ o
25.     /* 读取数据 */
    
26.     sCommand.Instruction = QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD; /* 32bit地址的4线快速读取命令 */
    ( x7 v+ z9 K0 X" W- L4 S
27.     sCommand.DummyCycles = 6;                    /* 空周期 */
    
28.     sCommand.AddressMode = QSPI_ADDRESS_4_LINES; /* 4线地址 */
    
29.     sCommand.DataMode    = QSPI_DATA_4_LINES;    /* 4线数据 */
    3 D1 W3 U' ~% A: o+ m9 Y4 }
30.     sCommand.NbData      = _uiSize;              /* 读取的数据大小 */
    1 L6 ]0 F5 T" L
31.     sCommand.Address     = _uiReadAddr;          /* 读取数据的起始地址 */
    ) I+ e, s3 {) N1 U+ Q
32. 
    / T  g; U+ r' g  y( D  K8 d
33.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    * O( X% W) _: P6 b" G
34.     {
    0 y. ]+ G; O5 }% ~8 L
35.         Error_Handler(__FILE__, __LINE__);
    
36.     }
    
37. 
    
38.     /* 读取 */
    5 c+ m' Q2 u% c# x3 K2 y
39.     if (HAL_QSPI_Receive(&QSPIHandle, _pBuf, 10000) != HAL_OK)
    % [$ y) _6 {" y* a+ y3 h
40.     {
    0 s* Q( k( |8 F
41.         Error_Handler(__FILE__, __LINE__);
    
42.     }   
    ( R7 u! N/ R; @) [! x4 t
43. }

复制代码

2 G' S! Y' [4 s- J, S此时函数使用的指令0xEC对应的W25Q256JV手册说明，注意红色方框位置：
  S$ ^4 A% n/ S$ z8 ^0 k
; f. G$ @; {  Z; b% V

左上角的1-4-4就是指令阶段使用1个IO，地址阶段使用4个IO，数据阶段也是使用4个IO，并且采用的4字节地址方式，反映到程序里面就是：
  J. ]5 J$ b  q' _& K
/ e% G. m2 i* g6 }( Z' r4 dsCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
( j, i6 k1 U, }2 _sCommand.AddressMode = QSPI_ADDRESS_4_LINES;
sCommand.AddressSize = QSPI_ADDRESS_32_BITS;
sCommand.DataMode = QSPI_DATA_4_LINES;
1 D# s! z( Y" F
79.4.4 第4步：W25QXX的编程实现
注：这里以查询方式的API进行说明，DMA方式是一样的。
  F) ~8 y1 D* b% Z
" k$ T3 V" a& \0 ?: H8 k下面实现了一个页编程函数：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: QSPI_WriteBuffer
   ! r. }  }6 `( S; `
4. *    功能说明: 页编程，页大小256字节，任意页都可以写入
   / N# \0 A$ K$ c' e$ l
5. *    形    参: _pBuf : 数据源缓冲区；
   7 T+ H7 V* W" O2 u) h/ {5 i! `
6. *              _uiWriteAddr ：目标区域首地址，即页首地址，比如0， 256, 512等。
   " `( i6 o/ A( y/ r$ b& m
7. *              _usWriteSize ：数据个数，不能超过页面大小，范围1 - 256。
   
8. *    返 回 值: 1:成功， 0：失败
   
9. *********************************************************************************************************
   * V- ~* J6 o0 v- p' F
10. */
    
11. uint8_t QSPI_WriteBuffer(uint8_t *_pBuf, uint32_t _uiWriteAddr, uint16_t _usWriteSize)
    
12. {
    
13.     QSPI_CommandTypeDef sCommand={0};
    
14. 
    
15.     /* 写使能 */
    
16.     QSPI_WriteEnable(&QSPIHandle);   
    " \) h+ b4 S5 _$ y
17. 
    9 j0 c- ^2 u) F0 R9 Y& @- \
18.     /* 基本配置 */
    / ^$ O: y7 M) V
19.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;    /* 1线方式发送指令 */
    
20.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;       /* 32位地址 */
    6 u5 l8 u& V4 y. x2 x  y
21.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    
22.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;      /* W25Q256JV不支持DDR */
    9 h5 G  y" I2 q/ P! O3 Y* r( V
23.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;  /* DDR模式，数据输出延迟 */
    
24.     sCommand.SIOOMode          = QSPI_SIOO_INST_ONLY_FIRST_CMD;     /* 仅发送一次命令 */   
    ; Q* ?' e6 L: u: l( A4 X
25. 
    9 r, |5 c2 a: q* M/ E. t# A# s
26.     /* 写序列配置 */
    ( j% _) c2 }! [' d. T5 I0 Z
27.     sCommand.Instruction = QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD; /* 32bit地址的4线快速写入命令 */
    
28.     sCommand.DummyCycles = 0;                    /* 不需要空周期 */
    7 R& h- O1 x$ m% E  h
29.     sCommand.AddressMode = QSPI_ADDRESS_1_LINE;  /* 4线地址方式 */
    
30.     sCommand.DataMode    = QSPI_DATA_4_LINES;    /* 4线数据方式 */
    - O; ]3 i; X" \6 `) w- S
31.     sCommand.NbData      = _usWriteSize;         /* 写数据大小 */   
    / @  Q1 l+ p, L! T9 j
32.     sCommand.Address     = _uiWriteAddr;         /* 写入地址 */
    
33. 
    
34.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    
35.     {
    
36.         //return 0;
    4 v: |  V5 ?. M; E1 d. T* C( W. H, \
37.         Error_Handler(__FILE__, __LINE__);
    
38.     }
    
39. 
    ( I% x0 f  ]# J) f: L2 s$ [
40.     /* 启动传输 */
    8 o1 _  }/ X1 P. F
41.     if (HAL_QSPI_Transmit(&QSPIHandle, _pBuf, 10000) != HAL_OK)
    ) e6 e( U& V+ e  B# m
42.     {
    
43.         //return 0;
    
44.         Error_Handler(__FILE__, __LINE__);
    
45. 
      {; h! O; h% C7 H! j4 Q
46.     }
    
47. 
    
48.     QSPI_AutoPollingMemReady(&QSPIHandle);   
    ) f/ ^. C7 l# y1 m3 y
49. 
    ! o6 q5 }' a6 `
50.     return 1;
    8 l, _  J1 v) V: |* }
51. }

复制代码

此时函数使用的指令0x34对应的W25Q256JV手册说明，注意红色方框位置：
- F5 c5 h+ I  B& n9 }$ M

. G/ v2 c9 J6 J: H# N$ b$ x
. M- g5 e3 z! ]左上角的1-4-4就是指令阶段使用1个IO，地址阶段使用4个IO，数据阶段也是使用4个IO，并且采用的4字节地址方式，反映到程序里面就是：
" r0 W  M7 z7 a
sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
! t9 J7 Y  ~2 O/ S& }- N, BsCommand.AddressMode = QSPI_ADDRESS_4_LINES;
  x0 f" C" r0 A' {& H. m9 B  ~2 G7 BsCommand.AddressSize = QSPI_ADDRESS_32_BITS;
# U& f) p0 f! L7 S0 _0 qsCommand.DataMode = QSPI_DATA_4_LINES;
" t& T  c  [: `* L: L/ ^+ z1 j
79.4.5 第5步：W25QXX的扇区擦除实现
注：这里以查询方式的API进行说明，DMA方式是一样的。

通过发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除，擦除的扇区大小是4KB。
$ r+ B8 L4 d  M
5 h0 |; M0 w/ ?8 _

1. /*
   
2. *********************************************************************************************************
   & `4 y+ L  t/ V5 J2 `0 y
3. *    函 数 名: QSPI_EraseSector
   % t% y: Y% Q$ b% `
4. *    功能说明: 擦除指定的扇区，扇区大小4KB
   
5. *    形    参: _uiSectorAddr : 扇区地址，以4KB为单位的地址，比如0，4096, 8192等，
   
6. *    返 回 值: 无
   # y8 _3 A' h' E+ K5 {
7. *********************************************************************************************************
   
8. */
   # f" N: g! k. c4 C, U3 C/ E- |
9. void QSPI_EraseSector(uint32_t _uiSectorAddr)
   
10. {
      `5 \1 m& q; G# u( e6 r3 Z
11.     QSPI_CommandTypeDef sCommand={0};
    ' M/ A) R4 z0 B! ~; a
12. 
    
13.     /* 写使能 */
    % e; Z% j9 ^& V2 Q
14.     QSPI_WriteEnable(&QSPIHandle);   
    . O3 h# x' p& R# o& |- w
15. 
    
16.     /* 基本配置 */
    
17.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;    /* 1线方式发送指令 */
    
18.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;       /* 32位地址 */
    $ `: s* W" N! h1 r; D6 X
19.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    
20.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;      /* W25Q256JV不支持DDR */
    : J, O/ b, O& |1 n: Y
21.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;  /* DDR模式，数据输出延迟 */
    ( m; x; H' C9 r# Q+ _7 Z4 W
22.     sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;     /* 每次传输都发指令 */   
    
23. 
    
24.     /* 擦除配置 */
    
25.     sCommand.Instruction = SUBSECTOR_ERASE_4_BYTE_ADDR_CMD;   /* 32bit地址方式的扇区擦除命令，扇区大小4KB*/      
    # m3 j+ T; a3 V3 V* C- e8 E: ]/ V
26.     sCommand.AddressMode = QSPI_ADDRESS_1_LINE;  /* 地址发送是1线方式 */      
    8 D7 S0 {. y  K1 q' K! ]+ t5 b
27.     sCommand.Address     = _uiSectorAddr;        /* 扇区首地址，保证是4KB整数倍 */   
    
28.     sCommand.DataMode    = QSPI_DATA_NONE;       /* 无需发送数据 */  
    3 {( L, P9 B( @* j  C
29.     sCommand.DummyCycles = 0;                    /* 无需空周期 */  
    $ g* e! M  D8 \  B. }3 W+ N
30. 
    
31.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    ) s5 [, W+ E# m
32.     {
    6 f9 d  R. S, p4 g2 O7 P. s0 d
33.         Error_Handler(__FILE__, __LINE__);
    0 R) K* L2 z! K7 M. {  a/ e
34.     }
    ( o" W# B8 D! [- a) _
35. 
    
36.     QSPI_AutoPollingMemReady(&QSPIHandle);   
    - n; Y5 H& S, g7 O, E$ Y
37. }

复制代码

# f4 z* l" M: l  G  y  r& }) V此时函数使用的指令0x21对应的W25Q256JV手册说明，注意红色方框位置：

( v# U: f9 `. z左上角的1-1-1就是指令阶段使用1个IO，地址阶段使用1个IO，数据阶段也是使用1个IO，并且采用的4字节地址方式，反映到程序里面就是：

sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;

sCommand.AddressMode = QSPI_ADDRESS_1_LINES;

8 y3 l9 ]. w: {0 I3 W& F sCommand.AddressSize = QSPI_ADDRESS_32_BITS;
! A6 T8 ^4 i9 y; }  X0 w( f" o
sCommand.DataMode = QSPI_DATA_1_LINES;

79.4.6 第6步：W25QXX的整个芯片擦除实现
! a  o0 J% E' \: a2 g8 e! s注：这里以查询方式的API进行说明，DMA方式是一样的。
! E5 o6 _) k0 N4 a
整个芯片的擦除可以通过擦除各个扇区来实现，也可以调用专门的整个芯片擦除指令实现。下面实现方法是发送整个芯片擦除命令实现：
2 L: Z% k% x- C" |" D+ Q# `- W
' t6 @" X; V- X- l( K5 [; ?* u% C

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: QSPI_EraseChip
   
4. *    功能说明: 整个芯片擦除
   ; h3 O& H7 s* T% U' b0 X
5. *    形    参: 无
   . H: o8 z4 O: @/ B/ b) ~+ n1 ~" U
6. *    返 回 值: 无
   ' M. \0 A) E5 F* v2 \
7. *********************************************************************************************************
   
8. */
   
9. void QSPI_EraseChip(void)
   0 a2 O( V6 e3 n
10. {
    
11.     QSPI_CommandTypeDef sCommand={0};
    
12. 
    5 \+ _3 z% T8 N4 q  I& d& X
13.     /* 写使能 */
    1 Q) E% e, }( Z0 Q! X! M- l
14.     QSPI_WriteEnable(&QSPIHandle);   
    
15. 
    
16.     /* 基本配置 */
    / s0 s* _6 Y' d* U3 w7 ~$ h
17.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;    /* 1线方式发送指令 */
    
18.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;       /* 32位地址 */
    0 k7 N; u, e: U- C7 D
19.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    1 q2 b) b0 ~& t
20.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;      /* W25Q256JV不支持DDR */
    + A  h$ M& P+ ]
21.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;  /* DDR模式，数据输出延迟 */
    
22.     sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;     /* 每次传输都发指令 */   
    
23. 
    8 K. x& \' r/ w
24.     /* 擦除配置 */
    
25.     sCommand.Instruction = BULK_ERASE_CMD;       /* 整个芯片擦除命令*/      
    / N8 `8 {& O; y. a: @7 s& f, V
26.     sCommand.AddressMode = QSPI_ADDRESS_1_LINE;  /* 地址发送是1线方式 */      
    ) b9 ]: }2 i3 W: O; ?$ q  }
27.     sCommand.Address     = 0;                    /* 地址 */   
    
28.     sCommand.DataMode    = QSPI_DATA_NONE;       /* 无需发送数据 */  
    
29.     sCommand.DummyCycles = 0;                    /* 无需空周期 */  
    
30. 
    
31.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    
32.     {
    , b0 h8 {  g  h
33.         Error_Handler(__FILE__, __LINE__);
    3 x( ^9 N; N8 B% s% @* K; w" Q
34.     }
    
35. 
    / J2 ]$ P6 }" F4 T) ~8 Q% z( E+ p
36.     QSPI_AutoPollingMemReady(&QSPIHandle);   
    . G) Q$ a& \. f7 R6 N& ~
37. }

复制代码

$ s+ A+ {: A7 q- e5 S0 @此时函数使用的指令0xC7对应的W25Q256JV手册说明，注意红色方框位置：



左上角的1-1-1就是指令阶段使用1个IO，地址阶段使用1个IO，数据阶段也是使用1个IO，并且采用的4字节地址方式，反应到程序里面就是：
; I8 ^, a1 C# V9 R
sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
+ Q) a8 Q7 K# i0 Z6 z7 zsCommand.AddressMode = QSPI_ADDRESS_1_LINES;
. h9 Y" V3 h6 K) O# l2 M2 usCommand.AddressSize = QSPI_ADDRESS_32_BITS;
9 [/ }5 q" \" x# w8 CsCommand.DataMode = QSPI_DATA_1_LINES;
& z3 @8 Z$ }3 C, d2 S
擦除用不到数据阶段，sCommand.DataMode  = QSPI_DATA_NONE即可。

79.4.7 第7步：W25QXX内存映射实现
8 ?/ x+ ]7 U: _" I! z注：这里以查询方式的API进行说明，DMA方式是一样的。

通过内存映射模式，就可以像使用内部Flash一样使用W25QXX，代码实现如下：
; h$ ~; U8 |' }( `' o1 S3 B, M+ ^

1. /*
   
2. *********************************************************************************************************
   6 d2 o! L) R1 F- S9 j+ r
3. *    函 数 名: QSPI_MemoryMapped
   
4. *    功能说明: QSPI内存映射，地址 0x90000000
   . s) m- M) P/ r$ t
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   + ~" Y+ K0 y( ~! f7 f6 ?
9. void QSPI_MemoryMapped(void)
   5 w. L( A9 e" ~# T- |( c4 x$ X
10. {
    
11.     QSPI_CommandTypeDef s_command = {0};
    
12.     QSPI_MemoryMappedTypeDef s_mem_mapped_cfg = {0};
    
13. 
    ' A5 F6 q: ]9 C6 \. p; W
14.     /* 基本配置 */
    
15.     s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;      /* 1线方式发送指令 */
    6 G4 n  X, o/ z, o
16.     s_command.AddressSize = QSPI_ADDRESS_32_BITS;             /* 32位地址 */
    % h4 _; d. H. Z
17.     s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    6 t( e! m% e  |, r$ P4 M; p
18.     s_command.DdrMode = QSPI_DDR_MODE_DISABLE;                /* W25Q256JV不支持DDR */
    
19.     s_command.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;   /* DDR模式，数据输出延迟 */
    
20.     s_command.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;            /* 每次传输都发指令 */
    
21. 
    
22.     /* 全部采用4线 */
    
23.     s_command.Instruction = QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD; /* 快速读取命令 */
    
24.     s_command.AddressMode = QSPI_ADDRESS_4_LINES;                 /* 4个地址线 */
      D8 Z: M% B  O- u  `* s+ z$ l8 F
25.     s_command.DataMode = QSPI_DATA_4_LINES;                       /* 4个数据线 */
    
26.     s_command.DummyCycles = 6;                                    /* 空周期 */
    5 e8 ]+ @2 g: P
27. 
    ( s7 P0 S% B5 O: D4 L% F1 p
28.     /* 关闭溢出计数 */
    % U  M; }9 C% W+ ]' m) t
29.     s_mem_mapped_cfg.TimeOutActivation = QSPI_TIMEOUT_COUNTER_DISABLE;
    0 s& ]3 s  k1 z* a- i: n- R; f3 i
30.     s_mem_mapped_cfg.TimeOutPeriod = 0;
    
31. 
    
32.     if (HAL_QSPI_MemoryMapped(&QSPIHandle, &s_command, &s_mem_mapped_cfg) != HAL_OK)
    2 W! H( M% `( _1 l
33.     {
    
34.        Error_Handler(__FILE__, __LINE__);
    9 T% X+ {7 k6 H+ E. z/ Y" \& j5 x
35.     }
      ^; K! i* C8 Y" C0 p
36. }

复制代码

此时函数使用的指令0xEC对应的W25Q256JV手册说明，注意红色方框位置：
& G$ u; N4 @+ z' Q
9 X3 q( W  |5 J8 P' }

7 ~9 S0 W& o' x. q% g( Q( r
左上角的1-4-4就是指令阶段使用1个IO，地址阶段使用4个IO，数据阶段也是使用4个IO，采用的4字节地址方式，反应到程序里面就是：

sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
sCommand.AddressMode = QSPI_ADDRESS_4_LINES;
* o( E7 h. \, ?, ~6 f9 }' OsCommand.AddressSize = QSPI_ADDRESS_32_BITS;
sCommand.DataMode = QSPI_DATA_4_LINES;
/ F+ X: Y1 t# d4 F2 ~
$ g3 [' C' u3 Q, X79.4.8 第8步：使用MDMA方式要注意Cache问题
* o0 V, S; `; h* f如果使用MDMA方式的话，可以使用TCM RAM，此时不用考虑Cache问题。如果使用的是其它RAM空间，要考虑Cache问题。因为MDMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭读Cache和写Cache，比如使用的AXI SRAM，这样可以方便大家做测试，测试通过后，再根据需要开启Cache。
0 h. x, g, [" }. s5 B" G, a$ a

1. /* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
   0 b8 G6 g" C4 \+ s  Q3 X5 d
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   
3. MPU_InitStruct.BaseAddress      = 0x24000000;
   
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
   " `$ n6 M6 v1 n3 M, G
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   ) g% b9 b0 `3 ]! Y& x* D) {
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   
7. MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   
8. MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   9 M$ Z0 [: f3 U$ v, j
9. MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
   
10. MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
11. MPU_InitStruct.SubRegionDisable = 0x00;
    
12. MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ) [4 [0 y) M& g3 ]% g& \
13. 
    
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

$ H* _: L7 N# u( L2 U# a9 k79.5 W25QXX板级支持包（bsp_qspi_w25q256.c）
W25QXX驱动文件bsp_qspi_w25q256.c主要实现了如下几个API供用户调用：
% F' ?. @' L9 A! r" z/ b) Z
! d4 S! D+ S: f  QSPI_ReadBuffer
1 n; n7 z) R: L# w1 n. i$ _7 s  QSPI_WriteBuffer
/ [5 U0 }* W) i/ W  QSPI_EraseSector
  QSPI_EraseChip
# h9 C/ [8 U' f  i5 ?  QSPI_MemoryMapped
79.5.1 函数QSPI_ReadBuffer
: W+ k4 _. T# k+ ]函数原型：
/ v+ t7 P2 h4 N& Q7 ?) j1 N/ c5 v
8 ~/ R2 Y$ X& Q# n1 N( u& w, uvoid QSPI_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize);
. S1 S- s/ Q+ S
函数描述：
& G, C% O" t" c( ^
; g1 i9 ^2 ]2 I" q' M+ m/ ~4 ~0 y此函数主要用于从QSPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可（如果使用DMA方式，每次最大65536字节）。
& b5 |) J6 x. r/ l
, H- ?6 Y7 M% E! w, ?* e$ y函数参数：
  S" }& b( [7 t" m+ W* J9 S0 ?7 v
$ a! W/ h5 n4 A$ X# N; B7 _8 b  第1个参数用于存储从QSPI Flash读取的数据。
" }2 ~4 k* T! T, r$ |  第2个参数是读取地址，不可以超过芯片容量。
  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
79.5.2 函数QSPI_WriteBuffer
3 u* p+ H8 E; a. h函数原型：

uint8_t QSPI_WriteBuffer(uint8_t *_pBuf, uint32_t _uiWriteAddr, uint16_t _usWriteSize);
# z1 P# d7 V3 ^  u' \- g: l2 a6 E; y
函数描述：

, ?4 f8 Y' E9 R2 F页编程，页大小256字节，任意页都可以写入。注意使用前，务必保证相应页已经做了擦除操作。

函数参数：

  第1个参数是源数据缓冲区。
  第2个参数是目标区域首地址，即页首地址，比如0， 256, 512等。
% z6 Y  i+ N' E0 g  第3个参数是数据个数，不能超过页面大小，范围1 – 256，单位字节个数。
7 `3 F+ x/ w/ k/ {+ Q& C6 |  返回值，返回1表示成功，返回0表示失败。
! ?' o' W4 K% |79.5.3 函数QSPI_EraseSector
函数原型：
0 e  y* x0 [) B, O) {. r: w
6 r  h- r3 q6 x1 x& qvoid QSPI_EraseSector(uint32_t _uiSectorAddr)
7 H& `3 m5 `9 z& O
函数描述：
5 t! F0 C2 a* D! k, S
$ Y8 S1 M2 r5 p, A此函数主要用于扇区擦除，一个扇区大小是4KB。
* e( a" u3 d& d6 p/ `4 w
8 M/ V1 N% R% E0 K# s. m2 e函数参数：
. g2 r0 ^6 \0 q3 L4 B& m0 t
  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
: q; l! A% f. J1 i; @79.5.4 函数QSPI_EraseChip
函数原型：

: N  X# o0 y1 y2 }' I# I: I2 kvoid QSPI_EraseChip(void)
" L5 h. Z. \$ U: e9 v) A1 T/ s" I! Y, t& G
; r4 @( b% {2 K' t8 _8 A  C函数描述：

此函数主要用于整个芯片擦除。
# h8 @; Y7 g, u5 n; N4 M/ L8 B
* T! K0 k" }9 C  x/ y3 B4 E+ ?79.5.5 函数QSPI_MemoryMapped
函数原型：
" ~: k* ]- l" n  V# W( z6 `8 H# n& S; Q
- p) M9 f6 w  L: H9 [0 m! `( Zvoid QSPI_MemoryMapped(void)

3 c6 L) f' y9 V# }. y0 f* v函数描述：
3 c& [% w" A& [! \
* O+ u+ \' A" R3 T" o; M调用了此函数就可以像使用内部Flash一样使用外部Flash。
" @1 i2 V# q1 e/ X. Y5 ~2 e
79.6 W25QXX驱动移植和使用
7 w+ v9 p$ }0 B/ ^7 _  p/ SW25QXX移植步骤如下：

* n) Y* g0 H: K# K* P+ K4 C% L  第1步：复制bsp_qspi_w25q256.c， bsp_qspi_w25q256.h到自己的工程目录，并添加到工程里面。
% j6 f9 Y. ~7 q3 H8 f7 X1 B  第2步：根据使用的QSPI引脚，时钟等，修改bsp_qspi_w25q256.c文件开头的宏定义。

1. /*
   9 Y) @; Z( e, T2 n$ c3 m4 ^# l4 f
2.     STM32-V7开发板接线
   7 w  _2 j* q  Q0 }7 y. M6 @% N
3. 
   
4.     PG6/QUADSPI_BK1_NCS AF10
   
5.     PF10/QUADSPI_CLK    AF9
   ( S5 y* I% m# ?$ R/ {* E
6.     PF8/QUADSPI_BK1_IO0 AF10
   - G- |! r% m- \( D! ?
7.     PF9/QUADSPI_BK1_IO1 AF10
   
8.     PF7/QUADSPI_BK1_IO2 AF9
   
9.     PF6/QUADSPI_BK1_IO3 AF9
   
10. 
    8 {3 \# }! ]0 V- G* Z5 t5 U; _
11.     W25Q256JV有512块，每块有16个扇区，每个扇区Sector有16页，每页有256字节，共计32MB
    
12. */
    ( ~1 l# {2 C* v; W, A7 A$ |
13. 
    ( N% }  ^3 ~5 z
14. /* QSPI引脚和时钟相关配置宏定义 */
    + v9 a2 K. `! D) ~8 r8 M
15. #define QSPI_CLK_ENABLE()              __HAL_RCC_QSPI_CLK_ENABLE()
    ; e: O5 J4 |! g
16. #define QSPI_CLK_DISABLE()             __HAL_RCC_QSPI_CLK_DISABLE()
    0 `) ^1 K. g; b" r7 F. j6 C5 s- g( Z  I
17. #define QSPI_CS_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOG_CLK_ENABLE()
    
18. #define QSPI_CLK_GPIO_CLK_ENABLE()     __HAL_RCC_GPIOF_CLK_ENABLE()
    
19. #define QSPI_BK1_D0_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOF_CLK_ENABLE()
    
20. #define QSPI_BK1_D1_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOF_CLK_ENABLE()
    
21. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOF_CLK_ENABLE()
    - u" l) Q9 H) i2 V: ^, g% ]
22. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOF_CLK_ENABLE()
    
23. 
    
24. #define QSPI_MDMA_CLK_ENABLE()         __HAL_RCC_MDMA_CLK_ENABLE()
    
25. #define QSPI_FORCE_RESET()             __HAL_RCC_QSPI_FORCE_RESET()
    
26. #define QSPI_RELEASE_RESET()           __HAL_RCC_QSPI_RELEASE_RESET()
    
27. 
    ( R; x6 L% }- \+ ?3 U; i$ z
28. #define QSPI_CS_PIN                    GPIO_PIN_6
    
29. #define QSPI_CS_GPIO_PORT              GPIOG
    
30. 
    / z9 b  _, m9 e& P) c* ~
31. #define QSPI_CLK_PIN                   GPIO_PIN_10
    
32. #define QSPI_CLK_GPIO_PORT             GPIOF
    7 h8 q! m2 @9 |; z- j4 o
33. 
    ; D2 p/ m/ H8 w, M
34. #define QSPI_BK1_D0_PIN                GPIO_PIN_8
    ( b2 v7 h1 t& \% ~, I9 N
35. #define QSPI_BK1_D0_GPIO_PORT          GPIOF
    ) D$ K; y9 S, J' J! Q7 D
36. 
    5 Z* d  o& D$ U4 \7 O: c
37. #define QSPI_BK1_D1_PIN                GPIO_PIN_9
    
38. #define QSPI_BK1_D1_GPIO_PORT          GPIOF
    
39. 
    
40. #define QSPI_BK1_D2_PIN                GPIO_PIN_7
    ' g6 K% o- j* \6 y* D
41. #define QSPI_BK1_D2_GPIO_PORT          GPIOF
    
42. 
    
43. #define QSPI_BK1_D3_PIN                GPIO_PIN_6
    
44. #define QSPI_BK1_D3_GPIO_PORT          GPIOF
    
45.   根据使用的QSPI命令不同，容量不同等，修改bsp_qspi_w25q256.h头文件
    
46. /* W25Q256JV基本信息 */
    $ A9 W7 f( P5 ?' S. j/ Z
47. #define QSPI_FLASH_SIZE     25                      /* Flash大小，2^25 = 32MB*/
    ! F8 v4 t; V, a' i/ s
48. #define QSPI_SECTOR_SIZE    (4 * 1024)              /* 扇区大小，4KB */
    
49. #define QSPI_PAGE_SIZE      256                        /* 页大小，256字节 */
    7 K$ N- W9 S0 v% l& D' w* |/ x2 l( @
50. #define QSPI_END_ADDR        (1 << QSPI_FLASH_SIZE)  /* 末尾地址 */
    
51. #define QSPI_FLASH_SIZES    32*1024*1024            /* Flash大小，2^25 = 32MB*/
    
52. 
    1 Q3 u$ Z5 r1 t
53. /* W25Q256JV相关命令 */
    
54. #define WRITE_ENABLE_CMD      0x06         /* 写使能指令 */  
    - y2 y- X  {# ^+ C: j
55. #define READ_ID_CMD2          0x9F         /* 读取ID命令 */  
    
56. #define READ_STATUS_REG_CMD   0x05         /* 读取状态命令 */
    & ?& h% p3 k% e6 m' P1 y5 Y
57. #define BULK_ERASE_CMD        0xC7         /* 整个芯片擦除命令 */
      W2 ?! z3 C7 G; f
58. #define SUBSECTOR_ERASE_4_BYTE_ADDR_CMD      0x21    /* 32bit地址扇区擦除指令, 4KB */
    1 @$ b: k! \: q
59. #define QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD    0x34    /* 32bit地址的4线快速写入命令 */
    # ]5 ~6 H6 j( A
60. #define QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD 0xEC    /* 32bit地址的4线快速读取命令 */

复制代码

  第4步：如果使用MDMA方式的话，可以使用TCM RAM，此时不用考虑Cache问题。如果使用的是其它RAM空间，要考虑Cache问题。因为MDMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭读Cache和写Cache，比如使用的AXI SRAM：
  t- o0 J& h3 ]+ j# h/* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
$ P$ b7 L, y: @8 [MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
MPU_InitStruct.BaseAddress      = 0x24000000;
MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
! Z5 k; H9 Z9 ]2 n, nMPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
+ N9 ~; W! A8 p) ]3 |" QMPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
0 a% b" R) D, W0 H/ }: p* v% NMPU_InitStruct.Number           = MPU_REGION_NUMBER0;
6 k7 p, N1 Y4 N8 N1 d9 _MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
. a7 r3 X) N8 q+ M8 ~MPU_InitStruct.SubRegionDisable = 0x00;
, |  U; ?& i: ^) [5 W/ H% m% u, t1 aMPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
! w& P% v" T4 @: j8 ]1 G& k
2 R/ U  x9 e1 S/ I8 L! M7 rHAL_MPU_ConfigRegion(&MPU_InitStruct);
4 p/ O. x! u6 z0 i  ^1 U. k  第5步：初始化QSPI。
/* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
& J4 m& ^1 z6 u4 Ebsp_InitQSPI_W25Q256();  /* 配置SPI总线 */
  第6步：QSPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第7步：应用方法看本章节配套例子即可。
79.7 实验例程设计框架
6 S% w9 R- m. A* _通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
6 d4 R8 {9 D( @; U$ H

  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
  第2阶段，进入main函数：

第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
1 }! q. y/ ~7 t% Q+ S% T/ O 第2部分，应用程序设计部分，实现QSPI Flash的查询和MDMA方式操作。
/ f3 w- r! X: I4 f7 E0 a) B79.8 实验例程说明（MDK）
配套例子：
, c. u9 ^2 q9 h- J( J4 J! d9 T
V7-029_QSPI读写例程，四线DMA方式，读每秒48MB（V1.1）
: m$ l) x0 i7 Z8 }1 }1 P1 I
V7-059_QSPI读写例程，查询方式
; W" g6 p) C5 u7 z9 P9 K+ x/ Y
! x7 t7 [' [" X, @4 p* U% _4 J实验目的：

学习QSPI Flash的读写测试例程
实验操作：
5 |8 [% x- w) e' e
8 w" a: C9 T2 W& a2 g# t支持以下7个功能，用户通过电脑端串口软件发送数字1-6给开发板即可
printf("请选择操作命令:\r\n");
; k6 |! V+ c3 k$ mprintf("【1 - 读QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
' `  c- O- G% n4 W( D: t3 Lprintf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
  e; _2 D  [- B) @* `: Rprintf("【4 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
- w/ o" b) _! p: h* r& O& o8 Gprintf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
! Y, O/ m1 ^* u+ T2 ^printf("其他任意键 - 显示命令提示\r\n");
上电后串口打印的信息：
" j6 Y( M! B' m, o; P. T
" E  x& _& y4 @6 W" i1 v  c2 |波特率 115200，数据位 8，奇偶校验位无，停止位 1。

5 |% j$ ?( O' ^% {; J$ h( t: F  x

程序设计：
! v5 m2 b, Z$ S" G2 r
( Z4 l* f5 N$ |) o6 b: C; J) H& H8 U  系统栈大小分配：
5 X. a, ~' a/ U0 w. {

! i( O& O! w8 e: s9 [
  RAM空间用的DTCM：

1 H" @- f! H( x" Q

. x. C" n5 n+ \' \) G7 O4 H
  硬件外设初始化

, J  x! @( ^. @/ R6 \4 y硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   * W- t4 R! I/ K6 h  a) z9 Z; M$ u
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
     G7 g( o3 g9 W. d# L
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    , a( d/ ]( c0 l* j' o( Q  _) B
11.     /* 配置MPU */
    0 b: n: x% e( P
12.     MPU_Config();
    2 ]" X: o+ m. K4 B
13. 
    
14.     /* 使能L1 Cache */
    - B1 S8 l: m& }; k
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    / N8 h  d. `  [9 s  w2 K1 N8 k
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    7 L8 P' O' ?' J0 M
20.        - 设置NVIV优先级分组为4。
    6 `9 y$ w$ z8 K, x: j
21.      */
    6 T) H3 p% ?- O; z$ Z9 B; |1 R
22.     HAL_Init();
    
23. 
    
24.     /*
    3 z1 U4 X* x% V# O5 {" B
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    ! k& M4 ~) I/ Y) r2 }
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    5 n5 [% u! P. g" Z# e  v/ c
29.     SystemClock_Config();
    
30. 
    + J6 g4 u" s7 S  B4 W; M
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ( V8 Y2 U$ x. j3 C
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ' _5 Z9 L/ H' z
35.     */   
    / W2 ]' B; W) s! @
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    0 Y, F3 y3 p) _. ^2 _& r: O* w
40. #endif
    * J7 E( I. N, A, A& ^: L2 \
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    * C# U7 P; ^( ?5 Z5 F& h* F- n
47.     bsp_InitLed();         /* 初始化LED */   
    5 b/ c# U$ @4 b% n6 D/ z
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. 
    
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    6 M* C  o* [9 C" y
51.     bsp_InitQSPI_W25Q256();  /* 配置SPI总线 */}

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
. q7 i- _4 L5 ]: U

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
     o5 w5 q  w. k. ]
4. *    功能说明: 配置MPU
   5 [3 V) S7 a* N# r
5. *    形    参: 无
   $ ~: l" }+ _2 q3 ^
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   6 w' d* M7 H8 n; k
8. */
   2 ?& W# ]: f6 M7 O* }
9. static void MPU_Config( void )
   - Y2 P  O, T' C6 P$ J
10. {
    8 B/ b9 L9 [& N4 g
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    3 D  N/ }0 D7 W. L4 ^0 T/ K
12. 
    & w* c: D+ h2 c/ E/ \% ~
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    0 E" m& M: O# n7 L
15. 
    + {$ c( E8 z- T7 F) N9 \# j
16. #if 0
    2 n* [3 ]# g0 m9 r& y' G" w
17.        /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    1 B$ A9 M7 h0 d  |) K( e
18.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
19.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
20.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
21.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    5 T& _7 \2 z8 v4 L) }8 Q2 n
22.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    , e* }; W9 c/ e- c$ A1 |, ]: Z
23.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
24.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 n+ N) q; {7 S' F/ |9 p/ I3 {
25.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
26.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
27.     MPU_InitStruct.SubRegionDisable = 0x00;
    / j% @7 q0 M* J( o. p( J5 t
28.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
29. 
    
30.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
31. 
    
32. #else
    ; `" V3 I) Z2 q' d0 X3 q
33.     /* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
    / K. `9 m- L* z8 W% i2 @
34.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ( n) N9 C5 U) U# J2 x; i  Z: L
35.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
36.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
      M# A& C' A& B5 L5 x5 v
37.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , {1 y$ O3 e4 Z9 T/ n* t* s
38.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
39.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    ) t1 o% t& r0 x. j( U$ N
40.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
41.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
42.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
43.     MPU_InitStruct.SubRegionDisable = 0x00;
    . p4 q5 X8 s* C, @; p* ]& n
44.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
45. 
    
46.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
47. #endif   
    
48. 
    8 K8 {, O( h" y2 f1 S
49.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    8 D) G8 f8 R" N: l- O  y
50.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
51.     MPU_InitStruct.BaseAddress      = 0x60000000;
    ! J1 E( }( Q+ J0 j! y
52.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
53.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
54.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : `" I, F. ~; \" F3 ^
55.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
56.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
57.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ! C4 `" P  l8 u+ h9 C
58.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
59.     MPU_InitStruct.SubRegionDisable = 0x00;
    
60.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    2 A4 p7 ~! j7 ~, u% \& O
61. 
      P3 B# v* D5 u, I
62.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    + Q$ [% g. g1 W& x2 O
63. 
      ~7 c. @# p! I2 ~
64.     /*使能 MPU */
    
65.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
66. }
    
67. 
    
68. /*
    & t4 Y. w2 u4 s* J4 T! K
69. *********************************************************************************************************
    
70. *    函 数 名: CPU_CACHE_Enable
    
71. *    功能说明: 使能L1 Cache
    . G4 b8 l+ N# c
72. *    形    参: 无
    
73. *    返 回 值: 无
    , Q8 g9 Y- {$ [6 t6 B
74. *********************************************************************************************************
    
75. */
    
76. static void CPU_CACHE_Enable(void)
    0 q) _! c. W7 d) I, D
77. {
    : [: S! ], Y: Y
78.     /* 使能 I-Cache */
    - J( g$ T6 Y; O: S1 x# S8 E. h
79.     SCB_EnableICache();
    * P, f' c; W. Y$ o: m( O- y
80. 
    
81.     /* 使能 D-Cache */
    
82.     SCB_EnableDCache();
    2 z& t+ {8 w% w' L: S
83. }

复制代码

  每10ms调用一次按键处理：
& o2 ]! f7 G) [% I: b/ J6 {0 R) w, }
) N  D7 f0 Z" v9 }6 m按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   4 `) l. K- ]  s7 {! h  F/ L
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   + X" T" B6 D* g  }
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   6 J7 ?$ B* ~: O  B! E
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
     ]6 N/ {4 l* D; Y4 H& G
7. *    返 回 值: 无
   ! x1 L1 W1 `6 T! w1 q
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    - Y  U9 h+ H" }) C1 J- b/ Z: v1 ^" S% A
11. {
    
12.     bsp_KeyScan10ms();
    0 f% I+ m. L$ p$ y
13. }

复制代码

& a. a; p. S; e  主功能：
* b% K) G5 M+ V: y
# w3 m; V$ [5 G( ?( @! G% n! h8 y1 J主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
6 z5 B3 t6 U4 e  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
( o2 C& [- j& E  printf("【1 - 读QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
  printf("【2 - 写QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
. _1 W0 u$ f+ m  printf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
  printf("【4 - 读整个串行Flash, 测试读速度】\r\n");
$ d" ?* ?8 T8 H0 g+ Z  printf("【Z - 读取前1K，地址自动减少】\r\n");
  printf("【X - 读取后1K，地址自动增加】\r\n");
  printf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
  printf("其他任意键 - 显示命令提示\r\n");

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: QSPI读写例程
   
5. *    形    参：无
   4 i( s' b5 U. H
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void DemoSpiFlash(void)
   
10. {
    
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0, id;
    
13. 
    - k% ?% O( D6 z, y" j" Y
14.     /* 检测串行Flash OK */
    5 i+ p3 o  A) K; r
15.     id = QSPI_ReadID();
    + \7 K% U1 j* j: Q. e) e8 D
16.     printf("检测到串行Flash, ID = %08X, 型号: WM25Q256JV\r\n", id);
    
17.     printf(" 容量 : 32M字节, 扇区大小 : 4096字节, 页大小：256字节\r\n");
    4 W# S3 l; c8 y' S3 J: H$ ~0 _
18. 
    ( y" Y. l. T; ~0 h
19.     sfDispMenu();        /* 打印命令提示 */
    
20. 
    
21.     bsp_StartAutoTimer(0, 200); /* 启动1个200ms的自动重装的定时器，软件定时器0 */
    
22.     while(1)
    * `% c0 j! @) v" g+ P+ F( Q# j' J
23.     {
    % m+ k" e3 }2 E; _3 ^
24.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    7 K6 W3 Q( z5 ?7 M3 _4 Z- ]0 s
25. 
    
26.         /* 判断软件定时器0是否超时 */
    
27.         if(bsp_CheckTimer(0))
    
28.         {
    ; v* P% B8 ^* W$ c
29.             /* 每隔200ms 进来一次 */  
    
30.             bsp_LedToggle(2);
    
31.         }
    
32. 
    
33.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
34.         {
    
35.             switch (cmd)
    
36.             {
    
37.                 case '1':
    8 E! ~2 c) e  j! o
38.                     printf("\r\n【1 - 读QSPI Flash, 地址:0x%X ,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
39.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    
40.                     break;
    
41. 
    
42.                 case '2':
    9 z7 U7 _# j3 p, ~( l, J
43.                     printf("\r\n【2 - 写QSPFlash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    / @* ^+ }9 a: O$ |
44.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    9 t( ]4 ?# m/ p4 m  j+ B$ n
45.                     break;
    ) q. Y! R' B6 L" p
46. 
    
47.                 case '3':
    ' T/ i8 y0 L) ^3 F. H9 y/ S$ i+ j
48.                     printf("\r\n【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
    
49.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
50.                     break;
    
51. 
    
52.                 case '4':
    
53.                     printf("\r\n【4 - 读整个QSPI Flash, %dM字节】\r\n", QSPI_FLASH_SIZES/(1024*1024));
    
54.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
55.                     break;
    " x" f& T' G/ m7 N7 ~1 Y
56. 
    1 {9 q0 o9 h. J: P. y% ^0 n
57.                 case 'y':
    ! c) d& W" \: G: h
58.                 case 'Y':
    
59.                     printf("\r\n【Y - 擦除整个QSPI Flash】\r\n");
    % o/ l7 z0 G# [  j$ D& q) [
60.                     printf("整个Flash擦除完毕大概需要300秒左右，请耐心等待");
    
61.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
62.                     break;
    
63. 
    
64.                 case 'z':
    
65.                 case 'Z': /* 读取前1K */
    
66.                     if (uiReadPageNo > 0)
    % E" x8 p! w+ M$ j/ s
67.                     {
    0 `: E3 Z4 k  Q/ a# H7 @
68.                         uiReadPageNo--;
    
69.                     }
    
70.                     else
    
71.                     {
    6 V# s; h5 x+ y' l) o+ L3 z
72.                         printf("已经是最前\r\n");
    
73.                     }
    
74.                     sfViewData(uiReadPageNo * 1024);
    0 o' I7 s2 C0 {! G% H! p
75.                     break;
    
76. 
    
77.                 case 'x':
    . H+ g& B  F8 F. O
78.                 case 'X': /* 读取后1K */
    
79.                     if (uiReadPageNo < QSPI_FLASH_SIZES / 1024 - 1)
    
80.                     {
    
81.                         uiReadPageNo++;
    5 o- C- {) y, T; ?
82.                     }
    " K; @3 ]; G) B- f' J
83.                     else
    
84.                     {
    
85.                         printf("已经是最后\r\n");
    * x0 |  [: G5 ~: q/ J
86.                     }
    , f" \8 F% q( c7 o, Z
87.                     sfViewData(uiReadPageNo * 1024);
    
88.                     break;
    
89. 
    & w5 @( T6 y3 x$ S' @
90.                 default:
    
91.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
92.                     break;
    1 @$ Z9 J1 r% \
93.             }
    # _# z) Y9 W  N, Z
94.         }
    ! T5 a0 O* q  H9 J
95.     }
    ; V+ P4 U; ], J% U* X9 \2 c  i; |
96. }

复制代码

, Q4 B/ G6 R0 o& x2 }1 T79.9 实验例程说明（IAR）
8 q( r- x  c( }配套例子：
, c4 S- Z* z) w
V7-029_QSPI读写例程，四线DMA方式，读每秒48MB（V1.1）
3 E" H* P) Z2 i8 ]& n7 ~, x" k- H4 p
; q# _  D, c9 H4 \V7-059_QSPI读写例程，查询方式
  p3 f: o/ w' V4 D. Z
# Z# s0 w/ G1 v实验目的：

学习QSPI Flash的读写测试例程
实验操作：

支持以下7个功能，用户通过电脑端串口软件发送数字1-6给开发板即可
printf("请选择操作命令:\r\n");
6 v) B: k  t9 d5 A+ i3 Iprintf("【1 - 读QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
2 W0 [7 ]; g* dprintf("【2 - 写QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
3 A3 ^# `6 Q) r- o: {4 nprintf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
printf("【4 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
7 q6 ?  h% A* Uprintf("【X - 读取后1K，地址自动增加】\r\n");
printf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
; ]$ X3 m$ n/ w, `3 g+ F# Tprintf("其他任意键 - 显示命令提示\r\n");
上电后串口打印的信息：
" Y5 j- V. L$ ?- x( |
  d+ p: n/ T4 Y5 b- _1 u+ F' R波特率 115200，数据位 8，奇偶校验位无，停止位 1。
9 k. o) X2 o, ]9 f9 ~

& P6 \* F7 }5 Q) {+ p
9 z+ \' e5 F" l+ {程序设计：

: [9 }) ]! n9 G5 h4 ]3 ?  系统栈大小分配：
3 U6 F1 T% K, }1 {) S8 @/ K
( l4 ?; ^5 Q& J

4 @8 ~" r% i3 x  RAM空间用的DTCM：

6 ?9 i5 Z7 k- @/ l, d: f
9 w2 P5 D% P' v" K  硬件外设初始化
9 h9 F" L5 S' _- k- A
4 N  p9 @8 s2 n! R+ g) b+ `硬件外设的初始化是在 bsp.c 文件实现：
& L: n5 @9 R, b# Q0 f+ V) L  ]

1. /*
   
2. *********************************************************************************************************
   8 G' l" L; B" [  |% `. X/ D/ r
3. *    函 数 名: bsp_Init
   ! [9 S  ~8 a+ u1 p
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   + v/ p! z! v- Z( q4 h2 t/ r+ P
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   1 a* z  W- _& [, r7 }
8. */
   
9. void bsp_Init(void)
   1 Z. l: T% w3 W/ e
10. {
    3 F) F: i2 F; R8 N
11.     /* 配置MPU */
    / {' O6 u1 J, ^( ^. i
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    # g( ^$ r* m6 w! ~3 d9 r  {6 V* w: a
16. 
    
17.     /*
    . }; A6 i* Y( o# I4 {2 L. E* n
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    3 _8 L+ X3 j2 @& r  e, j1 h. x
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    1 ?9 \: W4 G4 ~3 q2 j
23. 
    
24.     /*
    ! _; w$ \0 l: s: n' Z6 w5 q
25.        配置系统时钟到400MHz
    # S7 X" k& D* ]$ l
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    6 W4 b* l% X: P" [
29.     SystemClock_Config();
    $ C; a. u& e5 i8 A; {
30. 
    3 q+ @6 G1 ?( B( z4 u4 n! o. z
31.     /*
    . `% {+ }$ ]* q% y& S, m. R
32.        Event Recorder：
    ) G( ~) ]' t" z! I9 Q0 ~3 M
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    & N& Q) {- }3 T
36. #if Enable_EventRecorder == 1  
    7 @+ G" B; \+ Y4 h9 F  `
37.     /* 初始化EventRecorder并开启 */
      U" ?# e2 C2 Z4 ~7 n- R
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    2 r: _) `9 Z, W& o$ @+ T4 q% G2 n
40. #endif
    ; d& w$ b& c# f0 j: f* J9 I; }$ l
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    0 ?0 ^/ v; q  J
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    1 B- Z3 C7 Z  j; P; l
45.     bsp_InitLPUart();     /* 初始化串口 */
    ! \. l# n5 r# K& z7 k0 [
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();         /* 初始化LED */   
    * E5 o2 R3 M: Q1 @# x
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. 
    ; {6 n) v* J. P4 H1 s& b7 v' a, q
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    : ?& {7 M, F7 B/ a9 S9 i
51.     bsp_InitQSPI_W25Q256();  /* 配置SPI总线 */}

复制代码

  MPU配置和Cache配置：
6 k; Q, k, _2 \7 Z) }5 ^
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
4 |9 B. s* _9 ?' Q/ X- U& }) N: E( u3 g

1. /*
   4 Q6 c6 L7 [- t+ A8 h
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   7 F, f; c$ p' H2 I2 \& y5 b$ ~
4. *    功能说明: 配置MPU
   2 d" ^4 M- t6 n7 Z& R" A# H" g
5. *    形    参: 无
   % Q  }+ D# i1 h. j- L; U
6. *    返 回 值: 无
   ! O4 y2 h! B8 X5 I% d+ S
7. *********************************************************************************************************
   
8. */
   1 J0 b3 f) n: z' a4 X
9. static void MPU_Config( void )
   & S( L% A# h) N* E) v0 H9 `
10. {
    $ }* }# \# Z, ^9 C& m2 b0 \
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    ' A/ E- U" X/ K9 w+ P! @; H
12. 
    ' C% t7 b7 ]9 h; S4 H6 |: N
13.     /* 禁止 MPU */
    0 r$ ?) c1 N! O, p3 V9 S8 Y
14.     HAL_MPU_Disable();
    
15. 
    
16. #if 0
    
17.        /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
18.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    $ G2 ]( p5 j" x( G% F
19.     MPU_InitStruct.BaseAddress      = 0x24000000;
    ! r8 @" `' I0 V' d
20.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    * b. C2 w5 ]" Q/ }: o1 h
21.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
22.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & K7 f7 r" m6 n; _2 l" ]
23.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
24.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
25.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    $ ~. c( Y3 e/ T% }
26.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    / k! J2 J, o( s1 G: V0 z+ J6 ^
27.     MPU_InitStruct.SubRegionDisable = 0x00;
    
28.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
29. 
    ' n8 C( U  o* M% A" @$ T
30.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
31. 
    
32. #else
    3 o! x) S: i7 a7 [
33.     /* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
    
34.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    0 B. ^, ?6 D. ?; P, ~; g+ o) d5 A
35.     MPU_InitStruct.BaseAddress      = 0x24000000;
    5 s/ x% [$ \' `: e
36.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    : ?* Y) l+ T6 N: E9 d: N
37.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
38.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
      _9 K, e6 l0 Z2 T) ?7 e. U
39.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    ) m% M  t; V" @2 l
40.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
41.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    - _7 M! `, T" C/ n/ f7 x4 C0 ^
42.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    6 k. S+ D6 E! H( e4 c2 h
43.     MPU_InitStruct.SubRegionDisable = 0x00;
    # @. P$ c6 L' d! y1 \
44.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
45. 
    
46.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    " ^: S9 s9 w3 a
47. #endif   
    ) ^; s3 Z0 m$ E6 W! S$ R) a- }
48. 
    
49.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    4 q9 I/ {. r$ d3 {; x: R" s
50.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ( W- x* \6 O2 ~' O$ F, R, G0 {( Q
51.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
52.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
53.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 [* I& T( H4 i2 Y8 I
54.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    . }# B3 `) C0 O* N
55.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    - B* L4 @$ H- i" \) t, @& H
56.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    $ F9 u( t, e% o4 C- i# [
57.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    4 f: U. A. T; L
58.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ( W1 C9 F# y' c, ~
59.     MPU_InitStruct.SubRegionDisable = 0x00;
    / `0 b0 Y% G3 X8 H( @" F! A
60.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
61. 
    : t# K% x7 R1 W( a/ G8 D  D
62.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 T, Z7 M2 e' ~/ j; H  n+ M2 d" @
63. 
    0 ^4 V" K! q5 V5 L& e+ T( V+ \8 ]
64.     /*使能 MPU */
    
65.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    6 C5 Q3 k: W  u; J  Z9 M7 H! |* H
66. }
    
67. 
    
68. /*
    - U% k$ R/ w5 W$ e% P7 K. {
69. *********************************************************************************************************
    4 H& ]! Z( {1 k+ Z/ e; r
70. *    函 数 名: CPU_CACHE_Enable
    ; ^" m9 Z5 _# h4 K: K% U" k
71. *    功能说明: 使能L1 Cache
    4 }. ?' o6 F/ X+ i0 e" E) I
72. *    形    参: 无
    
73. *    返 回 值: 无
    4 f8 [5 h7 W5 c
74. *********************************************************************************************************
    
75. */
    ) }, ]! }% [$ h$ I
76. static void CPU_CACHE_Enable(void)
    
77. {
    
78.     /* 使能 I-Cache */
    % u' P* i: E$ l" U, o$ Z) w5 E
79.     SCB_EnableICache();
    
80. 
    ) r+ n. [; M7 d( E) [
81.     /* 使能 D-Cache */
    & Z$ Y1 a* z$ [1 q4 n/ T
82.     SCB_EnableDCache();
    % ]! I5 j. K/ C, q) A( T+ t5 f
83. }

复制代码

  每10ms调用一次按键处理：

按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。
/ D9 H* F3 J0 ^' x3 Q

1. /*
   - D$ j: K- _" i" `6 m/ W
2. *********************************************************************************************************
   4 [/ F6 l, M- P- _* ^, I( Q
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   & c/ r; ], ]: N" W5 j) ]+ O6 P
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   ; B- ^: `0 a3 M8 x- Y* n
6. *    形    参: 无
   . _) x! w3 [- _- l
7. *    返 回 值: 无
   ' }1 B6 c" ?3 }* }9 c8 |: s. n
8. *********************************************************************************************************
   / J+ }7 u% H1 `, r5 T- g' @/ m
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    
13. }

复制代码

1 q% ^$ m: ]; m7 u! f7 S  主功能：

0 L: O7 N0 m3 n# W& s0 u6 W$ ?* S主程序实现如下操作：

2 Y2 |2 b% p9 j( B# K  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
* A3 q# |6 Q7 S: b( H: [* V# K. C  printf("【1 - 读QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
7 O" A) S7 A- U% E  printf("【2 - 写QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
  printf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
9 k% Y3 J1 o1 b% {  }  printf("【4 - 读整个串行Flash, 测试读速度】\r\n");
  printf("【Z - 读取前1K，地址自动减少】\r\n");
$ K* D1 o# `1 Z( h3 s  printf("【X - 读取后1K，地址自动增加】\r\n");
" A) G, Y2 Z) |# d% z) T# e  printf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
7 `) R* i% v0 N, L  printf("其他任意键 - 显示命令提示\r\n");

1. /*
   
2. *********************************************************************************************************
   6 {1 p) S  U$ H2 w! N1 E" O: a
3. *    函 数 名: DemoSpiFlash
   ( a; u0 N0 d' B' v% q
4. *    功能说明: QSPI读写例程
   % t) g/ S& M( r' O
5. *    形    参：无
   , G8 A9 @" g$ k) _& ]0 H
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void DemoSpiFlash(void)
   
10. {
    & k6 s( N' q5 R; Y& ]5 y! l& F
11.     uint8_t cmd;
    . o" m. F, y1 u, h! R( o5 p4 s
12.     uint32_t uiReadPageNo = 0, id;
    
13. 
    . D8 W% d; @2 l0 j& F! p( a
14.     /* 检测串行Flash OK */
    5 n' C; [3 K. K& A
15.     id = QSPI_ReadID();
    
16.     printf("检测到串行Flash, ID = %08X, 型号: WM25Q256JV\r\n", id);
    
17.     printf(" 容量 : 32M字节, 扇区大小 : 4096字节, 页大小：256字节\r\n");
    
18. 
    ( K% _5 w; J9 `7 }2 Q
19.     sfDispMenu();        /* 打印命令提示 */
    / x- I( M1 y) q6 }* S8 `" i7 l
20. 
    
21.     bsp_StartAutoTimer(0, 200); /* 启动1个200ms的自动重装的定时器，软件定时器0 */
    
22.     while(1)
    * [, [7 n: c' |' [
23.     {
    
24.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ( M% n2 h& z' M' |
25. 
    + [- Y' l" M: @  c" \
26.         /* 判断软件定时器0是否超时 */
    + |, e) f3 b- r3 G, q2 a9 Q% O
27.         if(bsp_CheckTimer(0))
    $ i6 V9 R! O7 o5 t% t2 s
28.         {
    7 w; }8 j  p. t- ?
29.             /* 每隔200ms 进来一次 */  
    9 o8 y+ t5 b; a) ?, C
30.             bsp_LedToggle(2);
    # P+ `8 z% i2 `& K# {
31.         }
    
32. 
    / R+ Q; h) m0 r1 u
33.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    / }! t4 s2 s2 k- i) v# a
34.         {
    5 A( ^0 f4 g, T6 j+ j' p5 V
35.             switch (cmd)
    
36.             {
    % j9 S, F% D9 b% }2 O
37.                 case '1':
    : F2 ]1 w- g6 T5 a; t/ a+ }
38.                     printf("\r\n【1 - 读QSPI Flash, 地址:0x%X ,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    4 X# B; Q$ p$ s* e* ]
39.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    ; c) _) B; [7 ]- J  A9 z5 X5 [$ @  d
40.                     break;
      ]4 A+ c3 g: u9 ^+ T
41. 
    
42.                 case '2':
    
43.                     printf("\r\n【2 - 写QSPFlash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
44.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    ( }. H' W/ l" i! w) v
45.                     break;
    9 G% f- K" N7 R! {- z% }
46. 
    7 ?7 m+ j0 W- |) f" {2 Q; R
47.                 case '3':
    
48.                     printf("\r\n【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
    5 a$ J( }! N6 u  A& y
49.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
50.                     break;
    
51. 
    
52.                 case '4':
    9 k. t/ }" r) }$ i* Y
53.                     printf("\r\n【4 - 读整个QSPI Flash, %dM字节】\r\n", QSPI_FLASH_SIZES/(1024*1024));
    2 C7 d3 x, l, P5 a6 I0 V, X- |+ S; |
54.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
55.                     break;
    
56. 
    
57.                 case 'y':
    - f* K! K! Z4 Q
58.                 case 'Y':
    2 Q: u6 y! w+ V9 _2 ^, V- y
59.                     printf("\r\n【Y - 擦除整个QSPI Flash】\r\n");
    
60.                     printf("整个Flash擦除完毕大概需要300秒左右，请耐心等待");
    4 j) _- c. ~" s9 M. n( f* u$ U
61.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    + v+ f5 e" {. u6 y( L
62.                     break;
    6 U0 I0 @! M( }- M- d/ M
63. 
    
64.                 case 'z':
    ' W8 ]8 b# |/ s0 j0 Z# p. h
65.                 case 'Z': /* 读取前1K */
    
66.                     if (uiReadPageNo > 0)
    2 Z$ ~4 z# |- I9 T
67.                     {
    , @$ i8 S4 [- T( T* g0 k
68.                         uiReadPageNo--;
    
69.                     }
    
70.                     else
    
71.                     {
    * I# U" ?9 u, a/ w8 z( e5 ^. ?& B
72.                         printf("已经是最前\r\n");
    3 v3 C; h8 B3 g
73.                     }
    : z* }/ D' n$ {" h* B! L
74.                     sfViewData(uiReadPageNo * 1024);
    
75.                     break;
    
76. 
    7 g$ L; C$ c) E: \( [# T
77.                 case 'x':
    
78.                 case 'X': /* 读取后1K */
    $ ]5 a9 @3 {3 w2 _; [. n1 Q( k
79.                     if (uiReadPageNo < QSPI_FLASH_SIZES / 1024 - 1)
    
80.                     {
    " }3 h' d/ o" v4 K
81.                         uiReadPageNo++;
    4 {# P7 p5 ~+ m# o) Y2 l1 [1 S
82.                     }
    , y. E( J& B) M5 D9 ]$ r
83.                     else
    - m1 {3 C$ r  K" ^  O# ?
84.                     {
    6 U* T# T! {- O/ G: L/ O
85.                         printf("已经是最后\r\n");
    ' j6 m/ f) O- j6 Q! q
86.                     }
    
87.                     sfViewData(uiReadPageNo * 1024);
    # R2 z8 Y' ?9 S6 G
88.                     break;
    
89. 
    7 `- |* l/ m  `* v1 g
90.                 default:
    
91.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    ' {' W, o% v; H- y) g4 `
92.                     break;
    
93.             }
    
94.         }
    
95.     }
    # t- N+ m. |) B8 O& v; J
96. }

复制代码

79.10   总结
6 M; v4 i; I) p- Y: w9 M4 k7 G  n本章节就为大家讲解这么多，实际应用中根据需要选择DMA和查询方式。
2 U. v3 U6 }  i2 @+ o
# u* j( x% G% q# ]8 J