73.1 初学者重要提示
8 m- }. r5 F: ?2 Y  W25Q64FV属于NOR型Flash存储芯片。
  W25Q64JV手册下载地址：链接 （这是一个超链接），当前章节配套例子的Doc文件件里面也有存放。
5 I  k: [  q, P- G2 I, K

  本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。
  对SPI Flash W25QXX的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。
  W25Q64JV最高支持133MHz，但最高读命令03H速度是50MHz。
  文件bsp_spi_bus.c文件公共的总线驱动文件，支持串行FLASH、TSC2046、VS1053、AD7705、ADS1256等SPI设备的配置。
  函数sf_WriteBuffer不需要用户做擦除，会自动执行擦除功能，支持任意大小，任意地址，不超过芯片容量即可。
; g0 |2 @/ V1 Y# a
* B0 c* v2 v5 w+ k+ o73.2 W25QXX硬件设计
STM32H7驱动W25QXX的硬件设计如下：
. o( r7 F% H2 {% Q# `

5 V& E& b2 R. D  @% O/ A2 {6 S& H关于这个原理图，要了解到以下几个知识：

  V7开发板实际外接的芯片是W25Q64JV。
  CS片选最好接上拉电阻，防止意外操作。
  这里的PB3，PB4和PB5引脚可以复用SPI1，SPI3和SPI6。实际应用中是复用的SPI1。
  W25Q64的WP引脚用于写保护，低电平有效性，当前是直接高电平。
  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。
) Z4 O0 s* B3 D7 u' g73.3 W25QXX关键知识点整理（重要）
, t; _( j9 I  U9 S  X驱动W25QXX前要先了解下这个芯片的相关信息。

& Z; s% h9 S8 w% B

9 m1 e/ ~4 U& n+ i$ o
  M" n% }. s- s5 w73.3.1 W25QXX基础信息
  W25Q64FV的容量是8MB（256Mbit）。
) J% y: i2 e3 s( @, c. D8 k  W25Q64FV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
支持两线SPI，用到引脚CLK、CS、IO0、IO1 。
5 D  f4 }1 K! o( H, p* U# \
支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。
  k! h! B/ O' H- S' a  g
（注：这里几线的意思是几个数据线）。

  W25Q64FV支持的最高时钟是133MHz。
  每个扇区最少支持10万次擦写，可以保存20年数据。
3 C1 C. k8 D8 f+ U4 {5 H* g  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
整体框图如下：

1 d* |6 b2 g3 A! k7 ^9 r
- P) d7 o& C* f  J4 FW25Q64FV：
* q4 ^( k* ~: Y  l5 L. E- L
- }  @" C" e& a* L6 X  有128个Block，每个Block大小64KB。
  每个Block有16个Sector，每个Sector大小4KB。
  每个Sector有16个Page，每个Page大小是256字节。
: M4 u) Q  w" Y% A73.3.2 W25QXX命令
使用W25Q的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的标准SPI，即单线SPI，使用的命令如下：

( B7 i! K. f' b( e. j( C

' w8 J) f1 o: r( E
. l8 f. B* Z& B# w+ m( j; \+ N当前主要用到如下几个命令：

$ y1 f% z/ L+ }/ _' `

1. #define CMD_EWRSR       0x50  /* 允许写状态寄存器的命令 */
   8 T5 w( _5 B: a: x) W+ p1 i
2. #define CMD_WRSR      0x01  /* 写状态寄存器命令 */
   
3. #define CMD_WREN      0x06    /* 写使能命令 */
   1 t' _0 G% z# |/ m' t! m1 s1 V& \
4. #define CMD_READ      0x03  /* 读数据区命令 */
   
5. #define CMD_RDSR      0x05    /* 读状态寄存器命令 */
   
6. #define CMD_RDID      0x9F    /* 读器件ID命令 */
   
7. #define CMD_SE        0x20    /* 擦除扇区命令 */
   
8. #define CMD_BE        0xC7    /* 批量擦除命令 */
   $ ^( X; O. i, F* x8 Y% s4 W& N6 p
9. #define WIP_FLAG      0x01    /* 状态寄存器中的正在编程标志（WIP) */

复制代码

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

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   ! R% W  m) T  E! z
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   / Q8 I3 C  S1 k4 {* L
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   
5. 
   
6.     for (i = 0; i < _usSize; i++)
   
7.     {
   1 x) d: ^& G9 B
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   7 |3 N* m2 z7 |8 R1 J( O
10.     }

复制代码

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

; j5 P* U* [3 g: s% K比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：

1. uint8_t tempbuf[10] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00};
   % x/ ~6 o5 W  {5 |$ q
2. uint8_t temp1 = 0x10, temp2 = 0x29, temp3 = 0x48;

复制代码

  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
: |" I6 G1 V# A" F9 d5 j2 E  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
! I$ Z$ c, n, b! M. P/ G0 Z9 [下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。

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

如果给的不是扇区或者块的首地址也没有关系的，只要此地址是在扇区或者块的范围内，此扇区或者块也可以被正确擦除。不过建议使用时给首地址，方便管理。
9 R7 y( {6 X4 [+ d! r9 K
& R2 x5 t$ U" q73.3.5 W25QXX规格参数
. N2 f4 |/ X. D# L这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：

6 i2 y! G) @! m3 U! z

' E- W' r- n" Z1 ]6 C0 z
4 b& i$ W/ X+ |  页编程时间：典型值0.4ms，最大值3ms。
  扇区擦除时间（4KB）：典型值45ms，最大值400ms。
" r; V; y" U4 R" w& k  块擦除时间（32KB）：典型值120ms，最大值1600ms。
  块擦除时间（64KB）：典型值150ms，最大值2000ms。
, Y) D* p: L5 k4 I; {7 g  整个芯片擦除时间：典型值20s，最大值100s。


7 \0 s% n" N/ u6 g& a8 ]. v  A支持的速度参数如下：
) h7 k& U/ u6 t3 g. ^1 Z
, Y& H( J* M4 T7 O

0 |, K% {9 I8 J) C3 k
可以看到最高支持的读时钟（使用命令03H）速度是50MHz，其它命令速度可以做到133MHz。
/ x3 S) }7 M( m/ g9 {; }
73.4 W25QXX驱动设计
' R. ^' ^" i' S! ZW25QXX的程序驱动框架设计如下：
) R  |' q: f! H3 W! {; k& e

) A. X% [) c5 S4 D4 h
; c* y- q, t; g; m有了这个框图，程序设计就比较好理解了。
9 b8 C3 l0 E' {4 b# x, \* X" ]
73.4.1 第1步：SPI总线配置
spi总线配置通过如下两个函数实现：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_InitSPIBus
   
4. *    功能说明: 配置SPI总线。
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   , r3 o  L8 @) a. I
8. */
     c  a. @7 m# {. t0 a) G+ S
9. void bsp_InitSPIBus(void)
   : t/ o" e9 _7 z+ x* Z  T/ q
10. {   
    
11.     g_spi_busy = 0;
    6 u, X1 k/ @& o7 z( p/ ?# @
12. 
    
13.     bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_8, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);
    
14. }
    # d# |6 c' r7 Y2 a& E- @. J
15. 
    
16. /*
    9 x; d) l3 F# |: {3 T
17. *********************************************************************************************************
    6 y, [3 N# l7 m6 g/ i
18. *    函 数 名: bsp_InitSPIParam
    ( b! ?9 D) j1 G  a$ y* `4 {
19. *    功能说明: 配置SPI总线参数，时钟分频，时钟相位和时钟极性。
    
20. *    形    参: _BaudRatePrescaler  SPI总线时钟分频设置，支持的参数如下：
    
21. *                                 SPI_BAUDRATEPRESCALER_2    2分频
    3 G4 h% [7 |3 i7 h; H6 a4 U6 B
22. *                                 SPI_BAUDRATEPRESCALER_4    4分频
    9 ^6 X- F" i0 d0 N- b
23. *                                 SPI_BAUDRATEPRESCALER_8    8分频
    
24. *                                 SPI_BAUDRATEPRESCALER_16   16分频
    ; w5 a+ P& n7 N
25. *                                 SPI_BAUDRATEPRESCALER_32   32分频
    
26. *                                 SPI_BAUDRATEPRESCALER_64   64分频
    * X6 p8 t( u7 Z  z* a+ p. \
27. *                                 SPI_BAUDRATEPRESCALER_128  128分频
    
28. *                                 SPI_BAUDRATEPRESCALER_256  256分频
    
29. *                                                        
    1 a6 E# g2 E  o, Y+ o8 _' a
30. *             _CLKPhase           时钟相位，支持的参数如下：
    
31. *                                 SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
    
32. *                                 SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
    6 O* x. ~* ~& H+ a6 J4 p/ y
33. *                                 
    $ r8 R5 i8 ]' o6 M* p- V
34. *             _CLKPolarity        时钟极性，支持的参数如下：
    ; F4 p6 d. p4 G7 {' p
35. *                                 SPI_POLARITY_LOW    SCK引脚在空闲状态处于低电平
    
36. *                                 SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平
    # E3 [1 T, h& L8 H- I
37. *
    ! R- I6 c! a* m
38. *    返 回 值: 无
    1 `# z* u( K& F+ |. {1 M5 o
39. *********************************************************************************************************
    & r" j) s, N; b* Q
40. */
    
41. void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
    
42. {
    
43.     /* 提高执行效率，只有在SPI硬件参数发生变化时，才执行HAL_Init */
    
44.     if (s_BaudRatePrescaler == _BaudRatePrescaler && s_CLKPhase == _CLKPhase && s_CLKPolarity == _CLKPolarity)
    9 n0 L* U2 K8 [! P4 N5 K0 p" }
45.     {        
    * C: D9 k. l0 b" w% P* W4 v- @
46.         return;
    ! ?0 Q) J7 D0 ?  L$ w
47.     }
    7 N# z! \. c2 A9 C& t
48. 
    : }/ T$ H8 A2 V/ \
49.     s_BaudRatePrescaler = _BaudRatePrescaler;   
    ' X: k7 |: h) y5 n" a4 }
50.     s_CLKPhase = _CLKPhase;
    
51.     s_CLKPolarity = _CLKPolarity;
    , x! N4 t. q, u" u9 w% Q
52. 
    
53. 
    9 b; r  s  B. x8 H( d
54.     /* 设置SPI参数 */
    
55.     hspi.Instance               = SPIx;                   /* 例化SPI */
    " p* V4 z5 J$ J: _  q
56.     hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
    4 H) X/ M) p+ Z1 f6 A& _
57.     hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
    
58.     hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
    $ Q/ Q% b; A4 b0 v2 @
59.     hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
    # C  C5 i# F' W: p% V5 P
60.     hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
    + R" F" @- e$ v' A
61.     hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    , m9 Y9 E9 c$ a( f, g2 U8 Q
62.     hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    / n9 _* ?8 u/ k) e1 p# @7 O
63.     hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE; /* 禁止CRC */
    * L, f5 ]; x) A$ n/ l4 c
64.     hspi.Init.CRCPolynomial     = 7;                       /* 禁止CRC后，此位无效 */
    
65.     hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;     /* 禁止CRC后，此位无效 */
    : }  o. v* ], h8 e! U
66.     hspi.Init.NSS               = SPI_NSS_SOFT;               /* 使用软件方式管理片选引脚 */
    
67.     hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;  /* 设置FIFO大小是一个数据项 */
    / U! z9 b! k3 z. p, R
68.     hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;      /* 禁止脉冲输出 */
    3 b9 ?3 Y7 p) t) t$ Q: m
69.     hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    
70.     hspi.Init.Mode             = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    ' _' u) |$ f3 R
71. 
    ( Q& S# T2 A) t) c
72.     /* 复位配置 */
    
73.     if (HAL_SPI_DeInit(&hspi) != HAL_OK)
    : B, m" d9 ?, u- g: R1 x+ P1 D
74.     {
    
75.         Error_Handler(__FILE__, __LINE__);
    
76.     }   
    
77. 
    
78.     /* 初始化配置 */
    2 Q; N% w* x  O
79.     if (HAL_SPI_Init(&hspi) != HAL_OK)
    
80.     {
    
81.         Error_Handler(__FILE__, __LINE__);
    ( U" Z2 g1 S: Z, g1 u9 l* q
82.     }   
    5 Z5 ^& k8 \  v. Q0 P
83. }

复制代码

关于这两个函数有以下两点要做个说明：
! e. w- o0 A6 \; X, ?6 Q
) x7 h$ m$ p+ a5 W  函数bsp_InitSPIBus里面的配置是个初始设置。实际驱动芯片时，会通过函数bsp_InitSPIParam做再配置。
  函数bsp_InitSPIParam提供了时钟分频，时钟相位和时钟极性配置。驱动不同外设芯片时，基本上调整这三个参数就够。当SPI接口上接了多个不同类型的芯片时，通过此函数可以方便的切换配置。
; l$ N; q0 w7 d0 z3 i" j4 i& [1 |73.4.2 第2步：SPI总线的查询，中断和DMA方式设置
SPI驱动的查询，中断和DMA方式主要通过函数bsp_spiTransfer实现数据传输：
, g1 c$ E0 ~' m( y2 W% q' p

1. /*
   % T! g) @/ W7 j- X
2. *********************************************************************************************************
   
3. *                                 选择DMA，中断或者查询方式
   
4. *********************************************************************************************************
   
5. */
   9 X7 @6 C9 i3 j) E
6. //#define USE_SPI_DMA    /* DMA方式  */
   
7. //#define USE_SPI_INT    /* 中断方式 */
   
8. #define USE_SPI_POLL   /* 查询方式 */
   * L0 y0 C$ M2 j  H( V) N7 Q8 ^
9. 
   
10. /* 查询模式 */
    
11. #if defined (USE_SPI_POLL)
    
12. 
    
13. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];  
    5 q3 O1 l, }% J: L3 s/ C$ w  R
14. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    & n0 t( U% o1 K8 M9 k
15. 
    , \: a; B1 m# Q8 r- L8 T
16. /* 中断模式 */
    
17. #elif defined (USE_SPI_INT)
    
18. 
    
19. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    ( y: V  o! g* g4 h
20. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    5 Y' l6 U" v6 M. U7 x9 j
21. 
    
22. /* DMA模式使用的SRAM4 */
    7 x1 q; Z6 v9 a6 D
23. #elif defined (USE_SPI_DMA)
    ) X2 ?- t! E' {7 w
24.     #if defined ( __CC_ARM )    /* IAR *******/
    
25.         __attribute__((section (".RAM_D3"))) uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    9 l4 i. E$ a* l; t8 R" d
26.         __attribute__((section (".RAM_D3"))) uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
27.     #elif defined (__ICCARM__)   /* MDK ********/
    
28.         #pragma location = ".RAM_D3"
    
29.         uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
30.         #pragma location = ".RAM_D3"
    
31.         uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
32.     #endif
    $ |* r  Z' c2 a) j
33. #endif
    
34. 
      P7 n4 ?7 s% {8 P$ ^
35. /*
    ' ]2 t  s0 y7 R9 ^
36. *********************************************************************************************************
    : Y( g1 N# m; u# X
37. *    函 数 名: bsp_spiTransfer
    
38. *    功能说明: 启动数据传输
      ]! n$ C+ U% X: l: S6 C! a
39. *    形    参: 无
    # Z) E4 z3 f; ^& O& i  O
40. *    返 回 值: 无
      R+ {3 F7 U( \1 ~6 ?7 K
41. *********************************************************************************************************
    
42. */
    * n$ X- C$ s: m) u5 C* D
43. void bsp_spiTransfer(void)
    8 G$ \3 `* g& e( x, \4 q
44. {
    
45.     if (g_spiLen > SPI_BUFFER_SIZE)
    
46.     {
    5 h; R/ t7 v2 ]- D! f
47.         return;
    
48.     }
    " Y2 Z8 G% y' |0 c
49. 
    0 s. t& V+ y8 n  k7 ^# n1 S- R! T' e; V
50.     /* DMA方式传输 */
    
51. #ifdef USE_SPI_DMA
    
52.     wTransferState = TRANSFER_WAIT;
    
53. 
    
54.     if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    
55.     {
    
56.         Error_Handler(__FILE__, __LINE__);
    ! j! R! w9 ~, ]
57.     }
    
58. 
    
59.     while (wTransferState == TRANSFER_WAIT)
    
60.     {
    7 l7 T* Q7 H9 M1 `
61.         ;
      l2 Z4 }% y: K' j; e% R+ W
62.     }
    1 M# \5 X7 k  j  T. q! J
63. #endif
    7 ~& K) n& q- s5 Z% A5 R$ E7 t
64. 
    - ~; b* k4 W) I/ C% t) {
65.     /* 中断方式传输 */   
    0 L; _& R+ Q+ i% A
66. #ifdef USE_SPI_INT
    
67.     wTransferState = TRANSFER_WAIT;
    
68. 
    
69.     if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    
70.     {
    
71.         Error_Handler(__FILE__, __LINE__);
    2 G+ b+ h2 k* ^+ [* @- [; O
72.     }
    
73. 
    - A9 Y+ l0 H5 q- A
74.     while (wTransferState == TRANSFER_WAIT)
    " ~9 t0 w0 ~/ H/ a
75.     {
    ( I! ~' g) y2 p3 b  i7 K  ^1 E
76.         ;
    
77.     }
    
78. #endif
    % {) W8 [% j6 H: P- V
79. 
    8 t& G8 C6 W! r! j! Y, [0 C
80.     /* 查询方式传输 */   
    
81. #ifdef USE_SPI_POLL
    " {9 C- a# m: Y. D
82.     if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)   
    
83.     {
    / U& D) t7 U6 s1 H* R- p- d8 |
84.         Error_Handler(__FILE__, __LINE__);
    
85.     }   
    9 C5 `/ D- _8 E
86. #endif
    6 f7 b- B4 j3 F
87. }
    / ~0 k- A, J; @9 u

复制代码

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

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

1.     /* 配置SRAM4的MPU属性为Non-cacheable */
   ; E( l8 b8 X3 w# z5 `# v
2.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   
3.     MPU_InitStruct.BaseAddress      = 0x38000000;
   
4.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   
5.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   % q* D+ B' r7 Q2 T0 M) J$ c7 b: I; X5 `
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;
   
10.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
11.     MPU_InitStruct.SubRegionDisable = 0x00;
    
12.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    3 I  `) }0 ^0 x9 b5 L. E( ?
13. 
    
14.     HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

73.4.3 第3步：W25QXX的时钟极性和时钟相位配置
5 I& _! f: x1 a0 A6 l+ R2 _首先回忆下STM32H7支持的4种时序配置。

# J+ T& x# r  z2 n  当CPOL = 1， CPHA = 1时

1 l, c  Y( k/ a4 M2 CSCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。

* l, J# `, H2 E! Z2 X8 r4 `  当CPOL = 0， CPHA = 1时
3 ?( C: l% Q  P3 q+ @) j
: u: i  o( w# p% mSCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。

* {8 Y# ~7 i4 p6 P. f; |1 q  当CPOL = 1， CPHA = 0时

SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。
! B7 z; h1 L+ e/ y
; S0 Z1 y" q3 {' w% N7 b 当CPOL = 1， CPHA = 0时

SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
; w% w# r! L* K" O* G

有了H7支持的时序配置，再来看下W25Q的时序图：
2 [/ s7 {* ^! J
: Q' [  G8 O4 q* L3 g6 aMode0 ： 空闲状态的sck是低电平。

Mode1 ： 空闲状态的sck是高电平。
5 C1 B" H' y3 g  {" ^5 e9 N$ [' w* K, _

/ X0 T8 W: @, E+ F1 a首先W25Q是上升沿做数据采集，所以STM32H7的可选的配置就是：

CHOL = 1,  CPHA = 1
& Q, g% Q4 k! k/ {2 K
CHOL = 0,  CPHA = 0
# U" x! A: J, |) U9 L" B
' B2 T% t0 v0 w" g对于这两种情况，具体选择哪种，继续往下看。W25Q有两种SCK模式，分别是Mode0和Mode3，也就是空闲状态下，SCK既可以是高电平也可以是低电平。这样的话，这两种情况都可以使用，经过实际测试，STM32H7使用这两个配置均可以配置驱动W25Q。

73.4.4 第4步：单SPI接口管理多个SPI设备的切换机制
单SPI接口管理多个SPI设备最麻烦的地方是不同设备的时钟分配，时钟极性和时钟相位并不相同。对此的解决解决办法是在片选阶段配置切换，比如SPI Flash的片选：

1. /*
   
2. *********************************************************************************************************
   ; E0 f) S; s9 h
3. *    函 数 名: sf_SetCS
   
4. *    功能说明: 串行FALSH片选控制函数
   0 L& H* o1 C4 E1 ?  A
5. *    形    参: 无
   ' o9 l; }. k9 x7 i
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   6 P6 I+ X" O; m3 }- C
8. */
   3 a% Z0 ~# e& X( t. b, K& K5 i
9. void sf_SetCS(uint8_t _Level)
   ' z2 c9 x3 Q- A/ ^, j% G/ T
10. {
    
11.     if (_Level == 0)
    
12.     {
    ' s: y0 p3 B2 j: M) L# G" ^
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    
15.         SF_CS_0();
    
16.     }
    
17.     else
    ( R' a. C9 k& A! z8 C1 w
18.     {        
    % m9 r3 `) S6 Q
19.         SF_CS_1();   
    
20.         bsp_SpiBusExit();        
    
21.     }
    
22. }
    # E" ^, H9 Z  q4 [5 I5 J

复制代码

9 [  S( n  ~# {! Z7 j2 q1 c8 q通过这种方式就有效的解决了单SPI接口管理多设备的问题。因为给每个设备都配了一个独立的片选引脚，这样就可以为每个设备都配置这么一个片选配置。

但是频繁配置也比较繁琐，所以函数bsp_InitSPIParam里面做了特别处理。当前配置与之前配置相同的情况下无需重复配置。

73.4.5 第5步：W25QXX的读取实现
W25QXX的读取功能比较好实现，发送03H命令后，设置任意地址都可以读取数据，只要不超过芯片容量即可。

1. /*
   
2. *********************************************************************************************************
   + Z, r( T3 W+ I* \* i
3. *    函 数 名: sf_ReadBuffer
   
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   ' F) e, }/ [8 O& R7 [5 ~* x' S% ~0 P
5. *    形    参:      _pBuf : 数据源缓冲区；
   
6. *                _uiReadAddr ：首地址
   
7. *                _usSize ：数据个数, 不能超出芯片总容量
   ( a8 |& R, k) P0 T8 g) M
8. *    返 回 值: 无
   % n" I2 j& G* s$ e* |; p
9. *********************************************************************************************************
   ( I2 L9 R7 G+ [+ c
10. */
    + U& n4 b4 a3 P  k
11. void sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    
12. {
    
13.     uint16_t rem;
    1 T- E* ~( k0 K! h; t
14.     uint16_t i;
    
15. 
    3 k7 G3 p0 n! ^) w
16.     /* 如果读取的数据长度为0或者超出串行Flash地址空间，则直接返回 */
    
17.     if ((_uiSize == 0) ||(_uiReadAddr + _uiSize) > g_tSF.TotalSize)
    
18.     {
    - D' N+ G: P+ {& V! A
19.         return;
    
20.     }
    
21. 
    
22.     /* 擦除扇区操作 */
    
23.     sf_SetCS(0);                                    /* 使能片选 */
    
24.     g_spiLen = 0;
    
25.     g_spiTxBuf[g_spiLen++] = (CMD_READ);                            /* 发送读命令 */
    % X" o. \# ?$ ]- N, H$ G  e; I
26.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    : Y4 K3 a7 y, F# V, t; u
27.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF00) >> 8);        /* 发送扇区地址中间8bit */
    
28.     g_spiTxBuf[g_spiLen++] = (_uiReadAddr & 0xFF);                /* 发送扇区地址低8bit */
    % o" ]7 X9 Q3 Y+ C
29.     bsp_spiTransfer();
    * f/ F* U4 P2 u: u
30. 
    0 s  ?9 C2 I& W* d5 g
31.     /* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
    - h9 v# N$ J) l; }5 Q  ]. i
32.     for (i = 0; i < _uiSize / SPI_BUFFER_SIZE; i++)
    
33.     {
    ( Z$ C# @  y- x. a( H, [
34.         g_spiLen = SPI_BUFFER_SIZE;
    
35.         bsp_spiTransfer();
    
36. 
    
37.         memcpy(_pBuf, g_spiRxBuf, SPI_BUFFER_SIZE);
    9 T; `% ^' R; h$ `2 c
38.         _pBuf += SPI_BUFFER_SIZE;
    & [- W6 a: p% H( t* v" N6 b
39.     }
    
40. 
    
41.     rem = _uiSize % SPI_BUFFER_SIZE;    /* 剩余字节 */
    
42.     if (rem > 0)
    7 p1 _5 Z' z, M7 I2 u8 w
43.     {
    
44.         g_spiLen = rem;
    ) J5 B; X) b0 L
45.         bsp_spiTransfer();
    
46. 
    
47.         memcpy(_pBuf, g_spiRxBuf, rem);
    
48.     }
    
49. 
    + j' _0 u2 n+ ^; K
50.     sf_SetCS(1);                                    /* 禁能片选 */
    4 N8 r! y; Q. _! @' B5 v
51. }

复制代码

这个函数对DMA传输做了特别处理，方便分包进行。
& L/ G- R4 c9 H$ J4 V4 {1 m& i
, M/ C. {1 V+ j' w73.4.6 第6步：W25QXX的扇区擦除实现
$ g. S* p* O5 t. n扇区擦除的实现也比较简单，发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除。擦除的扇区大小是4KB。

; Q9 u. h# d+ W2 B8 T" `

1. /*
   7 ~) J/ V6 ~2 g7 ?) {- V- {
2. *********************************************************************************************************
   
3. *    函 数 名: sf_EraseSector
   : `: X1 [2 C; C0 ]$ p
4. *    功能说明: 擦除指定的扇区
   
5. *    形    参: _uiSectorAddr : 扇区地址
   
6. *    返 回 值: 无
   # @9 R+ r6 ^8 [$ g: F% ^
7. *********************************************************************************************************
   1 `8 \2 t6 j: j0 H8 }
8. */
   
9. void sf_EraseSector(uint32_t _uiSectorAddr)
   + k4 N9 ?, Y6 k' a0 j7 V7 g
10. {
    ( t  ?% z4 s$ {2 s
11.     sf_WriteEnable();                            /* 发送写使能命令 */
    
12. 
    ( `% ]1 S: v- L, ~# k
13.     /* 擦除扇区操作 */
    
14.     sf_SetCS(0);                                /* 使能片选 */
    " m5 |# W0 h) l( P: J
15.     g_spiLen = 0;
    & q& j4 E; ]8 R/ L
16.     g_spiTxBuf[g_spiLen++] = CMD_SE;                /* 发送擦除命令 */
    9 n, A" l' m8 h: E' L$ t
17.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    0 X1 y3 Y. k2 F; _, @; W
18.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF00) >> 8);    /* 发送扇区地址中间8bit */
    
19.     g_spiTxBuf[g_spiLen++] = (_uiSectorAddr & 0xFF);            /* 发送扇区地址低8bit */   
    7 n% N% f$ E4 a' i* A! N
20.     bsp_spiTransfer();
    . y% {* N- f6 j* P8 M4 b/ Z
21.     sf_SetCS(1);                                    /* 禁能片选 */
    6 z- Q& }2 b8 A3 M/ j6 R, Y0 t5 C
22. 
    ; O2 x2 y9 a. h. f( _5 O
23.     sf_WaitForWriteEnd();                            /* 等待串行Flash内部写操作完成 */
    
24. }
    : h# Q! Z7 @, Q

复制代码

8 I$ y6 \! a) b5 W: g
+ h& u0 n- ?+ R/ O整个芯片的擦除更省事些，仅发送整个芯片擦除命令即可：

. m+ ^/ y# E8 V# P- K: w" T% s5 v

1. /*
   4 H. L$ Y( `! H  q/ B- ?
2. *********************************************************************************************************
   
3. *    函 数 名: sf_EraseChip
   ) j4 K( w1 Z7 i6 ~5 g
4. *    功能说明: 擦除整个芯片
   
5. *    形    参:  无
   2 Y; i  W- }3 I$ A0 J" z
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   & s! `& E  y! s8 O: }5 E5 U
8. */
   
9. void sf_EraseChip(void)
   6 y2 \! C8 _# l/ j) ^0 }
10. {   
    6 N; b6 I5 K* b5 S, i0 k& e7 `$ q
11.     sf_WriteEnable();                                /* 发送写使能命令 */
    
12. 
    7 m3 |( n% n9 c* x( }3 {/ a( ^! y
13.     /* 擦除扇区操作 */
    + Q' v" E/ X) ~9 M! L" o
14.     sf_SetCS(0);        /* 使能片选 */
    
15.     g_spiLen = 0;
    
16.     g_spiTxBuf[g_spiLen++] = CMD_BE;        /* 发送整片擦除命令 */
    + P0 ^& b7 a" j$ u% e$ X7 s: _0 o
17.     bsp_spiTransfer();
    $ j+ F( h7 E2 b& D' v: A' g
18.     sf_SetCS(1);                        /* 禁能片选 */
    
19. 
    ; V! C$ k1 j6 s1 Q
20.     sf_WaitForWriteEnd();                /* 等待串行Flash内部写操作完成 */
    
21. }
    

复制代码

73.4.7 第7步：W25QXX的编程实现
W25QXX的编程实现略复杂，因为做了自动擦除支持，大家可以在任意地址，写任意大小的数据，只要不超过芯片容量即可。我们这里就不做展开讨论了，大家有兴趣可以研究下：
2 p$ ]+ l+ ?5 t5 r

1. /*
   
2. *********************************************************************************************************
   * ^) S: H% Z& \) M8 `
3. *    函 数 名: sf_WriteBuffer
   - c& l: E" r" k* F' [! r- \
4. *    功能说明: 写1个扇区并校验,如果不正确则再重写两次，本函数自动完成擦除操作。
   * B2 R9 R: ]/ m* N5 }* m  R
5. *    形    参:  _pBuf : 数据源缓冲区；
   
6. *               _uiWrAddr ：目标区域首地址
   * }3 |/ F+ ~- s* l0 u1 i0 ^
7. *               _usSize ：数据个数，任意大小，但不能超过芯片容量。
   
8. *    返 回 值: 1 : 成功， 0 ： 失败
   % a9 Y* v) _( O0 q& e$ f
9. *********************************************************************************************************
   ! `! y4 I  S( Z; @3 x9 b& i
10. */
    9 O  Q& q' k8 m4 d% [. I* X
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. 
    9 f5 c7 L- p- l- p/ }% N
15.     Addr = _uiWriteAddr % g_tSF.SectorSize;
    
16.     count = g_tSF.SectorSize - Addr;
    $ `' g3 X& o8 A3 {! M. a
17.     NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    ( |- y' g3 a( ~7 |# L" J6 C
18.     NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    
19. 
    
20.     if (Addr == 0) /* 起始地址是扇区首地址  */
    ( y' R4 F9 U; R/ T# x
21.     {
    
22.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    4 H6 U- K" g8 Y
23.         {
    
24.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    " o3 F8 W% J( X' `! ^5 P
25.             {
    $ @# g/ r( d( v, a/ |
26.                 return 0;
    
27.             }
    
28.         }
    * ]* j% l' m& C4 \
29.         else     /* 数据长度大于等于扇区大小 */
    6 P7 y5 _$ ^" l) x; Q# n* M: W) H' ~0 Y
30.         {
    3 b+ f$ d# ^6 h8 T/ P5 l
31.             while (NumOfPage--)
    * |4 d4 i2 ]! S( d( j& a
32.             {
    
33.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    
34.                 {
    * T" Y& j: a6 e: N
35.                     return 0;
    4 g# U+ V& |6 N: `: Q
36.                 }
    
37.                 _uiWriteAddr +=  g_tSF.SectorSize;
    
38.                 _pBuf += g_tSF.SectorSize;
    
39.             }
    
40.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
    
41.             {
    
42.                 return 0;
    ; F. [' r/ W. u; d' t- |# X$ K
43.             }
    3 S4 |  X! w  }( s; l1 \) r! J$ M
44.         }
    
45.     }
    2 f' J: \( T+ _; Q
46.     else  /* 起始地址不是扇区首地址  */
    
47.     {
    
48.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    / Y6 J6 w, x2 f" \; H5 A+ k5 H
49.         {
    * ]9 l$ p( F* @, }- i  u
50.             if (NumOfSingle > count)  /* (_usWriteSize + _uiWriteAddr) > SPI_FLASH_PAGESIZE */
    
51.             {
    
52.                 temp = NumOfSingle - count;
    & a. B1 Y+ S% Y( h
53. 
    
54.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    ! S( r. B- r$ @$ \
55.                 {
    2 @' N( V' u( u8 L6 B
56.                     return 0;
    
57.                 }
    
58. 
    % v& S' |+ @/ G5 a' w
59.                 _uiWriteAddr +=  count;
    ! C  j" O- b. ]7 A# P4 R1 w6 I1 A
60.                 _pBuf += count;
    : \$ Y: S2 A: f/ ^6 V' a
61. 
    
62.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, temp) == 0)
    ' R; Z# k& N# d! v8 F
63.                 {
    
64.                     return 0;
    ( D! f/ w4 r. c# d' d% L' _- S/ l
65.                 }
    ' y) a0 T& g! K3 \* Q- d. ^
66.             }
    
67.             else
    
68.             {
    + i8 H* ~- @3 p+ B& m
69.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    ! _! V+ E, {: @
70.                 {
    
71.                     return 0;
    
72.                 }
    . Y# ?3 [1 J0 H* x4 v) c; B" u1 B
73.             }
    $ C+ h' ?! P4 S3 b
74.         }
    , g+ `# M- U8 ~7 i& w
75.         else    /* 数据长度大于等于扇区大小 */
    : ~" A1 G+ J! n8 `2 V! R* ]
76.         {
    ) z( |) g  C/ X1 Z  m; B9 x4 f: l* O9 P
77.             _usWriteSize -= count;
    
78.             NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    / z0 {# x; Q& M: K3 y# i
79.             NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    1 |# k; Q# J9 s  U
80.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    
81.             {
    
82.                 return 0;
    
83.             }
    
84. 
    9 ]8 h4 v! ]1 }* H
85.             _uiWriteAddr +=  count;
    
86.             _pBuf += count;
    
87. 
    
88.             while (NumOfPage--)
    
89.             {
    7 W9 g5 w" T3 }& l6 b9 `/ l* V* W
90.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    
91.                 {
    : p8 V7 A* D& }8 {9 I
92.                     return 0;
    
93.                 }
    5 L4 i; u5 o% E( O) W& x9 Z
94.                 _uiWriteAddr +=  g_tSF.SectorSize;
    5 }7 u) l' o8 X( \
95.                 _pBuf += g_tSF.SectorSize;
      Q* V1 O$ C2 Y* F
96.             }
    
97. 
    
98.             if (NumOfSingle != 0)
    
99.             {
    + Z; O$ G& R% b8 `& A4 o
100.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
     
101.                 {
     
102.                     return 0;
     
103.                 }
     
104.             }
     
105.         }
     
106.     }
     
107.     return 1;    /* 成功 */
     
108. }

复制代码

9 ?9 g5 Y6 w) S6 P" Y& h73.5 SPI总线板级支持包（bsp_spi_bus.c）
" ^7 j( P1 ]- G& f# F7 _' \SPI总线驱动文件bsp_spi_bus.c主要实现了如下几个API供用户调用：
9 j" C+ V* m/ d+ S4 }
  bsp_InitSPIBus
  bsp_InitSPIParam
3 N* F2 v9 i2 k2 _+ F( Q  bsp_spiTransfer
73.5.1 函数bsp_InitSPIBus
) I3 {, X0 @3 y! ~( x1 l9 t函数原型：
( d, }/ s6 N+ e- ?: U
void bsp_InitSPIBus(void)

6 L1 z1 \' p2 _8 [% H% v7 G函数描述：
8 p7 l2 l% {" J" j+ r9 X
此函数主要用于SPI总线的初始化，在bsp.c文件调用一次即可。

) |& k. P) P% Z7 B( X( a: ?- Y( x73.5.2 函数bsp_InitSPIParam
! B/ S# M& d( E函数原型：
* ^  u  m7 g5 Q, b! _
void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)

1 W0 E) @1 v, p* S函数描述：

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

9 _! P- W' }8 n* N7 P, Y函数参数：

* V9 R$ e+ l: s0 A  第1个参数SPI总线的分频设置，支持的参数如下：
: ?% G. I% ~1 HSPI_BAUDRATEPRESCALER_2    2分频

SPI_BAUDRATEPRESCALER_4    4分频
. O/ P" J. G# ?; U: `8 c# U
# Y# i: k1 R" X, T+ m* m; lSPI_BAUDRATEPRESCALER_8    8分频

SPI_BAUDRATEPRESCALER_16   16分频
7 {7 a) W4 l! k8 Z' L9 b
SPI_BAUDRATEPRESCALER_32   32分频

SPI_BAUDRATEPRESCALER_64   64分频

SPI_BAUDRATEPRESCALER_128  128分频
2 f( G  z3 X% T
/ `% K5 O; F  G2 P. {% I( h3 T  OSPI_BAUDRATEPRESCALER_256  256分频

  第2个参数用于时钟相位配置，支持的参数如下：
. X- v  P/ w9 r# d9 xSPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据

: |# w% X7 L- A! Q  R3 w, G0 S% SSPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据

( @, f$ v# c1 p* O3 w  第3个参数是时钟极性配置，支持的参数如下：
SPI_POLARITY_LOW   SCK引脚在空闲状态处于低电平

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

* ?3 }  J! {5 n* z* _. i73.5.3 函数bsp_spiTransfer
函数原型：

void bsp_spiTransfer(void)
. W0 _0 I: z) @, a6 O; ^
% ]7 k0 {( _9 E* `) Y函数描述：

此函数用于启动SPI数据传输，支持查询，中断和DMA方式传输。

1 G5 p: a+ N6 K- m3 u( S73.6 W25QXX板级支持包（bsp_spi_flash.c）
  {% p# [9 A2 e; E- {" FW25QXX驱动文件bsp_spi_flash.c主要实现了如下几个API供用户调用：

) Q: S  ?- p: N* m! E  sf_ReadBuffer
  sf_WriteBuffer
, K7 b) C; \! N9 }; }5 G3 i! E  sf_EraseSector
  sf_EraseChip
  sf_EraseSector
5 Y" |* p3 g1 z+ ]: K% d. C73.6.1 函数sf_ReadBuffer
函数原型：
% Z' S; ?( V. o6 \: D, k' K
  L7 O3 k" q: v: d9 T, w/ t( zvoid sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)

: K2 a0 x3 S" e函数描述：

此函数主要用于从SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。
" R6 N( ~' N6 Y& I
& r( G& o1 }* P4 Q) S8 `2 m函数参数：
! Q3 q1 F0 Z1 \9 }9 r- V( V
7 \5 q% S, L; f9 [# V  第1个参数用于存储从SPI Flash读取的数据。
  第2个参数是读取地址，不可以超过芯片容量。
5 M1 e- x( L: p* w: f* _( |  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
73.6.2 函数sf_WriteBuffer（自动执行擦除）
函数原型：
! ^, T3 \" j& n. k: [- V& ]
+ W) t8 P1 O& g$ [uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)

函数描述：

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

  T" M/ q) s1 d! k3 j  U函数参数：

  第1个参数是源数据缓冲区。
  第2个参数是目标区域首地址。
  第3个参数是数据个数，支持任意大小，但不能超过芯片容量。单位字节个数。
. j! o6 }$ f0 a0 L! {( D+ I  返回值，返回1表示成功，返回0表示失败。
73.6.3 函数sf_EraseSector
函数原型：
, ^6 _: C5 \7 p& A/ x+ p2 j5 z
- `0 B. g  Q1 X7 u! M9 Lvoid sf_EraseSector(uint32_t _uiSectorAddr)

- k& V8 g7 v6 m/ v$ ^函数描述：

此函数主要用于扇区擦除，一个扇区大小是4KB。
4 u" b0 S4 T1 @0 r# K% t5 B" T  g
函数参数：
; M/ C: ~& c/ K- l( I  u
& E4 h! N2 @5 l+ h; V* N+ `  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
73.6.4 函数sf_EraseChip
0 S- x& z9 A& W; b% u' ]# J函数原型：

$ q9 M/ y/ V7 D5 g5 V6 Evoid sf_EraseChip(void)

7 K& ]  n+ S: L' w. l0 ]函数描述：
: i9 D" W$ A6 |3 ?: k3 E0 k
此函数主要用于整个芯片擦除。
8 ^3 ?% O! s/ j" {% `: P; q
73.6.5 函数sf_PageWrite（不推荐）
函数原型：

void sf_PageWrite(uint8_t * _pBuf, uint32_t _uiWriteAddr, uint16_t _usSize)
! E+ {% ]9 K' P  v3 w  O
/ s, V) Y; f% \2 u6 F9 x3 _# B函数描述：

此函数主要用于页编程，一次可以编程多个页，只要不超过芯片容量即可。不推荐大家调用此函数，因为调用这个函数前，需要大家调用函数sf_EraseSector进行扇区擦除。

函数参数：
8 @+ R+ b, d; ^
  第1个参数是数据源缓冲区。
  第2个参数目标区域首地址，比如编程页0，此处填0x0000，编程页1，此处填0x0100，编程页2，此处填0x0200，以此类推。
3 ?1 e. j# R  a$ o& f% Q  第3个参数是编程的数据大小，务必是256字节的整数倍，单位字节个数。
73.7 W25QXX驱动移植和使用
, q; L+ P: L& \; ~0 e. S3 vW25QXX移植步骤如下：

/ F# z! C' l1 s; y, q3 X  第1步：复制bsp_spi_bus.c，bsp_spi_bus.h，bsp_spi_flash.c，bsp_spi_flash.h到自己的工程目录，并添加到工程里面。
' g: T' ?4 w' Q1 i* B9 R2 j8 T' m. g  第2步：根据使用的第几个SPI，SPI时钟，SPI引脚和DMA通道等，修改bsp_spi_bus.c文件开头的宏定义
+ ^- \% j* D+ _) o0 v6 s0 N9 e

1. /*
   
2. *********************************************************************************************************
   % Y2 Q- r' O7 `; t" q
3. *                                时钟，引脚，DMA，中断等宏定义
   % u' D. h& e8 \9 u7 {& _
4. *********************************************************************************************************
   4 b) G, Q4 P6 K/ D. c) O+ h
5. */
   % Z- B/ L& @' {6 d' [) V* }$ o
6. #define SPIx                            SPI1
   9 K" W6 q" q7 i+ F+ H) k/ R  u: e
7. #define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
   
8. #define DMAx_CLK_ENABLE()                __HAL_RCC_DMA2_CLK_ENABLE()
   " z: ?: n" S) o7 q
9. 
   
10. #define SPIx_FORCE_RESET()                __HAL_RCC_SPI1_FORCE_RESET()
    + X$ g! {. o! E3 B7 r2 U8 h, X
11. #define SPIx_RELEASE_RESET()            __HAL_RCC_SPI1_RELEASE_RESET()
    
12. 
    
13. #define SPIx_SCK_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    6 L; ~! z5 ~5 _* I8 H8 ?# X
14. #define SPIx_SCK_GPIO                    GPIOB
    9 V8 i  A' [0 k& C$ o; |0 r
15. #define SPIx_SCK_PIN                    GPIO_PIN_3
    
16. #define SPIx_SCK_AF                        GPIO_AF5_SPI1
    1 j: w+ F0 l& S* V6 o
17. 
      O0 A' Y' ?( R: B4 |0 j
18. #define SPIx_MISO_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    ( S2 W, ~3 W! O1 }/ ]9 h9 s5 ~& j
19. #define SPIx_MISO_GPIO                    GPIOB
    
20. #define SPIx_MISO_PIN                     GPIO_PIN_4
    
21. #define SPIx_MISO_AF                    GPIO_AF5_SPI1
    
22. 
    
23. #define SPIx_MOSI_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    - Y" b- m, [) B  d, W
24. #define SPIx_MOSI_GPIO                    GPIOB
    
25. #define SPIx_MOSI_PIN                     GPIO_PIN_5
    
26. #define SPIx_MOSI_AF                    GPIO_AF5_SPI1
    
27. 
    + A7 \- k$ i; g3 K6 Q: x
28. #define SPIx_TX_DMA_STREAM               DMA2_Stream3
    
29. #define SPIx_RX_DMA_STREAM               DMA2_Stream2
    
30. 
    
31. #define SPIx_TX_DMA_REQUEST              DMA_REQUEST_SPI1_TX
    . j) Y. H1 e) V! K- {: t# L
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
    # v+ `: [1 ^! C8 x# P" {! E
36. 
    
37. #define SPIx_DMA_TX_IRQHandler           DMA2_Stream3_IRQHandler
    
38. #define SPIx_DMA_RX_IRQHandler           DMA2_Stream2_IRQHandler
    , x4 I# v0 s. D7 R2 `3 P
39. 
    
40. #define SPIx_IRQn                        SPI1_IRQn
    7 G% C. [( U# D" r
41. #define SPIx_IRQHandler                  SPI1_IRQHandler
    

复制代码

  第3步：根据使用的SPI ID，添加定义到文件bsp_spi_flash.h

1. /* 定义串行Flash ID */
   5 `5 F  f4 f" x) E. y, ~
2. enum
   % G% W( _7 y$ ~# J8 I
3. {
   
4.     SST25VF016B_ID = 0xBF2541,
   4 {( K, W( u- P
5.     MX25L1606E_ID  = 0xC22015,
   . ], i3 N2 b" C& i9 D
6.     W25Q64BV_ID    = 0xEF4017, /* BV, JV, FV */
   
7.     W25Q128_ID     = 0xEF4018
   " r  M0 D4 L6 L# f) {+ z2 p6 _
8. };

复制代码

  第4步：添加相应型号到bsp_spi_flash.c文件的函数sf_ReadInfo里面。
) U0 l  f$ |/ x! d* |

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_ReadInfo
   8 s+ N# ?+ C0 U
4. *    功能说明: 读取器件ID,并填充器件参数
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   % }* T3 n% P% T6 q
7. *********************************************************************************************************
   
8. */
   * I# v. M9 y8 I# }: b3 G
9. void sf_ReadInfo(void)
   
10. {
    
11.     /* 自动识别串行Flash型号 */
    
12.     {
      E' n9 i7 p; J# U
13.         g_tSF.ChipID = sf_ReadID();    /* 芯片ID */
      y$ I) n% ~/ X) V* l
14. 
    
15.         switch (g_tSF.ChipID)
    3 V8 i$ Q* q( a& H
16.         {
    
17.             case SST25VF016B_ID:
    
18.                 strcpy(g_tSF.ChipName, "SST25VF016B");
    
19.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    " h7 v3 r. i9 g# K" s) ]8 u
20.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
21.                 break;
    
22. 
    : b! T+ W" ~2 m- o0 o+ i0 r
23.             case MX25L1606E_ID:
    ! G8 ^' f- q' b- z/ U3 v1 j
24.                 strcpy(g_tSF.ChipName, "MX25L1606E");
    # F* L  S0 w2 }/ d( H
25.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    " D) }/ H2 v( d; j
26.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
27.                 break;
    + x2 U  @- `6 L' @! b+ }+ S
28. 
    . _& k, B) n) k! n8 O# o
29.             case W25Q64BV_ID:
    - B- s& D% e! Z4 z( e% J* o
30.                 strcpy(g_tSF.ChipName, "W25Q64");
    
31.                 g_tSF.TotalSize = 8 * 1024 * 1024;    /* 总容量 = 8M */
    
32.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
33.                 break;
    8 B+ ?1 i$ C9 Q0 }. [' d# t, \
34. 
    6 D% i0 H5 W8 u; z/ p; Y
35.             case W25Q128_ID:
    ' a4 G/ u1 L7 v& G' Q- q! \
36.                 strcpy(g_tSF.ChipName, "W25Q128");
      q/ R+ e1 q9 y; L' O
37.                 g_tSF.TotalSize = 16 * 1024 * 1024;    /* 总容量 = 8M */
    ( J  a2 G6 K1 `' d$ {# ~, ?
38.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
39.                 break;            
    ' q! j4 c  m- B: U! \
40. 
    7 F6 K0 t0 h3 Z: ~- c7 [
41.             default:
    
42.                 strcpy(g_tSF.ChipName, "Unknow Flash");
    " `# l3 u# B2 s- M2 c" ~! R: F5 O* b1 B
43.                 g_tSF.TotalSize = 2 * 1024 * 1024;
    8 W% K( Q4 U, Z' {  ?
44.                 g_tSF.SectorSize = 4 * 1024;
    , ~: E  {" w# ]/ Q, S
45.                 break;
    
46.         }
    , ^$ U6 h/ i7 B; Y8 @
47.     }
    ! T  K- H0 E- h: o9 {' W
48. }

复制代码

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

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_SetCS
   $ ?6 x+ L8 t& ]. _: o
4. *    功能说明: 串行FALSH片选控制函数
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ' ?+ X$ x# Z1 N; f1 `$ O& [) q
9. void sf_SetCS(uint8_t _Level)
   . L% e1 B' g& S  ?. v$ K
10. {
    3 P( |* G5 `+ r
11.     if (_Level == 0)
    $ G% R& G; S7 F
12.     {
    , `; D4 x* Y1 |* e/ L. v% J) s
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    " j4 Z9 o: b; U8 r
15.         SF_CS_0();
    & [; H0 i! B( B. v
16.     }
    
17.     else
    * v4 ?  w4 J9 [# r
18.     {        
    9 Z8 ]! |# b/ W7 P# W( j
19.         SF_CS_1();   
    
20.         bsp_SpiBusExit();        
    
21.     }
    ! `, s% r( o, q7 L4 B! e
22. }

复制代码

; h) T( m. b2 X9 p4 p, b& ]! ^; M  第6步：根据使用的SPI Flash片选引脚修改bsp_spi_bus.c文件开头的宏定义。
  s6 T: J* @* ]; m* x7 t7 ?

1. /* 串行Flash的片选GPIO端口， PD13  */
   
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
   
5. 
   - s% h. B% N3 p! y. V/ s0 l
6. #define SF_CS_0()                    SF_CS_GPIO->BSRR = ((uint32_t)SF_CS_PIN << 16U)
   0 V: E+ h+ T3 I
7. #define SF_CS_1()                    SF_CS_GPIO->BSRR = SF_CS_PIN

复制代码

  第7步：如果使用DMA方式的话，请不要使用TCM RAM，因为通用DMA1和DMA2不支持。并为了防止DMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭Cache处理，比如使用的SRAM4：
" r! e9 s; O3 `5 O( S

1. /* 配置SRAM4的MPU属性为Non-cacheable */
   
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   - ]1 {. `) `. g+ S0 d7 h# ]5 _8 P5 c
3. MPU_InitStruct.BaseAddress      = 0x38000000;
   
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   ; g' _% d' O# P& n7 u% x5 C* G+ V! _0 q
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   8 l5 y/ U7 i5 F0 h
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   ( B# F" g% h% ^
7. MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   
8. MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9. MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   9 H' e$ I/ K; h; |- ^. y( l  S
10. MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
11. MPU_InitStruct.SubRegionDisable = 0x00;
    
12. MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ' P7 N5 E- ?8 S# b) V0 u& E* t- b! p
13. 
    ) E+ Q7 p. U! ~5 r7 _) A
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

  第8步：初始化SPI。

1. /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
     E) J1 }: F2 [8 h, W
2. bsp_InitSPIBus();    /* 配置SPI总线 */        
   & o, U* g4 D6 P* h2 D/ p
3. bsp_InitSFlash();    /* 初始化SPI 串行Flash */

复制代码

! O" o; g: i3 }- [  第9步：SPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第10步：应用方法看本章节配套例子即可。
  P6 h2 s  _4 ?73.8 实验例程设计框架
3 S3 L8 h3 K" b通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

* j5 l8 u, g3 J) u* B

1 A7 n1 ?! L) I5 K! F, N* L  第1阶段，上电启动阶段：

! M0 b6 `# H/ g, L: }$ ?; Z- S这部分在第14章进行了详细说明。
, @3 V" l5 B8 ?5 K& R  J6 ^% D0 v  
  V" f9 ~$ K9 Y; x  X9 Y第2阶段，进入main函数：
% M! K, f1 p4 ]* P2 k/ |
) W. w+ I5 ?' B: m: g( z2 X" @第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现SPI Flash的中断，查询和DMA方式操作。
9 o/ j4 N4 i; X/ U) h
3 R) w1 P: _% X7 m73.9 实验例程说明（MDK）
配套例子：

) v/ d# G( l9 q( vV7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）
# ~, K5 ~  f  k% f# _! p. j
& S0 I; f2 h6 G4 ^V7-050_串行SPI Flash W25QXX读写例程（DMA方式）
& c! R4 X+ T& k
V7-051_串行SPI Flash W25QXX读写例程（中断方式）

实验目的：
. C; C1 |+ t$ A4 A! m
学习SPI Flash的读写实现，支持查询，中断和DMA方式。
& a% p$ i& d. d& Y$ i3 t2 o
8 |7 q  M8 M7 y$ @' T6 n) s7 i0 R实验操作：
: x6 m- e6 e/ ^( }$ l& R8 F0 ]
支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
( y' \% H' Y) d6 q5 H! eprintf("请选择操作命令:\r\n");
3 S1 p0 n, b, c) i8 l* Wprintf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
3 H4 [* l, R% Zprintf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
: ?) l( z1 ]2 }% F$ ]- E7 a, eprintf("【3 - 擦除整个串行Flash】\r\n");
. S, X9 Z8 D9 p' i* i3 mprintf("【4 - 写整个串行Flash, 全0x55】\r\n");
printf("【5 - 读整个串行Flash, 测试读速度】\r\n");
0 e) P; B& c0 X. A8 C2 Zprintf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
* G# J2 s. b" C6 Sprintf("其他任意键 - 显示命令提示\r\n");
6 ~" i* `: ]! g( i- o上电后串口打印的信息：
* u) z* n. J1 Z3 E9 T5 q$ K
7 U0 B$ O/ j5 {+ R' h( k波特率 115200，数据位 8，奇偶校验位无，停止位 1。

9 s4 Q' U! y2 [" f; B  F# A; H
- v" Q: X& A4 p5 j) P程序设计：
; \  m- X) G3 d* E7 s  J
  系统栈大小分配：
  Z4 m  ]7 x/ t7 h9 y7 n: a7 Z( ^% L+ `

; e" r/ d* E' e( Y  \9 K. W0 ?- F  RAM空间用的DTCM：
. Y7 n4 y& K5 u

  硬件外设初始化
0 L- G% ?6 [  Y2 i% Y# L2 ?
硬件外设的初始化是在 bsp.c 文件实现：
! j, n/ K6 H( y0 e; K3 c

1. /*
   1 N% g0 E0 ?% c3 N
2. *********************************************************************************************************
   # A7 \5 ], O/ M& m
3. *    函 数 名: bsp_Init
   " A( O% z: b5 z% O( m$ h
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   4 L3 Z; p; ~# s
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   & ]9 d1 i& v9 t" [* H1 T5 B/ H
8. */
   
9. void bsp_Init(void)
   8 l3 Y  Z4 R7 `: d7 j1 H
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    9 ^9 K5 e8 q; N3 o/ g. ?; V
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    $ r8 l# L0 N$ s: c8 `' i
22.     HAL_Init();
    
23. 
    / h9 t6 W1 t( m4 N
24.     /*
    # ]4 x2 S3 I" `3 q3 ~; Y  b
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    6 u( d7 u: {1 l% X0 X4 i) ]
28.     */
    
29.     SystemClock_Config();
    
30. 
    ' V+ e8 U3 N: [1 m, k9 q- D
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    ; h) I1 a; m0 b2 ?" d% Z
36. #if Enable_EventRecorder == 1  
    ) G  F! ?2 {3 B! u0 {
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    ; P) d; x4 l6 w; }& [
39.     EventRecorderStart();
    
40. #endif
    5 G/ g; Z: |1 [2 J/ w4 O+ `8 Z
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    $ B7 n- L! p$ o; G/ A) _! Y7 r
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    2 `& x  b5 b# x
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();         /* 初始化LED */   
    1 F3 }1 c/ K' H
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. 
    
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    $ v$ i4 J+ y" \' [
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    $ H) C, @' f- r) c( s5 H6 Y; |
53. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区以及SRAM4
8 y4 t, s. u3 u- N$ o, `, d  z
2 I+ }. p( p4 l6 f3 Q

1. /*
   
2. *********************************************************************************************************
   5 \6 N; L, {% @
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   . D8 r3 w' y' u/ o/ `7 l9 d
5. *    形    参: 无
   6 u( X: U+ B) b4 K3 g3 s" `% V. i& H
6. *    返 回 值: 无
   ( D. \2 o! s0 M- F6 l$ _
7. *********************************************************************************************************
   * s5 r( `& R% a
8. */
   5 j& N0 g: g, _  L6 ?
9. static void MPU_Config( void )
   
10. {
    + W! G7 q- m2 s' ^4 s8 I# K: M$ H
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    , s+ B. d6 c* @: T3 g8 h
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    + Q5 |: g& [9 A4 Q8 R( l( @
15. 
    7 Z  B' c* X9 r
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    & V+ y, _  v/ D; ?( M
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    6 @& [; m0 y# |
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    3 L* G7 c1 k/ w& N% S
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    - }7 y8 F" d0 H7 c1 Q9 z
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    2 h& h% P2 y) Q
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    8 s4 g% k3 c3 m  }  w2 S0 W/ M
31. 
    3 W5 \' G) O1 w! S
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; F6 r4 ^/ h% s  x+ B
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
      {3 c' g7 {" x* W# @# ]
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    $ y0 S( k& f# B: y, R
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    ; F% N7 t$ h3 `; b$ l$ {& J
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    8 F& c4 Y, w4 S( e; {$ 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);
    
46. 
    8 f+ N3 F# W+ M+ }( w
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    * O! Q2 r1 s. X4 i; ?) v
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; T2 d' _: A0 f. P2 R* P
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    % O% d- e& _4 w' |& R
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    & }/ Z3 t) K1 p7 _* A: Z" }" m
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    9 \3 M4 F$ C( k9 |7 k
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 u2 D- X& ]. f$ C* }7 i
61. 
    ( y5 W% v) p1 L7 I
62.     /*使能 MPU */
    
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    . [! z& M6 Z8 W) E5 B
64. }
    2 T6 D& g( Z" j9 b" R/ i  r1 R6 B
65. 
    ) k2 v0 A/ L5 m; }& I5 _" F. k& n
66. /*
    
67. *********************************************************************************************************
    8 ?' a2 T  v3 R
68. *    函 数 名: CPU_CACHE_Enable
    ( ?- l- L0 \/ i& u# \" e. U  l
69. *    功能说明: 使能L1 Cache
    + g# Y% s4 z7 M5 l- c5 ]
70. *    形    参: 无
    ; q( ^  g# w3 w; H" @
71. *    返 回 值: 无
    ! b: Y$ T9 }6 c/ ~9 y1 j0 ~
72. *********************************************************************************************************
    ! ]. w/ N) y" M5 p
73. */
    
74. static void CPU_CACHE_Enable(void)
    
75. {
    * x/ D; t5 s5 z2 R! `" v9 p
76.     /* 使能 I-Cache */
    
77.     SCB_EnableICache();
    
78. 
    
79.     /* 使能 D-Cache */
    
80.     SCB_EnableDCache();
    6 [4 T/ }: ~+ `, K) [# H
81. }

复制代码

2 U' `) D% j. C7 P' D% z( \  每10ms调用一次按键处理：
$ ]" w4 ?# [" F6 M
按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   ) E' J4 j. C6 J1 @; S- q9 G2 _
2. *********************************************************************************************************
   - `1 a& l! q3 j- V. n7 E' S
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   , j- m. A/ v- P
6. *    形    参: 无
   2 r  ?% j5 ^5 }, d8 e9 w
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   ( u1 w2 G. u3 x( ?
9. */
   
10. void bsp_RunPer10ms(void)
      k& r( n# S4 }6 K$ c
11. {
    1 b, E. j( A3 ]* F
12.     bsp_KeyScan10ms();
    5 D$ R% s9 @8 F- t+ r' {* F
13. }
    1 v+ k# E" f9 h8 F
14. 
    

复制代码

  主功能：

+ r* v+ W  n& V$ G8 q+ W- z& h主程序实现如下操作：
, D* i# ?% a/ y8 ?9 B3 z
+ S7 w) ?8 B" y* s- y  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
  1 - 读串行Flash
( }3 O, L* X6 r/ j' u  2 - 写串行Flash
  3 - 擦除整个串行Flash
- s! |7 d: ^4 V4 k8 I  4 - 写整个串行Flash
  5 - 读整个串行Flash
  Z - 读取前1K
  X - 读取后1K
  s# b, t/ v0 U6 o$ D* F

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: DemoSpiFlash
   , n" H$ ~2 F4 M& L
4. *    功能说明: 串行EEPROM读写例程
   
5. *    形    参：无
   ( u) N  D; g; m+ `. G9 t
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   " F* R! v$ n, A* N
8. */
   0 B0 G/ T7 J/ K' H( @
9. void DemoSpiFlash(void)
   8 e% ~- a; c+ p$ c7 l6 P* H+ M6 o
10. {
    
11.     uint8_t cmd;
    + c9 @7 S' P% t# V/ b) {" P2 r
12.     uint32_t uiReadPageNo = 0;
    4 i& `" s& x2 [& |* s3 m! Q# {
13. 
    # J1 f, s9 \; c6 r; \7 b) E% i
14. 
    - s( _8 w' ~# a
15.     /* 检测串行Flash OK */
    
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    # U' f3 }, y/ u& \; x; V
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    
18. 
      Q. U  a+ N) S* n  \0 ]6 p
19.     sfDispMenu();        /* 打印命令提示 */
    0 [0 C# ?, E! R1 X1 C9 A
20. 
    
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    ! o; _0 s! r7 |  {( E
22. 
    
23.     while(1)
    
24.     {
    ( Y! l2 J/ r' y& P' i" N
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    # T" j+ i! A+ m& _- s
26. 
    
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
    
29.         {
    
30.             /* 每隔100ms 进来一次 */  
    
31.             bsp_LedToggle(2);
    
32.         }
    6 Y+ D2 P  b: P: a
33. 
    - i/ s: C. n3 S# H4 ]; ]1 B2 s
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    * n' @& l( J. ^
35.         {
    * W8 b- R( p7 K7 z2 c
36.             switch (cmd)
    + S( R+ D, M* V+ R" s
37.             {
    
38.                 case '1':
    
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    % q% \) i; y& _1 N( T
41.                     break;
    
42. 
    
43.                 case '2':
    3 @( V( h! `& @9 ~
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
      ?" H& Q. r& }0 c; `8 ~% a
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    ; K* d6 n1 e6 a, e5 B! j
47. 
    " e  `: x4 q- z5 j/ g6 m: ^6 |
48.                 case '3':
    
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    / S  I9 c4 e5 r* v. E% K9 {' ~$ _
52.                     break;
    3 H5 q3 m4 y& Z" }5 N
53. 
    
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    + }8 O) B& P2 K% ~, L
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
      y6 i6 h: k5 q- ~# q
58.                     break;
    * k, ?+ T8 P% F5 x# c0 z
59. 
    
60.                 case '5':
    , s5 h, k% S3 l" g5 m. J
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    2 ^3 `* I! j1 c3 f" \% ?- h! f
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
63.                     break;
    , n1 I! O2 l0 n% ]
64. 
    $ J/ X2 l& V. L" p" i' j
65.                 case 'z':
    
66.                 case 'Z': /* 读取前1K */
    $ `0 v0 n' O% x7 z- g6 ?, o
67.                     if (uiReadPageNo > 0)
    " R. f1 z) ?! b: _5 e: q6 @( G+ h
68.                     {
    
69.                         uiReadPageNo--;
    6 q% W; d3 O/ D; |2 _8 D
70.                     }
    
71.                     else
    
72.                     {
    
73.                         printf("已经是最前\r\n");
    5 d* ~( {  X, J7 R+ R: [. n
74.                     }
    
75.                     sfViewData(uiReadPageNo * 1024);
    
76.                     break;
    0 [2 ~/ o" s# U
77. 
    / N$ X2 I/ O. e! f
78.                 case 'x':
    
79.                 case 'X': /* 读取后1K */
    & H' C0 R" D6 r$ A# U" e0 t9 B5 T
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    0 l* }6 Y& B- P; ^5 T
81.                     {
    
82.                         uiReadPageNo++;
    , J2 q- p  {! _6 S( `* Q. T0 h$ T
83.                     }
      I$ w7 H* P5 Z1 F* A- |
84.                     else
    
85.                     {
    : U( @3 G/ R# F' {# X
86.                         printf("已经是最后\r\n");
    ; L6 C* O+ f& E+ O3 o) ~9 Q  Z
87.                     }
    - a8 b% z' F; e9 o+ J& `
88.                     sfViewData(uiReadPageNo * 1024);
    + N8 F) M, A7 K; c+ X
89.                     break;
    
90. 
    7 a% m" T7 T$ G
91.                 default:
    3 ^( M* i# O0 F4 h2 n5 m% V
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    : P8 S) E! V. Z1 A& U$ v! L( W! s
94. 
    * I/ P( }& \% ~' ^4 y
95.             }
    
96.         }
    8 F+ b% x) C+ m
97.     }
    
98. }

复制代码

6 n: x* ?$ G8 |73.10          实验例程说明（IAR）
( j3 F+ I# b: t配套例子：

V7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）
5 }9 V. S6 N6 Q% N4 B. h
V7-050_串行SPI Flash W25QXX读写例程（DMA方式）

V7-051_串行SPI Flash W25QXX读写例程（中断方式）

+ D1 T! t$ \7 ]) e: h. a' @实验目的：
! N$ @5 ?! n( W% Q* Z
5 r, G* v8 e1 j学习SPI Flash的读写实现，支持查询，中断和DMA方式。

实验操作：
5 T, A8 K7 }1 m: V# m
支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
printf("请选择操作命令:\r\n");
+ ]$ ?) {0 A. c. ?printf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【3 - 擦除整个串行Flash】\r\n");
# h+ N( R3 u# `* E( T- rprintf("【4 - 写整个串行Flash, 全0x55】\r\n");
printf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
, P6 b3 s8 S7 f6 Bprintf("【X - 读取后1K，地址自动增加】\r\n");
printf("其他任意键 - 显示命令提示\r\n");

上电后串口打印的信息：
. r  K. O7 F/ a% B* J; B
波特率 115200，数据位 8，奇偶校验位无，停止位 1。
6 {& t9 l9 z8 z  a, b
# h9 R0 L, u3 Z$ i3 d: C) x5 U: Q3 v

程序设计：
& V  F$ a* ?1 w
  系统栈大小分配：

. q5 ^7 L( T$ v1 ?3 S: T

  RAM空间用的DTCM：

% g* D7 d1 b7 o9 `6 [9 T; T' J! e  硬件外设初始化
+ z$ \4 ?- C  s2 Z( A
: e. I( {4 ~! [: S0 R硬件外设的初始化是在 bsp.c 文件实现：
5 e6 i9 S, x/ Q4 O
( V  n6 l7 g' x

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

复制代码

  MPU配置和Cache配置：
5 B' o6 n$ x5 B
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   6 M& X. D# H0 S# a7 Q
2. *********************************************************************************************************
   ) T2 b5 D8 r3 U( |
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   ' g( v, @8 P7 c# j/ K
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   8 w7 D4 b* R  C# Q3 b+ O$ M
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    ) g' X2 U6 E% C
12. 
    . p! t# W6 }3 h( _  D8 z! t
13.     /* 禁止 MPU */
    , `3 h' c/ T2 J; ^4 H7 |
14.     HAL_MPU_Disable();
    
15. 
    5 e/ R8 l7 P# Y2 P
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    / `3 r5 F. H4 r9 |
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    + Z$ n# b& K  V. f
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ! F: g: C, L7 f( A) l4 w
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    # k! L% Q1 v: X( J+ j
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ' H) I1 }  p& i0 Y* g$ k* h! c3 u
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( w: m4 Q$ \. s! O" V
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    4 ^0 y+ o+ k. L
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 f( e! `) E+ l$ S6 Q: J! O! R: l
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    - n) g/ F7 u- @/ s/ B" K' q
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    8 d' R+ {+ \! f$ z4 J' x
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;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    $ V) |( s4 h+ b% g" g  ]
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    7 M5 @- P/ ?$ P# p" y! Z
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    0 ~6 d7 h2 A3 Q% \9 _: A" c. D
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , o/ `6 B. n0 K& |: I
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;
    - a% N8 ~2 @8 D) C! ]" l6 r
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    * R, \( }, c; |  U
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    . |* r; n% A' V) b: D+ R
61. 
    0 u  j' Y% s  R2 z
62.     /*使能 MPU */
    ( i8 u7 V8 ], z0 F& |
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
64. }
    / I7 h! ~( e% X, ~
65. 
    , w: Z( p4 J! V2 t% S9 ^& n1 c
66. /*
    9 {$ ]' [4 P1 f9 i  x* X
67. *********************************************************************************************************
    3 i  P# R6 z) r, k0 n9 |9 s
68. *    函 数 名: CPU_CACHE_Enable
    2 \2 ?1 ?( E, s' L
69. *    功能说明: 使能L1 Cache
    
70. *    形    参: 无
    
71. *    返 回 值: 无
    1 {7 m4 O- s! y; d& u1 O
72. *********************************************************************************************************
    
73. */
    
74. static void CPU_CACHE_Enable(void)
    . n. P, c; O/ _5 o" I
75. {
    
76.     /* 使能 I-Cache */
    
77.     SCB_EnableICache();
    3 R# j- e. \: S: ^9 T
78. 
    
79.     /* 使能 D-Cache */
    
80.     SCB_EnableDCache();
    
81. }
    6 n( F" A3 I4 }% P( q- o

复制代码

! D) C3 P; u: Q& c6 ~" S0 `; a$ L  每10ms调用一次按键处理：

按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。
) o5 D9 t  `  m5 C: H( ?& e
& d3 ~+ ~- a6 x. Z2 P8 V

1. /*
   ' K# Q1 H" J, W3 N$ D% x
2. *********************************************************************************************************
   6 {! U! l+ C$ L4 K1 W! }4 P
3. *    函 数 名: bsp_RunPer10ms
   8 Z, s0 P  d& a/ Z$ c
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   8 h) W, v, i! b
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   ; g, L3 ~+ j7 Q3 G/ }) C  d1 [! g
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   % j' G: l: W& r% @6 R# O8 O+ p
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    9 D" B- l1 `5 }( u. C9 j; O4 ^
12.     bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

8 {) E, z- {2 _: v" Q, ^; q主程序实现如下操作：
9 ^: ?. ?( }0 G8 F
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
4 g/ }) h& _( u  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
) P# ^9 k- H7 c5 q) O2 c  请选择操作命令:
  1 - 读串行Flash
* @& u. B& W8 T! N6 M  2 - 写串行Flash
  3 - 擦除整个串行Flash
  r4 ]5 w+ ~; K: I. O, F9 L5 q  4 - 写整个串行Flash
/ t8 N+ J- [/ p. D5 k  5 - 读整个串行Flash
  Z - 读取前1K
' {, T+ X/ o0 A% O9 ]; L2 M# z  X - 读取后1K

1. /*
   
2. *********************************************************************************************************
   4 M0 J# a% z! n0 A
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   1 u: K+ N  A! i2 I
5. *    形    参：无
   ; U% @3 i! T' Q
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void DemoSpiFlash(void)
   & Z/ b: j, \# ~5 _
10. {
    8 l# v6 J6 Y- s, G  i: `, f3 i/ z
11.     uint8_t cmd;
    % U$ W$ y; A  T' ?' ?0 x6 w5 \
12.     uint32_t uiReadPageNo = 0;
    : N' G0 k5 z+ C6 d- o
13. 
    5 i/ r- d5 {: X, g2 z
14. 
    / w9 F: {' ?( i& Q, x8 `3 N- D
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);
    / w' a4 n$ u% g" n
18. 
    
19.     sfDispMenu();        /* 打印命令提示 */
    
20. 
    # n& W/ |6 {6 b" L
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
22. 
    / a& ?* H/ ~+ \+ x5 G1 T
23.     while(1)
    
24.     {
    5 b- D5 X- ^* Q1 P
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
26. 
    
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
    
29.         {
    
30.             /* 每隔100ms 进来一次 */  
    " I- z) Y" e& |0 d# X" ~
31.             bsp_LedToggle(2);
    
32.         }
    
33. 
    
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
35.         {
    , x. ^9 x" F, W# s' I
36.             switch (cmd)
    
37.             {
    6 N/ V4 g/ M4 e3 g7 ~2 j
38.                 case '1':
    3 B" a' o4 b1 J) Q
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    4 A( F) Q2 w+ C3 [' @2 A
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    ( [+ r1 m/ m; q+ z( @4 P6 L/ u
41.                     break;
    ' x, [, H; t7 G; \" _
42. 
    
43.                 case '2':
      _; O% G  x- h( ?* P! @9 @: a
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    $ q. f; v. y# h
47. 
    # Q( t2 X6 e4 o' S, a
48.                 case '3':
    
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    2 N  c  e) A' b$ x* ?) `
52.                     break;
    
53. 
    
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    0 F7 h9 ^3 O- o+ q/ L! g& m
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    
59. 
    ' W& {4 q6 @- c: f% n/ b; W2 _
60.                 case '5':
    ; L0 y; t) R- b' ?: W
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    6 _4 K, A2 A2 z, V. ^& F$ c
63.                     break;
    
64. 
    
65.                 case 'z':
    0 t. g: `  Q! S# W5 J
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
    
68.                     {
    3 g3 k, T! o9 Z9 \7 a% v" }, O
69.                         uiReadPageNo--;
    
70.                     }
    
71.                     else
    
72.                     {
    
73.                         printf("已经是最前\r\n");
    
74.                     }
    
75.                     sfViewData(uiReadPageNo * 1024);
    
76.                     break;
    ; b- O4 {0 }/ ~3 m- I- e( `
77. 
    6 G! q! j: q- r6 u1 B+ `
78.                 case 'x':
    
79.                 case 'X': /* 读取后1K */
    8 @2 D3 b$ g& A$ U" ~
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    & Z. L3 X' x0 j  ?- }
81.                     {
    1 z* T& I! `" s4 p3 z( n8 f- i5 r
82.                         uiReadPageNo++;
    
83.                     }
    
84.                     else
    1 y7 l$ D+ V  f0 C
85.                     {
    
86.                         printf("已经是最后\r\n");
    6 h* T' l& Y# w5 i( u; G
87.                     }
    
88.                     sfViewData(uiReadPageNo * 1024);
    - U# [6 `, a# q
89.                     break;
    
90. 
    ) q7 B3 v! G& I! ~1 U
91.                 default:
    
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    
94. 
    
95.             }
    
96.         }
    # n" C! @* H* s! X
97.     }
    ; V& n) }6 a. a
98. }

复制代码

# Q, M" S3 m( ^/ I9 f9 x73.11   总结
0 H3 u' l, ^+ ~$ r6 [0 f& u( L! Q本章节就为大家讲解这么多，实际应用中根据需要选择DMA，中断和查询方式。
" p/ e; _" P5 @+ z$ M; y! E
$ w2 D+ j" m8 m* c5 P