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

9 |- A( A0 C' `
6 {& x$ u( e% J6 ~6 P# m$ N2 D- o  本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。
  对SPI Flash W25QXX的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。
  W25Q64JV最高支持133MHz，但最高读命令03H速度是50MHz。
" {. g5 ^; t# m2 o8 x& w  文件bsp_spi_bus.c文件公共的总线驱动文件，支持串行FLASH、TSC2046、VS1053、AD7705、ADS1256等SPI设备的配置。
  函数sf_WriteBuffer不需要用户做擦除，会自动执行擦除功能，支持任意大小，任意地址，不超过芯片容量即可。
5 b2 t; b, n- M" O4 Z# `
) }/ q) m1 w( T5 S$ n73.2 W25QXX硬件设计
STM32H7驱动W25QXX的硬件设计如下：
. D; l1 B. v7 L) ~7 c& E

1 o! m0 O; o# F* q/ w4 e9 q
# _! u0 q: G6 C关于这个原理图，要了解到以下几个知识：

  V7开发板实际外接的芯片是W25Q64JV。
  CS片选最好接上拉电阻，防止意外操作。
5 U& V' [* P) Y& q9 @  j0 ]  这里的PB3，PB4和PB5引脚可以复用SPI1，SPI3和SPI6。实际应用中是复用的SPI1。
1 R' |& |' o5 J) D6 ]' u  W25Q64的WP引脚用于写保护，低电平有效性，当前是直接高电平。
  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。
& M3 A" j9 i( W  r3 y2 A73.3 W25QXX关键知识点整理（重要）
& p- W, F+ E+ r% R1 o' _驱动W25QXX前要先了解下这个芯片的相关信息。
  t# k/ y5 y, [, ?2 J

73.3.1 W25QXX基础信息
  W25Q64FV的容量是8MB（256Mbit）。
8 }7 w! T$ w( [6 [% H  W25Q64FV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
- T) D4 [% a/ o6 ^. [) g, n$ F! a/ [支持两线SPI，用到引脚CLK、CS、IO0、IO1 。

5 j8 P4 R% [' t' U, Q- b- t% _" L: h! O支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。

（注：这里几线的意思是几个数据线）。
$ f! D3 |$ u- s$ m6 M
7 P+ Q$ o5 [+ o3 W" b) H  W25Q64FV支持的最高时钟是133MHz。
6 \3 I+ ~" c& T- G9 w  每个扇区最少支持10万次擦写，可以保存20年数据。
! m2 R4 Q0 h  Q; A6 s  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
整体框图如下：

; w9 j1 O. [' o9 R1 W# i( {
W25Q64FV：

  有128个Block，每个Block大小64KB。
0 t/ p" V$ I: f1 g" i  每个Block有16个Sector，每个Sector大小4KB。
  每个Sector有16个Page，每个Page大小是256字节。
73.3.2 W25QXX命令
使用W25Q的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的标准SPI，即单线SPI，使用的命令如下：

5 S' ?0 q, [. i/ `
+ A( k1 s) `- ~) Y. g% d8 q当前主要用到如下几个命令：
* R- i5 d/ Y% C  G' P2 y1 r1 P

1. #define CMD_EWRSR       0x50  /* 允许写状态寄存器的命令 */
   
2. #define CMD_WRSR      0x01  /* 写状态寄存器命令 */
   + x0 Z8 P( q! s$ E
3. #define CMD_WREN      0x06    /* 写使能命令 */
   . \) ~1 z7 j7 c& m: ^" f( Z1 i' W
4. #define CMD_READ      0x03  /* 读数据区命令 */
   ! L/ |: y; m3 S) M. ]
5. #define CMD_RDSR      0x05    /* 读状态寄存器命令 */
   * w1 Q) Y% v+ F# k8 _
6. #define CMD_RDID      0x9F    /* 读器件ID命令 */
   " |5 _5 H  y; j( a5 N5 G  h9 R
7. #define CMD_SE        0x20    /* 擦除扇区命令 */
   1 e/ t  p7 S  h: b
8. #define CMD_BE        0xC7    /* 批量擦除命令 */
   : x" j/ d" B1 H  M+ U5 ^, g
9. #define WIP_FLAG      0x01    /* 状态寄存器中的正在编程标志（WIP) */

复制代码

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

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   % m, {$ \8 m+ H) `3 R2 C
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   , p9 d" ?" C$ f/ M: c) u
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   # A9 C) J# u2 N2 q$ [9 v1 n1 _
5. 
   5 q4 u, W$ B; F9 L$ K
6.     for (i = 0; i < _usSize; i++)
   ( W/ R" \' @* O! c, C
7.     {
   
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   0 i4 z4 ?7 n$ _
10.     }

复制代码

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

比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：

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

复制代码

& V) A7 U  t! `( B  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
6 z2 V$ Q, D& ]) @  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
' [: q. N! Z6 @: f& _- A+ _  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
$ {+ ^( p. {" }1 r; |8 r  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
% g; L8 ?  R" l: g9 @" I下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。

3 r- s  X- L7 ~, U

73.3.4 W25QXX扇区擦除
% s6 T! S# Q6 D& l, N* P. ySPI Flash的擦除支持扇区擦除（4KB），块擦除（32KB或者64KB）以及整个芯片擦除。对于扇区擦除和块擦除，使用的时候要注意一点，一般情况下，只需用户给出扇区或者块的首地址即可。
7 u, ]! O9 [* Q3 }! l
如果给的不是扇区或者块的首地址也没有关系的，只要此地址是在扇区或者块的范围内，此扇区或者块也可以被正确擦除。不过建议使用时给首地址，方便管理。
& A' b- W2 T* f3 p+ G0 _+ s* ~* Q
& v# K, u/ s7 l3 z* j2 ]# `73.3.5 W25QXX规格参数
& V: K/ T5 I0 _; \( P这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：

1 K' U) _9 }+ ?* N& j3 R

" _1 k" b( u$ b1 N1 g
9 J6 J2 ?' ^( y  E3 W7 ?8 c  页编程时间：典型值0.4ms，最大值3ms。
: g5 [8 ^, f, z0 u) _/ S. g  扇区擦除时间（4KB）：典型值45ms，最大值400ms。
  块擦除时间（32KB）：典型值120ms，最大值1600ms。
  块擦除时间（64KB）：典型值150ms，最大值2000ms。
  整个芯片擦除时间：典型值20s，最大值100s。

) R+ e. B% T8 ]; B
0 W8 D8 `3 B  g! o" P支持的速度参数如下：
9 n% R7 ^/ T9 |+ s
% a" _$ W4 m: ~7 {& F+ F- y

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

1 x3 p0 |8 t- r' a4 y73.4 W25QXX驱动设计
W25QXX的程序驱动框架设计如下：
( [7 b  X" q" Q
' G; M- D9 a1 x; y- E  R0 T

9 ]* x3 Z: \9 n2 {! e6 b9 p
; p1 }! L; g: o% j3 I6 `" m有了这个框图，程序设计就比较好理解了。
3 n" `( a6 }( o" S& f# c, U* z
9 W+ N" E# g  X; ~* i5 g( v) c73.4.1 第1步：SPI总线配置
spi总线配置通过如下两个函数实现：
- w% @& ]% _* Q4 }# ?" I

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_InitSPIBus
   6 O. L- g4 H) l, K
4. *    功能说明: 配置SPI总线。
   0 \1 S+ l1 G% U6 a8 Z$ U6 C2 @
5. *    形    参: 无
   
6. *    返 回 值: 无
   # c' m: @  l2 K/ Q. a
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitSPIBus(void)
   & J4 Y: B8 h( M  q7 o* M
10. {   
    & [, e/ l7 W$ g: X9 d: m
11.     g_spi_busy = 0;
    
12. 
    
13.     bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_8, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);
    3 ^( w- s  X( w/ m
14. }
    
15. 
    # ^8 G' t7 E" |8 q& F8 E- g4 u
16. /*
    
17. *********************************************************************************************************
    3 t: e# o' _% a0 t* O% J/ g
18. *    函 数 名: bsp_InitSPIParam
    
19. *    功能说明: 配置SPI总线参数，时钟分频，时钟相位和时钟极性。
    
20. *    形    参: _BaudRatePrescaler  SPI总线时钟分频设置，支持的参数如下：
    . o( c4 x1 F( ~: i+ `* g
21. *                                 SPI_BAUDRATEPRESCALER_2    2分频
    
22. *                                 SPI_BAUDRATEPRESCALER_4    4分频
    
23. *                                 SPI_BAUDRATEPRESCALER_8    8分频
    % c: t& s3 c% f/ P7 B& h0 `
24. *                                 SPI_BAUDRATEPRESCALER_16   16分频
    / D. R* v5 `+ E" n) Y3 d: L
25. *                                 SPI_BAUDRATEPRESCALER_32   32分频
    
26. *                                 SPI_BAUDRATEPRESCALER_64   64分频
    + C$ M. ~4 }* W
27. *                                 SPI_BAUDRATEPRESCALER_128  128分频
    5 S3 d9 B% S  v1 T
28. *                                 SPI_BAUDRATEPRESCALER_256  256分频
    
29. *                                                        
    
30. *             _CLKPhase           时钟相位，支持的参数如下：
    
31. *                                 SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
    
32. *                                 SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
    % @0 U2 K: n$ C. {* N8 V
33. *                                 
    
34. *             _CLKPolarity        时钟极性，支持的参数如下：
    
35. *                                 SPI_POLARITY_LOW    SCK引脚在空闲状态处于低电平
    
36. *                                 SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平
    2 N+ r0 f5 R* T/ L
37. *
    
38. *    返 回 值: 无
    6 u7 I8 K* F1 W: v9 ]
39. *********************************************************************************************************
    
40. */
    , y: X% I4 P: N* o. J0 l, ?
41. void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
    0 K# @6 O: f: K4 d
42. {
    5 C6 h8 Q1 t$ [1 y! ]( I+ v: y
43.     /* 提高执行效率，只有在SPI硬件参数发生变化时，才执行HAL_Init */
    . n, e; X* ?: H/ r
44.     if (s_BaudRatePrescaler == _BaudRatePrescaler && s_CLKPhase == _CLKPhase && s_CLKPolarity == _CLKPolarity)
    
45.     {        
    
46.         return;
    
47.     }
    
48. 
    
49.     s_BaudRatePrescaler = _BaudRatePrescaler;   
    0 D, q- }! y" F. z9 Z' Z( R
50.     s_CLKPhase = _CLKPhase;
    
51.     s_CLKPolarity = _CLKPolarity;
    ' X- l8 n- C# e6 @6 V
52. 
    
53. 
    ( F7 D5 z2 f8 k: d
54.     /* 设置SPI参数 */
    * x; G- w* ~7 A2 ?8 {' R
55.     hspi.Instance               = SPIx;                   /* 例化SPI */
    
56.     hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
    & @% [  \% \( p
57.     hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
    1 P$ y6 [7 v: a+ P# F
58.     hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
    
59.     hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
    
60.     hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
    
61.     hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    
62.     hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    8 k3 S( m3 h2 p! O
63.     hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE; /* 禁止CRC */
    # _$ `2 y% Q2 v3 l  R& O" J
64.     hspi.Init.CRCPolynomial     = 7;                       /* 禁止CRC后，此位无效 */
    
65.     hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;     /* 禁止CRC后，此位无效 */
    " F) a) \) ^! z  C; q
66.     hspi.Init.NSS               = SPI_NSS_SOFT;               /* 使用软件方式管理片选引脚 */
    : g7 |9 u3 h: E; J5 F5 ~2 `5 w
67.     hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;  /* 设置FIFO大小是一个数据项 */
    7 v+ L; C4 a4 e: f, `
68.     hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;      /* 禁止脉冲输出 */
    
69.     hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    
70.     hspi.Init.Mode             = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    $ T+ ?8 {- J8 o' v8 w! N- ?
71. 
    
72.     /* 复位配置 */
    
73.     if (HAL_SPI_DeInit(&hspi) != HAL_OK)
    ; o( r. f7 Z. Q7 g  J# O
74.     {
    
75.         Error_Handler(__FILE__, __LINE__);
    6 R' e* ~4 l! a
76.     }   
    
77. 
    
78.     /* 初始化配置 */
    6 S% D3 L- A3 h3 K
79.     if (HAL_SPI_Init(&hspi) != HAL_OK)
    
80.     {
    
81.         Error_Handler(__FILE__, __LINE__);
    ; l, Y; e# i8 }. C( L
82.     }   
    & H. q( [, @: x) _. p& K, @2 F
83. }

复制代码

( q+ ]+ J; @2 f* ], Q9 s关于这两个函数有以下两点要做个说明：

  函数bsp_InitSPIBus里面的配置是个初始设置。实际驱动芯片时，会通过函数bsp_InitSPIParam做再配置。
  ?# V" l4 Q/ R( E' n5 b' }' c  函数bsp_InitSPIParam提供了时钟分频，时钟相位和时钟极性配置。驱动不同外设芯片时，基本上调整这三个参数就够。当SPI接口上接了多个不同类型的芯片时，通过此函数可以方便的切换配置。
73.4.2 第2步：SPI总线的查询，中断和DMA方式设置
SPI驱动的查询，中断和DMA方式主要通过函数bsp_spiTransfer实现数据传输：

% M. v! U" g8 c) _. l

1. /*
   
2. *********************************************************************************************************
   
3. *                                 选择DMA，中断或者查询方式
   
4. *********************************************************************************************************
   " o0 q& k" m% D( r# |
5. */
   
6. //#define USE_SPI_DMA    /* DMA方式  */
   & t6 z8 |4 R. i& O$ J& `
7. //#define USE_SPI_INT    /* 中断方式 */
   ( }9 @) Z2 e/ o5 K5 u/ O
8. #define USE_SPI_POLL   /* 查询方式 */
   
9. 
   
10. /* 查询模式 */
    
11. #if defined (USE_SPI_POLL)
    
12. 
    
13. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];  
    2 Z3 O0 W$ K( y% A: o+ g8 h* Z
14. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    ) g  x9 D( V  y0 X$ A
15. 
    6 o& e2 h5 q7 E- }9 h) P. Z4 k( U% n
16. /* 中断模式 */
    
17. #elif defined (USE_SPI_INT)
    4 j' N/ M7 Z+ o7 |3 M
18. 
    ; N$ N; g5 u- N( ?( G6 [' `
19. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    7 @8 X  }; n2 u6 L- @2 v" _$ p' Y! t+ [
20. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    * T) q( F8 ?4 U: I
21. 
    
22. /* DMA模式使用的SRAM4 */
    ( y; E1 p) g9 b  W+ L8 q8 o) W# `
23. #elif defined (USE_SPI_DMA)
    
24.     #if defined ( __CC_ARM )    /* IAR *******/
      H. o/ B3 V6 C0 Y7 z8 U
25.         __attribute__((section (".RAM_D3"))) uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    / Q5 ^7 m9 k  u& R* r* ]4 K
26.         __attribute__((section (".RAM_D3"))) uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    * t# C' ~: U7 H  N+ w7 }
27.     #elif defined (__ICCARM__)   /* MDK ********/
    8 D3 h8 p, b6 j  A+ W9 z$ w
28.         #pragma location = ".RAM_D3"
    
29.         uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
30.         #pragma location = ".RAM_D3"
    8 K5 L# I! A% r1 y: B3 X
31.         uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    ! ]7 U, ]6 p  o, m
32.     #endif
    ' p" G9 @* i( G1 T* \; n$ ?
33. #endif
    
34. 
    : x- J5 T4 G6 f0 s% ]9 T1 G( g
35. /*
    
36. *********************************************************************************************************
    % J+ L3 W8 a  T" q; f0 H
37. *    函 数 名: bsp_spiTransfer
    . B" O5 V" N5 A
38. *    功能说明: 启动数据传输
    
39. *    形    参: 无
    
40. *    返 回 值: 无
    3 y+ F6 \3 ^' z' C2 J
41. *********************************************************************************************************
    % C' n6 x- n1 Z) M1 v5 w/ e
42. */
    
43. void bsp_spiTransfer(void)
    
44. {
    3 X! q5 `7 s% k- g7 V: T6 Q
45.     if (g_spiLen > SPI_BUFFER_SIZE)
    
46.     {
    ! [* x, r4 }, [5 }: ^9 ~5 Q; ^- `
47.         return;
    
48.     }
    
49. 
    
50.     /* DMA方式传输 */
    / \8 ]! n+ R' @7 f* C8 z
51. #ifdef USE_SPI_DMA
    
52.     wTransferState = TRANSFER_WAIT;
    
53. 
    0 S& J' a. `* {1 H+ [* U) [
54.     if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    
55.     {
    4 N* i1 t; H9 G
56.         Error_Handler(__FILE__, __LINE__);
    2 ]7 W) c. V. }8 ~  H
57.     }
    1 A0 ^3 l" o0 [" Q( v. d
58. 
    % r: e& v2 z3 v, E7 s9 {
59.     while (wTransferState == TRANSFER_WAIT)
    + W& @: S8 s8 `1 |/ j' _( v
60.     {
    2 o- R0 Q& V8 @& Q9 u
61.         ;
    # ?! e# Z$ \3 b8 j; W
62.     }
    / q1 o$ ]7 u6 t& w* I
63. #endif
    5 Q" ^6 @: h! k3 u4 \
64. 
    " g# o& L: v/ u3 q( k+ d! `
65.     /* 中断方式传输 */   
    * g: Q2 `7 E- [$ y; s1 |
66. #ifdef USE_SPI_INT
    
67.     wTransferState = TRANSFER_WAIT;
    9 v  i$ l/ d2 J& A
68. 
    / B8 A- }/ d$ I. Q) N3 o
69.     if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    
70.     {
    
71.         Error_Handler(__FILE__, __LINE__);
    
72.     }
    3 W6 o0 b! c. i
73. 
    ; v. U7 `9 F2 m$ G: x
74.     while (wTransferState == TRANSFER_WAIT)
    7 K9 C' X% j2 [& f" J3 R
75.     {
    2 [1 S( D3 Y3 F  I
76.         ;
    
77.     }
    & O, c6 ]! ~* `: H
78. #endif
    
79. 
    ' g  m0 ~" q3 }) a
80.     /* 查询方式传输 */   
    4 {) i2 B4 |$ q" y. r) B! [+ {- n
81. #ifdef USE_SPI_POLL
    
82.     if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)   
    8 S: ^% A$ B8 D2 n% c2 T
83.     {
    
84.         Error_Handler(__FILE__, __LINE__);
    
85.     }   
    
86. #endif
    ; p2 j' y: ~% ?2 S
87. }
    4 j* S" a2 J) A  U% \5 g

复制代码

通过开头宏定义可以方便的切换中断，查询和DMA方式。其中查询和中断方式比较好理解，而DMA方式要特别注意两点：
; {6 I" Y/ G$ v2 M. @7 E
  通过本手册第26章的内存块超方便使用方式，将DMA缓冲定义到SRAM4上。因为本工程是用的DTCM做的主RAM空间，这个空间无法使用通用DMA1和DMA2。
  由于程序里面开启了数据Cache，会造成DMA和CPU访问SRAM4数据不一致的问题，特此将SRAM4空间关闭Cache。
8 Y2 d% C9 S/ A6 C  _, E

1.     /* 配置SRAM4的MPU属性为Non-cacheable */
   % m5 V: n- J9 O' H9 s) F- @, J
2.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   " E0 _7 ^& G8 Z; x) _2 M( y
3.     MPU_InitStruct.BaseAddress      = 0x38000000;
   
4.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   % S$ [: F" `- C8 `- ^* w: q* ~
5.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
     s9 T# L% f/ k' k6 I
6.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   
7.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   
8.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   * {0 Q% g+ `( p1 p& `
10.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    7 i. F+ J! p; J
11.     MPU_InitStruct.SubRegionDisable = 0x00;
    
12.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    2 k+ b# x. e- O; q. y
13. 
    - e* a% ~7 g+ _  D7 Y6 f
14.     HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

+ y6 b7 t4 B+ H73.4.3 第3步：W25QXX的时钟极性和时钟相位配置
+ Y# ^; f9 ~) e$ \. o首先回忆下STM32H7支持的4种时序配置。

# P+ z5 N- i  R! y  当CPOL = 1， CPHA = 1时
% |/ {" y) E: y6 V) }+ m
+ r$ F& @( s1 }. ZSCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。

% E9 w: C- l+ K5 O$ Q+ e4 K  当CPOL = 0， CPHA = 1时
6 q0 }! k' z) [: g  |% D. f# L% k
SCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。

  l' \* g9 u/ p, w# L6 k  当CPOL = 1， CPHA = 0时
. d5 U- s1 a- M9 n* f. j
SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

* A' ?, }" x. h6 U  a5 Q; E% t 当CPOL = 1， CPHA = 0时
  o$ N( T9 s9 Y5 ~
& W; [/ \% l% G3 ~9 l' U5 |: lSCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
& t# n' R, S4 h/ u& |* x' H/ h
# U; v* i& G8 u+ T  e; J

* T7 ^/ a( H! k4 D  h6 [
) v$ o7 X$ C* I有了H7支持的时序配置，再来看下W25Q的时序图：
$ [/ W: m6 t+ G/ p0 B9 G
Mode0 ： 空闲状态的sck是低电平。
# j4 h# D" E9 z, c6 i0 j' I/ F
Mode1 ： 空闲状态的sck是高电平。

* p- @- X0 s/ D- t/ y: L

, g6 D$ G* f4 [1 D  W7 _首先W25Q是上升沿做数据采集，所以STM32H7的可选的配置就是：
" o2 a- F. _* X! r
+ p+ K7 {# g, i5 x" V5 M2 _CHOL = 1,  CPHA = 1

CHOL = 0,  CPHA = 0
0 O- h! ^% L+ N6 _9 {4 W. Z- k
# N# G( j, O; c% v+ u1 _对于这两种情况，具体选择哪种，继续往下看。W25Q有两种SCK模式，分别是Mode0和Mode3，也就是空闲状态下，SCK既可以是高电平也可以是低电平。这样的话，这两种情况都可以使用，经过实际测试，STM32H7使用这两个配置均可以配置驱动W25Q。
  T& ^( B" R* p/ k, H7 i
73.4.4 第4步：单SPI接口管理多个SPI设备的切换机制
单SPI接口管理多个SPI设备最麻烦的地方是不同设备的时钟分配，时钟极性和时钟相位并不相同。对此的解决解决办法是在片选阶段配置切换，比如SPI Flash的片选：

9 o6 ~1 z( J- I0 i' W

1. /*
   $ {/ N. _. A+ ?0 w
2. *********************************************************************************************************
   , O  Y, W, A. q2 h
3. *    函 数 名: sf_SetCS
   ( l/ B- O  c  J+ _
4. *    功能说明: 串行FALSH片选控制函数
   & I( z, V* C/ Z+ _5 J, n
5. *    形    参: 无
   ! c0 Q# C2 L; Z1 s2 `3 J$ s
6. *    返 回 值: 无
   ! \, t5 y: W9 c, Q; q- @
7. *********************************************************************************************************
   4 _! E3 c/ Z5 z
8. */
   ) X  C$ N9 {- u$ m
9. void sf_SetCS(uint8_t _Level)
   ! q# k$ C- j& `; M# S, e% n
10. {
    6 Q- J" @) ?/ T5 d
11.     if (_Level == 0)
    6 s9 B. a: Q! s7 t1 o
12.     {
    * Z0 ?9 G# Y  k+ X
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    
15.         SF_CS_0();
    
16.     }
    
17.     else
    
18.     {        
    6 S6 a, a- b/ J0 O: r! i, {* d( n
19.         SF_CS_1();   
    
20.         bsp_SpiBusExit();        
    
21.     }
    
22. }
    / b' f2 p; d; d9 e. a+ l0 V

复制代码

通过这种方式就有效的解决了单SPI接口管理多设备的问题。因为给每个设备都配了一个独立的片选引脚，这样就可以为每个设备都配置这么一个片选配置。

但是频繁配置也比较繁琐，所以函数bsp_InitSPIParam里面做了特别处理。当前配置与之前配置相同的情况下无需重复配置。
, [8 M" e& I" F( t9 _8 U
73.4.5 第5步：W25QXX的读取实现
W25QXX的读取功能比较好实现，发送03H命令后，设置任意地址都可以读取数据，只要不超过芯片容量即可。

1. /*
   ! p( l8 b! P+ G% o0 z
2. *********************************************************************************************************
   % k4 a" w; m% F( }  K2 T# a
3. *    函 数 名: sf_ReadBuffer
   
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   
5. *    形    参:      _pBuf : 数据源缓冲区；
   
6. *                _uiReadAddr ：首地址
   ! z: _% N: R5 P, C( R1 @
7. *                _usSize ：数据个数, 不能超出芯片总容量
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    6 o8 {/ v5 e/ R3 P/ O
11. void sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    ! W7 P- O9 y0 G
12. {
    
13.     uint16_t rem;
    
14.     uint16_t i;
    
15. 
    
16.     /* 如果读取的数据长度为0或者超出串行Flash地址空间，则直接返回 */
    4 U' a; c6 q. p5 `
17.     if ((_uiSize == 0) ||(_uiReadAddr + _uiSize) > g_tSF.TotalSize)
    
18.     {
    8 P1 t2 K$ z, G) p) r
19.         return;
    * j/ O1 W& ~% X3 q+ `
20.     }
    
21. 
    2 T# q$ v. g8 M4 s, E
22.     /* 擦除扇区操作 */
    
23.     sf_SetCS(0);                                    /* 使能片选 */
    
24.     g_spiLen = 0;
    
25.     g_spiTxBuf[g_spiLen++] = (CMD_READ);                            /* 发送读命令 */
    6 c% ^  [6 K' N8 ?4 X( M. h0 ^
26.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    + V! C; s1 W2 q2 v# y
27.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF00) >> 8);        /* 发送扇区地址中间8bit */
    
28.     g_spiTxBuf[g_spiLen++] = (_uiReadAddr & 0xFF);                /* 发送扇区地址低8bit */
    
29.     bsp_spiTransfer();
    
30. 
    
31.     /* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
    
32.     for (i = 0; i < _uiSize / SPI_BUFFER_SIZE; i++)
    2 Z) y% `+ I3 B9 L
33.     {
    # x& c: B! E$ R
34.         g_spiLen = SPI_BUFFER_SIZE;
    % V, w, a9 Z' `1 F
35.         bsp_spiTransfer();
    % O8 F# {  B$ H, ^
36. 
    ( \/ B5 k( n% Q+ M, I& V* F
37.         memcpy(_pBuf, g_spiRxBuf, SPI_BUFFER_SIZE);
    4 {1 l% z: g* S; h
38.         _pBuf += SPI_BUFFER_SIZE;
    
39.     }
    ! S# X. r$ W2 U$ k2 w+ d3 i
40. 
    
41.     rem = _uiSize % SPI_BUFFER_SIZE;    /* 剩余字节 */
    
42.     if (rem > 0)
    
43.     {
    
44.         g_spiLen = rem;
    
45.         bsp_spiTransfer();
    6 J7 j) F+ |8 h5 F6 R6 C
46. 
    
47.         memcpy(_pBuf, g_spiRxBuf, rem);
    
48.     }
    % p. q% |5 h& U, W! R
49. 
    9 H4 D! Y( I+ H/ [: b
50.     sf_SetCS(1);                                    /* 禁能片选 */
    2 S! S  r% T& P, b( M* a( S5 Q
51. }

复制代码

这个函数对DMA传输做了特别处理，方便分包进行。

73.4.6 第6步：W25QXX的扇区擦除实现
% T5 n1 K( X7 c( V扇区擦除的实现也比较简单，发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除。擦除的扇区大小是4KB。

1. /*
   
2. *********************************************************************************************************
   9 F# p# |+ q5 v7 t, L+ P
3. *    函 数 名: sf_EraseSector
   
4. *    功能说明: 擦除指定的扇区
   
5. *    形    参: _uiSectorAddr : 扇区地址
   ' ?# W* G7 X' _- M2 _
6. *    返 回 值: 无
   * ]4 A. ^! [% P9 }5 b
7. *********************************************************************************************************
   
8. */
   
9. void sf_EraseSector(uint32_t _uiSectorAddr)
   
10. {
    * G, M- C  p) W2 c1 I
11.     sf_WriteEnable();                            /* 发送写使能命令 */
    ) g5 V1 G- T! T: m
12. 
    
13.     /* 擦除扇区操作 */
    4 k5 o7 }. n2 a# @5 u3 [
14.     sf_SetCS(0);                                /* 使能片选 */
    
15.     g_spiLen = 0;
    , h' x8 K/ U% X
16.     g_spiTxBuf[g_spiLen++] = CMD_SE;                /* 发送擦除命令 */
    ; ~, P- f" F, M# V, b* N& h
17.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    # u; X8 G8 x  z+ b/ v
18.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF00) >> 8);    /* 发送扇区地址中间8bit */
    
19.     g_spiTxBuf[g_spiLen++] = (_uiSectorAddr & 0xFF);            /* 发送扇区地址低8bit */   
    
20.     bsp_spiTransfer();
    
21.     sf_SetCS(1);                                    /* 禁能片选 */
    $ T8 i1 Z1 ]0 r
22. 
    7 b! }% R, q6 F4 u+ `: h* ~# g
23.     sf_WaitForWriteEnd();                            /* 等待串行Flash内部写操作完成 */
    
24. }
    

复制代码

8 h) V" ~9 t, U/ B$ G! j7 z" d" x
2 h/ S5 s; p3 x# h4 P3 c* N整个芯片的擦除更省事些，仅发送整个芯片擦除命令即可：

* q' G" A7 k, O/ ~! M

1. /*
   , ?1 a% o9 l7 h1 p5 q' }3 @' c
2. *********************************************************************************************************
   
3. *    函 数 名: sf_EraseChip
   
4. *    功能说明: 擦除整个芯片
   $ d3 f7 `, G. n" Q0 Q7 V1 H
5. *    形    参:  无
   & o7 d7 ]* e" |7 V. a
6. *    返 回 值: 无
   8 V& G" ?& ^- B
7. *********************************************************************************************************
   6 ?6 e, H! e- `9 |( ?
8. */
   & J: O( D! s/ V% Y" e2 ]
9. void sf_EraseChip(void)
   ; {2 P, l3 s& Z$ L8 w0 G! c) b5 k
10. {   
    
11.     sf_WriteEnable();                                /* 发送写使能命令 */
    6 w1 P! a  W4 o+ G0 T6 L* A
12. 
    
13.     /* 擦除扇区操作 */
    
14.     sf_SetCS(0);        /* 使能片选 */
    
15.     g_spiLen = 0;
    # g) ?3 z. j5 h4 G
16.     g_spiTxBuf[g_spiLen++] = CMD_BE;        /* 发送整片擦除命令 */
    
17.     bsp_spiTransfer();
    $ `, b, q' H6 M& }1 [$ m# t
18.     sf_SetCS(1);                        /* 禁能片选 */
    
19. 
    
20.     sf_WaitForWriteEnd();                /* 等待串行Flash内部写操作完成 */
    - z1 E$ D+ h7 Z  J1 x9 p, z1 A
21. }
    , x) S& K2 D$ c' E

复制代码

" m6 o8 P2 l! k3 u& Q73.4.7 第7步：W25QXX的编程实现
W25QXX的编程实现略复杂，因为做了自动擦除支持，大家可以在任意地址，写任意大小的数据，只要不超过芯片容量即可。我们这里就不做展开讨论了，大家有兴趣可以研究下：

1. /*
   ( y5 O7 l" x: G* }8 {
2. *********************************************************************************************************
   1 h' Q' B3 [! K" `  s+ Z" B
3. *    函 数 名: sf_WriteBuffer
   & j# @8 i4 m7 f* j: D7 i
4. *    功能说明: 写1个扇区并校验,如果不正确则再重写两次，本函数自动完成擦除操作。
   ! P( N8 h- [2 j, U* o
5. *    形    参:  _pBuf : 数据源缓冲区；
   
6. *               _uiWrAddr ：目标区域首地址
   
7. *               _usSize ：数据个数，任意大小，但不能超过芯片容量。
   
8. *    返 回 值: 1 : 成功， 0 ： 失败
   
9. *********************************************************************************************************
   " }4 G* _# A6 _; x8 n" n6 h9 ]
10. */
    / y5 @4 \/ i/ w% k: G1 ~: E  k, l% c, Z
11. uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)
    
12. {
    , n( x0 p5 m! J2 @) ?6 R  L+ O
13.     uint32_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
    
14. 
    
15.     Addr = _uiWriteAddr % g_tSF.SectorSize;
    
16.     count = g_tSF.SectorSize - Addr;
    ; _" h* r' B7 w; |; s
17.     NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    % V& S0 z  _! y5 {* I8 G
18.     NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    
19. 
    3 t8 l2 O* a7 N/ g! _9 K! \; p
20.     if (Addr == 0) /* 起始地址是扇区首地址  */
    
21.     {
    6 k  o+ j* x5 v
22.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    ) p% i' j% G+ Z. @
23.         {
    2 J  w, ^2 k1 [( A% x9 |
24.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    3 ~$ |* q# E) V1 N1 w; Z
25.             {
    9 J8 F8 {- U3 v1 d# }
26.                 return 0;
    
27.             }
    : ]' ?  B. w2 a
28.         }
    
29.         else     /* 数据长度大于等于扇区大小 */
    
30.         {
    , E/ a7 t* {0 I/ w  t! _; m+ }
31.             while (NumOfPage--)
    & h* V7 w+ s4 {: c/ A2 ^9 Q
32.             {
    
33.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    $ L  O$ Z$ U: k* q
34.                 {
    9 z  c0 S' @  e7 `$ Y* v8 X/ T  c( s
35.                     return 0;
    9 S; E) f" f4 A8 k7 Y/ P
36.                 }
    0 _2 k, k) J. `  Y9 f) _- B
37.                 _uiWriteAddr +=  g_tSF.SectorSize;
    # q' O3 G7 D) X* p# p+ v, W: n9 q: N& I
38.                 _pBuf += g_tSF.SectorSize;
    
39.             }
    
40.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
    
41.             {
    
42.                 return 0;
    
43.             }
    4 B$ d, }* d! u" e" P9 w
44.         }
    5 t$ L6 e0 P+ D% V! T
45.     }
    
46.     else  /* 起始地址不是扇区首地址  */
    
47.     {
    
48.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
49.         {
    
50.             if (NumOfSingle > count)  /* (_usWriteSize + _uiWriteAddr) > SPI_FLASH_PAGESIZE */
    : h! E) s- p; U- k& B0 Z
51.             {
    
52.                 temp = NumOfSingle - count;
    
53. 
    
54.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    6 k9 U& V* y, k! {
55.                 {
    7 B- J3 J0 C' H. X! o% U5 W
56.                     return 0;
    
57.                 }
    5 h9 {6 h* G' o
58. 
    
59.                 _uiWriteAddr +=  count;
    
60.                 _pBuf += count;
    
61. 
    / r3 `& H  P1 k, E, Y* @  \/ o0 o* A; I
62.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, temp) == 0)
    
63.                 {
    ! N  L, W7 e9 ]- f
64.                     return 0;
    3 }0 {/ s; v% `7 O( q
65.                 }
    " }% K1 s6 m4 B) S6 {
66.             }
    ' V% r5 z8 E' D% }
67.             else
    
68.             {
    
69.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    1 B( J' T+ J0 h: A
70.                 {
    
71.                     return 0;
    8 |* z0 e) |! ]7 F8 B: ^
72.                 }
    ; m" V. a* N1 k7 Q4 \; J/ Z
73.             }
    
74.         }
    7 [2 y4 M* b& D& k& ~; p
75.         else    /* 数据长度大于等于扇区大小 */
    
76.         {
    
77.             _usWriteSize -= count;
    : M3 g8 o7 E9 Y2 Y) k( s# J' B* A
78.             NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    
79.             NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    
80.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    
81.             {
    
82.                 return 0;
    % o* L: ^, k  F! ^
83.             }
    : p' s% E1 {  Q8 H+ |- q: R
84. 
    
85.             _uiWriteAddr +=  count;
    " o  t1 P/ |9 R
86.             _pBuf += count;
    ( A' b7 z+ p8 Z) v* M9 s+ g, H
87. 
    
88.             while (NumOfPage--)
      n  A7 \  j' L7 c8 {, `/ a$ f
89.             {
    
90.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    3 f5 x3 P4 |6 w/ j% U
91.                 {
    " j; K, e: T4 @& \. b# R  M
92.                     return 0;
    
93.                 }
    0 j4 U7 }) K* l. {/ y; j0 `
94.                 _uiWriteAddr +=  g_tSF.SectorSize;
    : o: u6 o" g9 r* D
95.                 _pBuf += g_tSF.SectorSize;
    - I8 N, s- i  K+ ^( w
96.             }
    ; _, z7 }( f% Y/ o5 M- ]' r
97. 
    8 z, k$ A: r& D( ]' w0 ]
98.             if (NumOfSingle != 0)
    $ y) M/ ]+ x/ T* J3 Z# o
99.             {
    
100.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
     ( r3 A  p! j! k, ~# }0 S
101.                 {
     
102.                     return 0;
     
103.                 }
     
104.             }
     8 L: d) m/ s8 x# q- a9 e# _2 ~
105.         }
     
106.     }
     
107.     return 1;    /* 成功 */
     7 [0 y! f8 P, y2 A
108. }

复制代码

73.5 SPI总线板级支持包（bsp_spi_bus.c）
; ?% Z0 v7 g; N/ M% s" S. vSPI总线驱动文件bsp_spi_bus.c主要实现了如下几个API供用户调用：

! g- o  H/ `7 r  bsp_InitSPIBus
% d6 I% h* {0 f( `0 [& h  bsp_InitSPIParam
  bsp_spiTransfer
73.5.1 函数bsp_InitSPIBus
函数原型：

void bsp_InitSPIBus(void)
1 z* y4 a1 _7 H: c$ U  `
) G) E+ K, c  i函数描述：

, O. }3 L; m& s- _- |. c此函数主要用于SPI总线的初始化，在bsp.c文件调用一次即可。
8 o4 d* W  V( i1 E% H( T; k4 c
73.5.2 函数bsp_InitSPIParam
5 C; Z/ b! _; Q' g/ L% M函数原型：
8 O' n1 ^! D# j! p6 k9 W
+ B2 Q/ W( ]4 ]' I7 ?3 fvoid bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)

函数描述：

) `3 \2 b6 ~" K) G7 `" Z* O7 w1 I此函数用于SPI总线的配置。

函数参数：

1 y7 U* V8 \3 p: p  第1个参数SPI总线的分频设置，支持的参数如下：
4 b' r3 x! B% @& f. |5 U, WSPI_BAUDRATEPRESCALER_2    2分频

: Z' i; l2 J8 d0 }5 v, |1 lSPI_BAUDRATEPRESCALER_4    4分频

& w: B) t1 t9 v) F2 ~SPI_BAUDRATEPRESCALER_8    8分频

0 N+ o$ P, a& ~  ESPI_BAUDRATEPRESCALER_16   16分频
' d7 `1 p; i( b* W0 n. a
SPI_BAUDRATEPRESCALER_32   32分频

% o6 n& v: M8 l( y2 v9 ^5 eSPI_BAUDRATEPRESCALER_64   64分频
8 Y' f( f  a4 W3 F1 G8 a- m
! H7 v" [2 G+ [, x) \  Y4 ^SPI_BAUDRATEPRESCALER_128  128分频

SPI_BAUDRATEPRESCALER_256  256分频
5 T1 c- d& x5 N; I' o- l
' U0 w- c$ X9 B6 q3 V  Z+ M  第2个参数用于时钟相位配置，支持的参数如下：
SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
$ x! q  @: z: @3 c
+ [: _3 [' l2 RSPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
9 z0 b" h" O+ i' a0 {6 r: b+ C
  第3个参数是时钟极性配置，支持的参数如下：
SPI_POLARITY_LOW   SCK引脚在空闲状态处于低电平
. u, M4 T4 ]- m4 X$ `; l
# p# o  h& \% O/ TSPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平

0 d$ Z  h4 p: C- o73.5.3 函数bsp_spiTransfer
函数原型：
8 X/ [  A* u; b
; S4 g8 V; f, O1 [void bsp_spiTransfer(void)

函数描述：
1 y' ^* l  C  m8 V, h$ y* I- d$ c
, a+ j6 O8 A! W3 k% T' r0 m此函数用于启动SPI数据传输，支持查询，中断和DMA方式传输。
% F0 ^( y/ \- j! e) o' j* |
73.6 W25QXX板级支持包（bsp_spi_flash.c）
! T, g4 \0 i1 [9 V  T) K0 l0 [W25QXX驱动文件bsp_spi_flash.c主要实现了如下几个API供用户调用：

  sf_ReadBuffer
6 L; I! ^- {2 P; O3 D6 A+ Y! {  sf_WriteBuffer
  sf_EraseSector
4 E) Y' G9 f7 @4 a0 }5 F. O  sf_EraseChip
  \2 g% T& Q3 e: \. W- d1 j' M- E  sf_EraseSector
) Y) V' O0 y* X5 C+ n. p$ A( z; N73.6.1 函数sf_ReadBuffer
0 r' ~- K/ g; N' R函数原型：

7 U5 z1 v9 o% j. y4 k& @) kvoid sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)

函数描述：

( |# k+ f$ J/ g/ N此函数主要用于从SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。

6 H9 G- M# o. d0 v& O$ T0 e函数参数：

9 k1 X( O' {) H) j& F  第1个参数用于存储从SPI Flash读取的数据。
9 f! B4 V4 H0 h) }2 \; Q; Q  H# o2 Z  第2个参数是读取地址，不可以超过芯片容量。
, Y  l5 m- T7 I' t$ Y  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
73.6.2 函数sf_WriteBuffer（自动执行擦除）
函数原型：

uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)

4 k- r# t( L" |4 q2 ]1 K函数描述：

2 \9 q+ u0 h, e; n) U此函数主要用于SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。特别注意，此函数会自动执行擦除，无需用户处理。

2 E+ h  t; R' W% R) @' ?- v函数参数：
* t" p, c) a0 U( B; H7 X
  第1个参数是源数据缓冲区。
0 [8 P1 q% i( R. j  第2个参数是目标区域首地址。
  S/ d) J, }4 |4 O9 J0 ^  第3个参数是数据个数，支持任意大小，但不能超过芯片容量。单位字节个数。
  返回值，返回1表示成功，返回0表示失败。
73.6.3 函数sf_EraseSector
函数原型：
  m% }$ M9 x1 H& p6 Q# h
void sf_EraseSector(uint32_t _uiSectorAddr)
8 x+ s4 a, |" \
5 i' r# d, \6 C( R/ ]函数描述：
" V6 O8 K0 S2 N# H' W
7 H9 y; @8 f8 x' O3 b: I此函数主要用于扇区擦除，一个扇区大小是4KB。

. |0 H1 X% x' G' X" m函数参数：
3 Y" H0 `/ V9 u6 K9 Z
8 [  J! w" G7 N  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
73.6.4 函数sf_EraseChip
函数原型：
/ V4 J7 O1 X! N( V5 l1 K
void sf_EraseChip(void)
1 q$ y+ o  F9 R# M" C$ r2 p
$ ?' w- J! E- K5 d- X+ e) ~7 P函数描述：
6 s" n* a; H" {: r* J2 W" @
# g  z8 h, t2 P/ Y! e- \此函数主要用于整个芯片擦除。

! L+ {& B  }9 r: h2 @$ t# B+ m1 y73.6.5 函数sf_PageWrite（不推荐）
+ M0 h& R- n8 \' k5 u) |# \, ^函数原型：

- f6 s" m0 N0 l2 R1 e+ m! kvoid sf_PageWrite(uint8_t * _pBuf, uint32_t _uiWriteAddr, uint16_t _usSize)

函数描述：
, _* _& A2 G" M' }8 ~. y3 S5 j
+ p( T3 Z& r0 c  }" M此函数主要用于页编程，一次可以编程多个页，只要不超过芯片容量即可。不推荐大家调用此函数，因为调用这个函数前，需要大家调用函数sf_EraseSector进行扇区擦除。
& C6 G+ j3 g# ~: @
6 A1 W! I- W5 p. h3 ~0 P" A函数参数：
, y1 L0 z7 q* V7 a9 b( z2 t
, T) j; O1 _! |2 D8 T! H  第1个参数是数据源缓冲区。
9 A7 n1 W+ _! y5 x! v  第2个参数目标区域首地址，比如编程页0，此处填0x0000，编程页1，此处填0x0100，编程页2，此处填0x0200，以此类推。
6 D1 \9 z, A) ^1 Q5 h  _  第3个参数是编程的数据大小，务必是256字节的整数倍，单位字节个数。
73.7 W25QXX驱动移植和使用
W25QXX移植步骤如下：
* {8 w, T9 [5 w& O$ A) t
  第1步：复制bsp_spi_bus.c，bsp_spi_bus.h，bsp_spi_flash.c，bsp_spi_flash.h到自己的工程目录，并添加到工程里面。
$ {! }/ o! F1 a& u" g7 u& P  第2步：根据使用的第几个SPI，SPI时钟，SPI引脚和DMA通道等，修改bsp_spi_bus.c文件开头的宏定义
) R5 n) }1 O4 r

1. /*
   1 s7 z" C4 n2 t/ Y* ?
2. *********************************************************************************************************
   + i5 ~& H5 H  C# g  b2 ?4 x
3. *                                时钟，引脚，DMA，中断等宏定义
   ) s" L! K# ^0 P9 Y! I9 e" F
4. *********************************************************************************************************
   
5. */
   
6. #define SPIx                            SPI1
   
7. #define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
   9 l: ]& d; I5 S
8. #define DMAx_CLK_ENABLE()                __HAL_RCC_DMA2_CLK_ENABLE()
   
9. 
   , M& ~/ |* ]2 j; J& |' K3 }
10. #define SPIx_FORCE_RESET()                __HAL_RCC_SPI1_FORCE_RESET()
    . |' P- ?& z; H$ l3 C0 m
11. #define SPIx_RELEASE_RESET()            __HAL_RCC_SPI1_RELEASE_RESET()
    & n  l9 E9 f  v+ O3 j6 f
12. 
    
13. #define SPIx_SCK_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    ( V  }9 D5 [+ J' m! u, r. j1 E
14. #define SPIx_SCK_GPIO                    GPIOB
    7 O& E: P8 S/ c' l
15. #define SPIx_SCK_PIN                    GPIO_PIN_3
    
16. #define SPIx_SCK_AF                        GPIO_AF5_SPI1
    
17. 
    , Y3 \1 c0 [: c, {  h( V
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
    7 u( z5 C" C: b
21. #define SPIx_MISO_AF                    GPIO_AF5_SPI1
    
22. 
    , o& ?. r$ N/ h# E: Y
23. #define SPIx_MOSI_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    . I/ e/ l6 \! D1 n0 R' @# P
24. #define SPIx_MOSI_GPIO                    GPIOB
      z3 M5 ^8 h" p5 d
25. #define SPIx_MOSI_PIN                     GPIO_PIN_5
    
26. #define SPIx_MOSI_AF                    GPIO_AF5_SPI1
    
27. 
    % O* o' T. m6 e  a: A
28. #define SPIx_TX_DMA_STREAM               DMA2_Stream3
    
29. #define SPIx_RX_DMA_STREAM               DMA2_Stream2
    
30. 
    2 i  z1 N: p$ p9 _# W6 _; O. T1 {) _0 T
31. #define SPIx_TX_DMA_REQUEST              DMA_REQUEST_SPI1_TX
    
32. #define SPIx_RX_DMA_REQUEST              DMA_REQUEST_SPI1_RX
    
33. 
    
34. #define SPIx_DMA_TX_IRQn                 DMA2_Stream3_IRQn
    
35. #define SPIx_DMA_RX_IRQn                 DMA2_Stream2_IRQn
    
36. 
    ( K  z. i# m2 g8 S1 c5 [4 j
37. #define SPIx_DMA_TX_IRQHandler           DMA2_Stream3_IRQHandler
    . i# T) a2 q1 J4 c4 _
38. #define SPIx_DMA_RX_IRQHandler           DMA2_Stream2_IRQHandler
    
39. 
    2 J, z0 Y7 z3 S& m  N
40. #define SPIx_IRQn                        SPI1_IRQn
    1 ?1 _, |# J# Q
41. #define SPIx_IRQHandler                  SPI1_IRQHandler
    ! H# P) X+ @- w

复制代码

: M( }( t% L# H1 P1 K1 J% D
  第3步：根据使用的SPI ID，添加定义到文件bsp_spi_flash.h
  v# N0 t6 g, T

1. /* 定义串行Flash ID */
   
2. enum
   
3. {
   
4.     SST25VF016B_ID = 0xBF2541,
     q0 n6 G& v8 |9 f
5.     MX25L1606E_ID  = 0xC22015,
   ' i4 e$ l- |4 }8 `4 r
6.     W25Q64BV_ID    = 0xEF4017, /* BV, JV, FV */
   7 g; @; u9 F1 V5 g: E
7.     W25Q128_ID     = 0xEF4018
   
8. };

复制代码

2 @, ]& s" K. \' {  第4步：添加相应型号到bsp_spi_flash.c文件的函数sf_ReadInfo里面。
" k- L* r3 P- w& i

1. /*
   ) Y3 V- U4 x% w& s$ @* J) x
2. *********************************************************************************************************
   6 X6 y- S+ z1 N( J& o6 R
3. *    函 数 名: sf_ReadInfo
   
4. *    功能说明: 读取器件ID,并填充器件参数
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   8 @$ o3 ?. E" ?+ @0 g& K( s, C6 t
7. *********************************************************************************************************
   
8. */
   $ o0 H. m4 r9 j9 F( p
9. void sf_ReadInfo(void)
   ' `& i$ V, i0 M! o
10. {
    
11.     /* 自动识别串行Flash型号 */
    + r, p+ s- a$ N1 S* ]; L0 H
12.     {
    
13.         g_tSF.ChipID = sf_ReadID();    /* 芯片ID */
      o. R& t& r  F/ z! i# h- s( D
14. 
    6 q9 M5 e4 E% w6 v4 b9 V+ ~  Q
15.         switch (g_tSF.ChipID)
    & x: [) L0 ^( Z6 F2 I7 J- ~
16.         {
    
17.             case SST25VF016B_ID:
    8 W1 ~. l. {9 K, \; O* F
18.                 strcpy(g_tSF.ChipName, "SST25VF016B");
    
19.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    7 f0 ]6 u6 w& z
20.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
21.                 break;
    
22. 
    & p% b8 {1 r6 ]
23.             case MX25L1606E_ID:
    % }7 X+ d' X4 K" ~) ^8 p9 e
24.                 strcpy(g_tSF.ChipName, "MX25L1606E");
    
25.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    
26.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
27.                 break;
    
28. 
    
29.             case W25Q64BV_ID:
    
30.                 strcpy(g_tSF.ChipName, "W25Q64");
    
31.                 g_tSF.TotalSize = 8 * 1024 * 1024;    /* 总容量 = 8M */
    . @: \4 L6 x& Z- Y
32.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    # p" f, G/ z1 _/ R
33.                 break;
    : {, f8 H1 ^' p+ N. Q
34. 
    
35.             case W25Q128_ID:
    $ ^) d$ T( P& k4 M$ Y9 |' q" u! i) \
36.                 strcpy(g_tSF.ChipName, "W25Q128");
    
37.                 g_tSF.TotalSize = 16 * 1024 * 1024;    /* 总容量 = 8M */
    , D1 v$ l2 g  u3 N9 c1 ?
38.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    ( i- f, e9 n' v5 w; z+ `
39.                 break;            
    : g2 o( B' I1 {
40. 
    % w+ N; V& i5 f9 G
41.             default:
    
42.                 strcpy(g_tSF.ChipName, "Unknow Flash");
    ( u2 b% `; \1 I$ Y4 z5 e4 ~2 i- Q
43.                 g_tSF.TotalSize = 2 * 1024 * 1024;
    
44.                 g_tSF.SectorSize = 4 * 1024;
    
45.                 break;
    
46.         }
    
47.     }
    6 l' N. z  U' _- s
48. }

复制代码

  第5步：根据芯片支持的时钟速度，时钟相位和时钟极性配置函数sf_SetCS。

1. /*
   # q' S' y8 m2 l/ K8 K7 K
2. *********************************************************************************************************
   ' b- G/ l* ?$ {9 x
3. *    函 数 名: sf_SetCS
   
4. *    功能说明: 串行FALSH片选控制函数
   
5. *    形    参: 无
   5 O5 ]0 g- y4 q8 F! r8 Q
6. *    返 回 值: 无
   : Y0 x, r: V6 {$ ?7 C$ C6 @/ e
7. *********************************************************************************************************
   
8. */
   
9. void sf_SetCS(uint8_t _Level)
   1 ]( B' l; c0 S9 ]
10. {
    
11.     if (_Level == 0)
    
12.     {
    
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    , v. {3 U/ L+ a5 V" `' m* X" `
15.         SF_CS_0();
    
16.     }
    
17.     else
    
18.     {        
      [/ B+ ~2 P* G, E6 K
19.         SF_CS_1();   
    
20.         bsp_SpiBusExit();        
    
21.     }
    
22. }

复制代码

  第6步：根据使用的SPI Flash片选引脚修改bsp_spi_bus.c文件开头的宏定义。
( k- A$ d; S9 L$ [6 d3 s

1. /* 串行Flash的片选GPIO端口， PD13  */
   . X& ~3 [1 j* H) ~3 P# w: U/ `6 d
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
   8 a0 d2 N5 g& }) p9 \% ]
5. 
   
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

复制代码

! C+ B- r+ c" l% R3 Q1 H- {" ]  第7步：如果使用DMA方式的话，请不要使用TCM RAM，因为通用DMA1和DMA2不支持。并为了防止DMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭Cache处理，比如使用的SRAM4：

1. /* 配置SRAM4的MPU属性为Non-cacheable */
   
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   0 g7 s. A5 n6 S: u
3. MPU_InitStruct.BaseAddress      = 0x38000000;
   , M1 I" a- |, }6 C
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   6 E  C& N4 h; M. {' ^" s% w
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   
7. MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   ; |; e9 K& L4 z8 F! r% d. n
8. MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9. MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   & Z% L4 U9 t+ o! x' \* m- j
10. MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
11. MPU_InitStruct.SubRegionDisable = 0x00;
    ; {' r. e2 g8 c3 x  h- I
12. MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
13. 
    
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

  第8步：初始化SPI。

1. /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
     K9 g+ v! U2 }7 E# d
2. bsp_InitSPIBus();    /* 配置SPI总线 */        
   ' A6 o! [. I5 U# @
3. bsp_InitSFlash();    /* 初始化SPI 串行Flash */

复制代码

: ]& q% [8 I; U0 H6 v& U  第9步：SPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第10步：应用方法看本章节配套例子即可。
/ G" l: r5 ], P4 l4 ?7 m73.8 实验例程设计框架
3 ^, v4 b6 \+ g通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
7 @' H/ F2 @( G) ]9 I

# K7 r) U+ q/ t  第1阶段，上电启动阶段：
: y* W2 U! F7 }' z+ Z: f$ x
这部分在第14章进行了详细说明。
  
第2阶段，进入main函数：
4 x# m0 C$ n4 {" K" b) Y& ^
第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  a/ K: L. I; p/ e& @; x- W. U第2部分，应用程序设计部分，实现SPI Flash的中断，查询和DMA方式操作。

73.9 实验例程说明（MDK）
配套例子：

V7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）
" z- i# q; R& T6 t2 R. ]! d, W
  N- M6 H% E0 v' x5 ^: O& r* y) CV7-050_串行SPI Flash W25QXX读写例程（DMA方式）
/ S' Q9 \. d1 v) S. w
9 _1 I& q( g, `9 |+ fV7-051_串行SPI Flash W25QXX读写例程（中断方式）
0 M4 u4 h; Y" r. h" A2 e" X  C$ O
实验目的：
: X! c0 X- {; s- x, A$ z. g, Z
学习SPI Flash的读写实现，支持查询，中断和DMA方式。

! D( S3 j5 m: c) e  r2 V" q实验操作：

支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
printf("请选择操作命令:\r\n");
0 W- v3 r) J) t+ d8 @0 kprintf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
2 q+ Y+ X' `! _7 d7 M3 ]printf("【3 - 擦除整个串行Flash】\r\n");
* u& j9 f2 {) t: m# E4 V1 o1 ]( R, Wprintf("【4 - 写整个串行Flash, 全0x55】\r\n");
7 ~! v: r0 T8 {/ wprintf("【5 - 读整个串行Flash, 测试读速度】\r\n");
1 `5 `! `- i" O. pprintf("【Z - 读取前1K，地址自动减少】\r\n");
/ r' r/ y  n" w* Y+ aprintf("【X - 读取后1K，地址自动增加】\r\n");
, ?- \) L+ E+ a# U" s' ?: @3 c* j% Nprintf("其他任意键 - 显示命令提示\r\n");
上电后串口打印的信息：
/ U( ]+ G0 v: Y* {* g' z* B
4 f8 e1 n- B" v波特率 115200，数据位 8，奇偶校验位无，停止位 1。
) n$ U* \" p5 |3 L  H0 Z  F8 J5 Z1 S; r

7 K2 I1 u4 M/ n4 A/ v
程序设计：

( m+ P6 m  O, K; M2 Q9 J  系统栈大小分配：
, ^- H9 K/ W( Y( {, I! F8 y

  RAM空间用的DTCM：

( o1 n3 y  I5 q! b2 L% d" Z

! r7 n3 _/ p- ]7 G$ g$ `4 t8 ~
  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   ! a0 G/ w& l- z" H% y9 d8 A- M
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   & B1 K" J7 k7 }9 U' V
5. *    形    参：无
   5 O' P* U/ y8 p, p+ Q  c
6. *    返 回 值: 无
   ) s# S# I) k2 }! W& b# ^- i
7. *********************************************************************************************************
   
8. */
   / W5 Z. i0 i1 ^
9. void bsp_Init(void)
   7 T6 }1 O! Q* j
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    4 G7 S# F( V8 j. [* u, T0 d
13. 
    7 V( A! K4 N; K' o
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    7 V5 g4 k4 l9 p3 F/ d7 l4 h
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    $ f- v' s+ u- Q+ N; p( Y
20.        - 设置NVIV优先级分组为4。
    ! C0 M' w3 _) w
21.      */
    $ ?0 \* R# j, R' V) K8 Z- d7 I
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    , A  e# `6 a9 p$ o+ u
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    9 I9 E* ^/ [) _% `4 _
28.     */
    
29.     SystemClock_Config();
    ! r1 o; P5 G; A
30. 
    
31.     /*
    3 r2 X: R$ J2 T5 P# L; w
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    " D0 A. L! p1 o4 G: G" ]% m
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    9 v7 [9 a6 t/ c+ F7 l9 t0 M
37.     /* 初始化EventRecorder并开启 */
    * q6 E! Z* [% G4 Z5 F( d$ M1 {" |
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    % ^  x; u, ^8 g8 l3 X+ m
41. 
    3 }) t0 n. T9 k, U
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();         /* 初始化LED */   
    7 |+ p8 r2 a7 {/ B+ O" [4 d4 G
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    6 K7 Q+ X7 r; f; u
49. 
    1 Y8 V9 D# I- ^/ ]" H; Z0 }6 k
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    7 ^  G& U. @+ ~0 q/ c, I; ]
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    
53. }

复制代码

  MPU配置和Cache配置：
3 V. a/ S" A( z& @/ S
1 w( ~; u( S  G7 `数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区以及SRAM4
1 S( A1 y& g9 K; \6 W' S! b( m

1. /*
   . m: J7 T5 c$ C
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   5 N" O' b- d# \3 C: ^% E3 e
8. */
   
9. static void MPU_Config( void )
   ) f" Y8 [% ?; o, w( ^  K% K
10. {
    $ `. V. e% Z+ |5 K; N; V5 ^
11.     MPU_Region_InitTypeDef MPU_InitStruct;
      Q4 x& m) ]5 J9 C6 m
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    ' B3 q* W: V6 v7 {$ }. m4 o# B0 C
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ( F' L1 z1 R! t( e
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    & X( r6 L& n1 T- o% h- q5 U! h
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ) h2 Y) u6 d/ p+ z
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ; P: `) X3 x( W2 u
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ' Y( x, ^1 ^9 n% u
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    6 K: |/ L' e3 [: Q" j
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    3 I3 ~: Y# g- T
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    % b5 v2 E- _3 i: P
30. 
    ) @' x, `  {4 J9 P  O6 i2 U
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    % e4 {2 T% r6 j) y1 i- W, u* @
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    - x6 x# A) D( E3 ?$ L
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    $ `: D) A: ~$ F+ `& t0 k0 ]
46. 
    9 a+ h% J8 @/ Z% x" i
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    3 P/ h5 B6 ]. K1 J9 [/ M8 [
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 W& u7 w) _& u6 s& Z$ Y
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    # \" A1 E4 T7 y3 r8 X: d
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    7 w" @( G1 d# m
59. 
    0 F7 ]3 g8 ^9 d
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 X, T8 ~5 N& j. ]; L
61. 
    
62.     /*使能 MPU */
    
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    0 E' d* Z4 t+ c2 j9 p+ \" {% [
64. }
    
65. 
    
66. /*
    9 o+ S: X: a' A$ U+ j& v
67. *********************************************************************************************************
    $ m' H; k* E# U8 f7 M, |# A
68. *    函 数 名: CPU_CACHE_Enable
    # m7 p4 T/ K  r
69. *    功能说明: 使能L1 Cache
    
70. *    形    参: 无
    
71. *    返 回 值: 无
    ! T7 Q; J9 {- S' F+ a4 T4 Q; p7 |
72. *********************************************************************************************************
    : M; L. f; }9 f6 Q9 M1 P' j
73. */
    
74. static void CPU_CACHE_Enable(void)
    
75. {
    ) @& [8 g- A1 e
76.     /* 使能 I-Cache */
    . w5 W* I. U$ {) s0 S0 h( @( L+ A, q
77.     SCB_EnableICache();
    " O, a" T$ F( u1 R, _' H7 {
78. 
    " `+ Y- C7 y1 _
79.     /* 使能 D-Cache */
    4 {# f1 d8 J9 H5 T( l! ~
80.     SCB_EnableDCache();
    
81. }

复制代码

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

9 a4 [3 ~8 Y, |4 C按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

% i0 l+ a3 {5 _

1. /*
   
2. *********************************************************************************************************
   $ x: ?# N7 V( m- h
3. *    函 数 名: bsp_RunPer10ms
   7 C0 M; j# i. T5 Z% D
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   / P) m& X( t- ^. T4 m: r
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   4 \- x  F% K& ]; }* C2 A! E: E
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    9 [& i% Y1 C' S, ~: V' Y
11. {
    7 z3 w% P8 k* j, h0 o
12.     bsp_KeyScan10ms();
    
13. }
    
14. 
    

复制代码

  主功能：

$ d; C  S3 _7 e# Z' d主程序实现如下操作：
0 ]$ Z" Y. W7 ~3 d
% S' b! J, T. T4 ?! S& }  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
! U1 l  b1 x" c2 q2 y6 I- v  1 - 读串行Flash
  2 - 写串行Flash
2 p& A) t/ i/ T  3 - 擦除整个串行Flash
2 f" y. Z5 V  }8 w% z4 @  \  4 - 写整个串行Flash
  5 - 读整个串行Flash
: R3 i% j( ]; r, J; {: A  Z - 读取前1K
  X - 读取后1K
7 T& Z& l0 K& v8 a7 U# H4 Y) U

1. /*
   
2. *********************************************************************************************************
   2 ^2 E' C, X; y9 G% n
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   2 V( @& G3 L: Z5 t: ~" o& T
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ; [% R  a8 h( l
9. void DemoSpiFlash(void)
   
10. {
    
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0;
    + E% I# m7 W, {9 [9 P$ ?8 N
13. 
    
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);
    " o& E7 G/ ~$ w8 Y
18. 
    + B: w2 o% T$ W1 i
19.     sfDispMenu();        /* 打印命令提示 */
    : J, h& u/ N) q0 ]) v7 Z1 z3 R, ~
20. 
    . g0 [' Z& z8 Z
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    , j6 e3 K# R6 _2 v: G
22. 
    7 y' Q$ y" H3 ^/ j
23.     while(1)
    - w7 k4 u6 Q" H: v, q
24.     {
    1 `1 w5 Q8 j9 r8 u( m( o* X" e2 X
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    7 k( f' D7 O4 D! E
26. 
    
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
    
29.         {
    
30.             /* 每隔100ms 进来一次 */  
    * Q* M8 X! y7 y4 i% {
31.             bsp_LedToggle(2);
    
32.         }
    ' J8 G% p! C7 [. Q9 T
33. 
    
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
35.         {
    2 c% D! z0 z  e- q9 H, F6 {* F
36.             switch (cmd)
    , e) }8 j) Z  `0 n, _0 L
37.             {
    ( \1 J" v/ ?$ r0 n3 Z9 M  ^5 D
38.                 case '1':
    
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    * e) y% _1 A2 f& O) _0 g. l1 u% x
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    ' m5 z- M9 f* M; F3 C" i
41.                     break;
    - H6 s$ _) O" U# q8 K+ p% d
42. 
    ( _" H2 S: z5 b1 S" B' ?9 R
43.                 case '2':
    
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    
47. 
    
48.                 case '3':
    
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    : E5 z4 ^( ~4 H
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
    
53. 
    6 ~3 H% Y# t& V3 b- ~
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    4 W* H5 o3 E2 l8 ~4 D6 _
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    * `9 }" C# Y. T7 }8 R
59. 
    & m2 c) d* N4 w9 B, {' C7 s- Z4 a  P
60.                 case '5':
    
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
63.                     break;
    , G( f- U0 P" F$ M
64. 
    
65.                 case 'z':
    + i& j* N- G/ ^5 h9 u
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
    0 X' J' y* d$ z7 M8 j0 D, R
68.                     {
    
69.                         uiReadPageNo--;
    $ R( c- ~1 [5 G8 T' Y
70.                     }
    
71.                     else
    ' `+ z+ \. A! @; `' K
72.                     {
    / G' v3 d5 C, b$ |$ H  F- I
73.                         printf("已经是最前\r\n");
    % O& x5 E* T1 D6 z) w. Q5 P
74.                     }
    4 s+ a  L/ k- y7 B, q, [2 V
75.                     sfViewData(uiReadPageNo * 1024);
    ) r& x  P1 b6 Z1 Y
76.                     break;
    4 Q: L  W5 G3 x/ \2 k+ c
77. 
    4 r: ?  o6 {* z# B5 C
78.                 case 'x':
    ' P( ]! W% Q. T8 I  s
79.                 case 'X': /* 读取后1K */
    4 y! Z, S0 ?8 \2 a+ E( `! G# g
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    ' g7 S- X6 |! c5 j8 g& Q$ d
81.                     {
    
82.                         uiReadPageNo++;
    7 U7 Y% B) I; }7 C! G- U) ]* T
83.                     }
    # o& c% z/ z0 v
84.                     else
    2 g7 i: S* P! `7 E5 @6 a, h6 O; C+ I
85.                     {
    
86.                         printf("已经是最后\r\n");
    
87.                     }
    
88.                     sfViewData(uiReadPageNo * 1024);
    
89.                     break;
    / m: l3 e& J$ u. [2 R  Q" p
90. 
    
91.                 default:
    9 a8 t& W/ {) B8 g
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    % E) n" F% q; |3 {
94. 
    
95.             }
    
96.         }
    $ i, _9 z/ S2 ~" P: n( @1 T; t
97.     }
    ) @6 O. C8 q0 F/ K4 H4 ]2 b, W3 J
98. }

复制代码

% s  K; f7 l7 A( E( T73.10          实验例程说明（IAR）
7 Q+ R. T( a* F8 s配套例子：
  u: B* t* D2 v6 [% V+ L
9 A# w4 a. K4 c( HV7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）

V7-050_串行SPI Flash W25QXX读写例程（DMA方式）
- O& g: j5 ?, W- H7 g% g
% m, D2 n. _' f  b  b% xV7-051_串行SPI Flash W25QXX读写例程（中断方式）
: j5 S/ ]( Q# v% x* l9 X1 |$ e  g& Q; r
实验目的：

学习SPI Flash的读写实现，支持查询，中断和DMA方式。

) C" t, Y3 q! p- n实验操作：
( W1 S* o- s$ {0 M$ B6 S2 A- L
支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
% G8 e) h7 s3 c# m5 P. R0 Fprintf("请选择操作命令:\r\n");
printf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
4 n. e# r2 a; a! l; z, Aprintf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
& V+ o  O% K, P$ _" fprintf("【3 - 擦除整个串行Flash】\r\n");
printf("【4 - 写整个串行Flash, 全0x55】\r\n");
printf("【5 - 读整个串行Flash, 测试读速度】\r\n");
6 W7 I0 j% y8 w% f" _printf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
- d7 B; w2 o0 ^/ O$ ~0 {, oprintf("其他任意键 - 显示命令提示\r\n");
1 t8 Z4 s. q1 _* O5 f0 i
上电后串口打印的信息：
$ d4 l5 c. i7 X; u6 M
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

7 G$ J8 A" D5 D3 B

3 D& W, ]5 k- r! j, {+ a
程序设计：

  系统栈大小分配：
2 A% Z9 n6 r% Q6 l' p/ U
" g5 @/ U& O! q' J2 x

- @% Q/ P% l8 U% r+ _! H& n) J
  RAM空间用的DTCM：

+ I; b6 I/ n, \  n" ~0 P  硬件外设初始化
& ^! C/ w; }9 I% {. ], a
4 u9 F2 h: q% E) @4 q6 n硬件外设的初始化是在 bsp.c 文件实现：

4 T' i. z& s) G7 f  |% e

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   5 g8 E$ w  J3 z. ]& x* P' Z3 s4 f8 v) D6 H
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   ( J- e! v' W) g7 N  ?
6. *    返 回 值: 无
   % k" D  j. S: \/ P5 g
7. *********************************************************************************************************
   " B4 {$ A+ [1 ?8 a' j8 z* W% X
8. */
   8 f* p1 n' ?% w, r& B( `! [
9. void bsp_Init(void)
   
10. {
    ' R5 F) x- {/ f1 S( \1 X: |: O
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    0 j% ]( l8 a  |6 k4 G
15.     CPU_CACHE_Enable();
    
16. 
    3 Z$ H. u+ s, [
17.     /*
    + q) G" D9 h) @& k; t* C3 R& m, b, Q7 d0 m
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    . X& p( O7 F, L+ u& V: F  p2 ~
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
      A# B6 C8 r$ a$ [5 A$ M6 M
24.     /*
    ) O4 e! |2 I9 k3 O# o& i% X% N
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    $ o6 {6 S3 e8 k; {% s" I
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    5 E: x; U% ~% m
29.     SystemClock_Config();
    ; h) p8 V4 }9 B: L. ~
30. 
    ' J% K) l4 A7 ?
31.     /*
    
32.        Event Recorder：
    : H3 n+ ^5 y1 _4 j/ b! Q
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    5 S! W- _6 ]5 [# i" ~  ~- L& k
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    " j. K" ]" k: e) l
35.     */   
    
36. #if Enable_EventRecorder == 1  
    4 l" ^4 h2 ~7 n; |" h
37.     /* 初始化EventRecorder并开启 */
    ! m. U4 p1 B% U- R$ T
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    & W5 w* p5 L  Z2 y; M
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    2 W" W; B0 W) a! ~& d/ m& P0 _
45.     bsp_InitLPUart();    /* 初始化串口 */
    / H5 ~" Z0 h6 F" H! l, z  ^/ Y5 Z
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
      z" h. n0 J! Z
47.     bsp_InitLed();        /* 初始化LED */   
    
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    2 A, u6 t% d3 @' b4 S$ K
49. 
    % b, d/ w) [& X$ S- W) w- Q) P2 E( t
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    9 w4 S* C% J0 {$ e& n
53. }

复制代码

8 v- ]0 L6 X+ p; J; i' Y9 V1 F  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
( v# R; B; m0 |% f+ x0 o

1. /*
   7 a5 B6 y+ H+ ^7 E
2. *********************************************************************************************************
   0 G# r& ]3 B0 W% J
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   , k! `8 t6 E# x5 a7 r% Y
6. *    返 回 值: 无
   $ X8 z. J, Y( ?
7. *********************************************************************************************************
   
8. */
   ; K$ c. j( R* J. {* T
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    - H5 b. _. b9 M6 X9 j9 q
14.     HAL_MPU_Disable();
    
15. 
    ' y5 x; ^5 z+ {' B
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    ( Z# [# V% K6 F0 L
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 \; D* B5 Q7 M
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ' t* x, J0 H4 _1 T( E) P, v, t& A
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    1 l$ ^8 t4 W* N% r+ s: m  `
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    # L, N( \4 _% f% Z3 l+ \
31. 
    + k2 x5 y+ y6 B. e7 T
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    : s8 w3 {( z4 G7 t2 y
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    , j$ a2 B) f% r
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    7 w" `3 |; b) s9 `
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    : j& K7 q0 ]9 g1 W& I- J  |6 m/ r
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ; j- q1 x9 ?; S: k0 _
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    , f9 @1 P( Z6 Z, B# _, N
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    7 \/ D; h) I: k/ s1 o% Z; M
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ' n5 Q: S5 n& |# m$ P* ^; }; ~
44. 
    9 O$ U+ x+ T2 Y6 w% @: B
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    7 e% R/ W4 m: r( b# ^3 U( N" P8 {
46. 
    
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    ; l" i: [5 _" N
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    : ?5 o3 H8 S& X& O
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    2 x% V  e1 x0 w, v0 v
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    # m6 h  L, f4 o- f( G/ ]8 v
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    + }- r1 ?; X6 {
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    + x' E! n: C/ J( o/ s- s
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    % G7 t3 K& _% p5 D$ P
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61. 
    
62.     /*使能 MPU */
    $ f, e* e  c$ f3 J
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    3 b5 M' N" ^: c5 a) D2 c
64. }
      Q' x& k5 {2 I# r+ K. j
65. 
    
66. /*
    6 ^$ E# N6 l9 f4 l  a6 l
67. *********************************************************************************************************
    . n: X! i7 \: u/ U7 }6 l3 {" M0 n
68. *    函 数 名: CPU_CACHE_Enable
    ' Q2 E8 c* G2 U4 i4 S7 N
69. *    功能说明: 使能L1 Cache
    + w  W6 q2 |( Z& S/ W+ N% ^
70. *    形    参: 无
    - c1 W3 C* \& p2 p3 n, r
71. *    返 回 值: 无
    
72. *********************************************************************************************************
    - ~; ]% f" i2 V+ G4 m
73. */
    
74. static void CPU_CACHE_Enable(void)
    ( W$ J5 [% {, ~! X& `7 T
75. {
    ) D( S* ^! v$ H( W( W7 R
76.     /* 使能 I-Cache */
    % h' u* \  B5 j) q! T
77.     SCB_EnableICache();
    ! U: ~( W& H2 \
78. 
    
79.     /* 使能 D-Cache */
    
80.     SCB_EnableDCache();
    
81. }
    

复制代码

* R  w0 ^, B" k& m
# ]+ u% z; b8 u/ u* {5 P  每10ms调用一次按键处理：
# }/ f3 O! b6 Z- d3 p
( B5 r/ ]( D0 J0 A按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

, v/ z9 B' W& ~

1. /*
   8 P! {/ a" _( Z$ w  m" K
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   2 V6 q3 i4 G1 t, A; r
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   6 a' H; A+ `8 p
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   / t  S  M, m) U4 y
7. *    返 回 值: 无
   ) B2 I/ a  t5 s7 V+ n
8. *********************************************************************************************************
   4 U* E4 _0 d6 I0 X
9. */
   ! u, e( ]( n8 U- v8 l
10. void bsp_RunPer10ms(void)
    " [/ ?6 O. x4 I3 {, n
11. {
    - g- g6 A& R& D% v  S# U9 t
12.     bsp_KeyScan10ms();
    # Z! i+ B& f% n2 E# b, ?/ y( l. X4 L
13. }

复制代码

  主功能：
7 K; Y: O3 X! Z/ Q- x+ P$ ~
主程序实现如下操作：
# ^  J, @% U$ o  T: t
+ A- b1 u0 o) P% s) z% ~  启动一个自动重装软件定时器，每100ms翻转一次LED2。
; }5 W) \" E5 |. Z/ E1 U: u  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
  1 - 读串行Flash
8 x: p+ `- [' r  Y% @/ j7 p) C  2 - 写串行Flash
3 P, K8 ^) b, {  3 - 擦除整个串行Flash
" b4 `6 ^" S" S0 E" g' C( S' r  4 - 写整个串行Flash
" I% l2 k' R3 V) `% G5 `6 W3 Y. `  5 - 读整个串行Flash
  Z - 读取前1K
  X - 读取后1K

1. /*
   ( T/ ]! L' b3 ^7 q1 J# ]
2. *********************************************************************************************************
   ' I; F( F9 U  ]
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ( W1 y) v4 V( }, G& G1 {( i
8. */
   1 c4 @7 Q7 o" [3 g1 T
9. void DemoSpiFlash(void)
   9 l3 O% m% i8 f3 L9 r  }1 n" `
10. {
    
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0;
    
13. 
    / J5 y% Z' [# m* o% P
14. 
    $ t' f. N! b+ }2 z8 d4 s* W
15.     /* 检测串行Flash OK */
    
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    " t9 j6 X+ n+ h' T
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    1 j1 q; W7 [: A5 ^$ m" V* F" W
18. 
    
19.     sfDispMenu();        /* 打印命令提示 */
    ( d/ U( R4 @: o: o( C( j+ o5 C- x2 j
20. 
    . x: x: i7 f" U9 a; r9 }1 w
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    8 Y, J* c7 N$ F2 A4 B; H
22. 
    & N# k  h0 V5 \
23.     while(1)
    + T# }: W6 y6 n, Z' W
24.     {
    
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    $ {6 P* N0 e* `' A/ L+ ~( Q3 a
26. 
    3 d* z: o8 h. z, J/ M
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
    
29.         {
    ! Z4 A: N# C% g( y0 p$ B3 ^% |
30.             /* 每隔100ms 进来一次 */  
    4 z8 A( D( B8 t5 H' F' {) Z
31.             bsp_LedToggle(2);
    6 g  T: `0 \5 m* o) c0 t
32.         }
    
33. 
    ; R: j" K  p* w
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    % N. e0 C9 e4 T2 l6 a
35.         {
    - \2 _- d+ M2 M; \
36.             switch (cmd)
    , R9 Y' \8 i- j; {- n4 A# P
37.             {
    
38.                 case '1':
    9 |9 R; M; E' Q
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    ( @, q1 r+ ~1 C+ r4 X
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    ; E* d5 _0 L: ?9 i9 q) x& ?' }0 n
41.                     break;
    & W, i0 V+ n" {8 h* i
42. 
    
43.                 case '2':
    
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    ! t( p8 \/ \3 X4 U
46.                     break;
    - F" \6 ~: Y8 g+ ^3 Q" o
47. 
    
48.                 case '3':
    / J0 @8 Z+ I3 }" n; _$ ?# D9 @  o
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    1 I+ _: G+ R2 ?- f+ \0 K* Q
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
    
53. 
    
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    ' G# w3 Y9 g1 _5 B' t. l  E
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    5 M/ E8 q( N% G' }! p9 D! e, t
59. 
    1 ]  o" D; _) k  Q6 L( \7 P6 D8 X
60.                 case '5':
    
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    2 G' x# T1 H& ]) W6 {( [
63.                     break;
    % a5 I4 j9 `# A/ ~  N* u
64. 
    
65.                 case 'z':
    
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
    
68.                     {
    
69.                         uiReadPageNo--;
    
70.                     }
      _9 e7 f7 A9 I% Q
71.                     else
    5 G0 N5 S& {" Z% W: e
72.                     {
    5 j+ j# ], Y  x3 `1 u1 q3 s& d- F8 p* E
73.                         printf("已经是最前\r\n");
    * C3 D+ j; u7 I, U$ G
74.                     }
    
75.                     sfViewData(uiReadPageNo * 1024);
    
76.                     break;
    
77. 
    0 Z0 v- a- R. K/ q" H9 {! k
78.                 case 'x':
    , m% s% q; D( b/ ]& u6 \, b
79.                 case 'X': /* 读取后1K */
    
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
      X2 M) _7 g! L2 R% @) A
81.                     {
    ' Q4 x$ m# [! M( l
82.                         uiReadPageNo++;
    % F  X0 l/ e; p; r% l% S
83.                     }
    : B( P) A9 A) V4 `- D# b( t' C
84.                     else
    
85.                     {
    7 L8 n' L  Q5 M) Z7 C  C
86.                         printf("已经是最后\r\n");
    & N# j. D5 M8 b* f
87.                     }
    - j+ e& f& S& g/ q+ l2 X% _$ e2 b
88.                     sfViewData(uiReadPageNo * 1024);
    : @+ X5 H* ]3 l8 }* D7 t
89.                     break;
    
90. 
    
91.                 default:
    
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    ( A* t: @" i8 Q; L7 Y
94. 
    - E( }7 Y/ {, s1 S3 h
95.             }
    % @; U9 Z% U1 [( S5 p( |
96.         }
    
97.     }
    
98. }

复制代码

7 L% @* k4 M* [73.11   总结
本章节就为大家讲解这么多，实际应用中根据需要选择DMA，中断和查询方式。
+ ]/ y, g# z( e  h# w- O( i4 ~
8 g1 N# J) z' `2 G$ Z$ b6 P! Q