73.1 初学者重要提示
# c; `4 P9 k  v/ ^" \  W25Q64FV属于NOR型Flash存储芯片。
! |* N/ b" H2 n$ f8 k3 C  W25Q64JV手册下载地址：链接 （这是一个超链接），当前章节配套例子的Doc文件件里面也有存放。

: P  B& R4 U: S+ C
  本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。
  对SPI Flash W25QXX的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。
  W25Q64JV最高支持133MHz，但最高读命令03H速度是50MHz。
  文件bsp_spi_bus.c文件公共的总线驱动文件，支持串行FLASH、TSC2046、VS1053、AD7705、ADS1256等SPI设备的配置。
  函数sf_WriteBuffer不需要用户做擦除，会自动执行擦除功能，支持任意大小，任意地址，不超过芯片容量即可。
7 U6 |6 e# e+ q8 s% g  K' B, h" E
0 {) _6 y; V! L7 K) W73.2 W25QXX硬件设计
STM32H7驱动W25QXX的硬件设计如下：

% [3 o! O  i8 N0 F. N

关于这个原理图，要了解到以下几个知识：
$ g- V+ _$ ^- ]) Q4 H! C+ w
  V7开发板实际外接的芯片是W25Q64JV。
( R$ O! g- i% ~& B  CS片选最好接上拉电阻，防止意外操作。
  这里的PB3，PB4和PB5引脚可以复用SPI1，SPI3和SPI6。实际应用中是复用的SPI1。
  W25Q64的WP引脚用于写保护，低电平有效性，当前是直接高电平。
2 c  D+ f; l, g" o  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。
73.3 W25QXX关键知识点整理（重要）
4 ?9 Z7 b% I. L$ e驱动W25QXX前要先了解下这个芯片的相关信息。

, O: ~- S3 l& C; X: I# }/ f73.3.1 W25QXX基础信息
  W25Q64FV的容量是8MB（256Mbit）。
  W25Q64FV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
" V$ ?" ^4 t4 A6 a) a0 ]  l! m支持两线SPI，用到引脚CLK、CS、IO0、IO1 。

( L- l/ m. A, c8 l支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。

( F, A0 \2 v9 g0 H5 E8 u（注：这里几线的意思是几个数据线）。
( R& t0 `7 o, l9 t
9 O% P" W" y1 A* d6 a  W25Q64FV支持的最高时钟是133MHz。
  每个扇区最少支持10万次擦写，可以保存20年数据。
+ p  b- E* `; n  f1 x/ l* `1 h  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
" `( x+ L, j8 A: Y! @. d. `  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
- Z9 h9 c3 }8 Q- r6 S8 Z整体框图如下：
% X. s5 p5 T9 d$ W. n- m/ @
- S: i; e) C' ^! g& d, \

# U3 [3 m& y. |- E! C
4 V4 ]* b3 i' V, \7 t) t) nW25Q64FV：

4 |+ j- W. K1 {6 ^* r8 ~  有128个Block，每个Block大小64KB。
  每个Block有16个Sector，每个Sector大小4KB。
' }' C8 T7 ^4 |, I6 P% ?; y5 ]  每个Sector有16个Page，每个Page大小是256字节。
73.3.2 W25QXX命令
" C  ?$ h4 g9 ]; W  a( u2 E, Q使用W25Q的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的标准SPI，即单线SPI，使用的命令如下：
, k# J$ ]3 A& G3 C
" x. s2 M1 d- U; H5 c0 _# u9 A

$ S* w/ F; D4 L. J0 @7 \
' K0 }& l6 ^3 h2 E" @3 l4 ]当前主要用到如下几个命令：
/ G) m6 o2 c) u  v) i

1. #define CMD_EWRSR       0x50  /* 允许写状态寄存器的命令 */
   
2. #define CMD_WRSR      0x01  /* 写状态寄存器命令 */
   * [5 ^: P  r) |% b
3. #define CMD_WREN      0x06    /* 写使能命令 */
   ; I% k7 y! Y- `& }
4. #define CMD_READ      0x03  /* 读数据区命令 */
   
5. #define CMD_RDSR      0x05    /* 读状态寄存器命令 */
   
6. #define CMD_RDID      0x9F    /* 读器件ID命令 */
   
7. #define CMD_SE        0x20    /* 擦除扇区命令 */
   9 u3 s2 m4 ~+ X- W5 N9 y0 [
8. #define CMD_BE        0xC7    /* 批量擦除命令 */
   
9. #define WIP_FLAG      0x01    /* 状态寄存器中的正在编程标志（WIP) */

复制代码

73.3.3 W25QXX页编程和页回卷
9 z7 Z0 \; I% W9 I1 v* E' f% j" r- xSPI Flash仅支持页编程（页大小256字节），所有其它大批量数据的写入都是以页为单位。这里注意所说的页编程含义，页编程分为以下三步（伪代码）：

& i  p3 a/ V0 K) @  x

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   0 x6 ^( ?% E6 K' c
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   0 Y  K+ ?2 C- E9 z9 w: X+ J
5. 
   
6.     for (i = 0; i < _usSize; i++)
   
7.     {
   
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   1 y; K& k1 B2 P3 e
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   * i; K. ]1 B$ }: @7 _8 q) s& K
10.     }

复制代码

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

# C# H4 H& X0 ~比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：
- A6 N. B# d  [- `

1. uint8_t tempbuf[10] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00};
   5 v6 c- T6 Y5 A* {. i' w" E7 G
2. uint8_t temp1 = 0x10, temp2 = 0x29, temp3 = 0x48;

复制代码

3 U8 z4 @( g% n, q$ b, k  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
# I; h& K3 w8 m0 u$ M9 s  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。

6 h7 a% F0 U+ P0 _4 \& ^
% \% }4 Q  K4 Y" i, T
3 C$ _2 S2 [6 l% D3 D73.3.4 W25QXX扇区擦除
SPI Flash的擦除支持扇区擦除（4KB），块擦除（32KB或者64KB）以及整个芯片擦除。对于扇区擦除和块擦除，使用的时候要注意一点，一般情况下，只需用户给出扇区或者块的首地址即可。
) o$ a$ E& L; y! s' N( x
. C; d( L1 \7 N* V& D如果给的不是扇区或者块的首地址也没有关系的，只要此地址是在扇区或者块的范围内，此扇区或者块也可以被正确擦除。不过建议使用时给首地址，方便管理。

' y# t+ N4 |$ f% g' V$ N73.3.5 W25QXX规格参数
: W( D4 P3 U$ X这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：
$ s& c* ^" u/ o& e$ q6 `1 a
' [. w* y, r% v

2 f2 ]* }2 o% W" R2 V5 ]
  页编程时间：典型值0.4ms，最大值3ms。
  扇区擦除时间（4KB）：典型值45ms，最大值400ms。
  块擦除时间（32KB）：典型值120ms，最大值1600ms。
6 O# a) V! S, g" G  块擦除时间（64KB）：典型值150ms，最大值2000ms。
  整个芯片擦除时间：典型值20s，最大值100s。
  c5 ]2 d" A5 t# X- u- _

支持的速度参数如下：

  b& P) K" T9 r$ u/ n2 c

5 U) t  A- F3 l+ X+ R  m0 V
可以看到最高支持的读时钟（使用命令03H）速度是50MHz，其它命令速度可以做到133MHz。
4 |' l5 Q; R+ V5 |! Q
73.4 W25QXX驱动设计
W25QXX的程序驱动框架设计如下：

0 {; n' m! _' \/ V

0 |, B' m& L" X$ v0 J' t
% }2 `" x. ?' W有了这个框图，程序设计就比较好理解了。

73.4.1 第1步：SPI总线配置
  h4 H( a/ N# ?7 H! N9 n" Y3 Dspi总线配置通过如下两个函数实现：
' ?6 q. y3 A8 |) O

1. /*
   
2. *********************************************************************************************************
   ; Z- H) O, x0 x0 x
3. *    函 数 名: bsp_InitSPIBus
   
4. *    功能说明: 配置SPI总线。
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitSPIBus(void)
   
10. {   
    
11.     g_spi_busy = 0;
    : ?/ R& Z& h* A) Z. _' Q
12. 
    
13.     bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_8, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);
    
14. }
    
15. 
    
16. /*
    
17. *********************************************************************************************************
    
18. *    函 数 名: bsp_InitSPIParam
    
19. *    功能说明: 配置SPI总线参数，时钟分频，时钟相位和时钟极性。
    ( q" x& a1 ~' Q! L% z" F7 Y& i8 }
20. *    形    参: _BaudRatePrescaler  SPI总线时钟分频设置，支持的参数如下：
    3 s* h4 @) T. t& {5 V
21. *                                 SPI_BAUDRATEPRESCALER_2    2分频
    
22. *                                 SPI_BAUDRATEPRESCALER_4    4分频
    
23. *                                 SPI_BAUDRATEPRESCALER_8    8分频
    + ?* P% f- q% B; X* t9 W
24. *                                 SPI_BAUDRATEPRESCALER_16   16分频
    
25. *                                 SPI_BAUDRATEPRESCALER_32   32分频
    7 ?5 s/ u* |9 b
26. *                                 SPI_BAUDRATEPRESCALER_64   64分频
    $ P( V0 x- ]# j, q/ q
27. *                                 SPI_BAUDRATEPRESCALER_128  128分频
    
28. *                                 SPI_BAUDRATEPRESCALER_256  256分频
    
29. *                                                        
    
30. *             _CLKPhase           时钟相位，支持的参数如下：
    
31. *                                 SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
    
32. *                                 SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
    
33. *                                 
    
34. *             _CLKPolarity        时钟极性，支持的参数如下：
    ; p1 h, m% {8 `4 ^% c) g9 ~
35. *                                 SPI_POLARITY_LOW    SCK引脚在空闲状态处于低电平
    0 Q" p0 ?! z7 ]9 {! |# p
36. *                                 SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平
    
37. *
    . {$ q2 l3 S6 ?6 z8 Z" g
38. *    返 回 值: 无
    
39. *********************************************************************************************************
    ' M4 p  s+ y# p: E: Q
40. */
    
41. void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
    
42. {
    ' \: G3 p& i; E( S0 J5 L2 q
43.     /* 提高执行效率，只有在SPI硬件参数发生变化时，才执行HAL_Init */
    1 L9 T' D; u6 R- Y! e
44.     if (s_BaudRatePrescaler == _BaudRatePrescaler && s_CLKPhase == _CLKPhase && s_CLKPolarity == _CLKPolarity)
    3 d% ]0 d0 E0 I: I% z  a) h1 P
45.     {        
    
46.         return;
    
47.     }
    : c- c9 ^  Z. ~, i
48. 
    
49.     s_BaudRatePrescaler = _BaudRatePrescaler;   
    : P, x" o9 f8 `, m. o
50.     s_CLKPhase = _CLKPhase;
    6 l8 c( J2 z! ]; W# |# |* B; B
51.     s_CLKPolarity = _CLKPolarity;
    . E0 z. j+ T+ y! @1 d5 t
52. 
    
53. 
    
54.     /* 设置SPI参数 */
    1 K4 c2 J# {2 B+ e
55.     hspi.Instance               = SPIx;                   /* 例化SPI */
    " G3 f% i# U6 [3 B
56.     hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
    
57.     hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
    7 W$ W, U& Q" _( P. z! K9 l6 w) c
58.     hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
    ' `9 x+ c' o( h9 `
59.     hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
    $ U  a* m# W8 Q1 f+ K0 v9 Q
60.     hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
    
61.     hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    
62.     hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    
63.     hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE; /* 禁止CRC */
    ' J- |( W, L+ q! c4 u
64.     hspi.Init.CRCPolynomial     = 7;                       /* 禁止CRC后，此位无效 */
    6 o- T  j/ V; x: H9 z8 D2 I/ V9 l
65.     hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;     /* 禁止CRC后，此位无效 */
    
66.     hspi.Init.NSS               = SPI_NSS_SOFT;               /* 使用软件方式管理片选引脚 */
    ) i1 |$ j( L) U4 S: [0 x2 P, A. t
67.     hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;  /* 设置FIFO大小是一个数据项 */
      L- U; F7 P4 [$ ]7 _: G  y3 Y' G/ m+ D
68.     hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;      /* 禁止脉冲输出 */
    
69.     hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    - [+ z3 t7 e% I) n; _4 g  _7 Q
70.     hspi.Init.Mode             = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    0 b/ q  Z. g3 c: ?4 a" U
71. 
    . r" ?/ s, S0 k3 ~9 y1 Z
72.     /* 复位配置 */
    
73.     if (HAL_SPI_DeInit(&hspi) != HAL_OK)
    4 p6 g4 S/ \8 S* x% P
74.     {
    : a4 M: K6 [6 X) W+ Z/ i  ~
75.         Error_Handler(__FILE__, __LINE__);
    9 Z! T$ V( o; m
76.     }   
    
77. 
    
78.     /* 初始化配置 */
    
79.     if (HAL_SPI_Init(&hspi) != HAL_OK)
    & `! `8 g$ A8 Y; y& Y) n2 j, W
80.     {
    
81.         Error_Handler(__FILE__, __LINE__);
    0 Q5 H8 d4 h: z
82.     }   
    
83. }

复制代码

9 C% S7 n1 h6 F# C1 h关于这两个函数有以下两点要做个说明：
: N. ~) E% i4 i# q. }# K
  函数bsp_InitSPIBus里面的配置是个初始设置。实际驱动芯片时，会通过函数bsp_InitSPIParam做再配置。
7 E/ w8 ^$ E9 ~0 Q. D, |( U  函数bsp_InitSPIParam提供了时钟分频，时钟相位和时钟极性配置。驱动不同外设芯片时，基本上调整这三个参数就够。当SPI接口上接了多个不同类型的芯片时，通过此函数可以方便的切换配置。
, ^  K* a$ {1 ~9 u; r5 Z73.4.2 第2步：SPI总线的查询，中断和DMA方式设置
SPI驱动的查询，中断和DMA方式主要通过函数bsp_spiTransfer实现数据传输：
9 p# ~$ v' ?) b) S

1. /*
   ! T6 X- F* g! ^. r' @+ @
2. *********************************************************************************************************
   
3. *                                 选择DMA，中断或者查询方式
   ' W; b; L% i( B+ I: I! }
4. *********************************************************************************************************
   * f2 F' A& ?% _5 }* a5 v! j0 r
5. */
   ! ~: V/ r! [2 A" X
6. //#define USE_SPI_DMA    /* DMA方式  */
   
7. //#define USE_SPI_INT    /* 中断方式 */
   - q4 h7 k; O8 B" ^8 r) D( e' n% w
8. #define USE_SPI_POLL   /* 查询方式 */
   
9. 
   2 G3 X+ T2 x. n' u$ ?* p# o1 `
10. /* 查询模式 */
    . b: S8 X0 O7 @2 y
11. #if defined (USE_SPI_POLL)
    : C9 C+ f1 Z; ^. H! S6 I
12. 
    5 q6 ^9 Q7 r1 o
13. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];  
    
14. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    & m# s1 J9 z; B# ~
15. 
    $ L. {8 l, v; j( N7 c# j. X9 Y
16. /* 中断模式 */
    
17. #elif defined (USE_SPI_INT)
    - i2 D! ~% J6 ^6 F9 [
18. 
    0 r. o; S+ p8 q( |$ S( N' ~5 C2 L
19. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    + ?6 J; O/ P9 a: x5 m; V
20. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
21. 
    
22. /* DMA模式使用的SRAM4 */
    : b) V2 T! B$ f8 f# N/ P
23. #elif defined (USE_SPI_DMA)
    
24.     #if defined ( __CC_ARM )    /* IAR *******/
    # s5 H1 E7 H8 L" @6 K! a8 D/ j
25.         __attribute__((section (".RAM_D3"))) uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
26.         __attribute__((section (".RAM_D3"))) uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
27.     #elif defined (__ICCARM__)   /* MDK ********/
    
28.         #pragma location = ".RAM_D3"
    ' F# B) x3 \4 O) A" q7 K+ V
29.         uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
30.         #pragma location = ".RAM_D3"
    
31.         uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    0 |, v5 j9 j; N% i4 C& }
32.     #endif
    
33. #endif
    ( {- N- Y/ {+ V) T: r/ K5 H  x: f$ [5 C
34. 
    
35. /*
    
36. *********************************************************************************************************
    
37. *    函 数 名: bsp_spiTransfer
    
38. *    功能说明: 启动数据传输
    
39. *    形    参: 无
    
40. *    返 回 值: 无
    . _% Z- g( @% i# m5 o
41. *********************************************************************************************************
    
42. */
    
43. void bsp_spiTransfer(void)
    
44. {
    
45.     if (g_spiLen > SPI_BUFFER_SIZE)
    
46.     {
    . J$ r$ E* Q/ s: E& k
47.         return;
    
48.     }
    
49. 
    
50.     /* DMA方式传输 */
    
51. #ifdef USE_SPI_DMA
    
52.     wTransferState = TRANSFER_WAIT;
    
53. 
    2 F* k% p! T3 t( O* Y, p5 a) `& W
54.     if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    0 i' S! _) s2 J& l; b2 u4 I9 u$ |
55.     {
    
56.         Error_Handler(__FILE__, __LINE__);
    - Y% c& x5 _( x" E! y# t
57.     }
    
58. 
    
59.     while (wTransferState == TRANSFER_WAIT)
    & l& k% {5 H) p
60.     {
    ; f; w0 j9 N8 b" Q; L' e
61.         ;
    6 ~4 c% Z% s6 u7 u4 W! U8 f% t
62.     }
    
63. #endif
    " s4 P: Z7 A; U, @) [9 u  q" H7 |: k
64. 
    
65.     /* 中断方式传输 */   
    1 \0 H) H7 q" [' o3 F
66. #ifdef USE_SPI_INT
    
67.     wTransferState = TRANSFER_WAIT;
    % V6 {; w1 g7 @; V
68. 
    . p$ h) n/ f; h1 f3 ^& T
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.     }
    5 D8 B3 Y, s9 W$ e1 a0 ?1 k1 Q
73. 
    
74.     while (wTransferState == TRANSFER_WAIT)
      j5 H' T# n  z* ]/ ^
75.     {
    ' q, i1 L3 |: A# m6 y
76.         ;
    . u2 g# ~5 W) O" w$ \, G
77.     }
    " [4 s9 v% ?8 m4 R
78. #endif
    
79. 
    
80.     /* 查询方式传输 */   
    
81. #ifdef USE_SPI_POLL
    
82.     if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)   
    
83.     {
    + w7 s$ A- a  r# j2 ]; e' O4 ]
84.         Error_Handler(__FILE__, __LINE__);
    2 @, i( `4 C; S. f
85.     }   
    ! U& S* m/ q5 ?
86. #endif
    ; O* R6 b: {* g, D- P
87. }
    " d! R; `) F$ o& D5 w

复制代码

通过开头宏定义可以方便的切换中断，查询和DMA方式。其中查询和中断方式比较好理解，而DMA方式要特别注意两点：

8 ]- u- {" r% O/ }  通过本手册第26章的内存块超方便使用方式，将DMA缓冲定义到SRAM4上。因为本工程是用的DTCM做的主RAM空间，这个空间无法使用通用DMA1和DMA2。
  由于程序里面开启了数据Cache，会造成DMA和CPU访问SRAM4数据不一致的问题，特此将SRAM4空间关闭Cache。

1.     /* 配置SRAM4的MPU属性为Non-cacheable */
   
2.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   4 Z& O: ?$ X) n1 [
3.     MPU_InitStruct.BaseAddress      = 0x38000000;
   
4.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
     g1 t( K5 B% c# T+ \/ Q( X; k
5.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   
6.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   
7.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   ; E# ?! j% z" K( j% o  @
8.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   3 n6 `- W( w; G% v
9.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   , h  @# ]4 n: A% ^% z8 S
10.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
      |: j( {4 s5 Z" c$ x3 v
11.     MPU_InitStruct.SubRegionDisable = 0x00;
    
12.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    7 w/ e, o! f9 g1 Q* _3 v6 Z
13. 
    
14.     HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

73.4.3 第3步：W25QXX的时钟极性和时钟相位配置
  }$ w8 o! Z5 Q首先回忆下STM32H7支持的4种时序配置。
& `/ K0 p- Z. U/ _7 [2 u% m
  当CPOL = 1， CPHA = 1时

SCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。

' R  }2 q+ C( w7 `; s6 h" @  当CPOL = 0， CPHA = 1时
3 ~: x' F' W+ D: G# `$ g2 n; {3 S
, C7 s& Y9 a  d" R( G2 eSCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。
+ w+ a* l7 j0 S! k
9 n- m- ]  m8 b5 M( {: A  当CPOL = 1， CPHA = 0时
/ ?/ P- f7 k6 U' e% s# _2 N
SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

当CPOL = 1， CPHA = 0时
/ ]4 }" Y  n) W1 \; N9 O" j/ z8 x
SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。

! l: g1 ?# w0 }$ u3 G$ R

7 j% j" n, m  A( S
有了H7支持的时序配置，再来看下W25Q的时序图：
: `% Y/ v" B$ \8 H1 k8 S8 @
Mode0 ： 空闲状态的sck是低电平。
9 {! a; h6 {' n7 ~" x- a
Mode1 ： 空闲状态的sck是高电平。
/ ?! ^2 W- b- P6 t6 Z2 Z: T
, r, X; B7 V2 J6 F$ L

* T' X+ J% |6 X4 E
( e7 O7 p. C% w5 \* i: Z- C首先W25Q是上升沿做数据采集，所以STM32H7的可选的配置就是：

! h* h, k. U/ o5 M/ G( v9 dCHOL = 1,  CPHA = 1
# Y5 n/ {& F( [. k  o1 Y) i0 S
) X* O5 r+ Q0 ~5 c) ~) ACHOL = 0,  CPHA = 0
/ A1 l: l( k# A$ i( B
对于这两种情况，具体选择哪种，继续往下看。W25Q有两种SCK模式，分别是Mode0和Mode3，也就是空闲状态下，SCK既可以是高电平也可以是低电平。这样的话，这两种情况都可以使用，经过实际测试，STM32H7使用这两个配置均可以配置驱动W25Q。

( P  \% o' T) X73.4.4 第4步：单SPI接口管理多个SPI设备的切换机制
/ T" L3 I% a4 C5 F单SPI接口管理多个SPI设备最麻烦的地方是不同设备的时钟分配，时钟极性和时钟相位并不相同。对此的解决解决办法是在片选阶段配置切换，比如SPI Flash的片选：

5 d$ C5 Z/ Q3 C, m

1. /*
   - W+ }! H8 K: q9 Z7 z
2. *********************************************************************************************************
   + O& @2 O7 q" B; i% K
3. *    函 数 名: sf_SetCS
   
4. *    功能说明: 串行FALSH片选控制函数
   9 o: C) a' o" u7 e, B. ]
5. *    形    参: 无
   
6. *    返 回 值: 无
   4 {* H; j# Z, C  `
7. *********************************************************************************************************
   & w' J3 q8 h6 N8 _% c  M9 Q
8. */
   
9. void sf_SetCS(uint8_t _Level)
   
10. {
    # t1 m* p8 r* x$ `( ]1 ~# L
11.     if (_Level == 0)
    
12.     {
    
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    6 D6 P: {7 L- c6 ]
15.         SF_CS_0();
    
16.     }
    / }; l/ c# a) [& S8 J3 m) ^0 W
17.     else
    
18.     {        
    
19.         SF_CS_1();   
    9 @; R: v, Y9 [1 W, A
20.         bsp_SpiBusExit();        
    9 G! ^! a% l3 z3 l" Y* B) c
21.     }
    & ?- x! _# |/ F& u/ x5 ?8 }
22. }
    + C- T6 U* E) {: K0 c

复制代码

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

0 h7 K# h+ g3 n: X6 w但是频繁配置也比较繁琐，所以函数bsp_InitSPIParam里面做了特别处理。当前配置与之前配置相同的情况下无需重复配置。
) ]" y1 ]0 D9 ]6 K; @- n  e
3 d$ N, t8 a* R- p6 o+ F# X+ d73.4.5 第5步：W25QXX的读取实现
W25QXX的读取功能比较好实现，发送03H命令后，设置任意地址都可以读取数据，只要不超过芯片容量即可。

1. /*
   3 z; h% p/ j6 H
2. *********************************************************************************************************
   
3. *    函 数 名: sf_ReadBuffer
   3 W! }# r# R2 X  |+ l2 p
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   7 E% v5 y% q# L+ z
5. *    形    参:      _pBuf : 数据源缓冲区；
   % C1 a! g% l, O: \! ]
6. *                _uiReadAddr ：首地址
   / G7 R, w# `& Z0 Y/ M9 u3 h
7. *                _usSize ：数据个数, 不能超出芯片总容量
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   3 r( s1 N5 c6 Z+ w9 s% [
10. */
    ' f+ {& V$ E: k# X8 B0 t7 X5 x: R% T
11. void sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    
12. {
    
13.     uint16_t rem;
    7 `0 @1 V& |% m' |+ m
14.     uint16_t i;
    4 F+ A( x% P4 j0 X, `; `
15. 
    , `+ }/ \5 N* m! j9 |( P
16.     /* 如果读取的数据长度为0或者超出串行Flash地址空间，则直接返回 */
    8 m1 |- c$ M0 V' p0 W1 [" U
17.     if ((_uiSize == 0) ||(_uiReadAddr + _uiSize) > g_tSF.TotalSize)
    
18.     {
    
19.         return;
    
20.     }
    8 f& _* b# B4 b8 D, s
21. 
    : p: n. G4 I* x; `/ r& O
22.     /* 擦除扇区操作 */
    ! m) P3 A0 Y1 L  F( K" Q
23.     sf_SetCS(0);                                    /* 使能片选 */
    
24.     g_spiLen = 0;
    
25.     g_spiTxBuf[g_spiLen++] = (CMD_READ);                            /* 发送读命令 */
    ( w9 C5 G0 D% S$ v' x
26.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    ( d; \  C- G# V: d6 Q
27.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF00) >> 8);        /* 发送扇区地址中间8bit */
    $ G/ b  I& B8 }9 s$ j, ^  u
28.     g_spiTxBuf[g_spiLen++] = (_uiReadAddr & 0xFF);                /* 发送扇区地址低8bit */
    
29.     bsp_spiTransfer();
    
30. 
    + c. ~& Y& X" |3 B9 C# c. w& h
31.     /* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
    
32.     for (i = 0; i < _uiSize / SPI_BUFFER_SIZE; i++)
    
33.     {
    
34.         g_spiLen = SPI_BUFFER_SIZE;
    
35.         bsp_spiTransfer();
    9 Q; M+ g1 u, ~3 J+ `; T1 M
36. 
    
37.         memcpy(_pBuf, g_spiRxBuf, SPI_BUFFER_SIZE);
    ; W3 y2 h# [, R3 l2 V
38.         _pBuf += SPI_BUFFER_SIZE;
    
39.     }
    
40. 
    
41.     rem = _uiSize % SPI_BUFFER_SIZE;    /* 剩余字节 */
    
42.     if (rem > 0)
    
43.     {
    6 ~9 Y) q3 X3 [. R( r" B6 s
44.         g_spiLen = rem;
      ~+ a/ ^0 R3 c# N, k4 _; s
45.         bsp_spiTransfer();
    
46. 
    
47.         memcpy(_pBuf, g_spiRxBuf, rem);
    9 H/ i. A( x$ y! W! W; E
48.     }
    
49. 
    
50.     sf_SetCS(1);                                    /* 禁能片选 */
    
51. }

复制代码

9 y1 W! A% C; ^, e3 I
这个函数对DMA传输做了特别处理，方便分包进行。
4 P& j" c, x! T7 f
5 X9 E7 c2 s$ q73.4.6 第6步：W25QXX的扇区擦除实现
扇区擦除的实现也比较简单，发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除。擦除的扇区大小是4KB。
$ M' ], r- K, ]# Y, B0 p( _
5 |( V. S6 `; s/ A6 v

1. /*
   3 V. c8 i2 f  o4 \6 ^4 f8 \
2. *********************************************************************************************************
   
3. *    函 数 名: sf_EraseSector
   , U, o$ e6 Z) Y% j. C9 S
4. *    功能说明: 擦除指定的扇区
   
5. *    形    参: _uiSectorAddr : 扇区地址
   # P/ }' A" P0 W3 Q1 R  {' W" y7 D
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ) _3 ~0 t( @/ Z  k6 I% H  b, y
8. */
   
9. void sf_EraseSector(uint32_t _uiSectorAddr)
   ( `0 h) T9 x2 M' h. z
10. {
    3 c5 W2 b8 b( W
11.     sf_WriteEnable();                            /* 发送写使能命令 */
    2 Q' i. R6 E1 I2 ], F+ h3 A. ]
12. 
    $ `+ A+ L1 r- i8 H5 y# a
13.     /* 擦除扇区操作 */
    
14.     sf_SetCS(0);                                /* 使能片选 */
    ; _# u" x/ N" r, L4 m: m
15.     g_spiLen = 0;
    
16.     g_spiTxBuf[g_spiLen++] = CMD_SE;                /* 发送擦除命令 */
    : ^% H3 @7 W" x$ U
17.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    % g& f, D! j" N6 F
18.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF00) >> 8);    /* 发送扇区地址中间8bit */
    : A& v. u, r. U& K
19.     g_spiTxBuf[g_spiLen++] = (_uiSectorAddr & 0xFF);            /* 发送扇区地址低8bit */   
    
20.     bsp_spiTransfer();
    
21.     sf_SetCS(1);                                    /* 禁能片选 */
    % q0 @( F' D0 O0 E# d( ^
22. 
    ! C+ G, X# `: b% q3 D
23.     sf_WaitForWriteEnd();                            /* 等待串行Flash内部写操作完成 */
    " p( @' Z7 a4 _; ?; R
24. }
    # [& N& k, p& D0 X- ~3 g9 n

复制代码

  |8 p: [! c0 p' f" j
* y2 y  W- B) ]- n1 \+ |整个芯片的擦除更省事些，仅发送整个芯片擦除命令即可：

1. /*
   6 K) k$ e3 e, j) z
2. *********************************************************************************************************
   / ~" k, H* p) X3 S& C7 Y' F" Z
3. *    函 数 名: sf_EraseChip
   
4. *    功能说明: 擦除整个芯片
   
5. *    形    参:  无
   3 h+ V: d2 z! q! _5 t% j
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   $ n: F: S3 h. Y+ t
8. */
   
9. void sf_EraseChip(void)
   
10. {   
    
11.     sf_WriteEnable();                                /* 发送写使能命令 */
    5 g$ ^( S7 D# `5 c$ Q& w) y: v8 L- G
12. 
    # N6 Y1 H* l% v8 E( t
13.     /* 擦除扇区操作 */
    
14.     sf_SetCS(0);        /* 使能片选 */
    4 v; H# A& {* E8 C! X
15.     g_spiLen = 0;
    + l" B  N9 q1 m; B0 {7 g
16.     g_spiTxBuf[g_spiLen++] = CMD_BE;        /* 发送整片擦除命令 */
    
17.     bsp_spiTransfer();
    
18.     sf_SetCS(1);                        /* 禁能片选 */
    
19. 
    + u3 C7 Z0 F& m+ E4 f" _4 g( v$ d
20.     sf_WaitForWriteEnd();                /* 等待串行Flash内部写操作完成 */
    2 [5 a. O2 b8 N; N3 G7 F: \
21. }
    % }( C, C- o1 r! O0 ~

复制代码

1 E1 q# i8 B- h  _# a73.4.7 第7步：W25QXX的编程实现
) B& C  |2 _  |W25QXX的编程实现略复杂，因为做了自动擦除支持，大家可以在任意地址，写任意大小的数据，只要不超过芯片容量即可。我们这里就不做展开讨论了，大家有兴趣可以研究下：
. ?2 h( }% r" q/ u/ a8 T5 g
4 E, c- p1 c: j8 m# R& c4 @  O; Z' W

1. /*
   
2. *********************************************************************************************************
   4 d$ u3 D' N8 a  k
3. *    函 数 名: sf_WriteBuffer
   
4. *    功能说明: 写1个扇区并校验,如果不正确则再重写两次，本函数自动完成擦除操作。
   
5. *    形    参:  _pBuf : 数据源缓冲区；
   
6. *               _uiWrAddr ：目标区域首地址
   
7. *               _usSize ：数据个数，任意大小，但不能超过芯片容量。
   
8. *    返 回 值: 1 : 成功， 0 ： 失败
   
9. *********************************************************************************************************
   % d2 t5 w% F8 c" a$ J
10. */
    
11. uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)
    
12. {
    
13.     uint32_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
    
14. 
    
15.     Addr = _uiWriteAddr % g_tSF.SectorSize;
    8 k3 \2 D5 P/ T3 _
16.     count = g_tSF.SectorSize - Addr;
    
17.     NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    
18.     NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    : F7 N+ r# h. u2 {  Z) S
19. 
    
20.     if (Addr == 0) /* 起始地址是扇区首地址  */
    
21.     {
    
22.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
23.         {
    3 e. y! g: K( F: }
24.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    4 x; w; U# m, X
25.             {
    0 `4 w) U# A' p' [* P8 x
26.                 return 0;
    * m$ b8 a5 \* O" h5 t! ~
27.             }
    
28.         }
    7 g# X! B6 y- d& R+ [; k6 h. Q) L1 g
29.         else     /* 数据长度大于等于扇区大小 */
    * y6 O5 i! ~! F) m+ e3 }7 D
30.         {
    ( _: a- e* e+ Z% ^0 s7 o
31.             while (NumOfPage--)
    
32.             {
    
33.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    ; B4 I; d4 n! w  u1 j
34.                 {
    + }. C6 g% ^7 B: a; y, I
35.                     return 0;
    7 |6 h; Q* n0 `) Z6 d8 V4 W3 e
36.                 }
    
37.                 _uiWriteAddr +=  g_tSF.SectorSize;
    6 S0 l1 x$ }' d  c2 S
38.                 _pBuf += g_tSF.SectorSize;
    
39.             }
    
40.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
    
41.             {
    
42.                 return 0;
    
43.             }
    8 u# ~3 q% z/ F1 A5 d. Z9 C
44.         }
    
45.     }
    
46.     else  /* 起始地址不是扇区首地址  */
    5 {3 R3 @5 ?0 s9 q8 m
47.     {
    
48.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
49.         {
    
50.             if (NumOfSingle > count)  /* (_usWriteSize + _uiWriteAddr) > SPI_FLASH_PAGESIZE */
    # O" t: R+ ]4 A0 U* h4 l
51.             {
    4 v6 `4 {9 [! X# Y) j
52.                 temp = NumOfSingle - count;
    5 @' |4 B9 S# F
53. 
    
54.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    : o$ w& ]0 u' C( B
55.                 {
    
56.                     return 0;
    
57.                 }
    $ ^- E5 B" a; X$ e* W" Y( @& I' X
58. 
    : Z+ G5 A) ?+ t, m, _
59.                 _uiWriteAddr +=  count;
    6 I; q9 R+ ?  y/ w# }, _& H
60.                 _pBuf += count;
    
61. 
    . X. O; D- A9 B$ e; @2 v
62.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, temp) == 0)
    ; f9 Y! b0 l4 n( o$ B
63.                 {
    " a5 `# ?8 y5 R! w2 K
64.                     return 0;
    & p3 t2 `4 B) u: d
65.                 }
    
66.             }
      R8 e9 Y' _( x
67.             else
    
68.             {
    ) U+ I3 f- h; X( L
69.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    
70.                 {
    $ v  S  D0 w+ r$ W7 e  Z
71.                     return 0;
    ) H$ c( L% p7 A2 r5 c2 y
72.                 }
    
73.             }
    
74.         }
    2 q1 |5 k# N! {8 g/ ?0 b( I% d
75.         else    /* 数据长度大于等于扇区大小 */
    
76.         {
    8 \% N; O- a- `
77.             _usWriteSize -= count;
    6 u! F" m. b7 [
78.             NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    
79.             NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    
80.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    
81.             {
    4 A% o6 R8 ]$ a: d
82.                 return 0;
    + H2 A4 a' ?5 K
83.             }
    
84. 
    $ o0 v- Q0 D2 L- T4 A4 h' t
85.             _uiWriteAddr +=  count;
    0 ~9 u0 x! y" p1 ^% H
86.             _pBuf += count;
    
87. 
    . @$ |7 y+ n! j7 n0 W9 u( `
88.             while (NumOfPage--)
    - T  B+ q  b5 _6 Z# u3 r" {
89.             {
    , \# Z! C& a, \( y
90.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    1 n( ?: F# |3 `& F" u
91.                 {
    
92.                     return 0;
    2 ]: H0 X5 A, ]0 U% e3 {$ J6 a4 {
93.                 }
    4 T  F# D+ @6 n; ~5 v3 N$ K
94.                 _uiWriteAddr +=  g_tSF.SectorSize;
    
95.                 _pBuf += g_tSF.SectorSize;
    , m& G) s# @3 S6 n6 Q" G+ y% j- o
96.             }
    1 X3 }" u. W# {" {
97. 
    8 N1 [! K. y, c: O$ H0 S" n
98.             if (NumOfSingle != 0)
    
99.             {
    " z9 I% S/ ?, K, V- I0 w8 }
100.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
     7 I  o, Q* M" E+ R: l
101.                 {
       N- B- y: b) E* E0 ^' _' N' u
102.                     return 0;
     8 }' z. e* A; E8 B6 K
103.                 }
     
104.             }
     ! k; _8 H& y- K% F
105.         }
     " J: n7 ~* V* A% Y3 L) b& c' t- R
106.     }
     9 R+ R5 N( t- I( R, r
107.     return 1;    /* 成功 */
     
108. }

复制代码

8 E& T% [7 O4 |$ B7 s: o$ Y0 N73.5 SPI总线板级支持包（bsp_spi_bus.c）
SPI总线驱动文件bsp_spi_bus.c主要实现了如下几个API供用户调用：
0 {* c- ]5 u2 b' ^7 ^1 Q* ]7 u/ c# A% y
, \# W7 J  u- A  bsp_InitSPIBus
! S. N( f  ~  p  bsp_InitSPIParam
/ q; ~4 k& ]. u# c- ]" T  bsp_spiTransfer
' l( R$ M0 i* A9 w0 y73.5.1 函数bsp_InitSPIBus
函数原型：
7 ~% q% h5 ?0 U0 ~
void bsp_InitSPIBus(void)

函数描述：

此函数主要用于SPI总线的初始化，在bsp.c文件调用一次即可。
5 |& j9 e+ g( x0 e) |% U7 ~; `+ N
/ t$ Y! w" r# e: @/ W73.5.2 函数bsp_InitSPIParam
函数原型：

! V" D+ W# x! |7 Jvoid bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)

函数描述：

此函数用于SPI总线的配置。

函数参数：
2 q. {( r: ^! z" Q7 h# m3 ^
  第1个参数SPI总线的分频设置，支持的参数如下：
2 ~" X" e- e" N+ u( ~' N4 Q/ ^SPI_BAUDRATEPRESCALER_2    2分频
% P, s! t3 l, T, v) W9 M- M0 r
SPI_BAUDRATEPRESCALER_4    4分频

8 G/ K, l2 q, t: ASPI_BAUDRATEPRESCALER_8    8分频
8 C3 k9 Y$ \# S. [, b8 w
! C! l# |, F5 Q- {) FSPI_BAUDRATEPRESCALER_16   16分频
# b, r7 s% o! ^( i
* e, t- H# N  Q' e  s" z! dSPI_BAUDRATEPRESCALER_32   32分频

SPI_BAUDRATEPRESCALER_64   64分频

SPI_BAUDRATEPRESCALER_128  128分频

- _* e; q. B; ]" {, x  pSPI_BAUDRATEPRESCALER_256  256分频

2 ], E2 f7 d8 [. j: [3 C% N# Z2 ^  第2个参数用于时钟相位配置，支持的参数如下：
SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
; Y. j7 o5 n% r6 ?0 t
SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
8 g& s: M  L. u/ l
( `8 ], A8 v/ W. _3 Q, O  第3个参数是时钟极性配置，支持的参数如下：
SPI_POLARITY_LOW   SCK引脚在空闲状态处于低电平

SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平
, W) O4 B- {8 ^4 I
$ d# p/ @# w6 F6 j; p* ?7 S0 p! ~" i73.5.3 函数bsp_spiTransfer
' t3 Q/ D/ t/ p6 a( c函数原型：
; J9 p$ s# K% l9 O; s3 ]1 S, d  P
void bsp_spiTransfer(void)
0 i' Q$ Q/ K: t4 }- j
函数描述：
0 |! R0 H$ h3 l1 @/ F) N) P  s
此函数用于启动SPI数据传输，支持查询，中断和DMA方式传输。
* L* U  `3 Q; l- x/ T; X
5 F) [" m5 m: g# i% \9 L0 e73.6 W25QXX板级支持包（bsp_spi_flash.c）
W25QXX驱动文件bsp_spi_flash.c主要实现了如下几个API供用户调用：

  sf_ReadBuffer
  sf_WriteBuffer
0 y! Q) N5 l) V% }/ b( R% V  sf_EraseSector
  sf_EraseChip
/ i# @9 R: X* d4 ~; D  sf_EraseSector
73.6.1 函数sf_ReadBuffer
函数原型：

$ M4 c" [! g/ x8 m. xvoid sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)

3 b6 O3 d. ~% c% v函数描述：
+ T6 p  E9 J& d* K/ G5 g4 t
1 G0 X' c. w$ }此函数主要用于从SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。
" Z5 b5 R5 V5 @0 c7 r, t2 W3 A
函数参数：
9 K* k8 r+ @% _/ V! S
) F8 Q. V  I$ z' w  z% `4 @9 j  [1 ^- Q  第1个参数用于存储从SPI Flash读取的数据。
  第2个参数是读取地址，不可以超过芯片容量。
  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
73.6.2 函数sf_WriteBuffer（自动执行擦除）
$ A4 h) j$ Z" x  ]. K1 o2 L0 K% W函数原型：

uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)
* W! w4 n  p5 V7 a) q) t& v
+ @6 h1 }8 `% B. D! O函数描述：

* h" [7 n4 [( K此函数主要用于SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。特别注意，此函数会自动执行擦除，无需用户处理。

函数参数：
2 N* L1 \/ D! g0 s
  第1个参数是源数据缓冲区。
  第2个参数是目标区域首地址。
  第3个参数是数据个数，支持任意大小，但不能超过芯片容量。单位字节个数。
6 {9 y/ c% H! z8 c  返回值，返回1表示成功，返回0表示失败。
, ~: j2 D8 I; _- l: p% S73.6.3 函数sf_EraseSector
函数原型：

void sf_EraseSector(uint32_t _uiSectorAddr)

% z$ D. V. P2 u" L函数描述：
% O/ l" ~) \  _: f0 L0 R: n
此函数主要用于扇区擦除，一个扇区大小是4KB。
- T) i# H/ X+ {5 r" b
. y/ M( Y+ ^6 ?! h% W6 ?9 ?2 n函数参数：

6 n( h" `7 f. S4 S/ o; q  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
73.6.4 函数sf_EraseChip
函数原型：
" a2 j* i4 R, b/ |
, Y) r! L, m6 Kvoid sf_EraseChip(void)
& m9 y7 d$ s  A% X# y) O& C
4 g8 z" o. X0 k3 v5 U! Z, A- U& C5 U0 Z& b函数描述：

此函数主要用于整个芯片擦除。

73.6.5 函数sf_PageWrite（不推荐）
* k( h# `  a4 b) ]4 Q2 o函数原型：
, L% @- z2 Q  c* w4 B9 U1 s
void sf_PageWrite(uint8_t * _pBuf, uint32_t _uiWriteAddr, uint16_t _usSize)

函数描述：
3 p% P; T) b8 w6 r& ?
$ i! z" @0 K& l  A此函数主要用于页编程，一次可以编程多个页，只要不超过芯片容量即可。不推荐大家调用此函数，因为调用这个函数前，需要大家调用函数sf_EraseSector进行扇区擦除。
% f9 S/ S2 O" E% T0 d! y* }
6 U. \# g5 x  p3 y1 ^* c+ M% n( A函数参数：

4 W0 Y: U! Q& ^: ^5 @& ]* ^7 M  第1个参数是数据源缓冲区。
; l. G% Q8 C4 b& g, `2 x7 m  第2个参数目标区域首地址，比如编程页0，此处填0x0000，编程页1，此处填0x0100，编程页2，此处填0x0200，以此类推。
, @/ ^9 e7 M& \- h" v" {9 g8 D6 B/ P1 U  第3个参数是编程的数据大小，务必是256字节的整数倍，单位字节个数。
73.7 W25QXX驱动移植和使用
% v$ \' t  \; K" G6 t' f* \W25QXX移植步骤如下：
  r8 i  H5 t% u; \
  第1步：复制bsp_spi_bus.c，bsp_spi_bus.h，bsp_spi_flash.c，bsp_spi_flash.h到自己的工程目录，并添加到工程里面。
$ e0 A9 I; U# H. I  第2步：根据使用的第几个SPI，SPI时钟，SPI引脚和DMA通道等，修改bsp_spi_bus.c文件开头的宏定义
+ ~& @7 m* B; X

1. /*
   1 y$ M. k' l# L& X: B! n4 `% D
2. *********************************************************************************************************
   
3. *                                时钟，引脚，DMA，中断等宏定义
     d, ^/ y6 J; ?+ D& v
4. *********************************************************************************************************
   
5. */
   
6. #define SPIx                            SPI1
   
7. #define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
   
8. #define DMAx_CLK_ENABLE()                __HAL_RCC_DMA2_CLK_ENABLE()
   
9. 
   
10. #define SPIx_FORCE_RESET()                __HAL_RCC_SPI1_FORCE_RESET()
      F9 c5 R& X7 S3 m
11. #define SPIx_RELEASE_RESET()            __HAL_RCC_SPI1_RELEASE_RESET()
    
12. 
    
13. #define SPIx_SCK_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    ; Y$ u* H3 M, U) }0 O! n
14. #define SPIx_SCK_GPIO                    GPIOB
    0 D- |1 q# q; G) X- I0 r
15. #define SPIx_SCK_PIN                    GPIO_PIN_3
    
16. #define SPIx_SCK_AF                        GPIO_AF5_SPI1
    $ t; L3 Y' o; X! K
17. 
    
18. #define SPIx_MISO_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    
19. #define SPIx_MISO_GPIO                    GPIOB
    " }; G, B8 u: d' z7 z
20. #define SPIx_MISO_PIN                     GPIO_PIN_4
    * t  t& h; e0 O( a0 \. x! t% c
21. #define SPIx_MISO_AF                    GPIO_AF5_SPI1
    # `1 H/ J8 a/ B, }" U
22. 
    % Q! v, r& P# P5 x
23. #define SPIx_MOSI_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    
24. #define SPIx_MOSI_GPIO                    GPIOB
    
25. #define SPIx_MOSI_PIN                     GPIO_PIN_5
    8 V- O4 g* [' u3 D0 v, q
26. #define SPIx_MOSI_AF                    GPIO_AF5_SPI1
    5 K/ e$ \( V* l
27. 
    
28. #define SPIx_TX_DMA_STREAM               DMA2_Stream3
    0 v! ]9 s& h8 P1 x( D7 m( q( H
29. #define SPIx_RX_DMA_STREAM               DMA2_Stream2
    
30. 
    
31. #define SPIx_TX_DMA_REQUEST              DMA_REQUEST_SPI1_TX
    
32. #define SPIx_RX_DMA_REQUEST              DMA_REQUEST_SPI1_RX
    0 R2 E* N- M/ s
33. 
    
34. #define SPIx_DMA_TX_IRQn                 DMA2_Stream3_IRQn
    % a$ f1 d0 r, ~( S
35. #define SPIx_DMA_RX_IRQn                 DMA2_Stream2_IRQn
    
36. 
    1 K. G3 {( B7 E6 i! x
37. #define SPIx_DMA_TX_IRQHandler           DMA2_Stream3_IRQHandler
    
38. #define SPIx_DMA_RX_IRQHandler           DMA2_Stream2_IRQHandler
    
39. 
    - X+ V0 F8 Y% d4 i3 ~
40. #define SPIx_IRQn                        SPI1_IRQn
    
41. #define SPIx_IRQHandler                  SPI1_IRQHandler
    

复制代码

9 B3 x8 A) Q" L) z
  第3步：根据使用的SPI ID，添加定义到文件bsp_spi_flash.h

1. /* 定义串行Flash ID */
   0 l' L0 L1 n; B  ]& y2 z
2. enum
   
3. {
   ; @& K9 z% q4 [" F% a* W% O1 j
4.     SST25VF016B_ID = 0xBF2541,
   : Z& k5 L$ Q# h% Q5 R
5.     MX25L1606E_ID  = 0xC22015,
   - d& p& w( U& y1 R! n9 [
6.     W25Q64BV_ID    = 0xEF4017, /* BV, JV, FV */
   3 p1 t( m6 W5 c, O1 W5 H
7.     W25Q128_ID     = 0xEF4018
   
8. };

复制代码

0 I+ i* u1 k: U! C+ T  e* @2 Y  第4步：添加相应型号到bsp_spi_flash.c文件的函数sf_ReadInfo里面。
. o" |5 S$ }& k5 D

1. /*
   : B, k# o! ~7 j2 w, |+ n
2. *********************************************************************************************************
   
3. *    函 数 名: sf_ReadInfo
   
4. *    功能说明: 读取器件ID,并填充器件参数
   - C6 J# [+ O+ B$ Z7 ]
5. *    形    参: 无
   ; `2 a. o4 a# L! z# ~: `) e
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   - |' G, V3 S- z7 J
8. */
   
9. void sf_ReadInfo(void)
   
10. {
    . Q. l" ]6 t2 N$ t0 S) Z
11.     /* 自动识别串行Flash型号 */
    1 ?1 A4 g) }/ }" G3 N
12.     {
    
13.         g_tSF.ChipID = sf_ReadID();    /* 芯片ID */
    
14. 
    6 c+ E" Q; _. B( ?
15.         switch (g_tSF.ChipID)
    
16.         {
    
17.             case SST25VF016B_ID:
    7 L' u% ]& @- p3 A  @
18.                 strcpy(g_tSF.ChipName, "SST25VF016B");
    
19.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    
20.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
      {, `6 l, _/ O: L6 m* I: D
21.                 break;
    
22. 
    
23.             case MX25L1606E_ID:
    : v$ o" ~2 G: L6 T; u2 Q6 @
24.                 strcpy(g_tSF.ChipName, "MX25L1606E");
    
25.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    
26.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    * y. |8 }7 B4 f" I; l
27.                 break;
    : o8 Z1 v2 X% a' U6 d
28. 
    : }" N+ I6 B9 R* u4 U
29.             case W25Q64BV_ID:
    
30.                 strcpy(g_tSF.ChipName, "W25Q64");
    
31.                 g_tSF.TotalSize = 8 * 1024 * 1024;    /* 总容量 = 8M */
    ' h( T5 I2 h  F8 L6 }( B: z
32.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    6 q5 K" L. ^" l3 P
33.                 break;
    
34. 
    
35.             case W25Q128_ID:
    & n( _" ]9 R* b5 z; t6 U
36.                 strcpy(g_tSF.ChipName, "W25Q128");
    5 t& a2 k/ ^5 ^, Z7 \1 V
37.                 g_tSF.TotalSize = 16 * 1024 * 1024;    /* 总容量 = 8M */
    
38.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    " V0 G% Z9 B2 P; ~
39.                 break;            
    , y+ Q3 k, [; @8 R. \8 H$ o" r
40. 
    6 T+ i) u5 X7 U0 p0 l! u
41.             default:
    
42.                 strcpy(g_tSF.ChipName, "Unknow Flash");
    
43.                 g_tSF.TotalSize = 2 * 1024 * 1024;
    
44.                 g_tSF.SectorSize = 4 * 1024;
    
45.                 break;
    , p  d- }4 }$ o. G
46.         }
    6 a. Q8 U# C" u
47.     }
    
48. }

复制代码

  第5步：根据芯片支持的时钟速度，时钟相位和时钟极性配置函数sf_SetCS。
7 E+ a0 R# N( y* D' y6 {% J# v, ?

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_SetCS
   ! H$ E% o0 g) j0 N
4. *    功能说明: 串行FALSH片选控制函数
   0 ~" k& w4 Y( O2 \9 [1 H# I( u, l
5. *    形    参: 无
   0 V! \( [( ]9 Q, e2 P: e
6. *    返 回 值: 无
   - T' `, ~6 Z3 L% [/ d& g, F: Z
7. *********************************************************************************************************
   
8. */
   : U" m0 O6 D2 Z2 i, J
9. void sf_SetCS(uint8_t _Level)
   & F# E9 X) |  k9 ^
10. {
    : x3 I5 h3 U: H! Q% x. Z
11.     if (_Level == 0)
    
12.     {
    , G$ V4 r7 U4 q  s3 C; k; |( d
13.         bsp_SpiBusEnter();   
    " m! [$ k1 Y$ V0 Q
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    9 O, X' p. p" E6 J7 W% n: j0 T
15.         SF_CS_0();
    1 p' E- j2 a0 h! A
16.     }
    ; j- R. V: ~' M3 H  q2 t
17.     else
    & l4 ?6 w9 `4 R: d% ]" ]. c$ T$ a/ V
18.     {        
    # c" K1 g& U4 M6 @+ c  `
19.         SF_CS_1();   
    
20.         bsp_SpiBusExit();        
    
21.     }
    2 `% K: ?) f& j, o
22. }

复制代码

7 l5 J+ {3 P% E. n+ _  第6步：根据使用的SPI Flash片选引脚修改bsp_spi_bus.c文件开头的宏定义。

1. /* 串行Flash的片选GPIO端口， PD13  */
   ! {4 J3 \3 c- @5 e+ Z% d" @
2. #define SF_CS_CLK_ENABLE()             __HAL_RCC_GPIOD_CLK_ENABLE()
   * U; |% A3 e* u8 V5 q* i0 Q4 s
3. #define SF_CS_GPIO                    GPIOD
   4 y- K$ N: x( [! }- d4 f: B8 ]
4. #define SF_CS_PIN                    GPIO_PIN_13
   ' l4 W! N4 g5 C0 w
5. 
   # `1 {- e' e% G& d. y/ X+ T4 m
6. #define SF_CS_0()                    SF_CS_GPIO->BSRR = ((uint32_t)SF_CS_PIN << 16U)
   % H1 x. N) B5 v9 a* h( m) I# u
7. #define SF_CS_1()                    SF_CS_GPIO->BSRR = SF_CS_PIN

复制代码

* P& Q, L6 e  J2 ?  n  第7步：如果使用DMA方式的话，请不要使用TCM RAM，因为通用DMA1和DMA2不支持。并为了防止DMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭Cache处理，比如使用的SRAM4：
3 C3 n: ~6 B% Z2 ]

1. /* 配置SRAM4的MPU属性为Non-cacheable */
   
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   
3. MPU_InitStruct.BaseAddress      = 0x38000000;
   & h! y" Y) T, I4 L' f7 e8 T
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   % f+ D# f; Y3 o8 Q9 `; l
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   . ^  N1 t, N  o2 {
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
     q6 ?) M0 G1 x/ D9 K* U
7. MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   $ Y, [1 m" b  K3 Y1 L) l( d; l2 l% R
8. MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9. MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   
10. MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
11. MPU_InitStruct.SubRegionDisable = 0x00;
    
12. MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
13. 
    
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

  第8步：初始化SPI。

1. /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
   + K" G1 i0 E4 f" u+ y2 d7 n
2. bsp_InitSPIBus();    /* 配置SPI总线 */        
   ( J8 V  R, a$ A; E5 P
3. bsp_InitSFlash();    /* 初始化SPI 串行Flash */

复制代码

  第9步：SPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第10步：应用方法看本章节配套例子即可。
1 V9 B4 r) X& ?1 ?9 a2 ]* f73.8 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

2 m' R9 O: e* Y7 P
  第1阶段，上电启动阶段：
, ?; c2 S2 i: W$ J; }: T
6 Q: c# t- M4 U4 C2 G8 g这部分在第14章进行了详细说明。
  
第2阶段，进入main函数：

第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
7 Z7 k! g5 O; M第2部分，应用程序设计部分，实现SPI Flash的中断，查询和DMA方式操作。
% `! }/ X8 G5 }' x; V7 ^
73.9 实验例程说明（MDK）
% B' T" z6 U! T5 Z+ ^/ y( U* @配套例子：
. q9 q7 z! J" Z
2 _- a) N: b3 ~% j8 y: {8 M) hV7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）
3 G+ m8 G) a; {% I- \) d' a
V7-050_串行SPI Flash W25QXX读写例程（DMA方式）
% T& `, T7 `" z, \$ a2 ]
) v: t! ?" w" Q; e0 Q4 `# cV7-051_串行SPI Flash W25QXX读写例程（中断方式）
: i1 N& e7 y3 s4 ]- Z
9 p! X1 e) Q3 x实验目的：
( ?4 S. q5 x$ R
学习SPI Flash的读写实现，支持查询，中断和DMA方式。

) k! b/ o# L7 _9 v; v实验操作：

支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
" I% c/ N5 L" |6 Iprintf("请选择操作命令:\r\n");
printf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
  z8 J% r7 U  \; f4 j- p* A% Pprintf("【3 - 擦除整个串行Flash】\r\n");
printf("【4 - 写整个串行Flash, 全0x55】\r\n");
printf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
/ s$ V0 W! e2 E  F0 a7 wprintf("【X - 读取后1K，地址自动增加】\r\n");
# o: ~% S0 k# ?& lprintf("其他任意键 - 显示命令提示\r\n");
上电后串口打印的信息：
+ J2 ?; k, F# D) J) t$ f# e( J6 M! w
8 G! l) J6 G5 F! q2 |! x1 j" d波特率 115200，数据位 8，奇偶校验位无，停止位 1。

$ F1 C7 X9 \" x( f: W& I5 G& F1 W

程序设计：

" D* n# _8 B: L& A3 a/ e  系统栈大小分配：
6 B  S7 ]( s- z2 b

! a! H0 N7 i: T2 A
' j$ I; x- X7 ^5 |7 U4 J) x. J  RAM空间用的DTCM：

4 M( U: y, d  r, P+ V) T

: ]4 _" W) j/ v5 r; N& D
  q- V! A; ^* v  ~  N, Q  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
; F! s- y+ h& }9 j
0 h) S1 N* w0 y2 e. _

1. /*
   5 W, I8 k3 Z. b; [/ p
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   ; Y$ Y6 n3 h( _% F3 A
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   $ G9 v" N7 y/ S$ U1 ?
5. *    形    参：无
   
6. *    返 回 值: 无
   9 p+ r5 K. \' W! h3 E) }
7. *********************************************************************************************************
   5 |' t$ T6 `6 h- U! A1 o" a
8. */
   * X: [( U$ X7 S3 U) j% |$ X
9. void bsp_Init(void)
   
10. {
    2 b" d) Q' T5 d& o. z
11.     /* 配置MPU */
    3 K" w3 B7 Q2 v) q9 _9 Y6 \" `, A
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    ; ?/ J; Y1 Z; K. S+ p
16. 
    % ?8 R$ V% E8 _& S3 |# H9 g1 \
17.     /*
    : b: U3 f4 C3 ^% R
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    2 a+ h  {3 D# U6 Z
20.        - 设置NVIV优先级分组为4。
    & L1 l1 [$ v/ F
21.      */
    2 X, }0 Z9 {/ i5 |' b+ B
22.     HAL_Init();
    
23. 
    
24.     /*
    $ \9 h& F6 c# h5 F3 W
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    6 k2 U' ?( ~- X
28.     */
    
29.     SystemClock_Config();
    
30. 
    # V) h! k  I/ @+ W/ T; C3 X
31.     /*
    ; v; {# P$ x: \. W( m
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    5 G5 n0 V& u/ L5 M6 j; f
35.     */   
    
36. #if Enable_EventRecorder == 1  
    , [. A3 o1 F! V2 y- j# R9 `
37.     /* 初始化EventRecorder并开启 */
    1 g+ f" }/ ^; t* Z0 X
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    7 v4 J1 E# {4 ?$ p3 M% V
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    $ i! ?' I: Y  a, z0 T  p
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ; g( z/ Y& d; T5 r& T! d0 ?
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    6 o6 M& d; Y% p
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    * w' t+ j0 Y. F; z: _
47.     bsp_InitLed();         /* 初始化LED */   
    % _/ T- _5 q" w1 d0 b
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. 
    / ~* Z8 o) n; C$ V
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    & c, A6 v: S) t# j' L* ?* u- x
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    
53. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区以及SRAM4
- c3 _  z2 m) j9 t, {9 n; b

1. /*
   
2. *********************************************************************************************************
   4 j, @4 Q3 O9 s) _& H0 ?' E
3. *    函 数 名: MPU_Config
   4 ?0 s1 j2 L7 P# |4 d3 Z
4. *    功能说明: 配置MPU
   % F# ]; z' n3 d; M
5. *    形    参: 无
   
6. *    返 回 值: 无
   8 k, }' ]. m0 U+ \% ~
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   ( S  j' ]: u$ c: E7 O& ~
10. {
    ! q8 N8 p0 k5 t/ ?" @
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    ( L, r# Q* i8 ^1 h7 O% }9 f
14.     HAL_MPU_Disable();
    
15. 
    , k4 \9 ^9 y8 J# D  i6 d/ S8 u) I
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    $ \1 M1 T; I- t! K
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;
    8 t5 X4 m( M$ E/ E! n& @+ `; ^
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;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    7 A7 o% v$ T. J# {% B
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    . S+ F$ J; W; S( |4 V
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
      u% b0 J, Q/ L, ?0 _; W
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
      _5 J* A0 R. i3 v$ Z' C4 A" Y
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    7 G; ]- P2 n  B+ I" G4 F8 `! i# u5 s! Z
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    3 o/ E7 @9 Y: Q' ?7 l
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ; Y6 p* y7 I+ p7 l6 p4 C/ S
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ) n2 E* D! w2 Z& B
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    6 x# z8 M' j  c
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    9 Q3 u9 \* K2 |0 i% \2 S
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    - e. H+ t: l; @7 k1 K, j: o
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    + V# b- m1 B$ P" g
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;
    3 l, J3 N0 ?* q
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    8 v& @/ s! b- [& U: M/ U4 r
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    & ]4 Z' [( f  s4 M1 f7 G8 s, V
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61. 
    ; @9 N  @3 E" d" Y8 `6 t( I
62.     /*使能 MPU */
    
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
64. }
    
65. 
    
66. /*
    
67. *********************************************************************************************************
    8 \5 m- J2 t$ Y6 c6 Z5 b
68. *    函 数 名: CPU_CACHE_Enable
    7 ?1 X( m' E: a% M% z) l2 j+ ^1 N
69. *    功能说明: 使能L1 Cache
    
70. *    形    参: 无
    
71. *    返 回 值: 无
    
72. *********************************************************************************************************
    " m, E& q1 Q" X' d
73. */
    
74. static void CPU_CACHE_Enable(void)
    8 X2 k. s) l9 b( K+ R
75. {
    
76.     /* 使能 I-Cache */
    
77.     SCB_EnableICache();
    % k. s/ F& y, D0 J% z
78. 
    
79.     /* 使能 D-Cache */
    " _" O! a8 T9 }& W+ N" ?" g  M
80.     SCB_EnableDCache();
    ( H+ E# G  `5 _0 k; N4 O" g( Q
81. }

复制代码

+ f- N) Y: L" c$ A7 y7 r  每10ms调用一次按键处理：

3 ]! ?# _( p" ]8 J( \7 r# E按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。
0 ~+ l( Y( }$ I& P8 z

1. /*
   % K$ c+ W% ^$ i9 v- \7 X' Y
2. *********************************************************************************************************
   7 _/ }( C3 x3 y0 `7 m
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   % D  l; D- p# x# j) L" n
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   6 N# J! D4 m% ?( M5 x
6. *    形    参: 无
   . b$ @5 u7 d3 ~
7. *    返 回 值: 无
   - S+ g. p7 t2 o  ]9 u% U& m+ B
8. *********************************************************************************************************
   1 W1 p. C6 X7 r' T6 o
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    4 _. f# f/ f) N& w3 N% R8 C
12.     bsp_KeyScan10ms();
    $ n" l. a$ g* v) O1 q
13. }
    3 c: q5 g2 S! n+ V7 G' x
14. 
    5 @/ R0 H! q/ y5 J

复制代码

  主功能：

2 [' i; n; y  r% X! B  H主程序实现如下操作：
4 w( A7 k" a* f! f6 p4 }
/ g" {* L0 v& e% O. x& m# L  启动一个自动重装软件定时器，每100ms翻转一次LED2。
) e/ i" f3 c' X9 ]4 s  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
  1 - 读串行Flash
  2 - 写串行Flash
  q/ w9 o4 j8 }. X) d+ @6 i3 c. R  3 - 擦除整个串行Flash
  4 - 写整个串行Flash
  5 - 读整个串行Flash
4 R4 m6 U  c. I5 |4 Y  Z - 读取前1K
) s( L( i" z6 r$ _  X - 读取后1K
! M- @' m$ I$ X9 |

1. /*
   
2. *********************************************************************************************************
   / D* F' B% f, v
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   
5. *    形    参：无
   3 |$ ]" a: G- T3 b, ^& z9 ?6 C
6. *    返 回 值: 无
   0 G* ~$ |; Q9 j5 b/ E9 ^
7. *********************************************************************************************************
   
8. */
   
9. void DemoSpiFlash(void)
   9 A0 ], C7 U2 C: l. W- M) A8 l
10. {
    ) Y8 x" _- [. H% U, z" s
11.     uint8_t cmd;
    ( c( C- T: i# L+ C5 V
12.     uint32_t uiReadPageNo = 0;
    ! c4 j% G( b, M; `% e& J
13. 
    
14. 
    
15.     /* 检测串行Flash OK */
    ( D3 L6 L* Z# L% |# {
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    8 v6 o# h% J! s
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    
18. 
    
19.     sfDispMenu();        /* 打印命令提示 */
    1 Y- R7 P# b1 ]# s
20. 
    # x8 h9 B9 [# J9 {! v
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
22. 
    9 ^* D6 d1 M+ Y) v8 o
23.     while(1)
    
24.     {
    
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    8 Q$ @# e7 G  S: ]9 x
26. 
    8 f; v% A( R- S. W
27.         /* 判断定时器超时时间 */
    ; X0 A+ l& l# o3 C" _
28.         if (bsp_CheckTimer(0))   
    5 K  o* L- Z! L% `
29.         {
    ! B& `$ P$ V9 M, R3 \3 G3 g. p
30.             /* 每隔100ms 进来一次 */  
    
31.             bsp_LedToggle(2);
    
32.         }
    
33. 
    $ P0 B9 G: i+ {% `! R( C- j* ^
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    " V. ^5 e9 D& i5 k1 V5 r
35.         {
    
36.             switch (cmd)
    / M% W4 k; R0 O) C( I, V
37.             {
    ! |' Z9 t; l# X
38.                 case '1':
    2 m& H' ~" [. L3 @
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    * N4 h% v  R1 Q0 B
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    
41.                     break;
    
42. 
    3 b- [; Q5 L: [1 v5 Z" c3 `; J
43.                 case '2':
    $ _/ @6 u3 o* t( Q. C
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    & T* ]3 H- U; f3 [; o/ n5 p
47. 
    ' e/ X: j) h8 i$ W
48.                 case '3':
    9 U, P0 r' n5 f! L& M" j" H
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    1 W5 L; T( E" b/ T4 ~7 S
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
    7 d, Q, v# d1 m
53. 
    # [" q" g8 W6 ^% x* u+ g+ q
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    - [) C  {8 z/ H% ]: W+ Y/ W
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    : X) u. S' E  }# R
58.                     break;
    2 u# d+ U6 _; `6 |' `. I+ \
59. 
    / R. w7 N  S4 y7 N, s4 p0 ^
60.                 case '5':
    
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    ) x( b" u  Z" ?/ g) ^
63.                     break;
    
64. 
    
65.                 case 'z':
    7 U1 s: d3 N5 ]
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
    
68.                     {
    # H* R* B+ j3 `4 l+ ~
69.                         uiReadPageNo--;
    
70.                     }
    1 W8 j' n4 C7 L) ^
71.                     else
    ; p/ ^) {* ]) i; @. {
72.                     {
    
73.                         printf("已经是最前\r\n");
    1 s) @" O* W" C2 S
74.                     }
    6 U: c+ s. i9 f3 N5 J. K
75.                     sfViewData(uiReadPageNo * 1024);
    + l% s0 G4 N9 {& Q8 a
76.                     break;
    * ]1 _; V* }3 K* S
77. 
    6 N3 X7 Z) d  {6 y8 w
78.                 case 'x':
    
79.                 case 'X': /* 读取后1K */
    
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    9 S/ H6 p$ y4 G: ^
81.                     {
    
82.                         uiReadPageNo++;
    ( S+ [6 F0 d9 F0 P; c# G" D
83.                     }
    ( O3 k1 Z( ]0 R$ @
84.                     else
    
85.                     {
    
86.                         printf("已经是最后\r\n");
    
87.                     }
    
88.                     sfViewData(uiReadPageNo * 1024);
    
89.                     break;
    + @3 o: J0 [: W: f( M
90. 
    
91.                 default:
    
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    0 y- ~5 W; Y; d; g
93.                     break;
    
94. 
    
95.             }
    
96.         }
    0 Q/ o! q1 |8 _( Z: @3 c! h8 {* Z
97.     }
    , @0 \% C( ?( E# O
98. }

复制代码

6 S2 q1 ~: M6 Y1 v1 t. ]) H2 V73.10          实验例程说明（IAR）
3 O' W8 l) P' f& W$ g配套例子：
% g& ~, c1 Y+ ^
0 m7 M/ y# U9 W, e# OV7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）

V7-050_串行SPI Flash W25QXX读写例程（DMA方式）
& s1 p& O$ C* @1 v7 a% c4 m* e: g
+ L# l; }# E+ OV7-051_串行SPI Flash W25QXX读写例程（中断方式）

实验目的：
1 }/ z. f; E4 g! @
* t* D/ ^3 K; q; s2 y5 a学习SPI Flash的读写实现，支持查询，中断和DMA方式。
- ~& A$ O8 a* _" }$ P# l: N
实验操作：
) t' Y- c; I# `9 h7 A% ^
支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
5 r& ^- i) Z% w- B* @! N5 Mprintf("请选择操作命令:\r\n");
printf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
" ~  }- W; i, o) F8 Mprintf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【3 - 擦除整个串行Flash】\r\n");
; F4 j5 w. p1 f4 _$ \printf("【4 - 写整个串行Flash, 全0x55】\r\n");
printf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
7 G0 W( e- m# w! T  q8 F4 Z+ oprintf("【X - 读取后1K，地址自动增加】\r\n");
printf("其他任意键 - 显示命令提示\r\n");

上电后串口打印的信息：

0 [4 F# b0 G% v4 k" _& g' d% }波特率 115200，数据位 8，奇偶校验位无，停止位 1。

( C5 j/ |8 l. b& ~& \& }, X程序设计：

9 R' L, E9 p/ @; _  系统栈大小分配：
$ F. H1 Q4 K4 }8 @5 }* i
4 R7 d0 @0 E+ u( K* \# U# i& g

, C( c! Q: ?' S  RAM空间用的DTCM：

$ R/ N6 C- N: I' x8 j5 m- ~

8 W* j( V1 v  r" w
  t; B& T4 V4 [2 O) G$ o5 l* d  硬件外设初始化

* B4 ?- F/ n/ B2 l7 ^硬件外设的初始化是在 bsp.c 文件实现：

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

复制代码

  MPU配置和Cache配置：

6 j* m/ d0 h- l* o( x% S数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
8 s; G7 G) G8 Z- V

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   # F4 q. N+ `8 G4 [* p. A, T: J
8. */
   + A/ A7 g  L6 K( I3 q0 C
9. static void MPU_Config( void )
   
10. {
    8 w6 \) L4 U# X& G# o5 a  B
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    7 U. i' l# w) n! W$ S
12. 
    , @+ y+ D3 O, s9 q* ^( S! Z
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    , A: F7 w5 R& J+ I" {* t
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    $ o$ G/ U& a+ }+ C6 U. w9 t
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    * x; h5 `" J# v
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    + l& e7 s6 @; S, G
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    - A/ o( L2 y% F7 m
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; R, n0 U" u) i5 A
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ) V% X% W0 p) }" Z) v, N2 a
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    & |0 g  X5 A$ A, ~0 Q4 x8 n4 A9 r/ J; F
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    + P" f: ?- l: P& v
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    ( M3 b4 j* D+ {6 u
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    - {- q2 W; f8 F9 d6 m2 N: t
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
      j6 w3 S7 Z0 O
30. 
    
31. 
    ) }9 [. B+ H( Q% u
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    # J9 F0 v! `! |% B5 D4 f; ~3 n
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;
    $ I3 z; Q+ r& ^
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;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    - s! t) b) m; W( Y+ R
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    % v4 D3 \& b5 i* j" q0 I) N
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    ; j. I. ~, Y5 u# L+ C% g) J
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    5 P2 L' v! b( h4 m+ L
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    ! L& u4 c! {, }* b7 l' H! ?1 {
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ! f# j: p3 r# W2 E+ p$ W: j
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    , t  m3 K/ a. ]8 }& Y* r5 q% r5 R
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( R0 X0 B, Q% T4 g% r9 e
59. 
    & o# C- E' n' r' `
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61. 
    ) O7 g* p4 c8 _4 g5 _
62.     /*使能 MPU */
    
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
64. }
    " N6 l- G0 v% [, X6 O
65. 
    2 C$ W# C) @" K, e! E
66. /*
    
67. *********************************************************************************************************
    
68. *    函 数 名: CPU_CACHE_Enable
    
69. *    功能说明: 使能L1 Cache
    
70. *    形    参: 无
    * N0 y1 d$ d! [% g9 |2 S+ z( {, n
71. *    返 回 值: 无
    $ c" J1 p6 U! @
72. *********************************************************************************************************
    
73. */
    # _* M* v. _( a" t2 p0 d& T2 c5 p
74. static void CPU_CACHE_Enable(void)
    
75. {
    7 D; K2 V+ h) i1 N1 Y
76.     /* 使能 I-Cache */
    
77.     SCB_EnableICache();
    
78. 
    4 P' T( H/ a# Q8 }0 D3 ]& x
79.     /* 使能 D-Cache */
    3 Z( y( p7 K* F
80.     SCB_EnableDCache();
    
81. }
    

复制代码

& S) x# b; [' K% K: M
  每10ms调用一次按键处理：
5 D' h' e* j0 X* f3 R
% o- t8 D% o: v6 G. ]2 _按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   " x2 F7 a( C' K& x. _9 ~4 S
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   " c8 M; u1 P! R% ~
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   * P0 Y2 m$ D, c# Z9 L$ P8 s
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   - I/ Y+ H' a, X# ]3 v3 V
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   . ?/ f  ^0 |! A& _5 b
9. */
   + S! l6 J) A% f4 ]
10. void bsp_RunPer10ms(void)
    ) x& h! l$ K% N: c( x% ^9 H3 c; D
11. {
      q. w7 }  W$ `+ ^& |, h
12.     bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
' f1 d, |3 i3 a& a; H1 l  请选择操作命令:
  1 - 读串行Flash
  2 - 写串行Flash
' o9 C8 M7 \6 J" s, H  3 - 擦除整个串行Flash
  4 - 写整个串行Flash
  5 - 读整个串行Flash
  Z - 读取前1K
% M! M0 u% z7 y3 o7 _5 k  X - 读取后1K

1. /*
   ' Y# M: L% r" d; ~0 B1 R
2. *********************************************************************************************************
   
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   & [: h: r) K0 K: T# A8 f
5. *    形    参：无
   
6. *    返 回 值: 无
   2 o7 j  d4 U: z, J1 \3 m
7. *********************************************************************************************************
   7 H2 N: v( L. ~, i  W: b
8. */
   8 v' W3 j: z7 |) S$ r
9. void DemoSpiFlash(void)
   
10. {
    5 t2 g" T& r' k9 m+ e
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0;
    
13. 
    5 J$ C5 H9 u# I. `9 b
14. 
    
15.     /* 检测串行Flash OK */
    
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    : y! r& v4 \' l4 [
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    1 m  w, H9 Y; S0 @3 @
18. 
    
19.     sfDispMenu();        /* 打印命令提示 */
    
20. 
    
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    * F/ z" X# t: X5 l/ |: I& ?
22. 
    : s# h% v! g+ H
23.     while(1)
    
24.     {
    
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
26. 
    3 e1 \$ S1 T1 K5 }! H
27.         /* 判断定时器超时时间 */
    4 t" w0 s# X8 L# p, E
28.         if (bsp_CheckTimer(0))   
    6 f" p' q, x9 j* q5 ^+ p2 l% H
29.         {
    2 [1 B/ @( F1 r. X- f
30.             /* 每隔100ms 进来一次 */  
    & [2 e: q9 x4 e2 `2 S( U" E
31.             bsp_LedToggle(2);
    . u* v& v, A" K% [" F  A2 x" v" z" c
32.         }
    
33. 
    
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
35.         {
    5 X; S6 s7 f$ l& V: {
36.             switch (cmd)
    
37.             {
    
38.                 case '1':
    
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    7 r6 c) B4 N: s
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    % l7 A2 n, y4 S
41.                     break;
    
42. 
    
43.                 case '2':
    9 e6 Z2 ]$ a6 E+ G" U4 _9 `
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    : c. ^7 q5 X. K- I& Q9 ]
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    ! w! W2 C8 P& J5 Y$ \( R
47. 
    + t' B/ |& x, V6 H) \6 E9 U0 Y
48.                 case '3':
    : }  t5 S8 w0 ~- F9 u  t/ |
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    + F1 q" W2 n0 `  W6 u
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
    
53. 
    ; }( I3 U. S" p7 v. q, B/ ?: R4 r
54.                 case '4':
    ' e, f( \2 J: S( w1 r
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    2 J8 C- r' D7 \- I
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    7 D& G5 }+ Y! L  t3 L) z2 {
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    , w# n1 }7 t9 {  y1 |& g' p7 Y
59. 
    
60.                 case '5':
    , w! M2 Z) @, Q
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    4 y# Z+ j& `3 Z! S5 d+ t2 L
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
63.                     break;
    . n9 N3 J+ Y. P' D% D
64. 
    ! r! L! Y6 C* K1 G1 V0 _1 O3 h, f
65.                 case 'z':
    
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
    
68.                     {
    & l) r7 X' W9 f0 a1 @9 V
69.                         uiReadPageNo--;
    
70.                     }
    
71.                     else
    9 N8 u7 C% Z5 ?+ U& O$ t3 E% a
72.                     {
    
73.                         printf("已经是最前\r\n");
    
74.                     }
    5 A9 r2 ~  A4 @8 ~
75.                     sfViewData(uiReadPageNo * 1024);
    
76.                     break;
    
77. 
    ' c0 e! D& l, L. P4 o( x1 m1 e7 X* H4 ~
78.                 case 'x':
    3 l) M, w; f$ b. x/ a! O
79.                 case 'X': /* 读取后1K */
    
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    " o* |% \+ P2 P2 [, C: @
81.                     {
    
82.                         uiReadPageNo++;
    
83.                     }
    
84.                     else
    + J+ d) ~+ m7 [
85.                     {
    1 S# o! c/ D" o$ {+ ?, \2 ^
86.                         printf("已经是最后\r\n");
    5 Q, B! @% a% S3 l  ], J: o( X
87.                     }
    
88.                     sfViewData(uiReadPageNo * 1024);
    
89.                     break;
    
90. 
    
91.                 default:
    % O- X& H1 ?; D( G% Y4 x
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    ; F8 Q% O- P/ r6 S
93.                     break;
    
94. 
    
95.             }
    
96.         }
    ; o5 U0 r7 ~8 Q; a" l
97.     }
    
98. }

复制代码

' A$ e; w% \2 a# Q7 N' }1 m73.11   总结
本章节就为大家讲解这么多，实际应用中根据需要选择DMA，中断和查询方式。
( l& T. `2 n( m# f$ I) I
& \, [: p5 A/ z* J+ i$ r+ O
& N2 x& \3 H2 K: m" _. A
9 z: U  U+ ]. Q' G% M: ?0 l/ y