73.1 初学者重要提示
  W25Q64FV属于NOR型Flash存储芯片。
  W25Q64JV手册下载地址：链接 （这是一个超链接），当前章节配套例子的Doc文件件里面也有存放。

) @$ K; e4 ]; L; o) v* H3 `7 u7 }  本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。
  对SPI Flash W25QXX的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。
  W25Q64JV最高支持133MHz，但最高读命令03H速度是50MHz。
  文件bsp_spi_bus.c文件公共的总线驱动文件，支持串行FLASH、TSC2046、VS1053、AD7705、ADS1256等SPI设备的配置。
3 }' v; K' Z' h7 j# A- H6 f  函数sf_WriteBuffer不需要用户做擦除，会自动执行擦除功能，支持任意大小，任意地址，不超过芯片容量即可。

7 W+ l, z+ C, T) [73.2 W25QXX硬件设计
STM32H7驱动W25QXX的硬件设计如下：

# m) [7 f: m8 y) {7 z

' y  d' ^. K' K
0 _3 Q. z! Z# h" x$ i( h  n) m- {1 U关于这个原理图，要了解到以下几个知识：

  V7开发板实际外接的芯片是W25Q64JV。
6 M) I/ F2 o6 _1 |: ]7 N0 F  CS片选最好接上拉电阻，防止意外操作。
( O- v2 _* `: L! Z  这里的PB3，PB4和PB5引脚可以复用SPI1，SPI3和SPI6。实际应用中是复用的SPI1。
  W25Q64的WP引脚用于写保护，低电平有效性，当前是直接高电平。
  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。
73.3 W25QXX关键知识点整理（重要）
驱动W25QXX前要先了解下这个芯片的相关信息。

% o* c6 G& l/ B. n3 F+ J; y
- M! l2 C, t  z  W% B73.3.1 W25QXX基础信息
; l5 \0 \" x1 M: @( m  W25Q64FV的容量是8MB（256Mbit）。
  W25Q64FV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
, x2 ]5 s) G) |支持两线SPI，用到引脚CLK、CS、IO0、IO1 。

# t! q. i$ ?. F/ F" d* G+ T7 x支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。

6 ?, j& q+ M, `" o' S（注：这里几线的意思是几个数据线）。
" m( A& _8 ?- w$ ]
  W25Q64FV支持的最高时钟是133MHz。
& s2 P7 B) J- X& y) j! H5 P! D0 {  每个扇区最少支持10万次擦写，可以保存20年数据。
& _2 u' A7 S& U) P, z3 C+ X  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
3 Z# I9 n7 T+ |5 J- L9 w: X  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
1 |% r% U9 L: X/ q& e- r' A整体框图如下：
6 G$ {& O% J/ N! A  ^. f
: y/ z: r1 I# ]

- ~# a4 l0 d* @7 h9 x% N" ]W25Q64FV：
' g* R  M. U4 Y& b$ B3 u" {4 ^* p
  有128个Block，每个Block大小64KB。
5 K* U5 R: Q- ~6 }/ i  每个Block有16个Sector，每个Sector大小4KB。
: Z; u- @$ ^* _# R- T  每个Sector有16个Page，每个Page大小是256字节。
! B2 y$ r! t" m  O( ^0 V5 k73.3.2 W25QXX命令
( f& T% j, V: `- ~' T; `+ ~0 u& e使用W25Q的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的标准SPI，即单线SPI，使用的命令如下：
% J$ @3 p# D# e. u/ L3 M
! C1 w/ {% W3 D( k6 \, y

! h& s3 n! }8 z" o当前主要用到如下几个命令：
. L% H7 Y. F& y2 ~) f

1. #define CMD_EWRSR       0x50  /* 允许写状态寄存器的命令 */
   
2. #define CMD_WRSR      0x01  /* 写状态寄存器命令 */
   
3. #define CMD_WREN      0x06    /* 写使能命令 */
   1 m7 N' ?# w, C. c0 N1 G* V
4. #define CMD_READ      0x03  /* 读数据区命令 */
   
5. #define CMD_RDSR      0x05    /* 读状态寄存器命令 */
   & W1 l) {! s/ {$ B! u6 J$ F
6. #define CMD_RDID      0x9F    /* 读器件ID命令 */
   " `" M7 H# |. P
7. #define CMD_SE        0x20    /* 擦除扇区命令 */
   
8. #define CMD_BE        0xC7    /* 批量擦除命令 */
   9 N7 b* N" q7 ~
9. #define WIP_FLAG      0x01    /* 状态寄存器中的正在编程标志（WIP) */

复制代码

73.3.3 W25QXX页编程和页回卷
SPI Flash仅支持页编程（页大小256字节），所有其它大批量数据的写入都是以页为单位。这里注意所说的页编程含义，页编程分为以下三步（伪代码）：

8 C, k" p- A: u/ ]+ l

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   - Z* Y) i8 B8 |  `' H. k
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   ; X; U  x5 q" P& Q
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   ( d: R7 |' u- b. _, s  B
5. 
   5 f0 Q8 N7 f5 Q4 z# D0 X
6.     for (i = 0; i < _usSize; i++)
   % o  V( _+ x: H# C
7.     {
     H- J8 M3 Z  J4 Y2 }/ R
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   9 W% }5 [8 G1 \. N' l9 }3 Q
10.     }

复制代码

页编程的含义恰恰就体现在第3步了，如果用户设置的“起始地址+数据长度”所确定的地址范围超过了此起始地址所在的页，地址自增不会超过页范围，而是重新回到了此页的首地进行编写。这一点要特别的注意。如果用户不需要使用地址自增效果，那么直接指定地址进行编写即可。可以任意指定地址进行编写，编写前一定要进行擦除。
6 [* H, s) v+ w+ D4 U1 E
6 r; p% [8 g9 V+ ?( Q比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：
" Y; d! B' l( g( R# F! u, _

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

复制代码

( {. w# k5 I/ X1 o* n  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
, Z6 v. u# I% K7 k: C' z! e) {  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
% V, f* i& s8 i; L1 W1 `下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。
! s( T6 B4 g5 U* ], D2 |) x" t  M

2 n$ B7 m4 L6 r5 M) _4 R& M7 ?: z73.3.4 W25QXX扇区擦除
SPI Flash的擦除支持扇区擦除（4KB），块擦除（32KB或者64KB）以及整个芯片擦除。对于扇区擦除和块擦除，使用的时候要注意一点，一般情况下，只需用户给出扇区或者块的首地址即可。

如果给的不是扇区或者块的首地址也没有关系的，只要此地址是在扇区或者块的范围内，此扇区或者块也可以被正确擦除。不过建议使用时给首地址，方便管理。
1 U/ _5 |2 e0 y- q) d( \8 p
; T! n. r8 h4 Z) d" g/ H* ^73.3.5 W25QXX规格参数
这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：
. j2 _( H+ a* T  T* L1 q

: o# z$ G- Q0 L7 r# ]0 Y  页编程时间：典型值0.4ms，最大值3ms。
  扇区擦除时间（4KB）：典型值45ms，最大值400ms。
  块擦除时间（32KB）：典型值120ms，最大值1600ms。
' Y3 X- Y! U4 I/ {/ J6 r' }  块擦除时间（64KB）：典型值150ms，最大值2000ms。
6 _5 J8 h8 @1 O4 s  整个芯片擦除时间：典型值20s，最大值100s。
/ O1 I4 ]( D  f- V6 e+ {. ~

/ c! Q4 L. Z" ?  k, u支持的速度参数如下：
6 b6 t; e) b9 r& k8 C( b

5 W: r/ t( V. L' g  i( {& e
' Q9 a& B2 E2 @; h/ i' q可以看到最高支持的读时钟（使用命令03H）速度是50MHz，其它命令速度可以做到133MHz。

$ Z8 h8 d: b( g$ g; F73.4 W25QXX驱动设计
W25QXX的程序驱动框架设计如下：
: K) K, H( }( _' g

1 p* S) m& \$ w+ r' ^3 P+ _
  D+ E, r3 H: v6 n2 @有了这个框图，程序设计就比较好理解了。
0 P( N* v3 G$ r+ \; u+ P
73.4.1 第1步：SPI总线配置
spi总线配置通过如下两个函数实现：
& W! z( {, M+ T5 Z  X( U" b

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_InitSPIBus
   
4. *    功能说明: 配置SPI总线。
   5 b' N, F' a' j9 C9 ^# t
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   5 N# p# |8 w3 L( G/ h
8. */
   3 J2 T: f4 o1 u; w8 H& q
9. void bsp_InitSPIBus(void)
   3 y7 ?' l' @( S. h  y
10. {   
    
11.     g_spi_busy = 0;
    1 f# I% P! s3 Q$ f: |
12. 
    : }+ V7 [! Y3 O% O3 L6 ^/ x
13.     bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_8, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);
    7 {: q+ n; G% j* x1 y
14. }
    
15. 
    4 J, w1 o- b1 K! F5 _4 T0 S
16. /*
    
17. *********************************************************************************************************
    ; [( ]3 j6 F6 s. A$ k5 H
18. *    函 数 名: bsp_InitSPIParam
    
19. *    功能说明: 配置SPI总线参数，时钟分频，时钟相位和时钟极性。
    : S# U. V  ^: ^
20. *    形    参: _BaudRatePrescaler  SPI总线时钟分频设置，支持的参数如下：
    6 P5 C" x0 i3 H
21. *                                 SPI_BAUDRATEPRESCALER_2    2分频
    1 v& I( M# k1 y$ g
22. *                                 SPI_BAUDRATEPRESCALER_4    4分频
    & ]& f1 t8 ]4 \4 B
23. *                                 SPI_BAUDRATEPRESCALER_8    8分频
    
24. *                                 SPI_BAUDRATEPRESCALER_16   16分频
    
25. *                                 SPI_BAUDRATEPRESCALER_32   32分频
    
26. *                                 SPI_BAUDRATEPRESCALER_64   64分频
    - F/ w6 ^, `: o/ W" i6 R/ F( H% W
27. *                                 SPI_BAUDRATEPRESCALER_128  128分频
    
28. *                                 SPI_BAUDRATEPRESCALER_256  256分频
    " Q; Q8 |, h% y6 F: V5 t
29. *                                                        
    
30. *             _CLKPhase           时钟相位，支持的参数如下：
    9 ~0 ~' Q2 H& c+ G3 w1 Z
31. *                                 SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
    ( q: ^/ n! I: v) Y3 ?# H
32. *                                 SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
    
33. *                                 
    
34. *             _CLKPolarity        时钟极性，支持的参数如下：
    
35. *                                 SPI_POLARITY_LOW    SCK引脚在空闲状态处于低电平
    2 S2 |. I. h3 D9 d% P
36. *                                 SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平
    7 i# u. n/ r) q* O% s5 N- P
37. *
    
38. *    返 回 值: 无
    4 W9 b$ p' H# g+ U: F; t1 ~- Q7 j
39. *********************************************************************************************************
    
40. */
    
41. void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
      z% M7 d8 Q  A
42. {
    : E9 r: O& W; [$ b
43.     /* 提高执行效率，只有在SPI硬件参数发生变化时，才执行HAL_Init */
    0 ?* B$ r9 j- W: h/ k, E0 D
44.     if (s_BaudRatePrescaler == _BaudRatePrescaler && s_CLKPhase == _CLKPhase && s_CLKPolarity == _CLKPolarity)
    : C/ |' p. r7 T+ ~
45.     {        
    5 `# s! e* a5 T' z; F0 \" ~
46.         return;
    
47.     }
    / l/ F& [! Q) |  g7 ?
48. 
    
49.     s_BaudRatePrescaler = _BaudRatePrescaler;   
    6 o: D. P* b8 o
50.     s_CLKPhase = _CLKPhase;
    
51.     s_CLKPolarity = _CLKPolarity;
      m8 T& V8 k/ F$ q( {
52. 
    " }; A( X* W6 D/ W
53. 
    
54.     /* 设置SPI参数 */
    
55.     hspi.Instance               = SPIx;                   /* 例化SPI */
    
56.     hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
    $ m% S+ B4 j% t) t; g6 G( }/ B
57.     hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
    . P6 e0 E, A% L( F# k9 O
58.     hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
    # h1 _5 ]8 O5 ^
59.     hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
    ; `  H/ U( ^! M; v% h" h
60.     hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
    . d/ A# n; i" C  I$ s- e
61.     hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    
62.     hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    5 K& Z! [) H, j. f
63.     hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE; /* 禁止CRC */
    
64.     hspi.Init.CRCPolynomial     = 7;                       /* 禁止CRC后，此位无效 */
    
65.     hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;     /* 禁止CRC后，此位无效 */
    
66.     hspi.Init.NSS               = SPI_NSS_SOFT;               /* 使用软件方式管理片选引脚 */
    
67.     hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;  /* 设置FIFO大小是一个数据项 */
    ; }: c7 @; I( v( r$ d; V* B  @* W! }
68.     hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;      /* 禁止脉冲输出 */
    * p  ^4 r1 ~! ^6 }- Y; V
69.     hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    , A7 X/ q$ U! q7 c, Q; B9 Y% b# _3 R
70.     hspi.Init.Mode             = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    / O6 z* Q* c4 D1 e# _% L# c
71. 
    + C1 C! f- z( G1 S1 G2 `( e
72.     /* 复位配置 */
    # @  B: ^$ L$ i7 I
73.     if (HAL_SPI_DeInit(&hspi) != HAL_OK)
    5 O; _) a8 u8 R" K# B/ u, ~) |8 _! V
74.     {
    
75.         Error_Handler(__FILE__, __LINE__);
    
76.     }   
    
77. 
    " C" O1 v7 M/ z' x) ?. G
78.     /* 初始化配置 */
    
79.     if (HAL_SPI_Init(&hspi) != HAL_OK)
    / S: H# C+ l$ H% K: ]- N3 L
80.     {
    
81.         Error_Handler(__FILE__, __LINE__);
    , n+ \' V! t8 O: S- Y' |% r$ P
82.     }   
    
83. }

复制代码

关于这两个函数有以下两点要做个说明：

  函数bsp_InitSPIBus里面的配置是个初始设置。实际驱动芯片时，会通过函数bsp_InitSPIParam做再配置。
. x9 {9 w, A) v$ r  函数bsp_InitSPIParam提供了时钟分频，时钟相位和时钟极性配置。驱动不同外设芯片时，基本上调整这三个参数就够。当SPI接口上接了多个不同类型的芯片时，通过此函数可以方便的切换配置。
73.4.2 第2步：SPI总线的查询，中断和DMA方式设置
SPI驱动的查询，中断和DMA方式主要通过函数bsp_spiTransfer实现数据传输：
8 u+ Z; m& h/ [7 J9 S5 R  B

1. /*
   
2. *********************************************************************************************************
   
3. *                                 选择DMA，中断或者查询方式
   
4. *********************************************************************************************************
   
5. */
   
6. //#define USE_SPI_DMA    /* DMA方式  */
   / q: `6 A- A6 @% C2 h/ d& x
7. //#define USE_SPI_INT    /* 中断方式 */
   
8. #define USE_SPI_POLL   /* 查询方式 */
   ' s7 W, f* t* L
9. 
   * F: R0 C( \% D4 L- D# u
10. /* 查询模式 */
    
11. #if defined (USE_SPI_POLL)
    $ \- u7 s; f( K, K0 L
12. 
    
13. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];  
    . W$ R' o; i( P) o9 C) Z7 y4 o/ t  p8 R( F
14. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
15. 
    
16. /* 中断模式 */
    
17. #elif defined (USE_SPI_INT)
    
18. 
    . P, e8 V0 C$ h& I1 M
19. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    6 M- P; ]  W$ J
20. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
21. 
    
22. /* DMA模式使用的SRAM4 */
    
23. #elif defined (USE_SPI_DMA)
    
24.     #if defined ( __CC_ARM )    /* IAR *******/
    
25.         __attribute__((section (".RAM_D3"))) uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    5 R3 }" Y. i0 F/ v& ]/ ~. Q
26.         __attribute__((section (".RAM_D3"))) uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    # ~7 `5 {* q. f$ f' `! h
27.     #elif defined (__ICCARM__)   /* MDK ********/
    % P# o9 e; X4 c6 k
28.         #pragma location = ".RAM_D3"
    2 ?( W  a2 l( ]6 r% @$ J# B
29.         uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
30.         #pragma location = ".RAM_D3"
    
31.         uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    4 ?7 i4 U' p2 {  ]6 ]+ y
32.     #endif
    2 l- z2 ]/ e5 _! h/ K( f
33. #endif
    
34. 
    3 j9 h' j+ h9 |; ?
35. /*
    
36. *********************************************************************************************************
    * y3 n! B. s5 V7 o
37. *    函 数 名: bsp_spiTransfer
    5 ]8 @- d9 o; j8 x
38. *    功能说明: 启动数据传输
    
39. *    形    参: 无
    
40. *    返 回 值: 无
    
41. *********************************************************************************************************
    
42. */
    % B1 R% u+ J( _& u
43. void bsp_spiTransfer(void)
    9 ]" ^: `/ [- N6 n0 b0 u4 A
44. {
    8 S  ]5 ^8 ]/ V5 B" t. t" l- E. g
45.     if (g_spiLen > SPI_BUFFER_SIZE)
    6 w: f! K1 Y) k% R$ [- [
46.     {
    
47.         return;
    
48.     }
    
49. 
    / u( M+ R" f: q: l/ z. T' a
50.     /* DMA方式传输 */
    
51. #ifdef USE_SPI_DMA
    3 G( ?, l! O4 ^
52.     wTransferState = TRANSFER_WAIT;
    
53. 
    % _: P/ h* x: m6 y3 O0 w
54.     if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    
55.     {
    ! b9 I7 P) s# O3 P1 ]
56.         Error_Handler(__FILE__, __LINE__);
    6 R: z( H8 w% b3 l+ B$ L4 }4 F! o+ g
57.     }
    # R$ j2 P7 i' I7 z" N
58. 
    " X* A4 A0 n9 H- ^0 U; f
59.     while (wTransferState == TRANSFER_WAIT)
    . C4 K$ ?+ @! [
60.     {
    + \+ B0 Y0 c5 j" r. p4 b
61.         ;
    / Q$ Z4 S$ z0 J+ O& ^$ t# S4 T
62.     }
    / Z8 m4 h& E) z
63. #endif
    # D0 ]9 R; p- ]) q1 d8 d
64. 
    
65.     /* 中断方式传输 */   
    
66. #ifdef USE_SPI_INT
    3 A$ {( x" O0 y+ _1 O3 ~. G
67.     wTransferState = TRANSFER_WAIT;
    
68. 
    
69.     if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    
70.     {
    4 j. i& Q4 m7 p% W: p6 H
71.         Error_Handler(__FILE__, __LINE__);
    0 a; z0 R/ W- G" k( T: _2 r0 r
72.     }
    $ h8 C4 f4 I3 C4 Y. N
73. 
    
74.     while (wTransferState == TRANSFER_WAIT)
    
75.     {
    
76.         ;
    
77.     }
    + j" m' C' \9 b+ L. ]( f+ v9 {
78. #endif
    
79. 
    1 o/ l9 Q; D7 R0 y9 ~; _( Q5 k" M
80.     /* 查询方式传输 */   
    ) n* j( E/ O, q. ^
81. #ifdef USE_SPI_POLL
    ' K. @& b* X3 p3 q$ Z" }  }, E
82.     if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)   
    
83.     {
    
84.         Error_Handler(__FILE__, __LINE__);
    # X$ W& d& d" P/ y( C  P
85.     }   
    8 A3 W9 b) x/ R
86. #endif
    : e" G! z8 p4 H+ D* i" w: L  o
87. }
    

复制代码

通过开头宏定义可以方便的切换中断，查询和DMA方式。其中查询和中断方式比较好理解，而DMA方式要特别注意两点：
# u) x6 U$ {2 Q9 j" T
- B) J6 v0 ?5 Q# S% n( ?  通过本手册第26章的内存块超方便使用方式，将DMA缓冲定义到SRAM4上。因为本工程是用的DTCM做的主RAM空间，这个空间无法使用通用DMA1和DMA2。
  由于程序里面开启了数据Cache，会造成DMA和CPU访问SRAM4数据不一致的问题，特此将SRAM4空间关闭Cache。
. G0 M/ c8 Q" R& i. \  N+ V

1.     /* 配置SRAM4的MPU属性为Non-cacheable */
   
2.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   ; Q* ~1 r9 D3 }+ t" j( s
3.     MPU_InitStruct.BaseAddress      = 0x38000000;
   / J2 k) M9 _8 c. S* K0 V6 i9 c- d+ `
4.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   
5.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   
6.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   
7.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   1 S& y. A6 j& t, V0 W- h
8.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   & C  J) i  x# J6 l. |
10.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    , o, Y; B, }8 z1 |; E# z! E! }
11.     MPU_InitStruct.SubRegionDisable = 0x00;
    
12.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : ^9 m6 y2 I; H7 b
13. 
    
14.     HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

4 a/ x0 z5 I* c9 ~) C73.4.3 第3步：W25QXX的时钟极性和时钟相位配置
: H' d6 Y4 b" D8 |# Y首先回忆下STM32H7支持的4种时序配置。
2 S8 t, H/ Q( S  l
$ O7 B* o9 A9 y  当CPOL = 1， CPHA = 1时
  p+ Q( m7 p: x! h, F, H, \; V
SCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。

9 Y8 N% ~7 a8 S. d9 b" D  当CPOL = 0， CPHA = 1时

) C' H* w0 s3 {, R+ C4 _+ K, u! lSCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。
$ M( X' h( B7 @
  当CPOL = 1， CPHA = 0时

, f% V) p# T0 [6 p1 @& [+ TSCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

当CPOL = 1， CPHA = 0时

# {8 g, F! v- Y+ E4 _1 a2 NSCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
0 e; j$ O# ?- k

7 i; l. a; _3 K' s9 Z有了H7支持的时序配置，再来看下W25Q的时序图：
, @* N: Y0 @7 x! r
Mode0 ： 空闲状态的sck是低电平。

Mode1 ： 空闲状态的sck是高电平。
. Y$ D% _4 E; f8 D3 ~( v2 W
5 v" @% {2 A1 E: P* r- X+ h3 I1 J

0 q0 C  F# Y+ S" h首先W25Q是上升沿做数据采集，所以STM32H7的可选的配置就是：

3 `& _$ {) c, \2 N- oCHOL = 1,  CPHA = 1
, Q( B$ ^. L% G- B' h; _. J
0 x9 S) \2 {) s9 Q) MCHOL = 0,  CPHA = 0
4 G) p8 i1 G3 C/ d  e! o* f
+ t: [9 X3 F. g; I+ k对于这两种情况，具体选择哪种，继续往下看。W25Q有两种SCK模式，分别是Mode0和Mode3，也就是空闲状态下，SCK既可以是高电平也可以是低电平。这样的话，这两种情况都可以使用，经过实际测试，STM32H7使用这两个配置均可以配置驱动W25Q。

# J9 i5 ?9 ]; W0 s% x3 Z73.4.4 第4步：单SPI接口管理多个SPI设备的切换机制
单SPI接口管理多个SPI设备最麻烦的地方是不同设备的时钟分配，时钟极性和时钟相位并不相同。对此的解决解决办法是在片选阶段配置切换，比如SPI Flash的片选：

' X+ s) E% A$ M9 S$ G& a& Q1 E

1. /*
   * [/ j4 \' I7 u1 K) j
2. *********************************************************************************************************
   
3. *    函 数 名: sf_SetCS
   & [- u7 Z! l& U) W( @$ D
4. *    功能说明: 串行FALSH片选控制函数
   0 X# a9 Z; T5 t, v
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ) ~& x7 x# ^& J  M
8. */
   
9. void sf_SetCS(uint8_t _Level)
   
10. {
    
11.     if (_Level == 0)
    ( k9 V1 u: V9 q+ y8 r
12.     {
    0 V8 x: X* Z0 Z3 g* V
13.         bsp_SpiBusEnter();   
    4 x% g# a( A, c6 L% v1 ~
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    
15.         SF_CS_0();
    
16.     }
    
17.     else
    , G8 {5 x8 O( o( I
18.     {        
    
19.         SF_CS_1();   
    
20.         bsp_SpiBusExit();        
    
21.     }
      N7 U( s3 c: k( g& k$ P, a; K
22. }
      F' }# U; s$ T" H

复制代码

5 K. b, g6 g# _+ A, c7 _! b
通过这种方式就有效的解决了单SPI接口管理多设备的问题。因为给每个设备都配了一个独立的片选引脚，这样就可以为每个设备都配置这么一个片选配置。
4 H2 |) ~, ^& t" @5 a& G1 O4 b
但是频繁配置也比较繁琐，所以函数bsp_InitSPIParam里面做了特别处理。当前配置与之前配置相同的情况下无需重复配置。

73.4.5 第5步：W25QXX的读取实现
4 L3 o7 B2 [( o& V: {0 e# b% A/ Q" YW25QXX的读取功能比较好实现，发送03H命令后，设置任意地址都可以读取数据，只要不超过芯片容量即可。

. k" f' v% D- K& _! }% m8 b  \: I

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_ReadBuffer
   
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   
5. *    形    参:      _pBuf : 数据源缓冲区；
   4 E& l* m; d" I0 H% L0 M
6. *                _uiReadAddr ：首地址
   6 E; e5 J7 F) m1 L
7. *                _usSize ：数据个数, 不能超出芯片总容量
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    8 _' i* D" k  B
11. void sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    , n- E: e5 y' H, ^& D2 d# z: t
12. {
    % j' D9 m* r# d( b  C* H
13.     uint16_t rem;
    
14.     uint16_t i;
    
15. 
    
16.     /* 如果读取的数据长度为0或者超出串行Flash地址空间，则直接返回 */
    
17.     if ((_uiSize == 0) ||(_uiReadAddr + _uiSize) > g_tSF.TotalSize)
    
18.     {
    
19.         return;
    7 \' V* ]+ s& u# S9 _9 @# @
20.     }
    
21. 
    , C( S9 q% y$ j& o3 i
22.     /* 擦除扇区操作 */
    . [* W* {( O5 B% ^; Q
23.     sf_SetCS(0);                                    /* 使能片选 */
    
24.     g_spiLen = 0;
    
25.     g_spiTxBuf[g_spiLen++] = (CMD_READ);                            /* 发送读命令 */
    
26.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
      w1 `8 V7 i6 H2 j
27.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF00) >> 8);        /* 发送扇区地址中间8bit */
    
28.     g_spiTxBuf[g_spiLen++] = (_uiReadAddr & 0xFF);                /* 发送扇区地址低8bit */
    % f" q2 }2 p' L; g/ Q  Q- Y
29.     bsp_spiTransfer();
    5 k# N4 S% {5 i4 S; n+ m) l% |6 J
30. 
    : X$ H1 p8 B% q1 F/ F
31.     /* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
    
32.     for (i = 0; i < _uiSize / SPI_BUFFER_SIZE; i++)
    
33.     {
    
34.         g_spiLen = SPI_BUFFER_SIZE;
    
35.         bsp_spiTransfer();
    . t3 D. ?- R# d! }: S& d' i1 i) J
36. 
    
37.         memcpy(_pBuf, g_spiRxBuf, SPI_BUFFER_SIZE);
    6 D: B4 r3 x; v) }9 e
38.         _pBuf += SPI_BUFFER_SIZE;
    - S3 C4 P1 C4 w) O1 ^1 E9 O" Z
39.     }
    6 j. c4 @- Z& ]2 n
40. 
    / w6 e$ |- D/ c+ }8 ^
41.     rem = _uiSize % SPI_BUFFER_SIZE;    /* 剩余字节 */
    1 Q. c) k( T4 q+ c& F0 u+ i/ s4 p
42.     if (rem > 0)
    + u& f& Z& m( D" }0 m1 m+ K
43.     {
    1 X+ _( u' C) g7 t1 Y
44.         g_spiLen = rem;
    2 q0 z/ r8 O+ }8 G
45.         bsp_spiTransfer();
    
46. 
    
47.         memcpy(_pBuf, g_spiRxBuf, rem);
    0 b8 s8 W. U) m7 K+ B4 c9 l  u1 g
48.     }
    3 m1 W" t  T& v6 n" O
49. 
    
50.     sf_SetCS(1);                                    /* 禁能片选 */
    ) k6 d" w- ~( O/ x
51. }

复制代码

4 O6 n! x7 ?; f5 U# _
1 D$ S' W% D' t6 P这个函数对DMA传输做了特别处理，方便分包进行。

73.4.6 第6步：W25QXX的扇区擦除实现
扇区擦除的实现也比较简单，发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除。擦除的扇区大小是4KB。
- ~! x/ G# ]" o* ^  c
7 ~" U% j! H! ?

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_EraseSector
   2 b" r: P) S. h/ O  c
4. *    功能说明: 擦除指定的扇区
   , }0 X" r, R) ^9 Y( s4 `
5. *    形    参: _uiSectorAddr : 扇区地址
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void sf_EraseSector(uint32_t _uiSectorAddr)
   
10. {
    4 y7 c7 |) x4 B( l7 u
11.     sf_WriteEnable();                            /* 发送写使能命令 */
    * M" u9 [# _+ G& a- Q6 x
12. 
    " y1 m$ \) a8 @) k8 g
13.     /* 擦除扇区操作 */
    
14.     sf_SetCS(0);                                /* 使能片选 */
    % Y, b* ?" n, a" `, r
15.     g_spiLen = 0;
    6 X% i" k9 i% M" I% a' W
16.     g_spiTxBuf[g_spiLen++] = CMD_SE;                /* 发送擦除命令 */
    4 u  I" `2 n( L( W( Q, Y& [
17.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    
18.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF00) >> 8);    /* 发送扇区地址中间8bit */
    
19.     g_spiTxBuf[g_spiLen++] = (_uiSectorAddr & 0xFF);            /* 发送扇区地址低8bit */   
    
20.     bsp_spiTransfer();
    
21.     sf_SetCS(1);                                    /* 禁能片选 */
    6 A* w! M! n+ f: z( z( W, h( J) j
22. 
    - p: W1 L) S, {* E( e, z8 @! A
23.     sf_WaitForWriteEnd();                            /* 等待串行Flash内部写操作完成 */
    ' D) Q. e, m  c- t
24. }
    

复制代码

整个芯片的擦除更省事些，仅发送整个芯片擦除命令即可：

1. /*
   % ~( h" D) j7 J) Q
2. *********************************************************************************************************
   * l; h; {1 _% J: i1 K8 w, s( M, |4 C
3. *    函 数 名: sf_EraseChip
   
4. *    功能说明: 擦除整个芯片
   # _* O" k/ e6 S
5. *    形    参:  无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
     u6 P& u* Z& a1 J/ D- r+ r, h
8. */
   
9. void sf_EraseChip(void)
   ) d- l: B5 _8 j9 Q5 B2 w
10. {   
    ( ^3 R: Z* K/ z6 U. B
11.     sf_WriteEnable();                                /* 发送写使能命令 */
    / Y5 l5 ?4 W; @3 V# N! F8 ?& U
12. 
    . ?+ q3 r% e0 n/ y0 R
13.     /* 擦除扇区操作 */
    . Q7 E) o9 P: Q
14.     sf_SetCS(0);        /* 使能片选 */
    : d, Q. C8 n, c2 H7 g* Z
15.     g_spiLen = 0;
    
16.     g_spiTxBuf[g_spiLen++] = CMD_BE;        /* 发送整片擦除命令 */
    " a  I$ @0 y4 v+ ~3 \
17.     bsp_spiTransfer();
    
18.     sf_SetCS(1);                        /* 禁能片选 */
    
19. 
    
20.     sf_WaitForWriteEnd();                /* 等待串行Flash内部写操作完成 */
    0 C. C# E/ |2 h7 i
21. }
    

复制代码

73.4.7 第7步：W25QXX的编程实现
* k2 Z1 H6 o9 S" f/ DW25QXX的编程实现略复杂，因为做了自动擦除支持，大家可以在任意地址，写任意大小的数据，只要不超过芯片容量即可。我们这里就不做展开讨论了，大家有兴趣可以研究下：
. ^8 L: {; h  M
! G( r! s0 @5 E' g8 h) Q

1. /*
   ( U  [/ y& v7 ?* Y" Q' @- Q6 I
2. *********************************************************************************************************
   ; ~6 Q7 v4 f/ N9 Y2 H4 `6 }2 l: [
3. *    函 数 名: sf_WriteBuffer
   & f8 C1 @. o# H: w; q, n
4. *    功能说明: 写1个扇区并校验,如果不正确则再重写两次，本函数自动完成擦除操作。
   ( L" ^4 _0 A" i7 c3 D7 w& G
5. *    形    参:  _pBuf : 数据源缓冲区；
   
6. *               _uiWrAddr ：目标区域首地址
   
7. *               _usSize ：数据个数，任意大小，但不能超过芯片容量。
   
8. *    返 回 值: 1 : 成功， 0 ： 失败
   
9. *********************************************************************************************************
   ; @/ _' c9 A# g6 V
10. */
    6 F1 N# \4 ]4 R7 o) D
11. uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)
    - t- N* L2 p9 M; D' R
12. {
    
13.     uint32_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
    4 _) i/ @- n4 S6 }
14. 
    . ]; M8 e, Z  s" z+ c% s+ `
15.     Addr = _uiWriteAddr % g_tSF.SectorSize;
    3 ^8 K$ y# T) P
16.     count = g_tSF.SectorSize - Addr;
    1 F9 h" K$ ?* N/ W$ f
17.     NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    
18.     NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    * Y$ T4 a% P$ G/ ]# E: h, u
19. 
    5 u5 t, y9 c% r. e9 c0 G
20.     if (Addr == 0) /* 起始地址是扇区首地址  */
    
21.     {
    5 ~' ^! x5 j/ Y( ^8 |
22.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
23.         {
    6 `% h0 R9 }+ S- N# T
24.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    " c2 @+ }# \% j, V7 Y
25.             {
    0 j" z* p6 K+ P% q9 G9 V$ g( j
26.                 return 0;
    5 N2 S  x/ t, b6 K, s/ z
27.             }
    3 j4 t5 q1 g2 u0 f( V
28.         }
    ' \7 G" T" H  g2 L; `% C
29.         else     /* 数据长度大于等于扇区大小 */
    & l+ g% }; H8 T2 d0 m
30.         {
    $ e" h/ b# ]5 y# `
31.             while (NumOfPage--)
    - g: E/ g' J  d+ o/ A( f5 E
32.             {
    
33.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    8 m( h( m8 z/ G3 C
34.                 {
    ; Q, c" x. k: @, n0 R
35.                     return 0;
    7 w3 U. X/ X% u8 L" T9 s
36.                 }
    
37.                 _uiWriteAddr +=  g_tSF.SectorSize;
    
38.                 _pBuf += g_tSF.SectorSize;
    ( @. A7 V. E. @# h6 k- S# O, z
39.             }
    $ M" F1 b. _  U7 u- X8 L
40.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
    ( c! D4 x0 F' h( d4 w# S9 K  J. D
41.             {
    
42.                 return 0;
    ' w) @4 j/ O% W3 n6 R
43.             }
    
44.         }
    
45.     }
    3 Q1 a3 K5 {. N& O( M0 _
46.     else  /* 起始地址不是扇区首地址  */
    - W  x9 Y/ o: ]! g; L% z; i! R
47.     {
    
48.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
49.         {
    
50.             if (NumOfSingle > count)  /* (_usWriteSize + _uiWriteAddr) > SPI_FLASH_PAGESIZE */
    
51.             {
    
52.                 temp = NumOfSingle - count;
    
53. 
    
54.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    
55.                 {
    7 M3 Q7 I; i: i! L! i
56.                     return 0;
    5 W  r0 M$ f' ]5 s8 \) e% [0 ]
57.                 }
    
58. 
    
59.                 _uiWriteAddr +=  count;
    
60.                 _pBuf += count;
    % m( ~1 B6 c4 `6 M
61. 
    
62.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, temp) == 0)
    
63.                 {
    
64.                     return 0;
    / z- g$ G& n7 c, p( @
65.                 }
    
66.             }
    
67.             else
    
68.             {
    
69.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    7 f# j+ \3 W# [/ R1 h5 @- j
70.                 {
    
71.                     return 0;
    ! Y; B" g( |5 ~4 q
72.                 }
    
73.             }
    
74.         }
    " y( ]7 h+ }" j) r. E1 q
75.         else    /* 数据长度大于等于扇区大小 */
    
76.         {
    
77.             _usWriteSize -= count;
    ) I. |  W, E4 ~, t% m
78.             NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    
79.             NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    * U3 J/ V* s4 a& f" h: t( j1 c
80.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    
81.             {
    * W4 \# N! F( \3 O9 \
82.                 return 0;
    
83.             }
    
84. 
    4 R9 L" Y1 c; i% ~5 o, L: q
85.             _uiWriteAddr +=  count;
    $ p- m) D( y3 U( l1 L1 h
86.             _pBuf += count;
    
87. 
    
88.             while (NumOfPage--)
    % W4 U9 }- F- O; Z) J4 |" D
89.             {
    " f( d9 e8 N9 |7 I7 [2 y9 L/ s- b
90.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    
91.                 {
    
92.                     return 0;
    ) E! y/ y5 E5 o( `
93.                 }
    ! a- k. J5 k, ~2 m" @( S2 D
94.                 _uiWriteAddr +=  g_tSF.SectorSize;
      P: k# W! P) H9 A
95.                 _pBuf += g_tSF.SectorSize;
    
96.             }
    " _7 q* a) {, R4 \- W
97. 
    " j8 j! j  [2 l$ v* D
98.             if (NumOfSingle != 0)
    
99.             {
    4 g' Q% ?+ f- }8 b+ c+ D
100.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
     5 m: v2 u& w) O/ {, E1 {
101.                 {
     ' C( C8 k* V5 V$ Q( @
102.                     return 0;
     5 u! P6 Q4 Q# \1 [
103.                 }
     : m9 w2 O2 `0 O: I
104.             }
     9 M; `' \6 T8 B
105.         }
     3 i4 e" A2 H$ M/ \( h
106.     }
     
107.     return 1;    /* 成功 */
     , I, l# Y' Q- N+ S" d$ O; r
108. }

复制代码

73.5 SPI总线板级支持包（bsp_spi_bus.c）
1 M6 f* l% R3 h/ a$ JSPI总线驱动文件bsp_spi_bus.c主要实现了如下几个API供用户调用：
0 S' d, M5 ?5 R! i% k0 U, b
  bsp_InitSPIBus
  bsp_InitSPIParam
6 \! M+ ~$ H6 Z6 P  bsp_spiTransfer
73.5.1 函数bsp_InitSPIBus
9 R, _3 ~3 O, B0 o. `函数原型：
6 ~% H8 G# F% x! F6 l5 H
6 o# F7 i0 m2 I0 D: p# v0 vvoid bsp_InitSPIBus(void)
- |4 \0 w( W5 H3 j5 A
- l, r4 w- @: x  F( S函数描述：

2 o& y' L) L$ k: d, x0 y/ j' _此函数主要用于SPI总线的初始化，在bsp.c文件调用一次即可。
; O) u/ |& o2 ?
3 c; Y8 |/ i9 P; X4 \/ V8 d( v73.5.2 函数bsp_InitSPIParam
9 g( d1 b2 h4 U" G! g函数原型：
  u0 \  @4 g6 I& n, S( E5 z
' Y) l3 w, L2 U6 L1 u9 \: d' Mvoid bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
" m# }$ e1 }4 a+ c# f
4 N, W; T! c! d9 m0 w  ?- H+ T! ?函数描述：

' U  J( E# P& e! m此函数用于SPI总线的配置。
1 v) b* n* E" }) @2 Y4 `
' j. W, f: W- O: k3 B2 B函数参数：
) k) h# ?8 s  T8 V
% l' ^. V0 n6 ?, S1 g$ H  第1个参数SPI总线的分频设置，支持的参数如下：
SPI_BAUDRATEPRESCALER_2    2分频
# t9 o- v& s0 |8 \$ Z
) G  Q5 `% R( {, w, D, U! vSPI_BAUDRATEPRESCALER_4    4分频

) ^5 L5 p$ N$ r: K) g# o/ iSPI_BAUDRATEPRESCALER_8    8分频

, x( C. E9 q6 S6 U3 }/ ]2 |6 F0 oSPI_BAUDRATEPRESCALER_16   16分频
$ \/ h9 z$ ?& {5 l* K( `
SPI_BAUDRATEPRESCALER_32   32分频

SPI_BAUDRATEPRESCALER_64   64分频
( a% F6 e7 k( ?& O0 x* E! x, o
SPI_BAUDRATEPRESCALER_128  128分频
+ `- s! e( e6 t9 f
SPI_BAUDRATEPRESCALER_256  256分频
" w3 n% o/ p  y* A' a% L. w% B
  第2个参数用于时钟相位配置，支持的参数如下：
# X1 m0 W2 V0 H% N5 x% \* XSPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据

6 h! H8 X5 N2 uSPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据

  第3个参数是时钟极性配置，支持的参数如下：
8 ^7 A5 E, A9 oSPI_POLARITY_LOW   SCK引脚在空闲状态处于低电平

SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平

+ v3 B" U3 ~# R: f: t73.5.3 函数bsp_spiTransfer
# m9 M3 D" O$ E- \3 Z# i8 v) q( Q1 R函数原型：

void bsp_spiTransfer(void)

& C, G; ]) u" J函数描述：
4 o! R: h  W. J! T/ I
' R0 i8 N5 g/ B7 {此函数用于启动SPI数据传输，支持查询，中断和DMA方式传输。
7 S9 [& s- i1 a
  n( g& A! |- V0 `$ t9 B* |) |* U73.6 W25QXX板级支持包（bsp_spi_flash.c）
7 m3 j4 T% u# w4 a! |W25QXX驱动文件bsp_spi_flash.c主要实现了如下几个API供用户调用：
7 ?4 @' D& u6 l+ z
  sf_ReadBuffer
- x; j; K& [+ L  U  sf_WriteBuffer
6 P1 m' n3 B8 }7 m: Z  sf_EraseSector
  sf_EraseChip
  sf_EraseSector
73.6.1 函数sf_ReadBuffer
3 R% e* Y: Y+ |& x) `( E/ {9 g! y) h函数原型：
+ q& M8 z/ y9 u& x( k" x
void sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)

8 j9 s* N3 H) h) B* S- S函数描述：
( Y& b" |/ r2 c: e# @; O  N
  z9 W" T/ a: l此函数主要用于从SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。

( g4 C+ q0 B7 O! \函数参数：

  第1个参数用于存储从SPI Flash读取的数据。
2 ~( h1 T. t; V1 m( L$ n  第2个参数是读取地址，不可以超过芯片容量。
( H9 T1 K1 z7 m& a0 N! V9 x  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
% y  N  b% _1 {9 V73.6.2 函数sf_WriteBuffer（自动执行擦除）
函数原型：
2 F- h/ ?! M9 }' F6 E! F! R
' Z, E/ D' @9 N: d4 f$ Duint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)

; C* F( d, _: H: `函数描述：
0 o6 m$ x) o5 D9 T8 {* ~( I( W
此函数主要用于SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。特别注意，此函数会自动执行擦除，无需用户处理。

0 {9 ?- r  ^7 x; O7 C函数参数：

: X. @5 m3 y. q! {3 Q  第1个参数是源数据缓冲区。
  第2个参数是目标区域首地址。
6 \7 m" Z" M( }8 @( ]! n  第3个参数是数据个数，支持任意大小，但不能超过芯片容量。单位字节个数。
; t4 |" a4 |, n( B3 t0 m  返回值，返回1表示成功，返回0表示失败。
73.6.3 函数sf_EraseSector
6 S$ q& q1 f7 N; E函数原型：
& W& Y. i8 y! I; U2 y: S
8 b0 W5 j: [* ~2 X% Y3 C$ Gvoid sf_EraseSector(uint32_t _uiSectorAddr)

, g% d! X2 O$ Q' _/ w- Q$ [函数描述：

此函数主要用于扇区擦除，一个扇区大小是4KB。

) p+ ~+ Y  j- o- k, _: X, _) O函数参数：
. @! z) x/ f# G; z3 [4 j
  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
73.6.4 函数sf_EraseChip
0 D( K6 G" \7 _. h6 y. N0 ?9 V8 @9 a9 ]函数原型：

/ b, Z+ D  j+ J6 ]: [8 Qvoid sf_EraseChip(void)

函数描述：

- ^. H' D. @# `6 f, y; S此函数主要用于整个芯片擦除。
# c2 \& h( I: {& l9 M  v. A
73.6.5 函数sf_PageWrite（不推荐）
* q$ B' I6 o$ x函数原型：

void sf_PageWrite(uint8_t * _pBuf, uint32_t _uiWriteAddr, uint16_t _usSize)

函数描述：

2 e8 j. M( H& `( w+ c/ c% |1 X此函数主要用于页编程，一次可以编程多个页，只要不超过芯片容量即可。不推荐大家调用此函数，因为调用这个函数前，需要大家调用函数sf_EraseSector进行扇区擦除。

函数参数：
- w% V, V% O7 r
  第1个参数是数据源缓冲区。
  第2个参数目标区域首地址，比如编程页0，此处填0x0000，编程页1，此处填0x0100，编程页2，此处填0x0200，以此类推。
: c! d: ~, b$ i4 ^  第3个参数是编程的数据大小，务必是256字节的整数倍，单位字节个数。
$ u, M8 r/ J3 k) T( b) h9 L73.7 W25QXX驱动移植和使用
1 c1 _( |$ C* CW25QXX移植步骤如下：
0 q5 c* h4 M+ l/ }3 g* F" Z
  第1步：复制bsp_spi_bus.c，bsp_spi_bus.h，bsp_spi_flash.c，bsp_spi_flash.h到自己的工程目录，并添加到工程里面。
  第2步：根据使用的第几个SPI，SPI时钟，SPI引脚和DMA通道等，修改bsp_spi_bus.c文件开头的宏定义

1. /*
   
2. *********************************************************************************************************
   ! r/ m2 R9 A( l( T7 m
3. *                                时钟，引脚，DMA，中断等宏定义
   ( b" K. S+ l* P8 p* s8 j6 S9 z* w
4. *********************************************************************************************************
   0 ?9 W7 }3 v' X1 ?; |0 L0 C
5. */
   , U, ?2 k( P% p; a+ q3 f
6. #define SPIx                            SPI1
   
7. #define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
   ) R% B# m- N6 g4 w) y7 z2 O
8. #define DMAx_CLK_ENABLE()                __HAL_RCC_DMA2_CLK_ENABLE()
   
9. 
   
10. #define SPIx_FORCE_RESET()                __HAL_RCC_SPI1_FORCE_RESET()
    
11. #define SPIx_RELEASE_RESET()            __HAL_RCC_SPI1_RELEASE_RESET()
    + W+ f2 w3 E5 k7 q4 y8 R5 _
12. 
    
13. #define SPIx_SCK_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    * M1 O: q. a: `$ u, `
14. #define SPIx_SCK_GPIO                    GPIOB
    % h' Q4 m& h; m: F( s1 V% j6 G+ a$ ^
15. #define SPIx_SCK_PIN                    GPIO_PIN_3
    : b& Z- W' D7 z1 [
16. #define SPIx_SCK_AF                        GPIO_AF5_SPI1
    
17. 
    
18. #define SPIx_MISO_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    
19. #define SPIx_MISO_GPIO                    GPIOB
    
20. #define SPIx_MISO_PIN                     GPIO_PIN_4
    
21. #define SPIx_MISO_AF                    GPIO_AF5_SPI1
      ?* i: _6 Q; i2 T3 v# G
22. 
    
23. #define SPIx_MOSI_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    + [# O" K7 R! @- }0 \: Q
24. #define SPIx_MOSI_GPIO                    GPIOB
    ' D4 X) _6 v) ?8 ]+ l
25. #define SPIx_MOSI_PIN                     GPIO_PIN_5
    ' I$ E3 A% \. G
26. #define SPIx_MOSI_AF                    GPIO_AF5_SPI1
    
27. 
    
28. #define SPIx_TX_DMA_STREAM               DMA2_Stream3
    , M- n2 g2 i$ S" f) ~
29. #define SPIx_RX_DMA_STREAM               DMA2_Stream2
    # v4 L2 B' o7 g6 g
30. 
    4 I) ~, O: ~2 e- K7 v5 L* q
31. #define SPIx_TX_DMA_REQUEST              DMA_REQUEST_SPI1_TX
    
32. #define SPIx_RX_DMA_REQUEST              DMA_REQUEST_SPI1_RX
    1 \% H! K# J! }9 X0 |7 X& c) U! Y
33. 
    / w( R9 a. Y/ g$ b# E4 E) q
34. #define SPIx_DMA_TX_IRQn                 DMA2_Stream3_IRQn
    
35. #define SPIx_DMA_RX_IRQn                 DMA2_Stream2_IRQn
    
36. 
    
37. #define SPIx_DMA_TX_IRQHandler           DMA2_Stream3_IRQHandler
    
38. #define SPIx_DMA_RX_IRQHandler           DMA2_Stream2_IRQHandler
    
39. 
    ( q$ L% x0 d) F  U
40. #define SPIx_IRQn                        SPI1_IRQn
    
41. #define SPIx_IRQHandler                  SPI1_IRQHandler
    

复制代码

7 |+ |: w5 Y  \9 x% Z
  第3步：根据使用的SPI ID，添加定义到文件bsp_spi_flash.h
- u6 V- K0 p3 g4 y! S

1. /* 定义串行Flash ID */
   
2. enum
   
3. {
   
4.     SST25VF016B_ID = 0xBF2541,
   ' V8 w0 a  s. O! n/ V
5.     MX25L1606E_ID  = 0xC22015,
   
6.     W25Q64BV_ID    = 0xEF4017, /* BV, JV, FV */
   
7.     W25Q128_ID     = 0xEF4018
   * s% x" m& [( L, O' h" o1 E) R5 N' i: J
8. };

复制代码

5 V! ^" _* {0 {# u& u  第4步：添加相应型号到bsp_spi_flash.c文件的函数sf_ReadInfo里面。
5 K: m0 z5 }$ F3 G

1. /*
   ) B4 L/ p& G! r) b/ A' J
2. *********************************************************************************************************
   * G6 F1 m9 g- u. e1 ?% V9 G$ ~
3. *    函 数 名: sf_ReadInfo
   
4. *    功能说明: 读取器件ID,并填充器件参数
   
5. *    形    参: 无
   6 G. j# A0 Z1 n
6. *    返 回 值: 无
   % Q1 g# d: [, c) E/ t
7. *********************************************************************************************************
   
8. */
   + r2 j( y: A0 D& c6 d. _
9. void sf_ReadInfo(void)
   8 J, N: d( e8 n3 O5 C7 |
10. {
    7 G+ Q! T' D$ m0 m9 n( g% x  x
11.     /* 自动识别串行Flash型号 */
    0 K) Q, x8 `6 o& Q5 V( [3 [2 r
12.     {
    7 n! J0 V  W4 B' a
13.         g_tSF.ChipID = sf_ReadID();    /* 芯片ID */
    ) ^. g1 E) C; D3 X
14. 
    
15.         switch (g_tSF.ChipID)
    
16.         {
    * U$ ?4 X" Y1 a; h9 o. Y* Z6 b
17.             case SST25VF016B_ID:
      h8 c; E" w5 j* p/ b( L6 g
18.                 strcpy(g_tSF.ChipName, "SST25VF016B");
    6 ]- S1 @- _% V. d4 a% R- P
19.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    $ n% r3 N9 \. D: n
20.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
21.                 break;
    ! Y2 j) T' {  ?3 `$ U
22. 
    
23.             case MX25L1606E_ID:
    " Q$ u8 T8 L3 Z/ u
24.                 strcpy(g_tSF.ChipName, "MX25L1606E");
    
25.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    " Q" \3 h2 }/ [6 A8 d9 x" v( Q
26.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    9 T! i7 i; `/ F& D. y) f
27.                 break;
    
28. 
    / j! U6 C9 i2 n. d) S, y
29.             case W25Q64BV_ID:
    0 d9 A& A% ^* _# O, g' x! h' Y
30.                 strcpy(g_tSF.ChipName, "W25Q64");
    
31.                 g_tSF.TotalSize = 8 * 1024 * 1024;    /* 总容量 = 8M */
    ( P" c' l5 c: X; j; ?( z
32.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    3 o8 W( e3 L3 E0 V) h! I
33.                 break;
    ! X8 W2 K+ B/ \9 A
34. 
    
35.             case W25Q128_ID:
    ' a/ m9 |5 Y4 h0 j
36.                 strcpy(g_tSF.ChipName, "W25Q128");
    
37.                 g_tSF.TotalSize = 16 * 1024 * 1024;    /* 总容量 = 8M */
    
38.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    4 k3 \% K4 r2 M( {$ s7 a
39.                 break;            
    
40. 
    
41.             default:
    ( E. {+ x1 ?/ n; J" [! t4 S
42.                 strcpy(g_tSF.ChipName, "Unknow Flash");
    
43.                 g_tSF.TotalSize = 2 * 1024 * 1024;
    
44.                 g_tSF.SectorSize = 4 * 1024;
      S, m0 Q* }2 _# p/ W
45.                 break;
    : X1 a/ {' R5 T- o8 T  |* e
46.         }
    4 w  [/ s& @0 E7 I+ \
47.     }
    
48. }

复制代码

  第5步：根据芯片支持的时钟速度，时钟相位和时钟极性配置函数sf_SetCS。
7 F  a! p' [! \

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_SetCS
   
4. *    功能说明: 串行FALSH片选控制函数
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   9 v9 V4 A. n3 \( W9 @. Z  D( B- L+ t
7. *********************************************************************************************************
   0 o2 ?9 T; e! @  F
8. */
   , Y& |1 }% h8 k* p# o
9. void sf_SetCS(uint8_t _Level)
   
10. {
    # I5 s8 e/ |) S# Z& b2 P9 G- @7 F
11.     if (_Level == 0)
    ; x( H: a5 i' Q
12.     {
    
13.         bsp_SpiBusEnter();   
    * A$ \7 i9 H+ V/ x3 @
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    9 f. Y2 i1 G  H6 a2 S+ U% L5 x. c
15.         SF_CS_0();
    * B' C3 P% R9 W& z& w
16.     }
    
17.     else
    / C0 w2 T- R9 \0 D
18.     {        
    
19.         SF_CS_1();   
    8 t& M% f. g6 K3 k& M0 p
20.         bsp_SpiBusExit();        
    
21.     }
    $ i" v" j, G* Q7 a* p
22. }

复制代码

7 u  T4 D$ _% |3 {  第6步：根据使用的SPI Flash片选引脚修改bsp_spi_bus.c文件开头的宏定义。

1. /* 串行Flash的片选GPIO端口， PD13  */
   # M8 a4 d" p1 d" z9 `* q: y) T
2. #define SF_CS_CLK_ENABLE()             __HAL_RCC_GPIOD_CLK_ENABLE()
   
3. #define SF_CS_GPIO                    GPIOD
   
4. #define SF_CS_PIN                    GPIO_PIN_13
   . I8 b+ N1 G# B9 M3 B7 @9 Z
5. 
   $ E) Z7 d- W0 r6 }4 R* e
6. #define SF_CS_0()                    SF_CS_GPIO->BSRR = ((uint32_t)SF_CS_PIN << 16U)
   
7. #define SF_CS_1()                    SF_CS_GPIO->BSRR = SF_CS_PIN

复制代码

$ H2 F& i+ i8 q$ C& r  第7步：如果使用DMA方式的话，请不要使用TCM RAM，因为通用DMA1和DMA2不支持。并为了防止DMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭Cache处理，比如使用的SRAM4：

1. /* 配置SRAM4的MPU属性为Non-cacheable */
   
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   2 X8 ?! Q5 r* v  T( \* K) e
3. MPU_InitStruct.BaseAddress      = 0x38000000;
   
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   , h. ]  r: y: ]# s- A! P
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   . P  [7 `; D) ]( L  e' V3 X; r& V$ }! D
7. MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   2 n, n5 K5 K5 J
8. MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9. MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   
10. MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    : g# Y# a& J, W/ @3 Y9 V1 z
11. MPU_InitStruct.SubRegionDisable = 0x00;
    7 E" D! f* u7 P1 v! b9 u% T
12. MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    . K! w; Z1 x2 I3 b' I9 l0 L
13. 
    
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

- ?4 N4 F) v3 B  e" n  第8步：初始化SPI。

1. /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
   ! J8 W, E8 q- Z6 e( L0 {' S) c
2. bsp_InitSPIBus();    /* 配置SPI总线 */        
   
3. bsp_InitSFlash();    /* 初始化SPI 串行Flash */

复制代码

4 y. [; p$ b+ E# r+ Z% f& H  第9步：SPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第10步：应用方法看本章节配套例子即可。
73.8 实验例程设计框架
: L7 M& b. |$ ]" e' B% q  M1 e通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

# N0 G4 Z( c, J7 V; ]% _
  第1阶段，上电启动阶段：
! u2 D7 a# ^6 S1 b9 t( X$ d, E! t
$ d% T7 p/ r' S' e+ v6 d$ N/ }这部分在第14章进行了详细说明。
, T2 v8 D3 n- i3 u9 q/ S  
第2阶段，进入main函数：
. ~, c+ A* y  V( L- E6 O$ X
第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现SPI Flash的中断，查询和DMA方式操作。
, S8 B5 u9 D( w  n) W* ^/ T
73.9 实验例程说明（MDK）
9 f7 @, R# ^+ I: c  Z/ U配套例子：

V7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）
$ _0 n' t6 [% P% o& h" U/ K1 t+ W
V7-050_串行SPI Flash W25QXX读写例程（DMA方式）
# P- ]* f5 U6 ?
V7-051_串行SPI Flash W25QXX读写例程（中断方式）

* g1 z/ U" g' ]* @- A5 G( |0 h实验目的：
- J) s( j$ K. b% T1 J) o* `& B
0 @2 A# S: Q! ^) O学习SPI Flash的读写实现，支持查询，中断和DMA方式。
6 j0 I% c; @! _% S9 I
实验操作：

6 W8 v6 R- x+ i+ ]支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
. D6 U$ N2 r5 {printf("请选择操作命令:\r\n");
/ r4 R0 o$ L$ D- V5 C; p! xprintf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【3 - 擦除整个串行Flash】\r\n");
- \9 k6 q4 J# ^9 g2 L' a0 ^* C/ E( P2 Vprintf("【4 - 写整个串行Flash, 全0x55】\r\n");
' |7 W5 {" a1 ~  d3 _) b  gprintf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
printf("其他任意键 - 显示命令提示\r\n");
5 c2 P  H0 f1 `" Y上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。
& b. y8 V# f6 }/ C# T! X$ |
# S$ X# B. B3 }* ~% x! f1 x, Y

程序设计：
$ m& d, J1 }/ O
: z6 ]/ b9 z& G2 T0 }2 k, [" m  系统栈大小分配：

7 n; v+ M  R" `

6 P2 h' M. q& o' B: b, C
  RAM空间用的DTCM：
9 _4 B, k$ f( d, F, X7 q6 x1 i! \
5 f) z" i: O6 W1 N+ W6 p6 Q6 l! ?

  硬件外设初始化

2 T, o: B+ d" p- j5 G" x& B硬件外设的初始化是在 bsp.c 文件实现：
' r9 u: J& }' y3 b
( k* r$ u- ^9 j9 W- y/ x9 }

1. /*
   
2. *********************************************************************************************************
   * S4 p( M: o2 z. u/ L7 C
3. *    函 数 名: bsp_Init
   ( _  [/ w+ Y  d3 l0 H
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ) A; j9 z% n+ o! F
5. *    形    参：无
   5 G* D  g: s# {2 m
6. *    返 回 值: 无
   - v- b7 g* ]. j* w, B7 t
7. *********************************************************************************************************
   ; e3 |8 h% ^8 i: G8 ~
8. */
   
9. void bsp_Init(void)
   # H+ @8 B4 c; [; o0 S
10. {
    
11.     /* 配置MPU */
    2 X. d: N; o$ j( \
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    ; `8 c2 ?1 G0 v) W, @* V8 d" E$ I
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    1 T, B2 T6 c$ I4 I  V
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    0 c, _" p5 n( K4 G6 S  e! S
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    + p" O" ~0 j' e+ D: R
20.        - 设置NVIV优先级分组为4。
    
21.      */
    $ `$ V( o8 h# A" t. {
22.     HAL_Init();
    & T' E: v* t- N8 |9 y9 T8 G
23. 
      Y& B6 B/ t+ \  J
24.     /*
    
25.        配置系统时钟到400MHz
    ) R4 g: O8 D1 [4 E
26.        - 切换使用HSE。
    : Q$ Z+ \! N2 k) B/ ?7 l" J  _
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    . R- Y- _" o( a* W# W: e
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ) f; r* @  a$ Q/ G- v9 f( g
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    6 K: y3 `7 F0 A4 G; C
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    
41. 
    , E$ I: l" @2 |3 b/ t9 X
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    $ t7 k- @) x( }$ ]; j, n
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ' \+ `* C3 h0 G. m
47.     bsp_InitLed();         /* 初始化LED */   
    
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    $ ?4 D0 d+ v3 U$ g# R( \
49. 
    # Y8 q% f* N3 R3 ~6 l
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    ( O) b  u; K$ W; o# I) ~. O
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    
53. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区以及SRAM4
# S9 a! |7 x. F
# A, E2 k2 l7 e- ]7 j7 Y

1. /*
   , Q6 r" [. B, j: {5 e2 ?1 w
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   3 x. |& D& v- {. W% f6 a9 h
4. *    功能说明: 配置MPU
   , X- l( ^: s+ B% w  |( ^( T: |
5. *    形    参: 无
   / [% ~0 [- l2 l7 @; p* `6 i- ?
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   * J" V7 _  R, V* @: o/ G8 _, {; N
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    - G. s0 }8 W/ T' s" |
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    # j$ h; P; h% q6 f6 z5 E
15. 
    4 W1 b' k0 _2 @) `: u
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    + n; b5 J9 b8 L/ g3 F
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    / ~! M4 u% L. x0 J- p3 t0 w
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      \# J3 b+ Q" v# Z
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    $ H0 d3 j" g% E: N7 f: Z1 n1 F
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 b, g% g/ E, h0 p% S$ V% ~  _
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    5 R- I1 |# G- Y6 j/ u  N1 A! ~1 n- N
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    3 t% i3 N* y& c; i3 G
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
      d+ X. B2 n9 T
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    3 ~6 h% `5 }% V3 O8 Y
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      s3 F7 F+ ?  l  W( }+ y9 G1 Y
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    9 B( H1 E- n% U6 X# P! u6 y
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    " D/ Z, \1 m! I8 S  S" n
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    0 d- Q3 q' u: \! I
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    $ n+ ]) U" h( m
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    0 A% Q3 G3 J. a. b
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    - M7 q6 b: E0 y; ?. c7 l* d
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    * ^/ B4 \* @4 ^  |( F( a
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    1 G: j& E9 B8 L! y
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    . r4 y1 A- w% z) V+ g9 f( j
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61. 
    
62.     /*使能 MPU */
    
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    ! I: j$ U' o% w  x9 W1 \
64. }
    
65. 
    
66. /*
    ( V4 A5 K. I, `0 Q0 J
67. *********************************************************************************************************
    + n) S' F8 R9 i7 n4 s9 X& p$ p" ~
68. *    函 数 名: CPU_CACHE_Enable
    ) A; K; x  ], @
69. *    功能说明: 使能L1 Cache
    
70. *    形    参: 无
    
71. *    返 回 值: 无
      a6 U- F' V, |7 U6 ^
72. *********************************************************************************************************
    ( H# z" p7 v# R6 A( B  i5 y: C7 l& v
73. */
    
74. static void CPU_CACHE_Enable(void)
    
75. {
    
76.     /* 使能 I-Cache */
    . e/ w: i3 O6 z; b9 `; N
77.     SCB_EnableICache();
    
78. 
    5 R0 |3 R' X' l7 z
79.     /* 使能 D-Cache */
    $ @& C; H$ N" M
80.     SCB_EnableDCache();
    
81. }

复制代码

4 Z) {4 j+ Q& l" p3 n6 z  每10ms调用一次按键处理：

4 i) _& b& O( L- s. \: w9 ^按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。
4 l0 n: E/ ~. U1 s; k8 ?' w

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   6 L3 F  w+ G9 B( C9 F
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   $ D: @2 K) ?9 o" @* G+ W& p9 R3 ~3 N, Z
10. void bsp_RunPer10ms(void)
    ! h; O. W( U$ z# p: k! E9 c
11. {
    
12.     bsp_KeyScan10ms();
    , {* \7 J1 J! Q% u! J" O
13. }
    
14. 
    

复制代码

  主功能：

主程序实现如下操作：
9 v: _% E- m  e7 u( c
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  V- |& J1 o% s: s5 Y  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
8 J4 b7 S# r( \  1 - 读串行Flash
  2 - 写串行Flash
  g& e  _* y9 s8 U6 s8 T( d  3 - 擦除整个串行Flash
( r6 J- D& ?' \/ d2 |4 Q/ F  4 - 写整个串行Flash
  5 - 读整个串行Flash
  Z - 读取前1K
/ V+ M! C3 i& [( b5 s* g$ n  \  X - 读取后1K
* U) e9 d5 o0 I7 }( y$ A5 a9 ^

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   
5. *    形    参：无
   
6. *    返 回 值: 无
   ) C- I8 z' N* ~$ J! j7 s7 s, {& [
7. *********************************************************************************************************
   ; G$ h( u8 `( [" n* Q7 K+ j8 l
8. */
   
9. void DemoSpiFlash(void)
   
10. {
    7 K5 o7 A) W8 q: u$ O
11.     uint8_t cmd;
    ' u3 I; S$ F/ f
12.     uint32_t uiReadPageNo = 0;
    7 s2 l+ O, g0 S7 c3 G
13. 
    6 u( i9 P- G( x8 A/ m, Y
14. 
    
15.     /* 检测串行Flash OK */
    - S5 M0 b- g- |) B6 l; |
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    7 X( q, B5 f7 z7 t  E
18. 
    ( H$ i' m) e! H/ [8 g" N# @
19.     sfDispMenu();        /* 打印命令提示 */
    - g: @4 P* U1 @0 K2 l: r7 c6 N
20. 
    5 h# N& y6 d( y6 J, _7 |3 n. |
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    ) l$ {' P8 J% S& I5 F, P) z; E
22. 
    0 Z; j, w5 U& \+ j1 a
23.     while(1)
    
24.     {
    ; f- V8 C# N$ V2 r
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    3 u* s0 B- q- i0 W0 B9 j8 T* j! @
26. 
    
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
      }) v3 b: S3 C( p/ ~9 g. x& P2 `- [
29.         {
    
30.             /* 每隔100ms 进来一次 */  
    
31.             bsp_LedToggle(2);
    9 b$ n0 q8 g: w, G2 g( s/ D& O
32.         }
    " M) b2 @  c4 n' ~4 i
33. 
    
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
35.         {
    
36.             switch (cmd)
    
37.             {
    
38.                 case '1':
    
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    7 f+ M  _2 E! r5 L
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    - W8 T0 ~) J. l5 W
41.                     break;
    * l4 `) N' j. c
42. 
    8 I8 R$ \: R* E
43.                 case '2':
    3 J. D  z7 d7 t5 `' C
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    
47. 
    # e- |8 W5 m7 W% q5 I6 q6 P
48.                 case '3':
    ' D$ M0 s  }+ Z2 v" h1 S
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    $ F. ?: Q: x) B) N  v1 Z& R$ L
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
      S/ h" z# M- ~: g8 Q
53. 
    & S2 J3 h8 t; x- X
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    4 j' P: ^3 T4 k1 J) ~
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    , U& O& M4 U0 G9 m. X
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    7 n1 H0 P% _" E  s! m* v, e
59. 
    ) n  \& j7 g* k
60.                 case '5':
    7 M% h% x( E; v! C8 n
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    2 \  ~- `  T5 [/ v0 M- k/ E  G
63.                     break;
    ' F; t" E4 _# x# C
64. 
    ' T9 E. J+ \' W2 J
65.                 case 'z':
    5 \/ q# [6 K9 a8 z3 L' k
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
    7 L9 o5 {6 t9 \; K8 e
68.                     {
    , M1 M' K# N5 r0 a/ f
69.                         uiReadPageNo--;
    
70.                     }
    
71.                     else
    
72.                     {
    . b: W1 g# m5 i& r5 E
73.                         printf("已经是最前\r\n");
    
74.                     }
    * x  s% I: y! X
75.                     sfViewData(uiReadPageNo * 1024);
    5 S9 p4 H2 f5 Y6 `/ S$ m8 [4 W
76.                     break;
    / `" U4 E9 b; B; x+ M! i/ ~
77. 
    
78.                 case 'x':
    4 @% A5 F: c; U" D1 ^8 T
79.                 case 'X': /* 读取后1K */
    # t( v& \- s+ Z! Y1 x
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    ) p' {: s9 P5 k; v5 f" G
81.                     {
    
82.                         uiReadPageNo++;
    
83.                     }
    
84.                     else
    
85.                     {
    2 u* W( J' c6 X
86.                         printf("已经是最后\r\n");
    6 @% _# u) m/ H& k
87.                     }
    / u5 `; f8 n+ L8 c! m% ^: e* r
88.                     sfViewData(uiReadPageNo * 1024);
    3 I' k2 m; O3 Y# R, O! _/ S
89.                     break;
    
90. 
    / a4 y6 M$ A) ?" Q" o5 Y
91.                 default:
    ( Q$ X. j+ o, m" a, J7 `4 V5 E
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    
94. 
    9 t0 }; l8 R# r% |$ B/ b
95.             }
    / N; w; d7 H: M- [
96.         }
    
97.     }
    6 v, N2 D9 p+ g. H& \  ~' H
98. }

复制代码

, h9 D. n: e# e4 L% U73.10          实验例程说明（IAR）
配套例子：
1 b/ ^- ^, |8 V
5 X& l0 t8 Z9 A: K+ h4 NV7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）

. E& d  y& r5 p6 m/ {V7-050_串行SPI Flash W25QXX读写例程（DMA方式）

V7-051_串行SPI Flash W25QXX读写例程（中断方式）
6 F4 U7 E% u, e) T
  S! g0 @, i( I( ~$ v  N, m& v/ l实验目的：

2 O5 n) y" D2 }8 ]/ I( Z9 b& A学习SPI Flash的读写实现，支持查询，中断和DMA方式。
8 F" o( W/ I8 h7 H! g
8 `( z! v# Y. P( X6 f6 n实验操作：

2 }) T. W) @5 M" m支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
7 w( f1 y  t9 g0 L2 @. `& f. X/ hprintf("请选择操作命令:\r\n");
printf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
  p7 V2 w, C. W* ?% Oprintf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
  `. I5 P7 t) S; @: @printf("【3 - 擦除整个串行Flash】\r\n");
printf("【4 - 写整个串行Flash, 全0x55】\r\n");
printf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
printf("其他任意键 - 显示命令提示\r\n");
, Z! \2 v6 ]! }; A8 ]
4 f- i; G6 p% ]( b; [+ q8 Q9 k上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。
# x/ ]4 K6 [8 H/ \

程序设计：
7 X$ t/ l$ U6 t! ?% J4 `! p
6 _' t- Q2 o7 S: j. ?1 k3 o. q; F) T  系统栈大小分配：
2 N: a# y" Z  J" M
+ y2 D. a, Q8 ]$ ?( g

5 J% U# M. o! I, ?/ Q  RAM空间用的DTCM：
) t- N- ~' {, V3 r

  硬件外设初始化

+ X5 k6 b2 T3 [7 `( j2 e4 }5 x硬件外设的初始化是在 bsp.c 文件实现：

. A; L8 S6 ?, p0 K4 h7 c- O8 I

1. /*
   , v! @- X1 X) X3 s0 w
2. *********************************************************************************************************
   . z$ @9 ]+ c) S+ o8 u* b
3. *    函 数 名: bsp_Init
   $ A5 L2 p' a$ _* g* P8 Q2 r
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ' Q! f9 [  b6 k& u( O. r7 V
5. *    形    参：无
   ( T- o+ \9 y& z& Q) p$ `6 i
6. *    返 回 值: 无
   9 J6 d% [7 B& W) x$ u
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    , F2 e. ~* Y* Z8 {* S# T
11.     /* 配置MPU */
    8 |  \2 ?$ q( k6 _$ C: ]4 }
12.     MPU_Config();
    
13. 
    , S" X2 Z; c- T0 @) k$ C, Z: I
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    # {2 R( a* h' P9 @# k
22.     HAL_Init();
    ! N4 I* v& {  x* p3 k8 w, ?- @
23. 
    
24.     /*
      }, x) N( V0 v7 n
25.        配置系统时钟到400MHz
    1 i$ d9 k1 d6 U; v8 q/ [
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    5 ?/ F. v# N) K/ o/ H
32.        Event Recorder：
    2 m; s5 y  Z+ o; |/ Q  T& V
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ' ~3 F6 m% m, e( b' o/ H
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    * B3 B2 n8 T8 U6 d4 @$ }" e1 _
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    6 L3 t  d2 f  H
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    2 b, i" _3 H5 X* z4 Y9 I
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    / d0 Y7 h* R! ]; |
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ; X5 }) o% ^6 _  P- Z. J
47.     bsp_InitLed();        /* 初始化LED */   
    
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    ( S0 |( y' j" \- G* f: j1 |
49. 
    
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    " U# W  X! c, A$ m$ T) Z  y# g
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    : Y5 F# X/ e. N# {! j: t
53. }

复制代码

' I% w; x1 Y/ c* q  MPU配置和Cache配置：

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

/ x7 t5 z0 p' l% _

1. /*
   
2. *********************************************************************************************************
   : d* O0 e0 U4 `1 g
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   / s% R5 C; F; P( N4 u
6. *    返 回 值: 无
   % y* x1 H4 r  L9 W* P
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   * `/ y; J! f  t& k' S
10. {
    . }! B$ `# }8 T; O, @% E5 Q) C. K
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    8 Y1 Q+ l8 `: F6 M% n& ^
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    1 w3 k- o7 {6 X- U
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    9 j! N% r5 d$ x2 W' x
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    % `* _  |1 M/ k  I$ @
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) j. v4 ^1 o- x
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    : m, n5 C4 c5 I: Z4 C1 m/ R6 w5 ]
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    8 }1 T6 n- ^5 Y4 C0 D$ Z5 Y* l
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    4 T# q0 E& i7 Q" V/ K
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ; J. ^! }. q; I" `" h" b
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ) B* Q, j: K" B0 H3 i- x- F
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    % @! ^  I! k1 [
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    + ]/ I* a1 o2 O" y7 J
46. 
    
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    & Q' g, l5 \4 v  ~6 w- q0 p% V
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
      _0 @% h9 d  y: G: s  ~, e7 {: K5 w
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    ; A! K0 g# z' o5 r6 ?
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    - ?3 r8 s- l! {( N9 G2 s
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : H! ~# Y& G! {% g
59. 
    " L' n; h5 W8 N9 c  I* g& U/ e
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61. 
    
62.     /*使能 MPU */
    6 n# ]# L+ t9 v" Z" w1 O  r# Z+ x/ M) Q
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    0 r$ K& [  e* i
64. }
    
65. 
    , j* C2 g. K, U! S2 [7 a
66. /*
    
67. *********************************************************************************************************
    8 P, b& ?. G2 k- I
68. *    函 数 名: CPU_CACHE_Enable
    
69. *    功能说明: 使能L1 Cache
    4 p5 j, m1 h# j
70. *    形    参: 无
    
71. *    返 回 值: 无
    
72. *********************************************************************************************************
    . k) T' f) O% T  A1 P+ o
73. */
    
74. static void CPU_CACHE_Enable(void)
    
75. {
    $ o% _# m  o4 M
76.     /* 使能 I-Cache */
    . p* Q6 D( }8 F0 ^# c- i0 q4 f; F$ s
77.     SCB_EnableICache();
    
78. 
    : ~" O4 U: a: X8 w/ r( a
79.     /* 使能 D-Cache */
    1 G. o0 ?3 `* U# _
80.     SCB_EnableDCache();
    
81. }
    

复制代码

6 f4 c: \% n! g: W7 o# Y
  每10ms调用一次按键处理：

按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   * o- X# n5 _- a: D' t* Q( }( H
2. *********************************************************************************************************
   - @7 \( U. ^, ?  c
3. *    函 数 名: bsp_RunPer10ms
   + ^1 x& D# Y  p( r. |2 g2 S- ^* K
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   # s/ C7 w7 x: G* A2 h) l' ~$ R. N9 |$ l% [8 ^
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   ) e: s7 k$ ~7 W; R
6. *    形    参: 无
   & r! H# `7 ~* B
7. *    返 回 值: 无
   0 l8 C& D6 B/ d. B1 l6 t7 f3 N
8. *********************************************************************************************************
   / m2 h0 d+ ]8 r) t; {% ?/ k+ `
9. */
   0 V- V7 f: P! i+ x. y
10. void bsp_RunPer10ms(void)
    2 r7 q' f( @7 Z& x6 s" N3 z
11. {
    3 \' s" ~! w# F# s! ~
12.     bsp_KeyScan10ms();
    
13. }

复制代码

$ c( e% y7 X& ~, W  主功能：

6 Z4 _+ T4 W) u: ~9 h0 k& ~主程序实现如下操作：
( `- r4 L- w+ P  v2 p+ b
1 ?0 Z0 A% z5 [# }  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
( U/ X7 j3 k0 f1 L7 K- X7 ]  1 - 读串行Flash
  2 - 写串行Flash
  3 - 擦除整个串行Flash
  4 - 写整个串行Flash
  5 - 读整个串行Flash
. q* z. z; c: ~  Z - 读取前1K
1 w. _4 i7 T- q5 Z3 ~% Y+ U# ^0 W( I  X - 读取后1K

1. /*
   
2. *********************************************************************************************************
   ; y" j& f9 j4 U1 _: |6 U/ D
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   0 M# x8 n& j3 |9 W& p
8. */
   * G$ R0 a& _5 p+ M+ m, O2 F2 T
9. void DemoSpiFlash(void)
   
10. {
      E7 n  P% Z$ H& c
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0;
    
13. 
    , L9 j) v" M7 G" ^* t5 ?
14. 
    
15.     /* 检测串行Flash OK */
    
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    
18. 
    7 K( d7 r$ M3 T* e" [. v/ s
19.     sfDispMenu();        /* 打印命令提示 */
    * r* U+ j# f# }) O2 \  n
20. 
    + k& p4 F' Z8 Q7 W( B# T
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
22. 
    
23.     while(1)
    
24.     {
    
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    2 |( U+ K: g" s' g6 s5 b+ f2 C3 S
26. 
    
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
    
29.         {
    ) D# S6 o/ f. h4 g
30.             /* 每隔100ms 进来一次 */  
    6 o* _# h5 Z- Z6 ]# k  v
31.             bsp_LedToggle(2);
    
32.         }
    / B, Y0 x6 `0 F2 ]( X. Z- q9 F
33. 
    
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    8 w" i9 p7 o8 @
35.         {
    
36.             switch (cmd)
    3 v0 [% {% e" N8 D) N. f  A
37.             {
    
38.                 case '1':
    
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
      ~2 \3 g; H3 j3 H- R5 B
41.                     break;
    + a, e0 V( Z4 F6 h" \
42. 
    1 ^1 g. h: w5 {6 ^$ \6 ]9 F
43.                 case '2':
    
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    
47. 
    % l1 S0 _, S0 e4 O2 d
48.                 case '3':
    
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    ; B2 U1 G8 o( {. a/ f& I
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
    
53. 
    * E1 n& h, g) A% e5 S! Z# [2 L" W
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    4 P" z& E; ]( ^" w. F
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    4 _' T, Q7 z0 v3 S$ Z
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    
59. 
    
60.                 case '5':
    ( _2 M5 V; {' g" t! A0 a) ], _- Y
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    ! Z+ h! i- P1 |5 z7 W2 o7 ~# q+ r
63.                     break;
    2 y# R! x) T6 [6 h4 _1 ^% N
64. 
    
65.                 case 'z':
    
66.                 case 'Z': /* 读取前1K */
    . x3 L4 \" o/ d
67.                     if (uiReadPageNo > 0)
    % S3 C1 R! b+ ~3 w3 B1 T
68.                     {
    ( q- p) T  j8 u$ o( x
69.                         uiReadPageNo--;
    
70.                     }
    5 E$ B( P! X* U0 x( K2 M2 _& p
71.                     else
    
72.                     {
    
73.                         printf("已经是最前\r\n");
    
74.                     }
    
75.                     sfViewData(uiReadPageNo * 1024);
    9 H# N  U& a3 z  C& g7 y! ~
76.                     break;
    6 [% i+ R3 ?; v' S" t
77. 
    4 r% j9 p- Q. G
78.                 case 'x':
    / [7 `* L) X) Y, a9 O
79.                 case 'X': /* 读取后1K */
    ' a0 L. b. [  B
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    2 {' W$ M5 o) |$ }% Y, R
81.                     {
    / V: R, `) L! U7 t
82.                         uiReadPageNo++;
    
83.                     }
    
84.                     else
    6 ?: |; w9 _: y1 v
85.                     {
    3 Q" ?3 D3 U: R  L, J* j
86.                         printf("已经是最后\r\n");
    $ v  }1 i% q/ K' z9 ?+ \3 C
87.                     }
    ; g4 R3 V  {) C/ Q# d; J+ j
88.                     sfViewData(uiReadPageNo * 1024);
    + A( E1 ~2 K  m1 I  e
89.                     break;
    2 j) z3 ~% C5 D/ v
90. 
    
91.                 default:
    7 N7 l# _. H: ^! [
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    : j+ L6 z. H2 C2 X" |) ^
94. 
      Y+ h& E/ O' F7 V  c* l- M+ d
95.             }
    6 W5 l! x: e* K( q+ h* D
96.         }
    3 b% `; u- W9 [0 s: |7 O( w
97.     }
    7 x" z2 R1 Y: l& v9 [( v1 t7 l/ h6 n, t
98. }

复制代码

73.11   总结
* L- t! f7 _7 O+ X# n' d  R本章节就为大家讲解这么多，实际应用中根据需要选择DMA，中断和查询方式。


" l* h! _3 T4 k$ }7 d# Z. N; G
+ w, l1 G$ Y% b