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

: R2 z, G  R+ E4 K  本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。
  对SPI Flash W25QXX的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。
  W25Q64JV最高支持133MHz，但最高读命令03H速度是50MHz。
  文件bsp_spi_bus.c文件公共的总线驱动文件，支持串行FLASH、TSC2046、VS1053、AD7705、ADS1256等SPI设备的配置。
& A% I2 y4 g. E& B: H  函数sf_WriteBuffer不需要用户做擦除，会自动执行擦除功能，支持任意大小，任意地址，不超过芯片容量即可。

73.2 W25QXX硬件设计
9 `( S, R2 z* d' C( C/ ?3 ?STM32H7驱动W25QXX的硬件设计如下：
( X' o6 w, r% j$ R% {9 b
  T9 G% U! c6 D

关于这个原理图，要了解到以下几个知识：

0 j8 J' a6 g! T3 k: r5 \9 x( b# I- F  V7开发板实际外接的芯片是W25Q64JV。
2 K  b% {2 J5 \( D2 f' v  CS片选最好接上拉电阻，防止意外操作。
8 m+ Z4 |5 Y; Z+ T  这里的PB3，PB4和PB5引脚可以复用SPI1，SPI3和SPI6。实际应用中是复用的SPI1。
5 @6 R5 b$ \: Q4 n  W25Q64的WP引脚用于写保护，低电平有效性，当前是直接高电平。
# Q+ e7 L  z; X3 u3 _$ I  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。
! U5 m% X+ g& ]6 m, q, H9 t& i4 P73.3 W25QXX关键知识点整理（重要）
驱动W25QXX前要先了解下这个芯片的相关信息。

' Y- t8 Z5 n+ R

. a$ D/ j: `' _! G; g( \$ b
4 @% L. ^' A, N6 P73.3.1 W25QXX基础信息
  W25Q64FV的容量是8MB（256Mbit）。
" p& \  t& t( y, _9 r' o  W25Q64FV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
支持两线SPI，用到引脚CLK、CS、IO0、IO1 。
& p# Y9 F* f. ?8 m  s, ?
支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。

* W* d- d' w  G8 w（注：这里几线的意思是几个数据线）。
- a$ ^/ H3 O+ E# \; k8 v
  W25Q64FV支持的最高时钟是133MHz。
; Z5 |. S( j, h3 @  每个扇区最少支持10万次擦写，可以保存20年数据。
  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
整体框图如下：
7 Y2 a! K7 t* N8 n7 `
3 ?4 d9 H$ ^: B

4 w0 ]1 ?+ V4 H/ r
( W3 g) c5 _* t4 ~- M3 MW25Q64FV：

  有128个Block，每个Block大小64KB。
: }7 J1 }8 w. f: \  O  每个Block有16个Sector，每个Sector大小4KB。
  每个Sector有16个Page，每个Page大小是256字节。
73.3.2 W25QXX命令
使用W25Q的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的标准SPI，即单线SPI，使用的命令如下：

当前主要用到如下几个命令：
, l! H, f4 l$ h( o+ o+ b

1. #define CMD_EWRSR       0x50  /* 允许写状态寄存器的命令 */
   
2. #define CMD_WRSR      0x01  /* 写状态寄存器命令 */
   
3. #define CMD_WREN      0x06    /* 写使能命令 */
   
4. #define CMD_READ      0x03  /* 读数据区命令 */
   
5. #define CMD_RDSR      0x05    /* 读状态寄存器命令 */
   3 F5 G8 l( a+ t8 E, c9 N! b
6. #define CMD_RDID      0x9F    /* 读器件ID命令 */
   3 U0 J1 Y9 v! O7 o' ^
7. #define CMD_SE        0x20    /* 擦除扇区命令 */
   ! J( j3 @9 _. |# c9 X$ i! k
8. #define CMD_BE        0xC7    /* 批量擦除命令 */
   
9. #define WIP_FLAG      0x01    /* 状态寄存器中的正在编程标志（WIP) */

复制代码

73.3.3 W25QXX页编程和页回卷
( Q( I1 V" A/ b" o% d% XSPI Flash仅支持页编程（页大小256字节），所有其它大批量数据的写入都是以页为单位。这里注意所说的页编程含义，页编程分为以下三步（伪代码）：
1 B! E5 ]8 N# s6 ^* l
! s* c& D1 D3 F% ~0 Q

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   . F& ~# |4 s0 u( h* X
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   : d( B" c: I! y4 [6 W. k
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   - v* Z6 h% Y9 R" D* A
5. 
   
6.     for (i = 0; i < _usSize; i++)
   
7.     {
   * p- p; p$ x% ~( q# {2 @
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   
10.     }

复制代码

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

- o2 [8 N0 `( h% O! R( j8 d5 v- e* V比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：
5 F. B$ a% n, U' ?1 y6 f

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

复制代码

( ^6 N" V  j+ e0 B  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
, o) f$ ^" M8 m( _9 E7 x) u3 [. p  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
, V: z; l, ?  {9 f! q  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
2 S3 O% T! k: h$ e下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。
: w4 u, }3 D% h* k' f, \3 V- F
3 F# G. |$ a$ u

9 l$ X" C- Q" ?3 V) ~
1 b7 U- z+ Y6 |; l. \73.3.4 W25QXX扇区擦除
SPI Flash的擦除支持扇区擦除（4KB），块擦除（32KB或者64KB）以及整个芯片擦除。对于扇区擦除和块擦除，使用的时候要注意一点，一般情况下，只需用户给出扇区或者块的首地址即可。
0 S. n- K( ~% J$ r' j
如果给的不是扇区或者块的首地址也没有关系的，只要此地址是在扇区或者块的范围内，此扇区或者块也可以被正确擦除。不过建议使用时给首地址，方便管理。
' X, k* ]7 z/ B3 R
73.3.5 W25QXX规格参数
这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：
# J% _) _, `8 N+ C1 d8 D2 R# i( c

  i1 u- i- D4 V: ?  页编程时间：典型值0.4ms，最大值3ms。
  扇区擦除时间（4KB）：典型值45ms，最大值400ms。
' E0 t& R" u; S+ }5 o/ x- Q4 X  块擦除时间（32KB）：典型值120ms，最大值1600ms。
9 b5 k& q8 {4 H1 I. O1 D! y  n: i  块擦除时间（64KB）：典型值150ms，最大值2000ms。
  整个芯片擦除时间：典型值20s，最大值100s。
3 m: x3 r, o9 u  S
( _+ I2 T& \& I3 Y. e. K, ~! \
% a  e' {7 A2 x/ l8 O0 W- H支持的速度参数如下：

$ ^" r* R" w7 u/ q, s3 {3 L
) B4 f9 n, N; v! F% A5 o可以看到最高支持的读时钟（使用命令03H）速度是50MHz，其它命令速度可以做到133MHz。

; ?' d6 c2 D* q5 `& b5 y3 X9 Q4 }9 s0 q73.4 W25QXX驱动设计
9 {& u# ^( Z8 I. XW25QXX的程序驱动框架设计如下：
3 `0 ^- N% I& ]5 R/ I* A) ]4 b9 {9 A

8 F8 d' x! W$ @4 t4 M; V" o% b
: c# w0 i* V7 g  u  C3 v有了这个框图，程序设计就比较好理解了。
! V/ ]2 g, L2 A* l* \& V
. s& }% r9 @6 G73.4.1 第1步：SPI总线配置
spi总线配置通过如下两个函数实现：
# M+ R8 d& S6 A1 o) F2 L3 @9 R! H: S

1. /*
   9 ~2 W% B2 T' e/ Y! C
2. *********************************************************************************************************
   ( i' z5 [4 h& `* l) S  p! c
3. *    函 数 名: bsp_InitSPIBus
   ' }/ d# d: R  I* `5 b/ f" r
4. *    功能说明: 配置SPI总线。
   : j7 ], M: i9 w; C/ o7 `0 I
5. *    形    参: 无
   % C2 ?3 K  q* C6 {2 N
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitSPIBus(void)
   9 `) k+ G) t( O8 m' u; `
10. {   
    
11.     g_spi_busy = 0;
    
12. 
    
13.     bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_8, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);
    * @/ F8 |9 c- e
14. }
    2 s& S6 u- v5 f( l' P6 C
15. 
    
16. /*
    
17. *********************************************************************************************************
    
18. *    函 数 名: bsp_InitSPIParam
    
19. *    功能说明: 配置SPI总线参数，时钟分频，时钟相位和时钟极性。
    $ y/ A2 B" D% n% v6 _% g
20. *    形    参: _BaudRatePrescaler  SPI总线时钟分频设置，支持的参数如下：
    
21. *                                 SPI_BAUDRATEPRESCALER_2    2分频
    ( g; t% Q% V! y# q& ~* s$ ?8 |, ~
22. *                                 SPI_BAUDRATEPRESCALER_4    4分频
    
23. *                                 SPI_BAUDRATEPRESCALER_8    8分频
    / W1 v4 L6 m  p. D( t: N
24. *                                 SPI_BAUDRATEPRESCALER_16   16分频
    
25. *                                 SPI_BAUDRATEPRESCALER_32   32分频
    # G; v9 Z9 o# }; m. ^  W* D( }
26. *                                 SPI_BAUDRATEPRESCALER_64   64分频
    
27. *                                 SPI_BAUDRATEPRESCALER_128  128分频
    
28. *                                 SPI_BAUDRATEPRESCALER_256  256分频
    ( ^7 X! e$ L# W* L
29. *                                                        
    " ^4 M9 o- K& Z3 o7 _* I) [
30. *             _CLKPhase           时钟相位，支持的参数如下：
    
31. *                                 SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
    4 g  J2 G  E  Z0 B+ ^( F
32. *                                 SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
    
33. *                                 
    
34. *             _CLKPolarity        时钟极性，支持的参数如下：
    8 f) r% \* B; b* |! b$ k
35. *                                 SPI_POLARITY_LOW    SCK引脚在空闲状态处于低电平
    
36. *                                 SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平
    : {% g4 j" C: I4 Z
37. *
    2 u+ C! O  _" m* S
38. *    返 回 值: 无
    
39. *********************************************************************************************************
      N9 N- p) o% A" M) t
40. */
    0 m* L+ c* b. Y% M2 M$ ~/ A
41. void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
    
42. {
    
43.     /* 提高执行效率，只有在SPI硬件参数发生变化时，才执行HAL_Init */
    * j; z) ]# R4 {# S: |% |' f
44.     if (s_BaudRatePrescaler == _BaudRatePrescaler && s_CLKPhase == _CLKPhase && s_CLKPolarity == _CLKPolarity)
    
45.     {        
    
46.         return;
    
47.     }
    8 Z* Q  {% c7 m$ n  o5 r" @0 M( T- k
48. 
    $ W8 ?! ^2 b+ k9 p
49.     s_BaudRatePrescaler = _BaudRatePrescaler;   
    
50.     s_CLKPhase = _CLKPhase;
    
51.     s_CLKPolarity = _CLKPolarity;
    
52. 
    : u% H" J# P" V+ ]; M: r! U
53. 
    2 x' U/ C7 a' [) K
54.     /* 设置SPI参数 */
      b8 S2 M% r/ m
55.     hspi.Instance               = SPIx;                   /* 例化SPI */
    
56.     hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
    
57.     hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
    
58.     hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
    
59.     hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
    
60.     hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
    ( b5 I, N0 U7 w9 Y. ^5 t' g! Y
61.     hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    
62.     hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    
63.     hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE; /* 禁止CRC */
    
64.     hspi.Init.CRCPolynomial     = 7;                       /* 禁止CRC后，此位无效 */
    , \/ L3 C* ?" S4 {- o3 j3 z! K
65.     hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;     /* 禁止CRC后，此位无效 */
    
66.     hspi.Init.NSS               = SPI_NSS_SOFT;               /* 使用软件方式管理片选引脚 */
    & A- m7 V6 N% K+ ~( [2 |  a
67.     hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;  /* 设置FIFO大小是一个数据项 */
    5 L( M, Y6 a" ]# d5 `3 N: U
68.     hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;      /* 禁止脉冲输出 */
    6 y! T1 C- L- Z) ^
69.     hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    
70.     hspi.Init.Mode             = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
      z( r% R* u5 y2 e
71. 
    
72.     /* 复位配置 */
    
73.     if (HAL_SPI_DeInit(&hspi) != HAL_OK)
    9 L5 I+ C( p+ _. y5 J% @% d! i" b
74.     {
    / {+ c6 n/ m& b( R1 ~) `
75.         Error_Handler(__FILE__, __LINE__);
    ' i7 x* f2 r" h  h, v5 l
76.     }   
    # f5 [! G% x% X  V3 b
77. 
    
78.     /* 初始化配置 */
    ' L; j6 E2 q9 g9 q! x! j
79.     if (HAL_SPI_Init(&hspi) != HAL_OK)
    
80.     {
    
81.         Error_Handler(__FILE__, __LINE__);
    
82.     }   
    , g. ]0 `! Z& o% t8 A1 e
83. }

复制代码

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

  函数bsp_InitSPIBus里面的配置是个初始设置。实际驱动芯片时，会通过函数bsp_InitSPIParam做再配置。
! w) Z! M0 }9 Z' Y3 @  函数bsp_InitSPIParam提供了时钟分频，时钟相位和时钟极性配置。驱动不同外设芯片时，基本上调整这三个参数就够。当SPI接口上接了多个不同类型的芯片时，通过此函数可以方便的切换配置。
6 w5 o/ n  i3 u, K, a73.4.2 第2步：SPI总线的查询，中断和DMA方式设置
# b" R$ n2 A/ C# N6 @SPI驱动的查询，中断和DMA方式主要通过函数bsp_spiTransfer实现数据传输：
6 Q, z8 n/ z( a6 t
* K1 Y) Q: I, g  O! p2 ?

1. /*
   + |8 v- g, ~" k
2. *********************************************************************************************************
   & I3 v+ [; D& e2 B# v3 o+ K0 N/ ]
3. *                                 选择DMA，中断或者查询方式
   $ @& r$ ^2 i! a1 [4 i' k
4. *********************************************************************************************************
   
5. */
   6 N5 J; K! U2 R8 x1 b4 T
6. //#define USE_SPI_DMA    /* DMA方式  */
   * H# t6 l! w+ A1 Z" i: x
7. //#define USE_SPI_INT    /* 中断方式 */
   
8. #define USE_SPI_POLL   /* 查询方式 */
   : @- H) h7 s7 n6 N, g
9. 
   + o, |- Z  Z& B% ^! D- D
10. /* 查询模式 */
    , a2 ~% p; h, F
11. #if defined (USE_SPI_POLL)
    
12. 
    
13. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];  
    8 r) e( P' h$ d; o1 l$ \% f
14. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
15. 
    
16. /* 中断模式 */
    ! p- p4 S0 b) o4 k; I
17. #elif defined (USE_SPI_INT)
    
18. 
    
19. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
20. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
21. 
    % j+ Z& P6 g! y5 p; j7 G( \
22. /* DMA模式使用的SRAM4 */
    2 h, x( _2 ?+ d0 G" S
23. #elif defined (USE_SPI_DMA)
    9 Z* Y* w0 r& ]& P- U
24.     #if defined ( __CC_ARM )    /* IAR *******/
    
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"
    
29.         uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    $ \% }; Q9 a  x
30.         #pragma location = ".RAM_D3"
    ' O7 v- M  |" @% H# X% u' J
31.         uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
32.     #endif
    : |8 ^$ X6 G! L  V6 Z
33. #endif
    - V" x% j5 L' }6 M; \6 p1 B
34. 
    " ?. @  N! K% ]! E% z
35. /*
      ]- n% ]. z0 D3 @8 X1 V
36. *********************************************************************************************************
    6 f! u' [# M' ?2 u4 w
37. *    函 数 名: bsp_spiTransfer
    5 q1 t' f# _0 U! p& F; u
38. *    功能说明: 启动数据传输
    
39. *    形    参: 无
    ' [& }: ?( O% {- Q- f2 o5 ~
40. *    返 回 值: 无
    
41. *********************************************************************************************************
    8 E/ s: X+ }0 A1 f. |
42. */
    
43. void bsp_spiTransfer(void)
    
44. {
    
45.     if (g_spiLen > SPI_BUFFER_SIZE)
    
46.     {
    
47.         return;
    
48.     }
    # |. N+ u; G, L
49. 
    
50.     /* DMA方式传输 */
    - l3 {: u4 ]/ }% J
51. #ifdef USE_SPI_DMA
    ; u- Z+ g: w$ m2 y) V4 L
52.     wTransferState = TRANSFER_WAIT;
    0 T9 t8 \! C3 ]  m  Q7 ^3 \8 v1 W
53. 
    1 O# h2 L2 R- G# u$ g
54.     if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    
55.     {
    & D1 u8 t. U: Z& o9 \% |8 i
56.         Error_Handler(__FILE__, __LINE__);
    
57.     }
    
58. 
    " B& Q3 N5 `3 `/ _0 i- Y! h7 ~7 S
59.     while (wTransferState == TRANSFER_WAIT)
    7 h7 ]) e% W- j
60.     {
    5 u( X+ \1 o. Y8 P* e$ d4 Q
61.         ;
    , d, l' q* }5 r% m1 H4 ]
62.     }
    
63. #endif
    ' P/ t( l0 z+ t3 \8 I
64. 
    ' r( E, U* O5 c2 @
65.     /* 中断方式传输 */   
    
66. #ifdef USE_SPI_INT
    4 p+ W: D% G7 g+ n$ D: p
67.     wTransferState = TRANSFER_WAIT;
    % x1 h4 O. b( q* |: G: i* A/ v
68. 
    2 C1 u; w' L' E* T5 E. y
69.     if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    . G5 I) B7 J3 t- h
70.     {
      }: r% j: v/ ?+ K
71.         Error_Handler(__FILE__, __LINE__);
    ! a8 x$ B* J+ K6 x5 u
72.     }
    
73. 
    
74.     while (wTransferState == TRANSFER_WAIT)
    
75.     {
    : |7 X% a7 J2 j- K4 Y& E. f
76.         ;
    
77.     }
    
78. #endif
    9 F, g0 j. P1 X) \, Z  X% n
79. 
    % a3 e& Z) [, V2 G# ?
80.     /* 查询方式传输 */   
    
81. #ifdef USE_SPI_POLL
    $ k7 U3 ^4 ]. A1 R# L0 i* O, G
82.     if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)   
    . A; @1 {9 ^8 Z/ V- x
83.     {
    
84.         Error_Handler(__FILE__, __LINE__);
    
85.     }   
    
86. #endif
    8 R" L: r3 a) `0 @2 z
87. }
    . x" M6 M8 U, v. l/ `5 [

复制代码

1 ^7 M1 g" \/ m/ p8 J通过开头宏定义可以方便的切换中断，查询和DMA方式。其中查询和中断方式比较好理解，而DMA方式要特别注意两点：

  通过本手册第26章的内存块超方便使用方式，将DMA缓冲定义到SRAM4上。因为本工程是用的DTCM做的主RAM空间，这个空间无法使用通用DMA1和DMA2。
/ n( R- E" Y0 u, h  由于程序里面开启了数据Cache，会造成DMA和CPU访问SRAM4数据不一致的问题，特此将SRAM4空间关闭Cache。
" V+ p+ f3 Y5 d+ y; {

1.     /* 配置SRAM4的MPU属性为Non-cacheable */
   
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;
   
6.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   
7.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   : _7 n/ f2 B6 t# E: E* s8 {
8.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
   
9.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
   * k/ {8 Q* x2 j
10.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
11.     MPU_InitStruct.SubRegionDisable = 0x00;
    
12.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & O9 _4 p3 }" f. [1 S& c# Q! m- d
13. 
    1 X. G& M+ `& G  x; z) g  W, p7 S
14.     HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

) G  Q- \0 e) T+ P3 p& j73.4.3 第3步：W25QXX的时钟极性和时钟相位配置
. U7 D- f3 Q8 x" \% K首先回忆下STM32H7支持的4种时序配置。
9 H$ N8 h: D0 W( m3 d
& Y& D1 c# T7 b0 x& X9 _  当CPOL = 1， CPHA = 1时
8 J9 y1 A! @; ~& u  J- N
2 l" j) K8 q5 l" N0 dSCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
) r9 P: \) G2 j8 N: ^/ r
8 T+ Z0 `% g  e5 K7 p  当CPOL = 0， CPHA = 1时

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

  当CPOL = 1， CPHA = 0时
" i3 w. {# Q. L7 x% ^; U% M3 |
SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

当CPOL = 1， CPHA = 0时
# b8 ~4 x5 r& p! [0 y  q% N0 N
6 ]$ p5 r3 ]8 T- ]; Z' bSCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。

% r7 H* A! V4 ?: w! [

有了H7支持的时序配置，再来看下W25Q的时序图：
) i4 C) J: g' R3 F  y1 c
Mode0 ： 空闲状态的sck是低电平。

% z4 l7 `& X+ M( _& OMode1 ： 空闲状态的sck是高电平。
2 R3 E, |4 d1 g' A" D$ i

: t  T. p9 O9 o* S8 N首先W25Q是上升沿做数据采集，所以STM32H7的可选的配置就是：
9 A8 m( F0 R6 d( K: {
CHOL = 1,  CPHA = 1

CHOL = 0,  CPHA = 0
6 j/ F6 ]( `. ?% z( `. E
5 K3 p7 Z2 x, t( i% B对于这两种情况，具体选择哪种，继续往下看。W25Q有两种SCK模式，分别是Mode0和Mode3，也就是空闲状态下，SCK既可以是高电平也可以是低电平。这样的话，这两种情况都可以使用，经过实际测试，STM32H7使用这两个配置均可以配置驱动W25Q。

! S4 L/ r: Z( X$ Z; @73.4.4 第4步：单SPI接口管理多个SPI设备的切换机制
1 R2 ]* m+ k/ p& N5 X7 ]2 t单SPI接口管理多个SPI设备最麻烦的地方是不同设备的时钟分配，时钟极性和时钟相位并不相同。对此的解决解决办法是在片选阶段配置切换，比如SPI Flash的片选：

. c; ]0 |* r3 S5 r

1. /*
   
2. *********************************************************************************************************
   1 c- C' h  a, c$ ^6 z4 k! H
3. *    函 数 名: sf_SetCS
   8 {: u" e& Z) G+ c% A
4. *    功能说明: 串行FALSH片选控制函数
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   0 Y3 G+ V3 O% d4 q: {$ W
7. *********************************************************************************************************
   
8. */
   
9. void sf_SetCS(uint8_t _Level)
   
10. {
    7 F' Y- J6 U( k# T
11.     if (_Level == 0)
    ( v, m' b* \4 c3 ]5 J0 k- n
12.     {
    
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    
15.         SF_CS_0();
    
16.     }
    
17.     else
    
18.     {        
    
19.         SF_CS_1();   
    . r/ F! i/ B6 s; T1 Z
20.         bsp_SpiBusExit();        
    - n# u4 h/ o1 w+ R
21.     }
    / e) \5 ^1 N8 b* V
22. }
    

复制代码

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

0 O6 I9 X( {% H( v" H$ F6 s7 U但是频繁配置也比较繁琐，所以函数bsp_InitSPIParam里面做了特别处理。当前配置与之前配置相同的情况下无需重复配置。

& t6 z9 i; |( Q6 B( b) h# @% [73.4.5 第5步：W25QXX的读取实现
3 G+ Y- p2 M7 G8 T" i9 SW25QXX的读取功能比较好实现，发送03H命令后，设置任意地址都可以读取数据，只要不超过芯片容量即可。

1. /*
   
2. *********************************************************************************************************
   5 r5 Y2 M4 V* ?
3. *    函 数 名: sf_ReadBuffer
   
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   , \2 y9 P& {6 P" q/ U
5. *    形    参:      _pBuf : 数据源缓冲区；
   $ S+ P6 u# a  _6 C, m
6. *                _uiReadAddr ：首地址
   
7. *                _usSize ：数据个数, 不能超出芯片总容量
   7 S. T6 ?8 U* B6 q. J2 ?4 I; O' g- K
8. *    返 回 值: 无
     Q* m+ n' z$ a; r0 t! y& a7 t+ m
9. *********************************************************************************************************
     J& C# X  w. n# @3 X2 ~+ F- j, p3 j
10. */
    8 m; n: V- v& _# r
11. void sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    - K# S$ j  N4 v7 j/ R
12. {
    9 O2 X9 ^! f& N* }; e
13.     uint16_t rem;
    & z& h9 V  W3 F  j
14.     uint16_t i;
    & P# Y8 k- {7 G2 b
15. 
    
16.     /* 如果读取的数据长度为0或者超出串行Flash地址空间，则直接返回 */
    / Q* ]' z% W& R: A+ A0 Y7 u  w9 h
17.     if ((_uiSize == 0) ||(_uiReadAddr + _uiSize) > g_tSF.TotalSize)
    ' j; q8 U3 Y" i4 {5 I
18.     {
    
19.         return;
    
20.     }
    . f4 x( R4 N% s8 |/ ^
21. 
    
22.     /* 擦除扇区操作 */
    ( U* o) f1 M* L3 o
23.     sf_SetCS(0);                                    /* 使能片选 */
    
24.     g_spiLen = 0;
    
25.     g_spiTxBuf[g_spiLen++] = (CMD_READ);                            /* 发送读命令 */
    
26.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    ) d! B# p% x: f
27.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF00) >> 8);        /* 发送扇区地址中间8bit */
    
28.     g_spiTxBuf[g_spiLen++] = (_uiReadAddr & 0xFF);                /* 发送扇区地址低8bit */
    6 P: }8 m5 F% ^6 k
29.     bsp_spiTransfer();
    / K& ?; S( I& i% f6 w1 @; M$ _# x
30. 
    ) m' Z0 C9 H7 T. Q, M6 H
31.     /* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
    8 P2 U' m3 f! F: S* X) z
32.     for (i = 0; i < _uiSize / SPI_BUFFER_SIZE; i++)
    ; |, y- F# G  M  s
33.     {
    8 F8 d- W+ k) l
34.         g_spiLen = SPI_BUFFER_SIZE;
    
35.         bsp_spiTransfer();
    
36. 
    ( B( i% }& ~, k: c$ |- F  j2 i
37.         memcpy(_pBuf, g_spiRxBuf, SPI_BUFFER_SIZE);
    0 U2 g& H/ @% W1 S4 y
38.         _pBuf += SPI_BUFFER_SIZE;
      r# C) i- N2 t2 M4 i1 D
39.     }
    
40. 
    
41.     rem = _uiSize % SPI_BUFFER_SIZE;    /* 剩余字节 */
    $ u( t0 [6 G; h% m: k, u( X" m
42.     if (rem > 0)
    
43.     {
    
44.         g_spiLen = rem;
    
45.         bsp_spiTransfer();
    
46. 
    : }6 ~! W& c& s# \6 L( a" S
47.         memcpy(_pBuf, g_spiRxBuf, rem);
    * ?0 Z) b3 F7 M+ v" e9 i7 Q
48.     }
    * e: t1 o6 F2 z/ B" I& R' [
49. 
    & X9 X- S) u, P
50.     sf_SetCS(1);                                    /* 禁能片选 */
    2 c0 |- k3 ]7 W' w/ l3 h. x
51. }

复制代码

  Z. s) t/ n+ r$ o  Z$ f
* i4 A4 N* O) q- c7 W/ N. y, H/ s这个函数对DMA传输做了特别处理，方便分包进行。
: [& Z3 Y. P$ q* D& ^" w
& x9 u: `" ?: b! A0 O; C' a73.4.6 第6步：W25QXX的扇区擦除实现
扇区擦除的实现也比较简单，发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除。擦除的扇区大小是4KB。
6 P- M; c7 `. j
" X& w6 G! f; ~1 N/ e

1. /*
   
2. *********************************************************************************************************
   ) D0 S$ _8 ~& h$ _; M6 s
3. *    函 数 名: sf_EraseSector
   
4. *    功能说明: 擦除指定的扇区
   ) y: o8 q) o4 g& q* U8 Z6 o
5. *    形    参: _uiSectorAddr : 扇区地址
   - ^4 t! B; T  v7 F: B
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   7 M7 m% d2 ]/ X* z) B) C
9. void sf_EraseSector(uint32_t _uiSectorAddr)
   $ M4 }) `( ^" n* k- `. z- l
10. {
    % X2 J* c7 J$ n9 F/ I7 u
11.     sf_WriteEnable();                            /* 发送写使能命令 */
    ; u7 r) {) V. c& G$ g8 ~. p
12. 
    ; z/ D& f* w- P: ~6 b
13.     /* 擦除扇区操作 */
    
14.     sf_SetCS(0);                                /* 使能片选 */
    1 L) D2 i$ X, a" W: O6 L
15.     g_spiLen = 0;
      ^" |2 B6 a3 F# S9 m
16.     g_spiTxBuf[g_spiLen++] = CMD_SE;                /* 发送擦除命令 */
    : K! }8 h% X5 l* Y1 T
17.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    
18.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF00) >> 8);    /* 发送扇区地址中间8bit */
    . f$ R) [. t( _8 M; W
19.     g_spiTxBuf[g_spiLen++] = (_uiSectorAddr & 0xFF);            /* 发送扇区地址低8bit */   
    , m; p6 {4 U* |1 m0 ^1 \1 P
20.     bsp_spiTransfer();
    
21.     sf_SetCS(1);                                    /* 禁能片选 */
    ; k3 f/ w# `8 T6 c
22. 
    & C9 x  j3 c# D; Y% u4 h
23.     sf_WaitForWriteEnd();                            /* 等待串行Flash内部写操作完成 */
    8 f9 \( L- `% ^) n4 j: ]# a" Z
24. }
    

复制代码

. Z  }, U% Q4 n) u: y整个芯片的擦除更省事些，仅发送整个芯片擦除命令即可：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_EraseChip
   ! h" T( S4 B" h! p$ g
4. *    功能说明: 擦除整个芯片
   ( g; _5 G" K; t& |! d0 ], F
5. *    形    参:  无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   8 j. c5 H9 {+ H4 j' u- R4 u
8. */
   : j0 ~3 w( B! g! f
9. void sf_EraseChip(void)
   7 A4 L3 j- x1 c  O
10. {   
    5 h  c) W* s5 O+ @6 e
11.     sf_WriteEnable();                                /* 发送写使能命令 */
    
12. 
    6 m  E" @8 |8 z& f, T& [4 c( g% w
13.     /* 擦除扇区操作 */
    ( p4 \: Y+ y* C5 K0 }# i
14.     sf_SetCS(0);        /* 使能片选 */
    
15.     g_spiLen = 0;
    
16.     g_spiTxBuf[g_spiLen++] = CMD_BE;        /* 发送整片擦除命令 */
    
17.     bsp_spiTransfer();
    $ `2 }( q) ?7 U& w9 i) M, r% P
18.     sf_SetCS(1);                        /* 禁能片选 */
    
19. 
    + D' }/ k1 H( t6 C/ r& {! C+ X
20.     sf_WaitForWriteEnd();                /* 等待串行Flash内部写操作完成 */
    ' i% A7 T& D# u( m6 ~/ _
21. }
    

复制代码

73.4.7 第7步：W25QXX的编程实现
4 ]3 N% l* ^% u5 \4 M/ wW25QXX的编程实现略复杂，因为做了自动擦除支持，大家可以在任意地址，写任意大小的数据，只要不超过芯片容量即可。我们这里就不做展开讨论了，大家有兴趣可以研究下：

+ J3 }4 u/ K) {# p( P0 x

1. /*
   / L& h5 @7 A) n# }- H, m( F& ~
2. *********************************************************************************************************
   9 H% s( I. d8 }- S3 t2 M: y4 I
3. *    函 数 名: sf_WriteBuffer
   ( ~" z$ r) @: b4 I" o, O) n
4. *    功能说明: 写1个扇区并校验,如果不正确则再重写两次，本函数自动完成擦除操作。
     a1 Z( b  W+ m+ E$ e$ t
5. *    形    参:  _pBuf : 数据源缓冲区；
   
6. *               _uiWrAddr ：目标区域首地址
   
7. *               _usSize ：数据个数，任意大小，但不能超过芯片容量。
   1 C& h: b# b( w* d- R  n9 b* Y7 f
8. *    返 回 值: 1 : 成功， 0 ： 失败
   
9. *********************************************************************************************************
   ) E- ]' l/ o: h: }$ Y5 l
10. */
    
11. uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)
    1 G( n" [' C- S5 X1 U3 t
12. {
    
13.     uint32_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
    ; T" ?1 O+ s6 `) l: f
14. 
    
15.     Addr = _uiWriteAddr % g_tSF.SectorSize;
    
16.     count = g_tSF.SectorSize - Addr;
    
17.     NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    , X' @& i6 y) H; a: ]7 A! r
18.     NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    
19. 
    
20.     if (Addr == 0) /* 起始地址是扇区首地址  */
    ! R( l3 ?: k3 V
21.     {
    9 U2 Z7 e' T" K) n, z# r
22.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
23.         {
    7 Q. O/ e( ], A0 u1 n
24.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
      w; U! R) k) c/ f* ]5 [
25.             {
    
26.                 return 0;
    
27.             }
    : g& Y) B/ O4 w( Z/ M% a9 P8 G7 Q3 P
28.         }
    
29.         else     /* 数据长度大于等于扇区大小 */
    % W. C5 \5 r2 ?! L$ i; ^& Z' u5 `
30.         {
    
31.             while (NumOfPage--)
    
32.             {
    9 i( l$ W# P2 u5 ?
33.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    
34.                 {
    1 S; S1 f. k! b/ n% y: v, I" _
35.                     return 0;
    
36.                 }
    , H; s$ G/ z! ?" \8 `9 Y
37.                 _uiWriteAddr +=  g_tSF.SectorSize;
    
38.                 _pBuf += g_tSF.SectorSize;
    & |  k4 G: z. o6 E1 Y4 i2 s
39.             }
    
40.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
    + u+ j- e" f- V, l2 P# ]; C9 [
41.             {
    
42.                 return 0;
    
43.             }
    
44.         }
    
45.     }
    
46.     else  /* 起始地址不是扇区首地址  */
    
47.     {
    
48.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
49.         {
    ' p* I; s8 e; W/ z6 j6 o" C
50.             if (NumOfSingle > count)  /* (_usWriteSize + _uiWriteAddr) > SPI_FLASH_PAGESIZE */
    
51.             {
    9 F1 c* \% y/ l1 R, Y# j, A" C
52.                 temp = NumOfSingle - count;
    
53. 
    ; ~4 w" W0 S' F
54.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    + j" L, x; G3 w  a- N  |  x
55.                 {
    ' D# l: ?6 v& M
56.                     return 0;
    
57.                 }
    
58. 
    
59.                 _uiWriteAddr +=  count;
    
60.                 _pBuf += count;
    
61. 
    6 g4 S6 p+ W) Z# c% C0 y9 A3 D
62.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, temp) == 0)
    . j2 W* f. ]9 ?" n# v" U. o2 b
63.                 {
    
64.                     return 0;
    
65.                 }
    
66.             }
    5 |, y7 i+ U4 ], b
67.             else
    2 a' d& z: ^  }) z/ J1 @. F
68.             {
    / i7 w4 o: C6 v  S
69.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    
70.                 {
    8 v* }7 v! t9 u0 o2 }: y' }
71.                     return 0;
    8 X3 a% F' k" i8 k- b: r
72.                 }
    
73.             }
    $ z' B/ W* v8 v5 T, s/ J
74.         }
    
75.         else    /* 数据长度大于等于扇区大小 */
    
76.         {
    3 z$ l/ ~! d9 X2 z6 d* b: w
77.             _usWriteSize -= count;
    
78.             NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    % Q" a3 c/ v5 @% l! t
79.             NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    * B9 h5 W$ T1 {) a" V# P
80.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
    
81.             {
    ! F/ Y# F3 v; Y) o8 E- m: u
82.                 return 0;
    1 o2 ?" z  m5 d
83.             }
    
84. 
    
85.             _uiWriteAddr +=  count;
    1 |; X. w& s0 Z6 Q% t! S2 @, t
86.             _pBuf += count;
    3 W) ?" ~% k# b0 U
87. 
    
88.             while (NumOfPage--)
    / s+ a; y! j+ {/ g9 B. v6 G5 e
89.             {
    3 P- `! t; p% h0 W; A5 s3 v
90.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    
91.                 {
    ( X8 s7 o- o" S: U. a# p, |" S
92.                     return 0;
    
93.                 }
    % W" s' w! u9 `; z4 C- G3 [
94.                 _uiWriteAddr +=  g_tSF.SectorSize;
    
95.                 _pBuf += g_tSF.SectorSize;
    
96.             }
    
97. 
    " B/ q5 w8 }% i2 F. p# |
98.             if (NumOfSingle != 0)
    0 v; m* ?" c2 B
99.             {
    ' r7 }1 [  k% `. r2 R5 S" d
100.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
     + n5 N1 O* H- W- h4 i
101.                 {
       P( w3 ?/ u5 J0 p1 S2 t+ F
102.                     return 0;
     $ i8 P  @9 E. P$ q% ?5 F% B; h/ E" d& a
103.                 }
     
104.             }
     
105.         }
     
106.     }
     
107.     return 1;    /* 成功 */
     ; p; C, m" B' k- v. C
108. }

复制代码

73.5 SPI总线板级支持包（bsp_spi_bus.c）
- j5 H7 e6 r0 U7 X7 Q6 nSPI总线驱动文件bsp_spi_bus.c主要实现了如下几个API供用户调用：
# U6 @) p3 F  G2 O$ }4 C, i$ c
! \4 G: k# A( O. S9 M, [  bsp_InitSPIBus
  bsp_InitSPIParam
% q& j# y! h7 O7 M8 u  bsp_spiTransfer
( K) I0 U' z% s, z73.5.1 函数bsp_InitSPIBus
函数原型：

7 w9 f; N+ S& U* ]$ ^void bsp_InitSPIBus(void)
, w) p  Z+ e# j- A
函数描述：

此函数主要用于SPI总线的初始化，在bsp.c文件调用一次即可。
: T3 @" C3 u6 @( V" v+ m6 M
0 b9 J1 P7 Q& h6 t& {8 k# q73.5.2 函数bsp_InitSPIParam
函数原型：

void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
7 L8 T+ W) x% a# u, j
: {" R! m  X. G) E! @函数描述：

7 ]4 a* p3 e4 h& Y* s此函数用于SPI总线的配置。
9 _& C  M: R6 P8 d, m% y+ D0 C* |
函数参数：

1 x* \3 \$ T- q( u0 {  第1个参数SPI总线的分频设置，支持的参数如下：
SPI_BAUDRATEPRESCALER_2    2分频

' a! r3 O* W/ DSPI_BAUDRATEPRESCALER_4    4分频
: T/ `1 a1 Z( t1 r, j
2 t7 S- `: c8 {% K5 G9 iSPI_BAUDRATEPRESCALER_8    8分频
$ o+ G! k$ K' N4 k3 c
SPI_BAUDRATEPRESCALER_16   16分频
' d' c3 V- v+ M: ]7 S4 @2 r
SPI_BAUDRATEPRESCALER_32   32分频

SPI_BAUDRATEPRESCALER_64   64分频
& R/ `$ e7 y' X- z% T
7 G; e- a6 o8 [! K# zSPI_BAUDRATEPRESCALER_128  128分频
+ o. K% G( ?+ v) ]/ C& }
SPI_BAUDRATEPRESCALER_256  256分频
5 T/ Y/ [8 S+ g/ ^4 S+ Z
  第2个参数用于时钟相位配置，支持的参数如下：
SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据

SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
: L5 l+ o% |) A5 M- C& ~
  第3个参数是时钟极性配置，支持的参数如下：
SPI_POLARITY_LOW   SCK引脚在空闲状态处于低电平
; l2 ^% a# ?0 c
SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平

7 o( @3 p) q3 r+ [/ g73.5.3 函数bsp_spiTransfer
函数原型：
% I- ]8 J2 u( [% [) _4 E- B* V
void bsp_spiTransfer(void)

/ o) q7 |- |7 K函数描述：
4 G& W' t- k2 Y8 W2 o6 f3 v
. X; ?" h( x6 J& C# j4 P# n& `. ^此函数用于启动SPI数据传输，支持查询，中断和DMA方式传输。
) A0 W% n2 Q& \$ o- \' P
. f: ~$ R3 G9 s73.6 W25QXX板级支持包（bsp_spi_flash.c）
W25QXX驱动文件bsp_spi_flash.c主要实现了如下几个API供用户调用：
+ G* s; E; _! P1 [; Q
  s/ V  U3 T+ s3 X, N. I  sf_ReadBuffer
7 c- t- v3 U0 S, x1 ~5 u1 X  sf_WriteBuffer
1 n  M9 R( g' W. e4 H9 Q( V3 b0 j2 e+ _  sf_EraseSector
0 X. w0 r# }  O2 j" T  Q6 N  sf_EraseChip
  sf_EraseSector
+ A8 S- w6 Y7 T7 |73.6.1 函数sf_ReadBuffer
函数原型：
7 Q( s! @8 \+ W& d" j
7 }( {9 c' h7 T! x) k3 Xvoid sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
, G+ d3 [+ M" t, f0 g
函数描述：
' U( G9 F8 ^) g9 B: M+ E6 Q
此函数主要用于从SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。

" P1 i4 H' M" P) P& Y函数参数：
! [% c- v; G! H% E& `% `* T: w$ u5 a
  第1个参数用于存储从SPI Flash读取的数据。
. f0 N* e4 S; J0 H& s) @& l/ K( p: v  第2个参数是读取地址，不可以超过芯片容量。
  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
) A; }( C+ J( g" ?& r- K  m73.6.2 函数sf_WriteBuffer（自动执行擦除）
' X- Q5 f+ P4 i函数原型：
3 e* d% \4 X/ l; x! ~# o$ S
uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)

函数描述：
4 t) A1 s! K+ X4 H
4 o' Q/ j& J: W0 X$ S( R& q/ ]  h此函数主要用于SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。特别注意，此函数会自动执行擦除，无需用户处理。

函数参数：

8 E( T  d% f* F8 i0 @4 X  第1个参数是源数据缓冲区。
  第2个参数是目标区域首地址。
  第3个参数是数据个数，支持任意大小，但不能超过芯片容量。单位字节个数。
  返回值，返回1表示成功，返回0表示失败。
73.6.3 函数sf_EraseSector
函数原型：
3 }% G3 b5 |6 J
void sf_EraseSector(uint32_t _uiSectorAddr)

% h4 Q' I/ ]( v2 N9 T1 l函数描述：

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

* I' Y. m) O! a5 s2 ^函数参数：

  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
73.6.4 函数sf_EraseChip
  v+ V# J8 @$ A, _& m7 T/ @" |! C函数原型：
7 S4 e' I5 J1 [& E
void sf_EraseChip(void)

函数描述：

1 L0 s8 b+ M1 X, R' Y+ J此函数主要用于整个芯片擦除。

73.6.5 函数sf_PageWrite（不推荐）
6 P( x' e& E! \3 S' i/ `函数原型：

8 v/ \1 t- [+ S1 Lvoid sf_PageWrite(uint8_t * _pBuf, uint32_t _uiWriteAddr, uint16_t _usSize)

函数描述：
  b+ b  \( Y- R( P6 u4 l
) G9 h) \! D; y( ]# u% o此函数主要用于页编程，一次可以编程多个页，只要不超过芯片容量即可。不推荐大家调用此函数，因为调用这个函数前，需要大家调用函数sf_EraseSector进行扇区擦除。

函数参数：
# U2 Q$ j7 _7 L
  第1个参数是数据源缓冲区。
  第2个参数目标区域首地址，比如编程页0，此处填0x0000，编程页1，此处填0x0100，编程页2，此处填0x0200，以此类推。
  第3个参数是编程的数据大小，务必是256字节的整数倍，单位字节个数。
/ V2 P# j; `9 \73.7 W25QXX驱动移植和使用
9 O3 L8 I0 o( _1 a7 ?& S; h. uW25QXX移植步骤如下：
. S9 l) R1 s$ n7 t
  第1步：复制bsp_spi_bus.c，bsp_spi_bus.h，bsp_spi_flash.c，bsp_spi_flash.h到自己的工程目录，并添加到工程里面。
  第2步：根据使用的第几个SPI，SPI时钟，SPI引脚和DMA通道等，修改bsp_spi_bus.c文件开头的宏定义
' U6 i3 s" x. ?. ]' s4 @

1. /*
   8 y6 i2 ?) s- Y
2. *********************************************************************************************************
   
3. *                                时钟，引脚，DMA，中断等宏定义
     s) ]9 V* u8 H3 ^1 }+ ~
4. *********************************************************************************************************
   
5. */
   $ ~6 p4 u# A/ ]8 k
6. #define SPIx                            SPI1
   6 Q$ p% C$ |( X* i) {& R7 c% v
7. #define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
   
8. #define DMAx_CLK_ENABLE()                __HAL_RCC_DMA2_CLK_ENABLE()
   / j3 c5 h, o  Y' t/ U4 P3 ^1 w
9. 
   & y) ~1 {: c8 w' V5 X' r& M
10. #define SPIx_FORCE_RESET()                __HAL_RCC_SPI1_FORCE_RESET()
    5 W- Y6 m' P/ C6 {  l( \
11. #define SPIx_RELEASE_RESET()            __HAL_RCC_SPI1_RELEASE_RESET()
    % m& {% B/ g$ F, x8 o, Q' o6 [, G( i2 q
12. 
    
13. #define SPIx_SCK_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    
14. #define SPIx_SCK_GPIO                    GPIOB
    
15. #define SPIx_SCK_PIN                    GPIO_PIN_3
    
16. #define SPIx_SCK_AF                        GPIO_AF5_SPI1
    0 w6 V6 U- }: ~
17. 
    
18. #define SPIx_MISO_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    
19. #define SPIx_MISO_GPIO                    GPIOB
    # P- Y9 o2 H/ B
20. #define SPIx_MISO_PIN                     GPIO_PIN_4
    0 \" M5 N8 c# z0 F
21. #define SPIx_MISO_AF                    GPIO_AF5_SPI1
    4 e* u8 H- d: x9 Q6 g4 Z) e2 v. v
22. 
    
23. #define SPIx_MOSI_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    & q2 w& T0 Z4 M* \" a: q- H7 Q
24. #define SPIx_MOSI_GPIO                    GPIOB
    
25. #define SPIx_MOSI_PIN                     GPIO_PIN_5
    
26. #define SPIx_MOSI_AF                    GPIO_AF5_SPI1
    3 G8 I& y/ Z, V, ~+ ]
27. 
    
28. #define SPIx_TX_DMA_STREAM               DMA2_Stream3
    / z. _( y( u3 S* c- s. ?/ y( W
29. #define SPIx_RX_DMA_STREAM               DMA2_Stream2
    7 J' H) D" H- M1 B4 m% T/ A2 V3 C* s
30. 
    $ u. q8 F. i9 E* w$ I' G- P6 r5 H' d
31. #define SPIx_TX_DMA_REQUEST              DMA_REQUEST_SPI1_TX
    
32. #define SPIx_RX_DMA_REQUEST              DMA_REQUEST_SPI1_RX
    $ ?3 X% a( T. L1 [7 Q/ U
33. 
    
34. #define SPIx_DMA_TX_IRQn                 DMA2_Stream3_IRQn
    
35. #define SPIx_DMA_RX_IRQn                 DMA2_Stream2_IRQn
    
36. 
    : @& V8 m% o, G7 q0 H2 A" I/ f* o
37. #define SPIx_DMA_TX_IRQHandler           DMA2_Stream3_IRQHandler
    0 d/ ^* T% Z0 o  ~8 _5 A# N' w
38. #define SPIx_DMA_RX_IRQHandler           DMA2_Stream2_IRQHandler
    . |4 ~. f: y& c; w# B  t
39. 
    
40. #define SPIx_IRQn                        SPI1_IRQn
    
41. #define SPIx_IRQHandler                  SPI1_IRQHandler
    

复制代码

* v, E6 @; K* S) _  f
  第3步：根据使用的SPI ID，添加定义到文件bsp_spi_flash.h

1. /* 定义串行Flash ID */
   1 s# o. p" U) H' I
2. enum
   1 `- [1 }) l' ^
3. {
   
4.     SST25VF016B_ID = 0xBF2541,
   . n; K" V; z2 n" c( S, O
5.     MX25L1606E_ID  = 0xC22015,
   , T' j: ]4 I* i% z3 m- Q
6.     W25Q64BV_ID    = 0xEF4017, /* BV, JV, FV */
   8 E9 ?  ?- d2 p: v2 D) C% l
7.     W25Q128_ID     = 0xEF4018
   
8. };

复制代码

  第4步：添加相应型号到bsp_spi_flash.c文件的函数sf_ReadInfo里面。

1. /*
   
2. *********************************************************************************************************
   ! }1 }, G: _# t. W5 x- L, R2 m( D/ u
3. *    函 数 名: sf_ReadInfo
   
4. *    功能说明: 读取器件ID,并填充器件参数
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   9 R, z) Y+ a/ Q: B: F9 r: I! G
7. *********************************************************************************************************
   
8. */
   & E( c4 c# r- [
9. void sf_ReadInfo(void)
   
10. {
    9 t$ X! G: m" I2 P3 U
11.     /* 自动识别串行Flash型号 */
    9 t5 _% }# V& U7 J- u
12.     {
    ( B, B' T" Y. r& z' e/ y: a
13.         g_tSF.ChipID = sf_ReadID();    /* 芯片ID */
    
14. 
      ^; z% b) ?! t# s4 J" W
15.         switch (g_tSF.ChipID)
    * p6 T+ Y! Z' r/ n$ s% K
16.         {
    
17.             case SST25VF016B_ID:
    
18.                 strcpy(g_tSF.ChipName, "SST25VF016B");
    
19.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    
20.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
21.                 break;
    1 Q. U8 P9 v' p$ {6 [7 w. w
22. 
    2 f+ e" ~' h9 ?) V/ `1 u5 j  ~
23.             case MX25L1606E_ID:
    
24.                 strcpy(g_tSF.ChipName, "MX25L1606E");
    0 p& U3 w& N$ H$ y) a  F# Z
25.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    
26.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    : J# v! N* }6 S+ L
27.                 break;
    
28. 
    
29.             case W25Q64BV_ID:
    : u$ U' q& S" n) Z0 P+ f3 u3 R
30.                 strcpy(g_tSF.ChipName, "W25Q64");
    
31.                 g_tSF.TotalSize = 8 * 1024 * 1024;    /* 总容量 = 8M */
    * a% B! S% X% v, N3 O- [
32.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
33.                 break;
    
34. 
    
35.             case W25Q128_ID:
    / D6 V5 b( ]7 k) P& ^& ^5 x" H( O
36.                 strcpy(g_tSF.ChipName, "W25Q128");
    4 ]- Y. v, Q1 i" {! R# d
37.                 g_tSF.TotalSize = 16 * 1024 * 1024;    /* 总容量 = 8M */
    : l" O) y8 }1 R5 h* T1 W5 ]: M/ i: t
38.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
39.                 break;            
    3 ~: @7 L, r% |$ J+ j
40. 
    
41.             default:
      P4 ~, g4 S/ _
42.                 strcpy(g_tSF.ChipName, "Unknow Flash");
    
43.                 g_tSF.TotalSize = 2 * 1024 * 1024;
    / ?" L' j' S9 K( w1 n
44.                 g_tSF.SectorSize = 4 * 1024;
    
45.                 break;
    
46.         }
    8 K+ k* m3 J: S7 S/ j
47.     }
    
48. }

复制代码

  第5步：根据芯片支持的时钟速度，时钟相位和时钟极性配置函数sf_SetCS。
  [) ]* a4 R* r, f* w

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_SetCS
   : [! C! F" _9 S! o
4. *    功能说明: 串行FALSH片选控制函数
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   + H9 ?# _4 \5 M2 [; x4 W
9. void sf_SetCS(uint8_t _Level)
   8 U8 h9 `3 x' w& ?" I# D8 I/ w
10. {
    
11.     if (_Level == 0)
    
12.     {
    $ X2 H1 T& d. w$ Q. @6 I
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    8 }7 M0 e) f4 ~$ j4 O3 Y6 T
15.         SF_CS_0();
    
16.     }
    0 ~* t% K& W& h4 I
17.     else
    / @" v6 Q- N4 c1 P
18.     {        
    % n/ Z/ z# j5 f) u; L. ?
19.         SF_CS_1();   
      v$ A. _9 G- f5 s/ v
20.         bsp_SpiBusExit();        
    0 s8 U( _: N6 n% Z
21.     }
    $ l8 h3 I. `" ]
22. }

复制代码

  第6步：根据使用的SPI Flash片选引脚修改bsp_spi_bus.c文件开头的宏定义。
+ [1 o* x# ?3 w1 c

1. /* 串行Flash的片选GPIO端口， PD13  */
   9 C, ]; e$ @1 J7 J
2. #define SF_CS_CLK_ENABLE()             __HAL_RCC_GPIOD_CLK_ENABLE()
   1 s$ A# j+ ~; a) _
3. #define SF_CS_GPIO                    GPIOD
   " S+ B' h9 p% S' U# e; E
4. #define SF_CS_PIN                    GPIO_PIN_13
   
5. 
   
6. #define SF_CS_0()                    SF_CS_GPIO->BSRR = ((uint32_t)SF_CS_PIN << 16U)
   
7. #define SF_CS_1()                    SF_CS_GPIO->BSRR = SF_CS_PIN

复制代码

  第7步：如果使用DMA方式的话，请不要使用TCM RAM，因为通用DMA1和DMA2不支持。并为了防止DMA和CPU同时访问DMA缓冲造成的数据一致性问题，将这块空间关闭Cache处理，比如使用的SRAM4：
7 ]1 p) E7 F- j; C8 o

1. /* 配置SRAM4的MPU属性为Non-cacheable */
   
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   
3. MPU_InitStruct.BaseAddress      = 0x38000000;
   ! L% L* b9 Q: D) F6 G: Z, J5 |" T
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   8 N! N, t9 K+ n9 A3 I
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   ' b4 S+ c! ]8 G7 Y
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   $ K! F" B" v! \# y% L8 x
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;
    ! {$ x; R! z; d& U) n) o1 u
11. MPU_InitStruct.SubRegionDisable = 0x00;
    4 p# V  D1 g5 i
12. MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    6 Z: L2 C( H+ W- i( [8 ?& Z1 {% }7 j
13. 
    8 E7 E  y' \: J* S
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

  第8步：初始化SPI。

1. /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
   
2. bsp_InitSPIBus();    /* 配置SPI总线 */        
   3 [, _. R9 f5 {9 b$ J
3. bsp_InitSFlash();    /* 初始化SPI 串行Flash */

复制代码

2 p  a  ^4 \% O  I* ]2 k  第9步：SPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
. d/ q1 p2 R$ a2 Q9 w6 \/ x  第10步：应用方法看本章节配套例子即可。
73.8 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
6 k. c' h; i+ }  u

  第1阶段，上电启动阶段：
5 V" |! @& v  \! @4 W; l
这部分在第14章进行了详细说明。
( K3 _: p  i4 R  R  
第2阶段，进入main函数：
4 D$ Q' ^) y- {9 d& ~! Y/ Q! q
/ S# |6 L4 R6 t8 d  z+ l3 A) R第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现SPI Flash的中断，查询和DMA方式操作。
  n' k) @( c0 ?! Z- e( i" e3 k: g* `8 |
7 W( \; b$ o. {5 u73.9 实验例程说明（MDK）
. c& ?8 L( O7 A" x; `配套例子：

4 H6 A5 p; h! I! VV7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）

V7-050_串行SPI Flash W25QXX读写例程（DMA方式）

V7-051_串行SPI Flash W25QXX读写例程（中断方式）
- a2 Q) x% M& ^; ^: t
' }) b# w+ G6 X4 X. W+ O实验目的：

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

实验操作：

支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
printf("请选择操作命令:\r\n");
5 }0 k  P# ^0 Eprintf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
# ^* V! z! m" i$ o3 h8 |printf("【3 - 擦除整个串行Flash】\r\n");
printf("【4 - 写整个串行Flash, 全0x55】\r\n");
2 ?' f; l8 S1 T$ Sprintf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
printf("其他任意键 - 显示命令提示\r\n");
上电后串口打印的信息：

4 W7 @9 s5 M( n; A8 P" F波特率 115200，数据位 8，奇偶校验位无，停止位 1。
; R( B/ \# Q! `' P
1 S1 L7 I5 x) P" _* I

5 v9 c1 m% r: k
0 L: T% z9 b, L0 o8 E$ M! |% I( r$ s程序设计：

2 k2 m* U* }8 X$ P" I: p  系统栈大小分配：
: D; V1 ?1 s, Z3 B+ L0 N$ R( B

3 i8 J; M6 Z# i
  RAM空间用的DTCM：

9 {( O+ Q4 I. I4 e

1 p' v# E" r) ~
7 t8 v7 d( g* J6 D) e  硬件外设初始化
' v# ~/ E8 {* R( g2 i. G
0 F7 P& }6 a( X! R: ?+ A硬件外设的初始化是在 bsp.c 文件实现：
1 S, T! o" a/ x9 _# Y

1. /*
   + Y+ H4 H% n, C. w9 l3 C
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   ' R1 n& J- q; U5 T% t
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ! C9 l$ H+ x9 }$ I: }/ T0 A
8. */
   
9. void bsp_Init(void)
   
10. {
    ( W) k' J) H& w# ]: z4 M# v/ A# s
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    . ~% s6 B* c) y. ]
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    6 J. S5 M+ K" V2 ^
16. 
    ( h3 b# \9 }* r4 }
17.     /*
    % L$ B- G6 K4 _' i
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    ; k  ?" n4 d2 \$ n
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    . Z9 q: l* P/ k7 d" a
28.     */
    ( ]1 a0 Y& ?, R+ k! _
29.     SystemClock_Config();
    
30. 
    ( A  s3 \  J1 Z+ }! ^/ z3 ?% L
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    * C2 t3 H% t3 [# r; A4 [
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    , j- z# Z& f! |/ O
37.     /* 初始化EventRecorder并开启 */
    , N7 W! B  `3 n7 S; P" o5 M
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    * @8 G! r- }8 C5 _$ e' ~2 L
40. #endif
    * _5 V2 j9 N( f- B
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    " r- V: Z5 D( \$ Q: l! |' s
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();     /* 初始化串口 */
    8 u3 D* Q5 f( t" Y# t3 I
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ' g% x7 s! P. O' j( [
47.     bsp_InitLed();         /* 初始化LED */   
    
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    / }+ u/ d5 y/ `2 b1 @
49. 
    
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    6 f5 v, j( N! \
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    4 S" S, C, R; @( p
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    
53. }

复制代码

  MPU配置和Cache配置：
, K5 D1 q! A, c& |
  F, _9 ?: l5 y5 N+ v, b数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区以及SRAM4
" ?8 [( r7 T5 @) G9 A/ S

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   # Y5 L: Z9 P, Q3 V/ Q/ v
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   , R6 H- M$ l4 z6 f: h" V9 e
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   # y7 Q' q, e+ n+ f
8. */
     B3 ]# o. C0 m) N7 F
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    # f9 A: x4 w" C$ S9 _  t
12. 
    ) o3 Z5 O* n; H* S0 [
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    0 S. B% t; ~8 x4 M; p% N7 T& ]5 C# R& i
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    9 h! G/ m6 i8 J
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    & Q& z% {; A0 p3 t( k$ r1 o
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ! M/ c& x0 V) j" [% b1 l5 d
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    & O4 u+ ~8 P0 X
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    . P% N& |7 u' X" g" s3 `
28. 
    " D) k6 o1 m5 v5 @9 T
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    & @+ Z5 M7 W. {1 J6 }6 l
31. 
    9 {# J( m, [: Z' r# j
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    1 D6 Y- m9 G3 X
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    % n/ K7 `3 w9 Q. j; x; d
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ! B2 _  b+ s2 g6 m% S) o
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ! l& \* w( M% N2 A8 G, ?: E
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    8 f. g8 }' G4 S) }% C
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ! b3 ^  C8 n. |# o1 t
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    9 }, a2 T. h2 G' A) Q
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    2 A) C( H9 V- T2 J3 {
44. 
    * V% C/ r: d/ e2 {
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
      S1 H4 ]- f9 g7 D
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 L4 @2 J- c! @4 v3 |( L4 z# ~/ u* I
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    ) E8 }4 y0 o7 l5 [
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    / ~' H' E+ c, n4 o: e
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    + s5 g* J8 S; Y/ c& z. m6 v: g
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    6 C6 \) @4 z5 Y
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    5 |) c/ e$ }2 K3 \0 z$ ?
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    , C6 q& r# s6 R$ I2 @' T' Q
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # a- B) u  g+ {6 S! U* U
61. 
    
62.     /*使能 MPU */
    ( e) ~* v9 j; v1 O; B
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
64. }
    
65. 
    * {3 s+ k7 l6 s9 J
66. /*
    
67. *********************************************************************************************************
    2 x4 p5 v6 J) S4 `6 A0 X( d+ g
68. *    函 数 名: CPU_CACHE_Enable
    
69. *    功能说明: 使能L1 Cache
    . w4 |' F1 y/ R. R2 J7 @
70. *    形    参: 无
    / {# B9 C2 P7 _6 L# ^0 ~; S0 Y
71. *    返 回 值: 无
    
72. *********************************************************************************************************
    % y  s% }+ A1 c; G: T2 t
73. */
    
74. static void CPU_CACHE_Enable(void)
    
75. {
    # v* O% G/ [4 _: k: m  }. ^6 `
76.     /* 使能 I-Cache */
    
77.     SCB_EnableICache();
    , i5 o# S) f3 D3 E9 @
78. 
    " S6 G" ?* B8 \, _  J
79.     /* 使能 D-Cache */
    / u3 J1 V) j+ B1 O& M1 Z; x  `5 q
80.     SCB_EnableDCache();
    - k1 u& C, Q$ a2 e& ^
81. }

复制代码

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

) b! `: J1 Y4 W5 _" e按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。
6 H6 q( F; r7 t# w7 t( A

1. /*
   8 y: X- C6 e7 \* m! v" m$ \
2. *********************************************************************************************************
   * ~0 ^- M% O( E& z
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   & _5 f7 `1 x, ^4 m3 X* q* o
7. *    返 回 值: 无
   # t3 x+ a! W# H6 {* W. R
8. *********************************************************************************************************
   $ K2 B2 [6 H8 Y4 _
9. */
   ) l/ j9 n2 B6 T% w4 [
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    2 g0 [2 x: B) s- N5 N
13. }
    7 h0 l3 S" c. p4 R% }6 l
14. 
    " w8 w5 t, Y2 e

复制代码

2 `/ l* w3 \! u0 E- y4 E. W7 r* y3 T  主功能：
* X5 e  m5 g8 H. _% f
/ q0 C0 q4 n9 y主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
( {' a$ j! ~# J) D7 f' @  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
' I9 O) n2 t) @. c& o* H+ |' ?  1 - 读串行Flash
  2 - 写串行Flash
  3 - 擦除整个串行Flash
  4 - 写整个串行Flash
  5 - 读整个串行Flash
1 t; g/ ^/ G& {  W  ]( r7 Q  Z - 读取前1K
  X - 读取后1K

1. /*
   4 |7 N8 S4 a+ B% x
2. *********************************************************************************************************
   ( O9 f0 }+ [+ O6 x0 ~; v" {
3. *    函 数 名: DemoSpiFlash
   3 D$ s+ r; T; r  i2 n8 U* C' \. s
4. *    功能说明: 串行EEPROM读写例程
   9 y6 d: n4 `% S
5. *    形    参：无
   
6. *    返 回 值: 无
   . t% M- k6 T5 R: l+ {/ r
7. *********************************************************************************************************
   
8. */
   
9. void DemoSpiFlash(void)
     P( S* w. u% p! G; }- M
10. {
    
11.     uint8_t cmd;
    ; y6 O2 g7 @' h4 F
12.     uint32_t uiReadPageNo = 0;
    
13. 
    
14. 
    % E& D5 T7 g% O
15.     /* 检测串行Flash OK */
    
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    7 k0 T5 i1 Y; s+ _3 n
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    
18. 
    : v9 j6 S) P) ]! e2 y
19.     sfDispMenu();        /* 打印命令提示 */
    8 x3 ?7 t6 J& S- X4 X6 n. Q4 P) e
20. 
    
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    6 G3 o2 ~' E8 ?' ]5 Y% @5 g
22. 
    
23.     while(1)
    ) y# e2 l+ l4 L5 L
24.     {
    
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
26. 
    
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
    
29.         {
    
30.             /* 每隔100ms 进来一次 */  
    
31.             bsp_LedToggle(2);
    , `/ @7 w& S3 a8 u9 v
32.         }
    
33. 
    ; G9 ]) G" b# H" I# D3 z2 p
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
35.         {
    + M3 n% Z9 e% j$ F: l: h
36.             switch (cmd)
    3 s- Z& ]4 F/ s8 b& T- M: C5 k( k
37.             {
    
38.                 case '1':
    7 c9 ~) [( o' A9 ^( Q$ E4 a
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    - P  @- ]( F+ ^2 s/ ?
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    
41.                     break;
    
42. 
    # U1 Y. j; R. _8 M  G8 V2 _# |
43.                 case '2':
    7 e- q, }$ O" A; D
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    2 R* H1 l( F& l; m6 x4 W
46.                     break;
    
47. 
    ; K: P: t6 r& X
48.                 case '3':
    ( C; S+ m4 m. K3 k1 l, J$ R1 }
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    % Y6 J) B/ s6 t8 D5 V+ L
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    : ?' z* F/ @4 L
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
    . Q9 e) `& {& s4 E  Y
53. 
    
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
      U$ g& t6 @, n0 V3 Y
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    
59. 
    
60.                 case '5':
    ' Y' g; p+ w* n0 g+ [
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    1 z& V! U- D% I! X+ B
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
63.                     break;
    
64. 
    0 Z( }7 `+ Z' ~% U
65.                 case 'z':
    ( V6 N" E; i, b& j6 ~& X1 M8 w, h
66.                 case 'Z': /* 读取前1K */
    5 f6 B2 y) r' Q5 q; ~! _( w
67.                     if (uiReadPageNo > 0)
    2 u% R: }$ S* T  W
68.                     {
    4 m+ e+ s- v2 L& l
69.                         uiReadPageNo--;
    
70.                     }
    
71.                     else
    
72.                     {
    ; b5 V3 B" |  B5 ]: ]. X
73.                         printf("已经是最前\r\n");
    / [, r3 |8 Z6 n
74.                     }
    + V8 |3 }; V2 g4 X/ \* q
75.                     sfViewData(uiReadPageNo * 1024);
    
76.                     break;
    ' p9 K2 \! W3 G$ p
77. 
    * C( E* }" Q0 B& r( h/ t/ M
78.                 case 'x':
    ) x9 c2 l/ A; b( C* l
79.                 case 'X': /* 读取后1K */
    , C0 d1 A% A9 H9 f  d; c
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    ; J7 k! K" Y# k& P; F* ^3 E
81.                     {
    
82.                         uiReadPageNo++;
    4 Y3 R2 J. E9 u) X
83.                     }
    ' R5 V( R5 N9 \
84.                     else
    " P+ P1 ~" [  z7 i  |$ o& w
85.                     {
    
86.                         printf("已经是最后\r\n");
    
87.                     }
    
88.                     sfViewData(uiReadPageNo * 1024);
    % J* e+ ^' N( P- @  m; w
89.                     break;
    
90. 
    
91.                 default:
    
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    
94. 
    ; c5 k" I4 A  B3 t5 f7 c7 v
95.             }
    
96.         }
    
97.     }
    
98. }

复制代码

73.10          实验例程说明（IAR）
8 z! T) O4 X& X( s% n0 g配套例子：
) {+ M: A1 j- z! l3 D7 l4 x
V7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）

) n2 ^8 E9 J3 f, @" z+ b; _V7-050_串行SPI Flash W25QXX读写例程（DMA方式）
9 }- H2 s8 V, P! b) _! ~
V7-051_串行SPI Flash W25QXX读写例程（中断方式）
! w: |8 I' G" j" X
实验目的：

8 J2 i# H, J2 I学习SPI Flash的读写实现，支持查询，中断和DMA方式。

3 _$ T. b8 F% y实验操作：
9 o3 E* g* B% ^5 U, u* N+ k( w  a
支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
1 ^6 j( }- H  w+ W* i) D; \* Aprintf("请选择操作命令:\r\n");
# Z3 O. d% s9 |  zprintf("【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");
printf("【4 - 写整个串行Flash, 全0x55】\r\n");
- y7 Z- w8 R4 c$ Sprintf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
printf("其他任意键 - 显示命令提示\r\n");

上电后串口打印的信息：
: H& P- i* f8 X7 t
波特率 115200，数据位 8，奇偶校验位无，停止位 1。
. w" T9 u/ K/ h# f
4 s5 r+ N6 H1 q* s

* x0 u! I9 S+ U  S
程序设计：

: q( \! |9 c# L+ v2 W8 q  系统栈大小分配：

. ~0 j( r8 ~3 v9 _8 w

! R1 P, l, h$ T3 G. F$ ]" h8 o3 Z1 z6 m
8 y2 N; a" R9 F8 w3 L+ ^  RAM空间用的DTCM：
# Z/ n1 y; L5 m, _) z8 X

0 ^0 F6 v. Z# U1 G$ ^( o5 Y# S! y  硬件外设初始化
. ^3 r" b% d) C9 K* X
硬件外设的初始化是在 bsp.c 文件实现：

; n7 @8 i3 T8 Y. Q* M  V6 \. w

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

复制代码

% c8 _$ Y4 z/ m  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
* g5 G+ f  H1 l3 y: z, D  L  i3 E+ H+ H
  j( H) `; q: Y' o5 G* v( o: v

1. /*
   " V1 O: z$ E* b2 X3 v, `, E4 _+ ?
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   % H5 m7 ?" F4 n
5. *    形    参: 无
   * S* ?% |) v( {; @/ Y7 r2 A
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   : N! w, q/ g9 n& T
8. */
   : l/ x. }; [/ `
9. static void MPU_Config( void )
   ) Z5 y+ t' X" \% C7 N
10. {
    ( d+ V4 ^8 d8 d& s4 H; U# ?
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    9 \, J  I2 `3 J" d
13.     /* 禁止 MPU */
    . z7 g+ O4 H9 d
14.     HAL_MPU_Disable();
    
15. 
    . |/ f6 h+ c/ q9 J; a8 t  m0 T
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
      c7 N3 \. W8 i, H* o
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    9 P+ d; w3 c$ f5 d
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    - N5 x# w; e6 O  @* q) L4 H
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 e% a5 [" P5 W$ j" b
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ( M# U9 l2 o2 C; U# Y6 _5 m" M2 W
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ' y; \: A# @* D
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ' Q3 q+ `$ P/ ~5 R: Y+ B% \; r
28. 
      r1 |# H* q& E& ^5 E' e
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    $ k/ b) j- w6 ]: Y5 Y
31. 
    : Y# \, |& ~2 J# k% g2 P
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    $ k, u5 }5 m% n
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    & q. `+ @2 B  g6 T* o# B
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    7 Z- c9 C6 b# _; D% B
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    3 v% Y3 I0 W6 g0 l- n
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    # O. d  [6 K. V: H" P
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    $ D& r& s$ B; E; ?2 F; A2 i
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 s7 w! I1 H* Z2 y, t
46. 
    ! H/ Z8 _8 j2 Q9 M
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    & d  s. e1 M2 y. F6 t+ a/ W" @
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    & `, e! `3 O4 U3 M
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    3 Q3 B/ r2 c$ ~- X% t7 _5 x
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    " q( J; h  P/ T# _2 D
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    & E6 x% _* U, S* |0 O
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    ) f# D7 v, a# c! K' x
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61. 
    ) [$ K; S) @7 m0 d1 h
62.     /*使能 MPU */
    
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
64. }
    
65. 
    
66. /*
    
67. *********************************************************************************************************
    6 d3 A( P2 m+ Q& T
68. *    函 数 名: CPU_CACHE_Enable
    6 w# X4 P2 t* M' u9 l- V# W7 F
69. *    功能说明: 使能L1 Cache
    % d, D9 Y) H, o# Q
70. *    形    参: 无
    0 \" {) G# w! ]+ I  X. v
71. *    返 回 值: 无
    
72. *********************************************************************************************************
    
73. */
    
74. static void CPU_CACHE_Enable(void)
    
75. {
    ) N+ _: t- Y( K: Z" G$ G# l' j0 q0 K
76.     /* 使能 I-Cache */
    
77.     SCB_EnableICache();
    
78. 
    8 c# B2 v. r( B! V% U
79.     /* 使能 D-Cache */
    - x" o# q/ s+ M( _/ X
80.     SCB_EnableDCache();
    
81. }
    + I6 H; K0 \4 [

复制代码

. a7 ]+ K- I' w( V4 B
  每10ms调用一次按键处理：

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

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   ! h: g7 ^2 e/ j% @0 Z# y4 w! [
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   ( ]% X, K% n1 a8 o3 A
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   + D; N$ T7 ^* p" P; h' M
6. *    形    参: 无
   ! h9 q4 F2 y6 Y; T& E# T7 p7 J, W7 M
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   7 @& W6 k1 Z2 _8 B4 j7 f
9. */
   $ l  j7 u8 G2 O+ f+ {3 V
10. void bsp_RunPer10ms(void)
    + P& a1 Z9 T/ f6 d6 n
11. {
    
12.     bsp_KeyScan10ms();
    . x; o- ^) Y  o) x
13. }

复制代码

  主功能：
) o, L) b0 ^( ^
2 N5 x" M* a" \5 t* W$ k主程序实现如下操作：

" O# x( j2 D9 n3 X# Y3 i/ R: ^( H  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
% T# X  x7 v$ B2 v4 ^. p' ~  请选择操作命令:
  1 - 读串行Flash
7 J  v' ?+ @# l- f  2 - 写串行Flash
  3 - 擦除整个串行Flash
  4 - 写整个串行Flash
  5 - 读整个串行Flash
  Z - 读取前1K
  X - 读取后1K

1. /*
   
2. *********************************************************************************************************
   3 w) A. D8 T/ X7 e, k+ u+ F
3. *    函 数 名: DemoSpiFlash
     s; f+ }! H, k  `. [
4. *    功能说明: 串行EEPROM读写例程
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void DemoSpiFlash(void)
   9 n- _# a3 o' k' ?8 u+ p# `
10. {
    / v4 _. I* b6 S4 B
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0;
    + X5 S+ j0 I$ v* {: E% n
13. 
    
14. 
      W" J8 v0 E' V& [
15.     /* 检测串行Flash OK */
    1 m. H8 s9 A9 c; X1 R! \7 ~9 {
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    ! N) v, M% V9 U4 C  v$ m
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    ( Z& Q; i% T9 \' z4 G0 N
18. 
    1 S/ }' l/ L/ d: \# s9 B; l2 y
19.     sfDispMenu();        /* 打印命令提示 */
    
20. 
    
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    6 R/ A% J& A- _6 \9 s
22. 
    
23.     while(1)
    
24.     {
    ! h0 s% n, B7 z1 ?, P
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    - ?$ Y4 V7 X3 B) ^: i0 d
26. 
    4 o' v8 F5 {9 ^# {
27.         /* 判断定时器超时时间 */
    ; w! V9 B9 R/ }4 z7 S) M: V* w
28.         if (bsp_CheckTimer(0))   
    ; `! C: b: g) Z9 D1 a) B
29.         {
    
30.             /* 每隔100ms 进来一次 */  
    
31.             bsp_LedToggle(2);
    ( d+ e( I, \8 u
32.         }
    8 D2 ^2 m* l# w: I
33. 
    5 M$ [* k. V( ?$ O5 v: z$ J) t5 O
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    
35.         {
    
36.             switch (cmd)
    7 ]. e' g! A% S. U3 G0 ?' x6 J4 Q( [
37.             {
    * s4 z& V2 z9 U/ j- r4 y6 d, M
38.                 case '1':
    : j6 V+ w2 S* ^" Z( l6 v1 e
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    1 ?( i) T% ?: X, t& s
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    , u' D2 z. w, t
41.                     break;
    ( S& I( `' w4 K8 q( r3 \( b% O
42. 
    8 j8 v! ~' c6 \$ }) Z; r7 p
43.                 case '2':
    
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    , u& ~& z, F% O( t& x- W" j
47. 
    
48.                 case '3':
    % u+ Y3 {" Q" f9 b# Y
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    / y7 [. t; F% v8 d
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    - c. F: K0 K7 ]" o. k
52.                     break;
    ' h+ t7 m6 w' Q* x5 f
53. 
    
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    , a6 `$ F1 y/ o6 P3 r" Y3 u
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    $ H0 U% t! P, T! k& X
58.                     break;
    ( u9 Y* Y+ h8 D1 g
59. 
    
60.                 case '5':
    
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    9 b8 f" D* b4 S( z
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
63.                     break;
    
64. 
    
65.                 case 'z':
    
66.                 case 'Z': /* 读取前1K */
    9 v! |7 |" C1 j5 V& `# o! i* [
67.                     if (uiReadPageNo > 0)
    
68.                     {
    
69.                         uiReadPageNo--;
    ! K4 G# y% s: I5 @% C/ e( O+ |4 A
70.                     }
    
71.                     else
    , A9 S" U1 B* B( _  K
72.                     {
    
73.                         printf("已经是最前\r\n");
    & H1 z, x8 A2 m; f" y
74.                     }
    % q/ c: c& K! ?1 m) s2 d% ], K
75.                     sfViewData(uiReadPageNo * 1024);
    
76.                     break;
    
77. 
    ) s# x$ ~/ \+ m4 m4 Z& P
78.                 case 'x':
    
79.                 case 'X': /* 读取后1K */
    
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    % Y7 h! z9 m% F+ ^3 l0 s
81.                     {
    
82.                         uiReadPageNo++;
    - n& e8 o2 g' ?  I; k
83.                     }
    8 V2 _1 e( w: D& d  E1 E, v2 b* n
84.                     else
    3 |0 L! E8 S1 p1 V3 {
85.                     {
    
86.                         printf("已经是最后\r\n");
    
87.                     }
    
88.                     sfViewData(uiReadPageNo * 1024);
    2 C1 T5 ]1 [4 F$ ?9 \# d
89.                     break;
    
90. 
    
91.                 default:
    
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    
94. 
    
95.             }
    ' s9 ^7 m$ V/ j( _3 j+ P
96.         }
    
97.     }
    
98. }

复制代码

73.11   总结
本章节就为大家讲解这么多，实际应用中根据需要选择DMA，中断和查询方式。
9 ]6 @- T$ d. m) b


+ n2 b) ]8 I- |* r' j5 k8 s# ^: `