79.1 初学者重要提示
; _( |0 Q9 O) Z: d 1、 学习本章节前，务必优先学习第79章。

2、 W25Q256JV属于NOR型Flash存储芯片。
5 _- |7 y) Z6 N0 O
3、 W25Q256JV手册下载地址。

$ x2 K1 w% a5 h 4、 本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。
8 p3 I' H+ p8 G+ g9 ^
5、 对QSPI Flash W25Q256JV的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。
9 F- E; V  @( e) R1 Y) u
% D: b( b2 W) T+ }/ e* p2 x 6、 W25Q256JV最高支持133MHz。

! h2 F# Q# o- E& y 7、 STM32H7驱动QSPI Flash的4线DMA模式，读速度48MB/S左右。

. I* E1 d* ~( |0 Q, D, v" L6 P 8、 内存映射模式下，最后一个字节无法正常读取的解决办法。

3 U# h! n: q% u# P. F 9、 本章配套例子的DMA是采用性能最强的MDMA。

/ j* O( Y1 t# Q' n79.2 W25QXX硬件设计
( T- Y; o& `* h/ @$ a) SSTM32H7驱动W25Q256JV的硬件设计如下：
" V1 Y% `- e/ z  \# c

% B& ^' D0 O; c! w% i关于这个原理图，要了解到以下几个知识：
3 b- a5 C6 L# k6 t/ O* }# c
  V7开发板实际外接的芯片是W25Q256JV。
! X; A& Q# U, j0 Y' c# E* P3 |7 [  CS片选最好接上拉电阻，防止意外操作。
+ n7 O. R' v3 X  W25Q256的WP引脚用于写保护，低电平有效性，当前是将其作为4方式的IO2。
  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。当前是将其作为4线方式的IO3。
79.3 W25QXX关键知识点整理（重要）
驱动W25QXX前要先了解下这个芯片的相关信息。

1 ?7 j* l3 T$ ~. N& j

# t- n  Z' G" i( A
( `$ S) G0 A2 I1 x9 z79.3.1 W25QXX基础信息
2 V% J+ v/ u3 F7 E) P  W25Q256JV是32MB（256Mbit）。
  W25Q256JV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
支持两线SPI，用到引脚CLK、CS、IO0、IO1 。

, K$ G; Z) A( y5 ^支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。

  T7 ?$ _( k6 f; @/ h+ h% h- H1 a（注：这里几线的意思是几个数据线）。

  W25Q256JV支持的最高时钟是133MHz。
5 }- U* L3 V4 u* ?% u  每个扇区最少支持10万次擦写，可以保存20年数据。
  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
; E4 F; ], T6 Z8 b4 E整体框图如下：
, C" |: V' x/ y, |0 t6 l
8 X  Z, a$ p5 D  }

  U( c2 q( o8 i' a& d" L
) l9 \3 w: H% R! V- g5 RW25Q256JV：

  有512个Block，每个Block大小64KB。
, u: |8 a/ L8 W4 j. t+ ^* |  每个Block有16个Sector，每个Sector大小4KB。
3 Y" {4 L& U+ k' x0 _! t  每个Sector有16个Page，每个Page大小是256字节。
79.3.2 W25QXX命令
使用W25Q256的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的QSPI，即4线SPI，并且用的4字节地址模式，使用的命令如下：
# `6 B. `/ N( z" B

1 Z: u. ?& e5 j9 Q

* f) F' v: T7 W" z* W! r3 J- |
当前主要用到如下几个命令：
6 L% T8 k; a& r0 W0 X

1. #define WRITE_ENABLE_CMD      0x06         /* 写使能指令 */  
   9 o) R' P, w0 s0 w' R4 Z! E
2. #define READ_ID_CMD2          0x9F         /* 读取ID命令 */  
   9 a6 l/ y) {0 f- }% N, W
3. #define READ_STATUS_REG_CMD   0x05         /* 读取状态命令 */
   
4. #define BULK_ERASE_CMD        0xC7         /* 整个芯片擦除命令 */
   
5. #define SUBSECTOR_ERASE_4_BYTE_ADDR_CMD      0x21    /* 32bit地址扇区擦除指令, 4KB */
   * h; A- Y0 Q( B9 }1 G
6. #define QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD    0x34    /* 32bit地址的4线快速写入命令 */
   3 D9 f) }% T0 g; U2 X! u9 @3 \- k
7. #define QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD 0xEC    /* 32bit地址的4线快速读取命令 */

复制代码

! K$ Z; j5 `( m: v2 [79.3.3 W25QXX页编程和页回卷
9 g) ^: p% Q  TSPI Flash仅支持页编程（页大小256字节），所有其它大批量数据的写入都是以页为单位。这里注意所说的页编程含义，页编程分为以下三步（伪代码）：
5 L, T8 b3 J3 A/ n
% ?5 ~' ~1 q+ T4 b$ ^  A

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   5 v% d$ o5 T! l1 ^" q. A
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   5 m. c6 ~+ t: g( P- h
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   
5. 
   
6.     for (i = 0; i < _usSize; i++)
   
7.     {
   $ {3 k/ W4 O  {. r% t2 d! d9 c
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   / W4 O0 R2 ^  \9 M( i
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   2 c( o, \8 N- l
10.     }

复制代码

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

$ _. I: M4 O  ^- g& R! N比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：
" y2 e8 ~: O# v7 \& |
* u2 i/ w1 o# d5 }9 e$ c

1. uint8_t tempbuf[10] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00};
   ) o) D# @$ l- i: O8 |4 D7 D; i& b' C- `
2. uint8_t temp1 = 0x10, temp2 = 0x29, temp3 = 0x48;

复制代码

; p' p! ^7 q/ h; {. W; h  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。
9 W, q" F. o. E: ~

) r9 O, S# o5 O4 R0 ]: y2 o79.3.4 W25QXX扇区擦除
SPI Flash的擦除支持扇区擦除（4KB），块擦除（32KB或者64KB）以及整个芯片擦除。对于扇区擦除和块擦除，使用的时候要注意一点，一般情况下，只需用户给出扇区或者块的首地址即可。

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

79.3.5 W25QXX规格参数
这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：
* t) @* y8 K) t( D: E: |

# i& T) g5 k# n$ Q. }* |

  页编程时间：典型值0.4ms，最大值3ms。
1 E# d/ q& U) M+ s4 C& d  J# h  扇区擦除时间（4KB）：典型值50ms，最大值400ms。
, |& n- j  o3 P( I" H  块擦除时间（32KB）：典型值120ms，最大值1600ms。
. I0 V/ L0 I8 d  块擦除时间（64KB）：典型值150ms，最大值2000ms。
  整个芯片擦除时间：典型值80s，最大值400s。
* k; r! t# s  ?4 B" u
支持的速度参数如下：

9 z4 l$ {/ [" q; j可以看到最高支持的读时钟（使用命令03H）速度是50MHz，其它命令速度可以做到133MHz。
+ K, J: q0 v( V9 \: e) h4 z( n% V
79.4 W25QXX驱动设计
W25QXX的程序驱动框架设计如下：

% G' a+ R' R7 W* a6 u2 ?
1 V: L( d9 f4 {; H有了这个框图，程序设计就比较好理解了。

* l$ j+ _* ]4 W79.4.1 第1步：QSPI总线配置
7 b) W' V* T- KQSPI总线配置如下：
, H6 ?1 m( p, n# M) X5 _

1. /*
   " t, ?0 [/ v0 k# S8 N0 M* ]# }7 @
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_InitQSPI_W25Q256
   * n% P' h+ X5 y: k& w8 M. h" h
4. *    功能说明: QSPI Flash硬件初始化，配置基本参数
   5 r1 I5 Q7 C; e, g4 a5 X
5. *    形    参: 无
   8 |, R) ~; ^- \2 A. E
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitQSPI_W25Q256(void)
   
10. {
    
11.     /* 复位QSPI */
    
12.     QSPIHandle.Instance = QUADSPI;
    
13.     if (HAL_QSPI_DeInit(&QSPIHandle) != HAL_OK)
    / F. S! ^$ _8 z; w: k$ _
14.     {
    6 Q' V9 @" p6 y5 D
15.         Error_Handler(__FILE__, __LINE__);
    + |. u6 m7 d* e, I4 a' C
16.     }
    ) N5 p- K1 z- q8 ^% y5 Y" \
17. 
    
18.     /* 设置时钟速度，QSPI clock = 200MHz / (ClockPrescaler+1) = 100MHz */
    " N; A' P: P6 e# l, a* X  K
19.     QSPIHandle.Init.ClockPrescaler  = 1;  
    $ q# d# [. P; I7 {- y
20. 
    
21.     /* 设置FIFO阀值，范围1 - 32 */
    
22.     QSPIHandle.Init.FifoThreshold   = 32;
    
23. 
    4 Z8 v1 l8 @  b7 L7 C, v
24.     /*
    
25.         QUADSPI在FLASH驱动信号后过半个CLK周期才对FLASH驱动的数据采样。
    5 d) s7 t) C$ v6 {1 j* ]
26.         在外部信号延迟时，这有利于推迟数据采样。
    
27.     */
    
28.     QSPIHandle.Init.SampleShifting  = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
    4 T9 z0 b; ?' w1 ~  f& l# x
29. 
    
30.     /*Flash大小是2^(FlashSize + 1) = 2^25 = 32MB */
    % f! c* e; Q! V  |5 ~
31.     //QSPI_FLASH_SIZE - 1; 需要扩大一倍，否则内存映射方位最后1个地址时，会异常。
      Q1 E, Y! a1 F/ w) w
32.     QSPIHandle.Init.FlashSize       = QSPI_FLASH_SIZE;
    * ^0 o+ B9 Q, n2 ~% T; ^! m# X( `! v  u8 V
33. 
    
34.     /* 命令之间的CS片选至少保持2个时钟周期的高电平 */
    
35.     QSPIHandle.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_2_CYCLE;
    ) W, K: v/ K' A4 V; t0 r; P
36. 
    * N& S: b2 o, ]  p* D5 E: c
37.     /*
    
38.        MODE0: 表示片选信号空闲期间，CLK时钟信号是低电平
    
39.        MODE3: 表示片选信号空闲期间，CLK时钟信号是高电平
    & j% H) R- h5 {: S6 B
40.     */
    
41.     QSPIHandle.Init.ClockMode = QSPI_CLOCK_MODE_0;
    
42. 
    8 K& ~8 C6 B" u$ W) i
43.     /* QSPI有两个BANK，这里使用的BANK1 */
    
44.     QSPIHandle.Init.FlashID   = QSPI_FLASH_ID_1;
    " `$ [& F: l5 t" ]
45. 
    ' `) u9 o3 O7 i$ b, v/ f
46.     /* V7开发板仅使用了BANK1，这里是禁止双BANK */
    ' I, ?0 R" C4 q
47.     QSPIHandle.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
    ! W( J  u' `3 @; y) e
48. 
    
49.     /* 初始化配置QSPI */
    8 ^8 R) c* q* T6 {6 I& D1 T+ _) F
50.     if (HAL_QSPI_Init(&QSPIHandle) != HAL_OK)
    
51.     {
    
52.         Error_Handler(__FILE__, __LINE__);
    
53.     }   
    
54. }

复制代码

# P. b- j5 Y* ~2 Q7 O2 LQSPI这部分配置，要特别注意Flash大小的设置，这里做了特别处理，本来是应该填入QSPI_FLASH_SIZE-1，而我们实际上填入的是QSPI_FLASH_SIZE，主要是因为内存映射模式下，最后一个字节访问有问题。
0 R* C( R( \* s7 [
5 P7 ]3 W5 q) @8 Y; u6 Z4 L79.4.2 第2步：QSPI总线的查询和MDMA方式设置
4 m; `4 G# D7 Y3 i本章提供了QSPI Flash的查询和MDMA两种方式的例子，驱动的区别是调用的API不同，查询方式调用的API是HAL_QSPI_Transmit和HAL_QSPI_Receive，而DMA方式使用的API是HAL_QSPI_Transmit_DMA和HAL_QSPI_Receive_DMA。
# _- Q$ Y& w2 v1 b3 t
* J' C( S* _" L  ]2 k( o4 h0 J' H79.4.3 第3步：W25QXX的读取实现
9 d6 z- j. v( Z5 H4 n8 l9 B  @8 U注：这里以查询方式的API进行说明，DMA方式是一样的。
& b% m- E. S+ K) o& u2 M  W
# h" _0 x1 a% W9 w# A# nW25QXX的读取功能是发送的4线快速读取指令0xEC，设置任意地址都可以读取数据，只要不超过芯片容量即可（如果采用的DMA方式，限制每次最大读取65536字节）。

1 a; n' P! |3 B0 J

1. /*
   8 f+ h4 k2 d8 U- ], n9 X  u
2. *********************************************************************************************************
   
3. *    函 数 名: QSPI_ReadBuffer
   + [, }+ e5 ]' e1 I( p* O: a# x
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   
5. *    形    参: _pBuf : 数据源缓冲区。
   . O; {$ P( L* N) q: e- l
6. *              _uiReadAddr ：起始地址。
   
7. *              _usSize ：数据个数, 可以大于PAGE_SIZE, 但是不能超出芯片总容量。
   
8. *    返 回 值: 无
   / t6 N/ T/ H  @" Y1 P! g
9. *********************************************************************************************************
   
10. */
    ( _8 q7 U3 w0 V  D# J
11. void QSPI_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    
12. {
    9 O# f7 ^0 P" ^) F; V9 A2 K
13. 
    
14.     QSPI_CommandTypeDef sCommand = {0};
    
15. 
    $ E: O1 z" _  J1 K
16. 
    
17.     /* 基本配置 */
    
18.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;        /* 1线方式发送指令 */
    
19.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;          /* 32位地址 */
    
20.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;      /* 无交替字节 */
    
21.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;          /* W25Q256JV不支持DDR */
    
22.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;      /* DDR模式，数据输出延迟 */
    
23.     sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;        /* 每次传输要发指令 */   
    
24. 
    2 l5 o* X- W$ L) _
25.     /* 读取数据 */
    7 q& y: x# ]# H5 ?( n' e
26.     sCommand.Instruction = QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD; /* 32bit地址的4线快速读取命令 */
    
27.     sCommand.DummyCycles = 6;                    /* 空周期 */
    
28.     sCommand.AddressMode = QSPI_ADDRESS_4_LINES; /* 4线地址 */
    9 F6 l( U0 i# ~) O
29.     sCommand.DataMode    = QSPI_DATA_4_LINES;    /* 4线数据 */
    0 G- [6 J3 [( B- C9 b
30.     sCommand.NbData      = _uiSize;              /* 读取的数据大小 */
    
31.     sCommand.Address     = _uiReadAddr;          /* 读取数据的起始地址 */
    : h, t' s  w3 P6 X4 i
32. 
    - d: ~5 i7 `2 }9 U
33.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    9 g" n1 |8 n: H) E' B+ }$ z
34.     {
    * o" Z7 |4 j6 ~$ n9 X5 f! ?
35.         Error_Handler(__FILE__, __LINE__);
    
36.     }
    
37. 
    
38.     /* 读取 */
    3 u5 g* L" R  @6 p) w2 A/ h2 {
39.     if (HAL_QSPI_Receive(&QSPIHandle, _pBuf, 10000) != HAL_OK)
    7 J& Q. c$ t4 q
40.     {
    0 R7 ~( E- Q/ F
41.         Error_Handler(__FILE__, __LINE__);
    
42.     }   
    1 E  P4 S3 U9 v! Z0 [. L" A1 i, G
43. }

复制代码

5 ^: \8 U) x: ~1 z  J此时函数使用的指令0xEC对应的W25Q256JV手册说明，注意红色方框位置：

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

! y6 o5 p. `4 n  WsCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
1 n  t" z9 e' n& T2 ksCommand.AddressMode = QSPI_ADDRESS_4_LINES;
sCommand.AddressSize = QSPI_ADDRESS_32_BITS;
sCommand.DataMode = QSPI_DATA_4_LINES;

) z) C6 B& H4 N3 s79.4.4 第4步：W25QXX的编程实现
$ C3 I6 N& k/ f( C1 _3 C6 h( L注：这里以查询方式的API进行说明，DMA方式是一样的。

下面实现了一个页编程函数：
/ k8 i, Y2 e: f* \% [* T1 g, h4 Q
( A: M0 j; M# o3 {* Q

1. /*
   : `: c1 P9 J+ i- m1 M, h) e9 f/ Y
2. *********************************************************************************************************
   * n7 |1 L1 T5 B$ l2 z% C6 _
3. *    函 数 名: QSPI_WriteBuffer
   
4. *    功能说明: 页编程，页大小256字节，任意页都可以写入
   ' S9 b9 E" ~* ~& h
5. *    形    参: _pBuf : 数据源缓冲区；
   
6. *              _uiWriteAddr ：目标区域首地址，即页首地址，比如0， 256, 512等。
   
7. *              _usWriteSize ：数据个数，不能超过页面大小，范围1 - 256。
   5 z0 Z7 P+ m$ d" [2 e3 K: g9 D
8. *    返 回 值: 1:成功， 0：失败
   4 a% S2 `( c( d3 U
9. *********************************************************************************************************
   , i9 E  j6 |1 b3 q! U- O
10. */
    
11. uint8_t QSPI_WriteBuffer(uint8_t *_pBuf, uint32_t _uiWriteAddr, uint16_t _usWriteSize)
    
12. {
    
13.     QSPI_CommandTypeDef sCommand={0};
    % t; p* n% F9 n3 X( i) i
14. 
    ( b- I( r# X2 y' V) O" p1 U" U7 h/ R+ L
15.     /* 写使能 */
    
16.     QSPI_WriteEnable(&QSPIHandle);   
    
17. 
    * H4 d$ Q7 t$ B" @, T& T! Q
18.     /* 基本配置 */
    6 _! \5 |% X. W& e/ Y9 Y
19.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;    /* 1线方式发送指令 */
    
20.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;       /* 32位地址 */
    4 u8 ]; `9 g2 v% J, Y# a
21.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    1 w, v9 y  W# _  ]
22.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;      /* W25Q256JV不支持DDR */
    ( O, k- Y3 }$ _; d" L" [9 s" Y
23.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;  /* DDR模式，数据输出延迟 */
    0 D) q! i, x9 Q2 v& F6 s8 ?" E
24.     sCommand.SIOOMode          = QSPI_SIOO_INST_ONLY_FIRST_CMD;     /* 仅发送一次命令 */   
    
25. 
    * ]8 X! z# Y' b7 }; [
26.     /* 写序列配置 */
    5 o5 V( Q; b6 Z3 B
27.     sCommand.Instruction = QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD; /* 32bit地址的4线快速写入命令 */
    
28.     sCommand.DummyCycles = 0;                    /* 不需要空周期 */
    
29.     sCommand.AddressMode = QSPI_ADDRESS_1_LINE;  /* 4线地址方式 */
    ( s: r" R3 X1 b* Q6 E5 s5 f
30.     sCommand.DataMode    = QSPI_DATA_4_LINES;    /* 4线数据方式 */
    
31.     sCommand.NbData      = _usWriteSize;         /* 写数据大小 */   
    , ]( ]! F8 q  M: N+ S' w. V* i0 G
32.     sCommand.Address     = _uiWriteAddr;         /* 写入地址 */
    ' J* T8 G% U0 p) s3 c! ?5 _
33. 
    
34.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    
35.     {
    ( Z6 Y! S, K" J
36.         //return 0;
    3 Q2 l; e4 Y) p. h: R
37.         Error_Handler(__FILE__, __LINE__);
    
38.     }
    
39. 
    " R& G; t# ^- _& }- G( e7 S
40.     /* 启动传输 */
    
41.     if (HAL_QSPI_Transmit(&QSPIHandle, _pBuf, 10000) != HAL_OK)
    $ O+ q. ]# I& {+ b5 ~# q2 F
42.     {
    
43.         //return 0;
    ; Z/ F! L' U! D7 b. U/ B
44.         Error_Handler(__FILE__, __LINE__);
    
45. 
    
46.     }
    
47. 
    * k. q: o; C9 A5 V
48.     QSPI_AutoPollingMemReady(&QSPIHandle);   
    
49. 
    
50.     return 1;
    
51. }

复制代码

5 J- O" {7 C3 ~, }/ {3 Z% L此时函数使用的指令0x34对应的W25Q256JV手册说明，注意红色方框位置：
7 B7 y- ~! r$ j% S, Z, l

0 u6 N6 p: `& q! G' f* F
) H8 z+ z: y! o/ D6 D左上角的1-4-4就是指令阶段使用1个IO，地址阶段使用4个IO，数据阶段也是使用4个IO，并且采用的4字节地址方式，反映到程序里面就是：

sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
* D9 R3 M, m: j: `sCommand.AddressMode = QSPI_ADDRESS_4_LINES;
; ~/ l/ ~& l/ \sCommand.AddressSize = QSPI_ADDRESS_32_BITS;
sCommand.DataMode = QSPI_DATA_4_LINES;

79.4.5 第5步：W25QXX的扇区擦除实现
, \. t; l) q# C$ k6 x6 e2 {注：这里以查询方式的API进行说明，DMA方式是一样的。

8 T- ]. \: G: c& P; q: K8 i$ C通过发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除，擦除的扇区大小是4KB。

4 ?6 \4 V' @6 H. J+ n9 J

1. /*
   3 k* |3 I' U" L: t$ F" c
2. *********************************************************************************************************
   
3. *    函 数 名: QSPI_EraseSector
   ! f4 x" d0 n& s2 c* t* z- H3 B" Z
4. *    功能说明: 擦除指定的扇区，扇区大小4KB
   
5. *    形    参: _uiSectorAddr : 扇区地址，以4KB为单位的地址，比如0，4096, 8192等，
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   . g5 ~, u% s1 l/ V$ L
9. void QSPI_EraseSector(uint32_t _uiSectorAddr)
   ! x9 r; l2 `/ |* a1 C' W  X
10. {
    , N. q/ P1 G; d% p6 n3 U4 ?
11.     QSPI_CommandTypeDef sCommand={0};
    3 L7 Q  u# n" W9 |( j. Y. p7 K. t2 G. i
12. 
    6 A7 O, |2 z% E$ q# k( o& Y
13.     /* 写使能 */
    ! T) i" Q- x$ E  [9 p
14.     QSPI_WriteEnable(&QSPIHandle);   
    - B1 _0 L" I3 ~! e, w
15. 
    0 b& [3 z$ a# C$ }; u: e
16.     /* 基本配置 */
    6 E/ I& c& [  r9 Q' d1 e
17.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;    /* 1线方式发送指令 */
    7 M5 Q9 H$ p; b3 F- L3 R
18.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;       /* 32位地址 */
    0 y, M' n4 P* T
19.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    - J6 |3 I; h  T! P  w5 {/ V
20.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;      /* W25Q256JV不支持DDR */
    
21.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;  /* DDR模式，数据输出延迟 */
    
22.     sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;     /* 每次传输都发指令 */   
    % m) ?" E+ b/ W* j/ {$ r+ o
23. 
    
24.     /* 擦除配置 */
    " J3 f1 X" m4 Y5 i
25.     sCommand.Instruction = SUBSECTOR_ERASE_4_BYTE_ADDR_CMD;   /* 32bit地址方式的扇区擦除命令，扇区大小4KB*/      
    
26.     sCommand.AddressMode = QSPI_ADDRESS_1_LINE;  /* 地址发送是1线方式 */      
      |3 m0 H& P! f! O8 i2 M4 p
27.     sCommand.Address     = _uiSectorAddr;        /* 扇区首地址，保证是4KB整数倍 */   
    , S/ l# w  f: x0 G* m8 b
28.     sCommand.DataMode    = QSPI_DATA_NONE;       /* 无需发送数据 */  
    ! r0 Y1 I# d( ^, K$ {4 J$ q' g
29.     sCommand.DummyCycles = 0;                    /* 无需空周期 */  
    
30. 
    
31.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    
32.     {
    
33.         Error_Handler(__FILE__, __LINE__);
    
34.     }
    
35. 
    
36.     QSPI_AutoPollingMemReady(&QSPIHandle);   
    
37. }

复制代码

此时函数使用的指令0x21对应的W25Q256JV手册说明，注意红色方框位置：
9 _. R. n3 r0 Z1 P6 _# V

$ V, b3 s, O# J( T5 O& V
% m2 m  t* ]0 Q. k: h左上角的1-1-1就是指令阶段使用1个IO，地址阶段使用1个IO，数据阶段也是使用1个IO，并且采用的4字节地址方式，反映到程序里面就是：
* K  T! {/ Q0 |" b
sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;

4 Q0 _" j3 ?3 ?; Y  \6 I7 N sCommand.AddressMode = QSPI_ADDRESS_1_LINES;
6 u9 ]* Y2 D' ]. n
sCommand.AddressSize = QSPI_ADDRESS_32_BITS;

sCommand.DataMode = QSPI_DATA_1_LINES;
4 |7 G4 ^1 O: }9 n5 M/ g, V
4 F% c5 ^) k; s0 U& [  E9 U79.4.6 第6步：W25QXX的整个芯片擦除实现
注：这里以查询方式的API进行说明，DMA方式是一样的。
" C/ a$ E% v1 _
* Z5 o) O# ~* q# ~. v1 k9 U" m1 I整个芯片的擦除可以通过擦除各个扇区来实现，也可以调用专门的整个芯片擦除指令实现。下面实现方法是发送整个芯片擦除命令实现：

" W7 t2 ]9 c# }2 S1 g

1. /*
   - ^3 e9 s) ~8 h) x
2. *********************************************************************************************************
   5 g+ i5 S* w; S  L5 S' j& N
3. *    函 数 名: QSPI_EraseChip
   
4. *    功能说明: 整个芯片擦除
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ! j" M# H3 ~9 m  m1 \3 t4 S) r2 }; g
8. */
   5 O% U9 ]* J) j/ x
9. void QSPI_EraseChip(void)
   
10. {
    2 `' e' R- r! |1 B7 L. M
11.     QSPI_CommandTypeDef sCommand={0};
    
12. 
    
13.     /* 写使能 */
    
14.     QSPI_WriteEnable(&QSPIHandle);   
    
15. 
    3 H' c5 u. f0 n" l& Z4 ]1 H8 x
16.     /* 基本配置 */
    7 c1 a2 P/ g4 H  x( v: m, a
17.     sCommand.InstructionMode   = QSPI_INSTRUCTION_1_LINE;    /* 1线方式发送指令 */
    ( r, k. X$ K- R. B/ _
18.     sCommand.AddressSize       = QSPI_ADDRESS_32_BITS;       /* 32位地址 */
    
19.     sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    9 h+ L2 y: {9 q! ?+ e. c
20.     sCommand.DdrMode           = QSPI_DDR_MODE_DISABLE;      /* W25Q256JV不支持DDR */
    
21.     sCommand.DdrHoldHalfCycle  = QSPI_DDR_HHC_ANALOG_DELAY;  /* DDR模式，数据输出延迟 */
    
22.     sCommand.SIOOMode          = QSPI_SIOO_INST_EVERY_CMD;     /* 每次传输都发指令 */   
    * a* G# k& V7 H) O0 f
23. 
    
24.     /* 擦除配置 */
    
25.     sCommand.Instruction = BULK_ERASE_CMD;       /* 整个芯片擦除命令*/      
    
26.     sCommand.AddressMode = QSPI_ADDRESS_1_LINE;  /* 地址发送是1线方式 */      
    
27.     sCommand.Address     = 0;                    /* 地址 */   
    " b9 t- H+ |* ~, b9 m1 C; m8 c4 N
28.     sCommand.DataMode    = QSPI_DATA_NONE;       /* 无需发送数据 */  
    
29.     sCommand.DummyCycles = 0;                    /* 无需空周期 */  
    
30. 
    
31.     if (HAL_QSPI_Command(&QSPIHandle, &sCommand, 10000) != HAL_OK)
    6 Z5 ]0 ]& R; ?% b% k
32.     {
    ! `$ p5 w' _2 h& ]1 A
33.         Error_Handler(__FILE__, __LINE__);
    / z" P, D. ~' ^* P5 p
34.     }
    
35. 
    * W% W2 ~) |5 i& `! u6 ~0 T; ^
36.     QSPI_AutoPollingMemReady(&QSPIHandle);   
    1 U, B6 R6 g- b. j' y6 {% r
37. }

复制代码

  @5 O5 S& V, [6 |+ O4 `4 Q此时函数使用的指令0xC7对应的W25Q256JV手册说明，注意红色方框位置：
# u( q" e$ x% F# s3 v" t$ P0 [# v


% `# N, I" V% \& s# `左上角的1-1-1就是指令阶段使用1个IO，地址阶段使用1个IO，数据阶段也是使用1个IO，并且采用的4字节地址方式，反应到程序里面就是：

sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
sCommand.AddressMode = QSPI_ADDRESS_1_LINES;
! C+ t; a* Y4 L. K+ jsCommand.AddressSize = QSPI_ADDRESS_32_BITS;
sCommand.DataMode = QSPI_DATA_1_LINES;

擦除用不到数据阶段，sCommand.DataMode  = QSPI_DATA_NONE即可。

& M* L8 A& C& }- N- m79.4.7 第7步：W25QXX内存映射实现
/ \2 j8 B: M6 g. j) ?: m' ^注：这里以查询方式的API进行说明，DMA方式是一样的。

通过内存映射模式，就可以像使用内部Flash一样使用W25QXX，代码实现如下：

1. /*
   6 D+ K; ~1 F8 Y, p, C$ r
2. *********************************************************************************************************
   
3. *    函 数 名: QSPI_MemoryMapped
   
4. *    功能说明: QSPI内存映射，地址 0x90000000
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   ; h% a. ~, j) l
7. *********************************************************************************************************
   1 B# ]. O! C: }7 m: K1 E
8. */
   
9. void QSPI_MemoryMapped(void)
   
10. {
    % q" L- J" i: E& f8 ~, h
11.     QSPI_CommandTypeDef s_command = {0};
    
12.     QSPI_MemoryMappedTypeDef s_mem_mapped_cfg = {0};
    
13. 
    2 ~) i1 r6 A1 }. B$ Z" Q# g
14.     /* 基本配置 */
    
15.     s_command.InstructionMode = QSPI_INSTRUCTION_1_LINE;      /* 1线方式发送指令 */
    ( v3 I' ~1 j  G. I0 j( [2 {
16.     s_command.AddressSize = QSPI_ADDRESS_32_BITS;             /* 32位地址 */
    
17.     s_command.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;  /* 无交替字节 */
    
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;            /* 每次传输都发指令 */
    ! r* p3 U8 Y  U- Y) o! ?6 t8 D
21. 
    ) g; ?# C! S/ W$ C
22.     /* 全部采用4线 */
    ; C4 d  I+ w' C* `
23.     s_command.Instruction = QUAD_INOUT_FAST_READ_4_BYTE_ADDR_CMD; /* 快速读取命令 */
    3 [- s- n' D! u1 Z( U1 n
24.     s_command.AddressMode = QSPI_ADDRESS_4_LINES;                 /* 4个地址线 */
    
25.     s_command.DataMode = QSPI_DATA_4_LINES;                       /* 4个数据线 */
    9 u  _+ v; @8 h# g4 s/ A
26.     s_command.DummyCycles = 6;                                    /* 空周期 */
    
27. 
    
28.     /* 关闭溢出计数 */
    ' l) N. i2 [0 _3 H' p7 H. r/ P
29.     s_mem_mapped_cfg.TimeOutActivation = QSPI_TIMEOUT_COUNTER_DISABLE;
    
30.     s_mem_mapped_cfg.TimeOutPeriod = 0;
    
31. 
    8 \$ w/ q; q$ T0 @, Q) x
32.     if (HAL_QSPI_MemoryMapped(&QSPIHandle, &s_command, &s_mem_mapped_cfg) != HAL_OK)
    1 @3 \+ H$ ~/ @% ], x
33.     {
    
34.        Error_Handler(__FILE__, __LINE__);
    % S3 p# ^# s! ^' l
35.     }
    ! a/ E9 l# A3 z0 P
36. }

复制代码

+ j, b9 O$ B. M& E2 h/ M6 Q0 U此时函数使用的指令0xEC对应的W25Q256JV手册说明，注意红色方框位置：
$ n+ T  }: [) l! i) {% w8 L

7 z1 Q2 p, G5 r: }) i( U! v! R: e
左上角的1-4-4就是指令阶段使用1个IO，地址阶段使用4个IO，数据阶段也是使用4个IO，采用的4字节地址方式，反应到程序里面就是：
- \* J2 v) t( x. X; {8 q1 F) X8 Q
. ~* F) a% m7 h9 v5 B  GsCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
' u% H& L5 H2 G; q& x* z* I2 O' JsCommand.AddressMode = QSPI_ADDRESS_4_LINES;
0 p! Y8 |+ d" Z% L0 y- {; a9 psCommand.AddressSize = QSPI_ADDRESS_32_BITS;
+ P1 l4 o6 v2 U6 t7 f  |( w; asCommand.DataMode = QSPI_DATA_4_LINES;

- R) C6 n  g. d  h" i79.4.8 第8步：使用MDMA方式要注意Cache问题
如果使用MDMA方式的话，可以使用TCM RAM，此时不用考虑Cache问题。如果使用的是其它RAM空间，要考虑Cache问题。因为MDMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭读Cache和写Cache，比如使用的AXI SRAM，这样可以方便大家做测试，测试通过后，再根据需要开启Cache。
- b4 k* w: ^9 P& d

1. /* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
   2 g2 k- x9 q3 e& @1 j/ c, ~. u
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   
3. MPU_InitStruct.BaseAddress      = 0x24000000;
   ; [7 A4 _' O+ i9 I
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
   
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   6 F  }: D7 M: t8 c5 T
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   8 M2 N3 n  h& r( {
7. MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   
8. MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9. MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
   
10. MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    $ O$ m: A2 z! k3 f+ U4 u
11. MPU_InitStruct.SubRegionDisable = 0x00;
    7 f. q( [1 y5 W1 C  n! `" {
12. MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
13. 
    ' c2 @# q" H: T( J8 e6 w
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

6 J' v: w7 v" h6 o; W79.5 W25QXX板级支持包（bsp_qspi_w25q256.c）
* d/ E$ C4 Q% QW25QXX驱动文件bsp_qspi_w25q256.c主要实现了如下几个API供用户调用：
# s6 Q4 w) l1 x7 J4 c& }% q
5 i6 c9 j- H  O7 I  QSPI_ReadBuffer
  QSPI_WriteBuffer
  QSPI_EraseSector
  QSPI_EraseChip
6 |4 _& v/ K5 H/ b3 @3 J  QSPI_MemoryMapped
' o. ?" Z$ n0 j. I79.5.1 函数QSPI_ReadBuffer
函数原型：

4 S! Q: v( i$ ~) i! J( i6 L& ~void QSPI_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize);

函数描述：

  R/ n. ?8 w) Y) }7 j此函数主要用于从QSPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可（如果使用DMA方式，每次最大65536字节）。

函数参数：
' q: S+ X( y( i/ V: s5 r! z5 f
$ M% o! R$ o  ]: G+ w  第1个参数用于存储从QSPI Flash读取的数据。
  第2个参数是读取地址，不可以超过芯片容量。
( y7 o  z0 l. x# I5 i. r2 h2 H& e4 }  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
79.5.2 函数QSPI_WriteBuffer
函数原型：
; l2 q9 n+ ^$ P5 S' C
6 e0 z. F) c; [) c# @+ j* Kuint8_t QSPI_WriteBuffer(uint8_t *_pBuf, uint32_t _uiWriteAddr, uint16_t _usWriteSize);
7 Z0 z$ R7 f0 r; |; L
! x; Q  ~4 c9 _+ u6 R, B+ D+ v$ W# U函数描述：
/ n1 @( c  Z7 N& s% t! @, }5 \9 V9 L
页编程，页大小256字节，任意页都可以写入。注意使用前，务必保证相应页已经做了擦除操作。
0 _4 k) h, t: Z( M/ ]. P
函数参数：
; n* F, F9 d0 p. J! a% j& }- l5 n3 B
) S0 A4 T1 Q# d) l+ B, f  第1个参数是源数据缓冲区。
  第2个参数是目标区域首地址，即页首地址，比如0， 256, 512等。
, F, q' \  U3 C* W  第3个参数是数据个数，不能超过页面大小，范围1 – 256，单位字节个数。
/ T7 A" B( h/ w+ ~3 F* O  M  返回值，返回1表示成功，返回0表示失败。
- J8 j' @4 F9 V: }' I6 [3 ^( C; ~; n) W79.5.3 函数QSPI_EraseSector
函数原型：
+ q/ B6 n$ c  u, F2 H, e
void QSPI_EraseSector(uint32_t _uiSectorAddr)
0 \0 q  o3 j6 [
# J( G" e# s. U' H4 a- n7 x函数描述：
8 H' o7 d* n+ g: _7 J" ~1 x
1 D' L# O8 P5 \& y" V此函数主要用于扇区擦除，一个扇区大小是4KB。

' ^$ j; n& y& Q( w' t1 _函数参数：
) O: z& F* }! {4 `! G
' C7 X$ e. S" j0 A: |7 E  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
# ~5 ~+ L! B" N79.5.4 函数QSPI_EraseChip
函数原型：
; I* M. G2 l: ~* q/ \6 D" V& u1 P
void QSPI_EraseChip(void)
$ b/ L# o! j% \9 ?/ y
函数描述：

此函数主要用于整个芯片擦除。
+ ~! u' O9 ~, F* H6 q( F0 b) @
2 S7 N% i8 A& G5 s( d79.5.5 函数QSPI_MemoryMapped
函数原型：

void QSPI_MemoryMapped(void)
* T4 B* x3 I; ]8 \
) P" r: h: M; L8 ]5 z6 R, ~函数描述：
2 m* y( h0 \- J' @; l2 y+ B
$ z/ V" P' d7 X; E6 G4 B调用了此函数就可以像使用内部Flash一样使用外部Flash。
( N5 h5 }. F% q. s# [
79.6 W25QXX驱动移植和使用
, A; w9 |/ D, \4 y( K$ xW25QXX移植步骤如下：
6 i6 m1 B% Z: U. @0 t8 Q
3 U- t& F, q5 `' t2 R6 @  第1步：复制bsp_qspi_w25q256.c， bsp_qspi_w25q256.h到自己的工程目录，并添加到工程里面。
1 b0 P* }4 c8 g1 l  第2步：根据使用的QSPI引脚，时钟等，修改bsp_qspi_w25q256.c文件开头的宏定义。
: Z9 _) f4 {" G

1. /*
   / b8 s  d# y) I6 l" K
2.     STM32-V7开发板接线
   
3. 
   
4.     PG6/QUADSPI_BK1_NCS AF10
   
5.     PF10/QUADSPI_CLK    AF9
   
6.     PF8/QUADSPI_BK1_IO0 AF10
   2 v: I2 ?" g! l2 x+ u! N, _
7.     PF9/QUADSPI_BK1_IO1 AF10
   
8.     PF7/QUADSPI_BK1_IO2 AF9
   
9.     PF6/QUADSPI_BK1_IO3 AF9
   3 h1 J: U1 e0 F+ D
10. 
    5 q; w) R& }) h6 `
11.     W25Q256JV有512块，每块有16个扇区，每个扇区Sector有16页，每页有256字节，共计32MB
    
12. */
    ' F" ?, X, b) Y; h4 w
13. 
    $ M0 T8 c& R/ U( ^3 y) [
14. /* QSPI引脚和时钟相关配置宏定义 */
    , c, A$ Q2 N0 s1 p1 K& A! I
15. #define QSPI_CLK_ENABLE()              __HAL_RCC_QSPI_CLK_ENABLE()
    
16. #define QSPI_CLK_DISABLE()             __HAL_RCC_QSPI_CLK_DISABLE()
    3 A5 \. G4 I+ d# n0 O" g: V
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()
    $ B% L& o: O' ^4 Q2 m
21. #define QSPI_BK1_D2_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOF_CLK_ENABLE()
    
22. #define QSPI_BK1_D3_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOF_CLK_ENABLE()
    1 C5 K& C3 v1 t+ B  b* P5 s
23. 
    
24. #define QSPI_MDMA_CLK_ENABLE()         __HAL_RCC_MDMA_CLK_ENABLE()
    8 f5 a: S0 Y3 ]6 e2 I
25. #define QSPI_FORCE_RESET()             __HAL_RCC_QSPI_FORCE_RESET()
    
26. #define QSPI_RELEASE_RESET()           __HAL_RCC_QSPI_RELEASE_RESET()
    
27. 
    . x" X( G+ ?6 o
28. #define QSPI_CS_PIN                    GPIO_PIN_6
    8 u1 y; ]( _& y
29. #define QSPI_CS_GPIO_PORT              GPIOG
    
30. 
    
31. #define QSPI_CLK_PIN                   GPIO_PIN_10
    
32. #define QSPI_CLK_GPIO_PORT             GPIOF
    
33. 
    
34. #define QSPI_BK1_D0_PIN                GPIO_PIN_8
    
35. #define QSPI_BK1_D0_GPIO_PORT          GPIOF
    - ^9 N. d" |' l- ]: H9 ]
36. 
    
37. #define QSPI_BK1_D1_PIN                GPIO_PIN_9
    ! l3 R4 j7 l, h6 D
38. #define QSPI_BK1_D1_GPIO_PORT          GPIOF
    ' q, r5 r  a/ D9 E7 a7 C7 C
39. 
    ! U$ n+ m) x7 L9 L$ r1 w0 v1 B
40. #define QSPI_BK1_D2_PIN                GPIO_PIN_7
    
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基本信息 */
    
47. #define QSPI_FLASH_SIZE     25                      /* Flash大小，2^25 = 32MB*/
    
48. #define QSPI_SECTOR_SIZE    (4 * 1024)              /* 扇区大小，4KB */
    " ?" @, m4 `5 C( r# [- ?/ k
49. #define QSPI_PAGE_SIZE      256                        /* 页大小，256字节 */
    " ~( m( V9 J( A8 y! d
50. #define QSPI_END_ADDR        (1 << QSPI_FLASH_SIZE)  /* 末尾地址 */
    
51. #define QSPI_FLASH_SIZES    32*1024*1024            /* Flash大小，2^25 = 32MB*/
    
52. 
    
53. /* W25Q256JV相关命令 */
    + j# }* A) V# B0 ?
54. #define WRITE_ENABLE_CMD      0x06         /* 写使能指令 */  
    5 L3 g- v9 W& ^( v. A8 u
55. #define READ_ID_CMD2          0x9F         /* 读取ID命令 */  
    
56. #define READ_STATUS_REG_CMD   0x05         /* 读取状态命令 */
    $ \+ `  s5 }2 h5 G
57. #define BULK_ERASE_CMD        0xC7         /* 整个芯片擦除命令 */
    
58. #define SUBSECTOR_ERASE_4_BYTE_ADDR_CMD      0x21    /* 32bit地址扇区擦除指令, 4KB */
    
59. #define QUAD_IN_FAST_PROG_4_BYTE_ADDR_CMD    0x34    /* 32bit地址的4线快速写入命令 */
    
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：
' m- S& h  l! n7 E1 {( k/* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
& g* i8 v5 f! u$ w. ~; M/ cMPU_InitStruct.Enable           = MPU_REGION_ENABLE;
MPU_InitStruct.BaseAddress      = 0x24000000;
MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
% _, F, v5 p2 O1 d/ d( \( K9 }9 QMPU_InitStruct.Number           = MPU_REGION_NUMBER0;
MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
( X& c# q" Y+ u- U! t+ W0 i# gMPU_InitStruct.SubRegionDisable = 0x00;
$ o3 @  K" o" ?' v( e, z4 LMPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
  D; I" R' H* x/ P8 b+ r4 f
( o- t5 M3 S& w& p4 `: fHAL_MPU_ConfigRegion(&MPU_InitStruct);
  第5步：初始化QSPI。
& V" K) I0 @& Z; a/ s8 [/* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
& z9 U# |" N2 p& Ebsp_InitQSPI_W25Q256();  /* 配置SPI总线 */
7 f0 J+ Y7 V* f  第6步：QSPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第7步：应用方法看本章节配套例子即可。
( _) J! `& ^. P) J8 E79.7 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
( N; j4 v8 e: j8 \! P; T

9 h* X6 _, J3 d& l. d
0 _5 D; M; u# o  @, B9 K, k; v  第1阶段，上电启动阶段：
4 `! j* @$ O. p% p1 ~: h
. d' |+ a; |4 X: v. I这部分在第14章进行了详细说明。
9 {/ U1 N* |2 g# }  第2阶段，进入main函数：

* @. l/ f2 _: z2 e$ M3 h 第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
# ?% U; s7 D! S) ^! y& h- y 第2部分，应用程序设计部分，实现QSPI Flash的查询和MDMA方式操作。
; g5 z) h/ U; P+ z3 g7 }79.8 实验例程说明（MDK）
配套例子：

# I2 l* l9 h0 E4 X9 r# HV7-029_QSPI读写例程，四线DMA方式，读每秒48MB（V1.1）

  u# L# G1 Y5 b7 n& f. CV7-059_QSPI读写例程，查询方式
' C7 l/ R1 S  c" w! `4 E. N
/ C  s+ r, ?" \实验目的：

2 _. t9 D8 N: P5 J学习QSPI Flash的读写测试例程
8 z6 `( p4 I! H! _9 S: R+ [3 T实验操作：

; [) w. M% ^$ a- u支持以下7个功能，用户通过电脑端串口软件发送数字1-6给开发板即可
2 H' u2 p6 i9 H+ ^1 rprintf("请选择操作命令:\r\n");
printf("【1 - 读QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
- }6 {1 p* y. _/ ~printf("【2 - 写QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
* P8 a; w- k6 _5 nprintf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
! C4 M# h- a8 Cprintf("【4 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
" |; F% t. K* c; Bprintf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
printf("其他任意键 - 显示命令提示\r\n");
( S; q  z; r, [, B6 r上电后串口打印的信息：
8 g. }0 o, b1 C4 I4 [
" R9 L4 `6 i* r) L) a* ^/ s. w波特率 115200，数据位 8，奇偶校验位无，停止位 1。

, o/ f2 w  U" R9 N程序设计：

  系统栈大小分配：

8 \+ X0 K  _9 S" N; U9 {; G9 X: i

  RAM空间用的DTCM：
% m* R% S: o( K+ a' G  H" w8 n. T
2 v3 \, D. k6 C* Y$ b4 C

# W# ]8 K5 l3 `- ~' S# a7 _2 N% z
3 q( X6 w' m' F  硬件外设初始化
; L- F) c2 {$ L. g: {( t  c6 t2 a
硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   & D$ u  t9 e# B$ `
5. *    形    参：无
   " g1 G: ]) w" @
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   $ c) U$ [! F/ [6 S3 g+ _9 l' ?
8. */
   + C* ?3 o( V: Q7 r
9. void bsp_Init(void)
   & W2 u+ m* ~4 c- @. H- u& ^
10. {
    & H) v' ^$ y! I. s% U6 d! P
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    2 c5 T. f/ @5 \6 c, X
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    3 q1 f; s# D0 Q# j6 e5 o
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    4 a2 P6 G5 s: w9 g) H. `/ J
21.      */
    
22.     HAL_Init();
    ! Q0 \- z4 s  s  I& A4 Y% s
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    ) t" _7 m- g7 G6 E  S  U
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    & H7 s. E0 V- ^2 R* A8 _5 I
28.     */
    5 V% G6 |$ M. a' P8 f$ K
29.     SystemClock_Config();
    
30. 
    / X, a/ j' W4 S8 T* j6 M8 V
31.     /*
    
32.        Event Recorder：
    - V. j6 s& S7 ^( J/ s
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    & Y1 e8 v$ E; l3 N6 Z
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    . y+ J+ V2 W' x0 u1 b
35.     */   
    & {* {' i) R7 g  U) H) x3 ]; I$ x* n1 r
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    3 V( z0 d% y- i% J9 z/ d' n
38.     EventRecorderInitialize(EventRecordAll, 1U);
    " H5 w" W4 H2 y0 E: n7 ~! @
39.     EventRecorderStart();
    - d0 C, O/ l0 Q, v/ k1 t5 W9 n
40. #endif
    
41. 
    - s1 S, z5 V; y9 j2 T& S' o" M. ]
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    ' y/ R! T  U/ N8 B0 ?  X- p5 N
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    6 x6 X5 E& s9 s! g4 ?; @1 a% X
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();         /* 初始化LED */   
    
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    " A; R  W, n, ?9 H
49. 
    - D1 `8 @, Z( J  j5 z! ~9 M
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    : U0 `6 X2 W9 ?0 K1 x8 b
51.     bsp_InitQSPI_W25Q256();  /* 配置SPI总线 */}

复制代码

# [# N" q3 O! ~0 q$ E  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   * u" z4 p( \  N; I. u! v
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   % F  a* N+ i9 u0 @
5. *    形    参: 无
   - e9 C6 X8 v1 ~2 e5 I
6. *    返 回 值: 无
   % e" ~3 g- n* b- _/ x
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   4 h- D. I+ E; p; Z& g. s
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    $ L) }# P7 Z' q5 q# e; i, v
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    9 m$ V$ P+ C7 D* H3 d
15. 
    
16. #if 0
    / w) V8 C2 g4 l" U0 f) S
17.        /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    , U  V8 u# x, J0 a: H6 S% q
18.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    1 B  l' H/ O5 x4 t* g
19.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
20.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    & n# e# t4 u; H3 o1 r
21.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    4 C1 o; w$ t* F- X
22.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    " a" p" `6 v# Z. b1 i" A, a
23.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
24.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ' h: F1 y% p8 i& ~8 I
25.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
26.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 Y: U8 r7 B: [/ _
27.     MPU_InitStruct.SubRegionDisable = 0x00;
    
28.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
29. 
    
30.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
31. 
    $ |$ k3 C/ R% \- G
32. #else
    
33.     /* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
    
34.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    - {( X7 g" q* p! u1 j, `# Z- t
35.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
36.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
37.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
38.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    / g! o1 K/ A5 T2 W0 f( g$ H, d8 G
39.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    * n. b9 |% P' Y: j$ ~* a
40.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % j, m' m6 h) p( Y& m7 Q
41.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ' ~' [, u7 l! Z9 p2 P% h
42.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    $ L. v; ]+ B8 X2 M* f
43.     MPU_InitStruct.SubRegionDisable = 0x00;
    
44.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 j0 B8 t( ~) P5 @9 d  t8 b* q9 n
45. 
    7 ^3 I; d/ R5 H: H; K' S
46.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    * F$ c  Z6 L5 K" \! W) g, \
47. #endif   
    
48. 
    8 ?7 ~$ f) n6 w  K# h8 B9 \; @
49.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
50.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
51.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
52.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
53.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    6 f2 S  v8 }( ]' e# g+ k% P
54.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % V' d' |) n2 z  b) ]% G6 l
55.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    ) w- ~  O- _0 \/ n! a9 k+ E3 _6 t
56.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    " L' }( t3 ?/ Y, O
57.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    1 B% c7 X8 S* \7 V& I$ Q% e
58.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
59.     MPU_InitStruct.SubRegionDisable = 0x00;
    
60.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
61. 
    
62.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 j  [% z9 v( L! X' }7 ?, a
63. 
    
64.     /*使能 MPU */
    ! @' o' |, r" U
65.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    , q& L& D, T* @+ T/ i
66. }
    
67. 
    
68. /*
    
69. *********************************************************************************************************
    
70. *    函 数 名: CPU_CACHE_Enable
    
71. *    功能说明: 使能L1 Cache
    6 @  o: @" L4 v! o: q
72. *    形    参: 无
    
73. *    返 回 值: 无
      v0 `' ?. u2 j3 O+ H5 L7 ~; H8 X8 g
74. *********************************************************************************************************
    ! k& @; R5 o& t  u
75. */
    / s6 M' I- z( V) K5 a1 A) G' {
76. static void CPU_CACHE_Enable(void)
    & Q9 O0 h) B- V3 e. f8 h+ Q
77. {
    % H$ r9 ^2 ?6 \  G) Q4 y
78.     /* 使能 I-Cache */
    
79.     SCB_EnableICache();
    
80. 
    
81.     /* 使能 D-Cache */
    
82.     SCB_EnableDCache();
    2 h1 e/ w% v3 j
83. }

复制代码

: y: i! |. b; O4 T  每10ms调用一次按键处理：

2 F5 ~+ E$ F7 `: O" |按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   / x+ i: o" h1 R4 g" G
6. *    形    参: 无
   $ T- J3 [) [+ E' }) P% u3 ]
7. *    返 回 值: 无
   0 B0 d3 e' `- O8 J7 g3 X7 W
8. *********************************************************************************************************
   1 h5 M8 H4 I% f9 r* d
9. */
   
10. void bsp_RunPer10ms(void)
    # a8 ]9 e4 Z, A( }
11. {
    
12.     bsp_KeyScan10ms();
    / u  F! \+ b9 T3 _+ D8 J. Q
13. }

复制代码

  主功能：

- ?% r% f0 l  b主程序实现如下操作：
* p; o# y* y; u3 p* n
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
0 A' ~! d. P$ W7 R+ I6 R& V  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  printf("【1 - 读QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
: q  J5 {% n# d4 t( _  printf("【2 - 写QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
. A, X  l1 F% [0 k8 B2 H8 C* ~  printf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
; a3 H3 D* U$ K; g, E2 V0 M* X  printf("【4 - 读整个串行Flash, 测试读速度】\r\n");
( g$ }* ^" \7 j3 {+ F  printf("【Z - 读取前1K，地址自动减少】\r\n");
  printf("【X - 读取后1K，地址自动增加】\r\n");
& j: U+ m6 S+ s$ d; P( a% f$ Q  printf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
# t; E. n+ Y' ~6 l4 y7 Y. t  printf("其他任意键 - 显示命令提示\r\n");
/ E9 {: C1 ?( e# T

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: QSPI读写例程
   
5. *    形    参：无
   4 Q5 j, t# l* |& ~0 x
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   4 X4 B- N. P1 R3 F- O0 `1 K% ]
8. */
   
9. void DemoSpiFlash(void)
   * Z! j3 ]3 ?: [! b* Q
10. {
    ) L, E: ]+ t" K! S
11.     uint8_t cmd;
    & z* @' Q8 v# w
12.     uint32_t uiReadPageNo = 0, id;
    
13. 
    
14.     /* 检测串行Flash OK */
    ; k5 D9 }9 w- \  d: E/ t# L
15.     id = QSPI_ReadID();
    
16.     printf("检测到串行Flash, ID = %08X, 型号: WM25Q256JV\r\n", id);
      w3 ?4 n6 @7 c/ P! m' p/ |, i7 E
17.     printf(" 容量 : 32M字节, 扇区大小 : 4096字节, 页大小：256字节\r\n");
    
18. 
    0 S) P" j7 q, }. k$ [
19.     sfDispMenu();        /* 打印命令提示 */
    
20. 
    + ^3 Z* ~9 \5 [( z2 ^
21.     bsp_StartAutoTimer(0, 200); /* 启动1个200ms的自动重装的定时器，软件定时器0 */
    
22.     while(1)
    & ]$ @6 d4 w* a7 Z1 e0 O+ r
23.     {
    / I! t$ H6 `9 z
24.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ) |9 S& q- v! {. v
25. 
    8 Z8 d4 v. f+ B, [
26.         /* 判断软件定时器0是否超时 */
    ( ?) H1 I" G" A/ C
27.         if(bsp_CheckTimer(0))
    
28.         {
    4 h, E/ w/ X- v: }1 ?& e7 i+ _9 d
29.             /* 每隔200ms 进来一次 */  
    
30.             bsp_LedToggle(2);
    
31.         }
    
32. 
    
33.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
34.         {
    3 j' m) j0 O( C% [, s5 d
35.             switch (cmd)
    
36.             {
    5 j8 S! [" H3 F4 w2 h/ s, j
37.                 case '1':
    / }* E% N/ k8 R$ Q9 p
38.                     printf("\r\n【1 - 读QSPI Flash, 地址:0x%X ,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
39.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    
40.                     break;
    
41. 
    1 n* _6 Y9 @' n: T" N; o% A6 C
42.                 case '2':
    
43.                     printf("\r\n【2 - 写QSPFlash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    1 B$ Q& h( ?, J# @" m
44.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    # R9 n( k2 r1 _. V- u5 [; ~% G. A
45.                     break;
    ) g' h1 P, B! W
46. 
    ( y! }* N! h4 q
47.                 case '3':
    
48.                     printf("\r\n【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
    7 z( |6 W' F) h; Y/ D: Z% n4 l
49.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
50.                     break;
    
51. 
    
52.                 case '4':
    + T/ W5 H2 L$ o3 n, \3 Y5 d+ a
53.                     printf("\r\n【4 - 读整个QSPI Flash, %dM字节】\r\n", QSPI_FLASH_SIZES/(1024*1024));
    
54.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
55.                     break;
    6 ^* l* h  s( p( T0 k* [
56. 
      r5 ?; }7 \8 @9 w  T# b3 Q5 {8 k
57.                 case 'y':
    
58.                 case 'Y':
    / U/ b9 P' l; _6 I
59.                     printf("\r\n【Y - 擦除整个QSPI Flash】\r\n");
    
60.                     printf("整个Flash擦除完毕大概需要300秒左右，请耐心等待");
    
61.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    & n% j" L( B% q8 a
62.                     break;
    
63. 
    9 d- ?# U2 k0 z: M4 N% B4 k! K
64.                 case 'z':
    
65.                 case 'Z': /* 读取前1K */
    ) G5 k& {- i+ Y
66.                     if (uiReadPageNo > 0)
    ' n; U3 n8 G% q8 e
67.                     {
    
68.                         uiReadPageNo--;
    
69.                     }
    1 h; m( g4 x& a& O7 B/ Q3 j- C: i
70.                     else
    ; v2 T: a- c1 N; F9 b1 ?
71.                     {
    
72.                         printf("已经是最前\r\n");
    
73.                     }
    
74.                     sfViewData(uiReadPageNo * 1024);
    
75.                     break;
    
76. 
    
77.                 case 'x':
    
78.                 case 'X': /* 读取后1K */
    
79.                     if (uiReadPageNo < QSPI_FLASH_SIZES / 1024 - 1)
    
80.                     {
    $ {, b' w2 Q* v5 B  V
81.                         uiReadPageNo++;
    8 m' S2 E, ~. |/ h" P5 {
82.                     }
    
83.                     else
    
84.                     {
    2 o) @6 V, o3 a' p3 c- }
85.                         printf("已经是最后\r\n");
    
86.                     }
    $ r1 j# f+ I* Z
87.                     sfViewData(uiReadPageNo * 1024);
    ' B) m- l' L5 x& i1 h  Z
88.                     break;
    
89. 
    
90.                 default:
    
91.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
92.                     break;
    
93.             }
    $ K0 H: s& B! ~9 g- ~& @
94.         }
      a; A8 f6 a- L- R* V' N
95.     }
    * O5 U# B- Y0 X+ e7 i. o
96. }

复制代码

- L7 R, Z& Z. Q, e8 [9 W79.9 实验例程说明（IAR）
配套例子：
! H* P# P% w8 D) g" r; E; H; _( `
V7-029_QSPI读写例程，四线DMA方式，读每秒48MB（V1.1）
: z- s6 W7 Y# A" j/ G
V7-059_QSPI读写例程，查询方式
( V0 S3 `+ T. V* T/ G# ~
+ p0 c+ i+ x3 T4 ?  p2 @实验目的：
* [! ]$ m- \  I  m' |2 w+ S
学习QSPI Flash的读写测试例程
实验操作：

支持以下7个功能，用户通过电脑端串口软件发送数字1-6给开发板即可
printf("请选择操作命令:\r\n");
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);
printf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
printf("【4 - 读整个串行Flash, 测试读速度】\r\n");
% D* F$ z6 J1 {& s  G$ ?' U9 Lprintf("【Z - 读取前1K，地址自动减少】\r\n");
8 \  A: F/ O7 R0 }! i8 M, P  `printf("【X - 读取后1K，地址自动增加】\r\n");
printf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
printf("其他任意键 - 显示命令提示\r\n");
上电后串口打印的信息：

! M- V8 H) p) {' R  s* q波特率 115200，数据位 8，奇偶校验位无，停止位 1。

+ l4 E1 y$ A$ }! Z/ T! q

4 S! f. ^, l! R
程序设计：

- O) ?( a7 G5 R5 x( b  系统栈大小分配：
6 {( L0 o0 E3 R1 {* {6 k

  RAM空间用的DTCM：

) @! f  R1 p6 \, o
, X" m+ \9 P/ A* Y7 W" ~  硬件外设初始化

+ @. O1 T/ h) D2 k硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   2 r; M% X/ R7 d0 `7 A: S& U; K4 m
2. *********************************************************************************************************
   7 n0 R( z- o) h. P; v) V
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   / j  s0 G4 ~: K
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    0 L' O; j  N/ y# Y5 H6 h" X
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    3 n" w/ n7 X! T# q  B5 W* B4 e! _
14.     /* 使能L1 Cache */
    , C; R9 r1 x4 e  _3 S
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ! g$ S- F1 K) P- G! s
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    5 x9 F+ H" G4 x- P! H, o
21.      */
    3 r* ~0 L+ i( O. [4 L
22.     HAL_Init();
    + r" A, B% _+ i0 u! a
23. 
    5 A" s4 M( r+ V; x7 ?" T
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ' N: N( H. E* ?4 f9 {# i2 P
28.     */
    
29.     SystemClock_Config();
    . O- c( [+ _6 O, h
30. 
    ) y5 Z4 x8 d. ~" Y% {
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    5 J$ s% ]8 C" }* R- u, v' a
36. #if Enable_EventRecorder == 1  
      J7 H# S4 z. C3 `5 U) B7 T, r1 _
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    : a8 o( u5 z0 U% l( C5 V, ~7 W$ _9 A5 y
40. #endif
    ! F8 x1 Y3 N& K, ]! a/ r& @4 J9 ~
41. 
    " f. t; W2 r5 F( W4 `5 i
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    % z5 i/ x; t6 j! `* r" D
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();         /* 初始化LED */   
    * O1 e9 v. P. V1 a$ Y( S1 I
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. 
    
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    / s7 ]& r9 n/ L$ F! Q
51.     bsp_InitQSPI_W25Q256();  /* 配置SPI总线 */}

复制代码

: Q1 v: u% L& i4 d2 m5 X, H  MPU配置和Cache配置：

: d" J2 |! f& U数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
: \2 `( L% i& n- N
2 Q3 c; }, P; q9 ~9 P3 t/ C

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   9 b% q1 i( ^3 J8 c# G* A: O. c7 N
4. *    功能说明: 配置MPU
   & C1 Y3 O6 {  \! x/ H* ], G8 s: B
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   & Z/ p6 ^% @: G/ a$ i; N' Y* f
8. */
   ! O" w1 ?2 g) U5 t. V
9. static void MPU_Config( void )
   ( h! f$ p. R4 M: n6 s. l
10. {
    3 u* s0 a% E9 Y* P' Y: {
11.     MPU_Region_InitTypeDef MPU_InitStruct;
      \& _/ _% j6 k! ~/ ~
12. 
    8 A/ |6 B  y; \& Y; Y$ P+ I9 j  A
13.     /* 禁止 MPU */
    # v, ]7 z0 {) t9 i& _7 T. @$ ?( ]
14.     HAL_MPU_Disable();
    
15. 
    0 X6 k# i" ^9 M% E. j
16. #if 0
    * r: X) b% S! L+ D$ r
17.        /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    " e- [* `5 _, ?: l! l  ]( I5 W2 L
18.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    0 T% s. ]5 ~! [  I& l* j# s- x
19.     MPU_InitStruct.BaseAddress      = 0x24000000;
    2 ~$ M3 _  K. C. n
20.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
21.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
22.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
23.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ( m$ p5 M0 M- H9 N3 n7 n/ k, F1 e
24.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
25.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    & E( T5 z2 h+ J& ~
26.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    . i  ~# e% I+ l8 J, u5 i6 Q
27.     MPU_InitStruct.SubRegionDisable = 0x00;
    9 d$ J4 v; U( e, e6 m4 ]
28.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
29. 
    
30.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
31. 
    
32. #else
    & [% A: V/ o  J
33.     /* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
    
34.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
35.     MPU_InitStruct.BaseAddress      = 0x24000000;
    / r8 @  D/ P( J6 ]( E. t( o
36.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    + Z% c+ ^3 r3 H( [8 S, U
37.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
38.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    % b9 r5 A6 X- P
39.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
40.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
41.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    6 b8 A. t1 x% t1 O
42.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
43.     MPU_InitStruct.SubRegionDisable = 0x00;
    2 x5 }* Z/ }/ C; V& M. M% Y
44.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    - U# _! S2 E3 A4 U  V5 d' }& a
45. 
    
46.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # ~4 ?" _* [/ [9 Y4 |/ ^# e0 ~
47. #endif   
    
48. 
    
49.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    6 E6 \' l7 b- z( k7 t# j% A1 N
50.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
51.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
52.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
53.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
54.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
55.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
56.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
57.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    & |0 C7 E; V6 E7 b% K* _+ [9 {+ M
58.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
      `3 o& i- [) [" ?5 b
59.     MPU_InitStruct.SubRegionDisable = 0x00;
    ! N9 R: L7 l! N# k3 U# H' e
60.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    5 R' X9 v' n, O9 E# z, g4 k( l. D
61. 
    * o0 I2 d& l- W+ T; ?( v+ y1 |) K
62.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
63. 
    / y# x3 U7 v+ j  Z8 X
64.     /*使能 MPU */
    . ~8 `& v+ g* X
65.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
66. }
    / \4 y9 U. v' E& Z3 V$ [
67. 
    
68. /*
    
69. *********************************************************************************************************
    ; _1 e% e" n) s4 k, ~6 |( @& `6 o7 k
70. *    函 数 名: CPU_CACHE_Enable
    . D0 b$ q  q, N2 e. j
71. *    功能说明: 使能L1 Cache
    
72. *    形    参: 无
    
73. *    返 回 值: 无
    . s& e, {0 r8 z; L/ r0 m
74. *********************************************************************************************************
    ! d9 S5 S5 B, b9 r
75. */
    
76. static void CPU_CACHE_Enable(void)
    
77. {
    $ w6 h8 N$ v- _
78.     /* 使能 I-Cache */
    3 w& Z+ o8 |: i, M' l# C
79.     SCB_EnableICache();
    
80. 
    # s1 C3 ^' o6 l2 a' V8 Q0 J
81.     /* 使能 D-Cache */
    
82.     SCB_EnableDCache();
    4 [# c4 w/ P6 B4 i! H- e. S
83. }

复制代码

8 F3 F- j, ~+ T  每10ms调用一次按键处理：

; ?& d4 S& I* j! m! v9 n. g按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

; K& D* @9 ?# A' S

1. /*
   4 W1 p' |: w+ Z& B. s2 X9 {
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   * ^% W0 M- ]6 U) K2 P9 r, r3 Z% b
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   , E7 D# `+ k  t) N8 W1 r
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   7 z& w( W1 u' m! A! Q' }/ b
7. *    返 回 值: 无
   ' F( e! ]- S( m- Y
8. *********************************************************************************************************
   , `6 K. d, ^, b" x' ~
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    % n$ x9 V. F. E4 f
12.     bsp_KeyScan10ms();
    
13. }

复制代码

' y3 ]! l2 J1 N5 N- k  e8 K$ Y  主功能：
0 B# [: r, I$ ?2 b# O( `+ g
+ G; r! e, Q# {9 f% Y1 a3 ^8 m主程序实现如下操作：
6 X. U$ s( E* a: W0 e; f
" o  l/ l0 q5 m1 D! d. B( m  启动一个自动重装软件定时器，每100ms翻转一次LED2。
- q3 \0 V2 z/ {. g) G1 U8 {7 d6 ^  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  printf("【1 - 读QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
' ?: G3 W$ s. x2 G, N  b- C  printf("【2 - 写QSPI Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
  printf("【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
! A( d* ?2 E" Y6 l  printf("【4 - 读整个串行Flash, 测试读速度】\r\n");
# [- ?3 L* f0 x6 r. ^1 L  printf("【Z - 读取前1K，地址自动减少】\r\n");
  printf("【X - 读取后1K，地址自动增加】\r\n");
  printf("【Y - 擦除整个串行Flash，整片32MB擦除大概300秒左右】\r\n");
1 `! g6 ]1 j7 L: F  printf("其他任意键 - 显示命令提示\r\n");

1. /*
   
2. *********************************************************************************************************
   9 _$ }0 L" j/ X3 C$ S' b% C
3. *    函 数 名: DemoSpiFlash
   0 n# C7 s0 Z. v0 l
4. *    功能说明: QSPI读写例程
   3 R! t$ |1 B2 h% _% R
5. *    形    参：无
   
6. *    返 回 值: 无
   . q+ n+ N' W3 V  }, O! W' U+ x
7. *********************************************************************************************************
   
8. */
   
9. void DemoSpiFlash(void)
   2 u! L! [% {/ E3 v2 z
10. {
    
11.     uint8_t cmd;
    2 h1 c- x1 I8 p: F6 s% |
12.     uint32_t uiReadPageNo = 0, id;
    5 G8 `% a$ K4 f7 d1 Z3 I
13. 
    
14.     /* 检测串行Flash OK */
    
15.     id = QSPI_ReadID();
    
16.     printf("检测到串行Flash, ID = %08X, 型号: WM25Q256JV\r\n", id);
    % m, E0 l* F: V. J$ B5 x6 U
17.     printf(" 容量 : 32M字节, 扇区大小 : 4096字节, 页大小：256字节\r\n");
    ) P* R& V' L0 b* {$ A6 Z
18. 
    9 {& d/ m1 P; Q9 o
19.     sfDispMenu();        /* 打印命令提示 */
    7 |, R* L1 d- V) {
20. 
    
21.     bsp_StartAutoTimer(0, 200); /* 启动1个200ms的自动重装的定时器，软件定时器0 */
    
22.     while(1)
    
23.     {
    * q; l9 F( a$ u/ r
24.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    1 p/ z+ P0 u; Q5 y) S
25. 
    
26.         /* 判断软件定时器0是否超时 */
    
27.         if(bsp_CheckTimer(0))
    
28.         {
    - [6 W5 l' q7 v1 t+ z/ d
29.             /* 每隔200ms 进来一次 */  
    8 D$ p# {2 @, ~3 ?
30.             bsp_LedToggle(2);
    
31.         }
    
32. 
    
33.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
34.         {
    
35.             switch (cmd)
    
36.             {
    
37.                 case '1':
    3 {& y* A3 o4 K# E7 k3 n
38.                     printf("\r\n【1 - 读QSPI Flash, 地址:0x%X ,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    6 h0 `+ _$ s" ^: ]: J% `
39.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    
40.                     break;
    3 J# V. {; T7 [; g  ~6 f# R/ ^  J
41. 
    ! b$ y+ o6 N3 J
42.                 case '2':
    
43.                     printf("\r\n【2 - 写QSPFlash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    # `# c, w6 Q1 Z7 U3 @
44.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
45.                     break;
    $ l. [: {# n3 m+ c/ ?) y+ I
46. 
    ) E) P; p; ?1 y  q( ~: T9 y. r
47.                 case '3':
    
48.                     printf("\r\n【3 - 写QSPI Flash前10KB空间, 全0x55】\r\n");
    $ o6 \' o  G. }
49.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    ; x  V3 e4 R, ^: T, N9 c0 ?
50.                     break;
    
51. 
    
52.                 case '4':
    ! e1 G: e" W! T6 @9 Q, y. M
53.                     printf("\r\n【4 - 读整个QSPI Flash, %dM字节】\r\n", QSPI_FLASH_SIZES/(1024*1024));
    
54.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    * Z: `! E) f$ W
55.                     break;
    
56. 
    7 t# e, n7 N2 K. i  I/ g
57.                 case 'y':
    4 i6 `+ p3 s# Q$ _0 |6 V. I! I
58.                 case 'Y':
    
59.                     printf("\r\n【Y - 擦除整个QSPI Flash】\r\n");
    
60.                     printf("整个Flash擦除完毕大概需要300秒左右，请耐心等待");
    3 p% m; s0 l. o- K, x9 |
61.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
62.                     break;
    
63. 
    
64.                 case 'z':
    , V& _% d+ L7 N& k4 @
65.                 case 'Z': /* 读取前1K */
    0 M# o/ s  n  W! ~
66.                     if (uiReadPageNo > 0)
    & F% Z7 L5 k, x5 q, \
67.                     {
    
68.                         uiReadPageNo--;
    " o/ ~' l- m3 r3 O
69.                     }
    
70.                     else
    
71.                     {
    & e7 C# D" p# S$ F& U2 K
72.                         printf("已经是最前\r\n");
    - @8 m& M& _2 ^3 x  U+ l
73.                     }
    
74.                     sfViewData(uiReadPageNo * 1024);
    
75.                     break;
    % N, J' \& b! B% o2 M, f
76. 
    
77.                 case 'x':
    
78.                 case 'X': /* 读取后1K */
    
79.                     if (uiReadPageNo < QSPI_FLASH_SIZES / 1024 - 1)
    ' W4 X+ I+ Z# r7 D
80.                     {
    : J0 `# [' c' m, ~1 i. b
81.                         uiReadPageNo++;
    - p' F* O$ `7 c% i' @
82.                     }
    
83.                     else
    
84.                     {
    # l; x- l" F/ l. Z
85.                         printf("已经是最后\r\n");
    ) \2 `) X' _( ], @7 ?7 {# g/ K
86.                     }
    
87.                     sfViewData(uiReadPageNo * 1024);
    1 `' G% h6 f8 f: q* p
88.                     break;
    ! |3 c4 I. x" s, Y4 Y
89. 
    2 w0 w% q/ Q) s+ @1 }
90.                 default:
    5 A" s% w$ ?/ \6 A* q
91.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    5 j$ {5 o/ q( I& D. o: C1 Q
92.                     break;
    
93.             }
    
94.         }
    " u/ b# F! g) P9 Y0 V: u
95.     }
    1 C* |! q/ C5 I' |
96. }

复制代码

( u% c, i, Y1 z79.10   总结
- c3 @' a  F/ |+ |0 w- x7 \本章节就为大家讲解这么多，实际应用中根据需要选择DMA和查询方式。
& m  I. V, |; ]+ e2 g

" J" I( z7 v6 y+ y