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

$ W. [4 [  `" A/ B2 G) X  Y$ u
$ v3 Q/ ^2 b1 ?2 x% Z4 p0 L  本章第3小节整理的知识点比较重要，务必要了解下，特别是页编程和页回卷。
$ _( T% a0 q$ E: g8 u6 T  s/ Z  对SPI Flash W25QXX的不同接线方式（1线，2线或者4线，这里的线是指的数据线），编程命令是不同的。
  W25Q64JV最高支持133MHz，但最高读命令03H速度是50MHz。
' _$ T. q  e1 }3 @5 P  文件bsp_spi_bus.c文件公共的总线驱动文件，支持串行FLASH、TSC2046、VS1053、AD7705、ADS1256等SPI设备的配置。
1 N1 i' {" q6 y8 Y) C  函数sf_WriteBuffer不需要用户做擦除，会自动执行擦除功能，支持任意大小，任意地址，不超过芯片容量即可。

7 W1 W$ N& u. ^3 D) k+ j73.2 W25QXX硬件设计
# F0 b: J- K) {STM32H7驱动W25QXX的硬件设计如下：

! h) ]1 x7 u/ U5 t$ I

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

0 {/ _# U( n! Y0 W  V7开发板实际外接的芯片是W25Q64JV。
6 V, f7 O$ Y% Z( c% q, d  CS片选最好接上拉电阻，防止意外操作。
5 E/ t* z/ i! m8 S) E$ k% [  这里的PB3，PB4和PB5引脚可以复用SPI1，SPI3和SPI6。实际应用中是复用的SPI1。
; }6 d" c2 A. j. B/ \$ F7 m" A  W25Q64的WP引脚用于写保护，低电平有效性，当前是直接高电平。
  HOLD引脚也是低电平有效，当前是将其接到高电平。此引脚的作用是CS片选低电平时，DO引脚输出高阻，忽略CLK和DI引脚上的信号。
73.3 W25QXX关键知识点整理（重要）
驱动W25QXX前要先了解下这个芯片的相关信息。

1 U$ h4 m% Q# L1 y

7 F, V! m& D0 \9 S7 }& @
8 k& z$ _9 d/ I+ D73.3.1 W25QXX基础信息
9 |( v# J, G  f( g7 ~( F  W25Q64FV的容量是8MB（256Mbit）。
  W25Q64FV支持标准SPI（单线SPI），用到引脚CLK、CS，DI和DO引脚。
支持两线SPI，用到引脚CLK、CS、IO0、IO1 。

支持四线SPI，用到引脚CLK、CS、IO0、IO1，IO2、IO3。
: y% H7 l6 k2 K2 r2 Q  `
（注：这里几线的意思是几个数据线）。
+ q' J. Q" B& a) ]( q$ c3 P
: C- w9 C6 C% t; z: W  W25Q64FV支持的最高时钟是133MHz。
/ W: d8 J( |0 A6 Y# \% P  每个扇区最少支持10万次擦写，可以保存20年数据。
$ p- x! W+ q; Q2 u  页大小是256字节，支持页编程，也就是一次编写256个字节，也可以一个一个编写。
  b) c, y. Y! ^: ]2 O  支持4KB为单位的扇区擦除，也可以32KB或者64KB为单位的擦除。
整体框图如下：
  P1 S$ i6 h6 B: D7 e# f+ \: ?
8 Z( a( G- Y3 z& i' x

0 \& j8 x" \' O8 g, `
$ W; k# I, S9 g( NW25Q64FV：

9 m) U4 l. M( C2 s% i  有128个Block，每个Block大小64KB。
  c3 l& P$ B1 j- P( k1 p  每个Block有16个Sector，每个Sector大小4KB。
  每个Sector有16个Page，每个Page大小是256字节。
1 g: P. {# c7 v+ r73.3.2 W25QXX命令
$ c" X' d! w( O# h使用W25Q的接线方式不同，使用的命令也有所不同，使用的时候务必要注意，当前我们使用的标准SPI，即单线SPI，使用的命令如下：
; {0 ~# H! Y9 N
8 p( t6 |$ _% }6 X7 u1 |7 r; _

当前主要用到如下几个命令：
) d9 Z8 h, ^7 U3 e2 d

1. #define CMD_EWRSR       0x50  /* 允许写状态寄存器的命令 */
   
2. #define CMD_WRSR      0x01  /* 写状态寄存器命令 */
   5 @$ A5 c- O/ n. g
3. #define CMD_WREN      0x06    /* 写使能命令 */
   
4. #define CMD_READ      0x03  /* 读数据区命令 */
   
5. #define CMD_RDSR      0x05    /* 读状态寄存器命令 */
   7 I  M/ T& V9 x
6. #define CMD_RDID      0x9F    /* 读器件ID命令 */
   3 }! f( a0 ]" F( U# K% g
7. #define CMD_SE        0x20    /* 擦除扇区命令 */
   3 ?* L, v0 P$ s( ^; h' i
8. #define CMD_BE        0xC7    /* 批量擦除命令 */
   
9. #define WIP_FLAG      0x01    /* 状态寄存器中的正在编程标志（WIP) */

复制代码

73.3.3 W25QXX页编程和页回卷
& r* ?& K; E6 YSPI Flash仅支持页编程（页大小256字节），所有其它大批量数据的写入都是以页为单位。这里注意所说的页编程含义，页编程分为以下三步（伪代码）：
8 s: O" h5 d; }9 d
- z/ o1 y5 C) V* x6 n+ O8 i

1. bsp_spiWrite1(0x02);                               ----------第1步发送页编程命令        
   ; V5 s6 A4 H1 A4 A/ c: U5 q1 j; R
2. bsp_spiWrite1((_uiWriteAddr & 0xFF0000) >> 16);    ----------第2步发送地址   
   1 Y% N6 [- n8 `/ h% y3 Q
3. bsp_spiWrite1((_uiWriteAddr & 0xFF00) >> 8);   
   
4. bsp_spiWrite1(_uiWriteAddr & 0xFF);               
   . M: S' A( J8 {6 E+ G8 K2 `
5. 
   ! T! n3 }) b: ~5 u% K! w3 I. ^  e$ i
6.     for (i = 0; i < _usSize; i++)
   - i4 ]. ^6 s2 u% Z
7.     {
   % r( ]6 T4 C; }
8.         bsp_spiWrite1(*_pBuf++);   ----------第3步写数据，此时就可以连续写入数据了，
   ; e  c9 }4 \3 n/ k* [/ s% a* G2 w
9.                                              不需要再重新设置地址，地址会自增。这样可以大大加快写入速度。   
   
10.     }

复制代码

页编程的含义恰恰就体现在第3步了，如果用户设置的“起始地址+数据长度”所确定的地址范围超过了此起始地址所在的页，地址自增不会超过页范围，而是重新回到了此页的首地进行编写。这一点要特别的注意。如果用户不需要使用地址自增效果，那么直接指定地址进行编写即可。可以任意指定地址进行编写，编写前一定要进行擦除。
, U/ m  j5 l9 \* s9 a: Z: o7 s4 b) I
比如下面就是页内操作（使用前已经进行了扇区擦除，每次擦除最少擦除一个扇区4KB）：

1 F0 L# d; u: }9 |4 J5 r

1. uint8_t tempbuf[10] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00};
   : L, q( P: b1 Z0 H
2. uint8_t temp1 = 0x10, temp2 = 0x29, temp3 = 0x48;

复制代码

  从250地址开始写入10个字节数据 PageWrite(tempbuf,  250,  10);（因为一旦写入超过地址255，就会从0地址开始重新写）。
, D' h9 @- `2 v+ m0 A  向地址20写入1个字节数据：PageWrite(&temp1,  20,  1);
  向地址30写入1个字节数据：PageWrite(&temp2,  30,  1);
  向地址510写入1个字节数据：PageWrite(&temp3,  510,  1) (这里已经是写到下一页了)
下面是将从0地址到511地址读取出来的512个字节数据，一行32字节。
& T+ R- Y; q% z  j) l/ o6 o
/ v  \) c& v9 F3 ?; m/ Q4 x

9 T' i+ X/ m# l$ X1 ~% x

73.3.4 W25QXX扇区擦除
SPI Flash的擦除支持扇区擦除（4KB），块擦除（32KB或者64KB）以及整个芯片擦除。对于扇区擦除和块擦除，使用的时候要注意一点，一般情况下，只需用户给出扇区或者块的首地址即可。
( A2 P: [6 G3 \. Z2 I. E8 V' [
' p' l1 i5 l8 Z7 u如果给的不是扇区或者块的首地址也没有关系的，只要此地址是在扇区或者块的范围内，此扇区或者块也可以被正确擦除。不过建议使用时给首地址，方便管理。

73.3.5 W25QXX规格参数
这里我们主要了解擦写耗时和支持的时钟速度，下面是擦写时间参数：
* G6 k7 y* Y' ?: v3 n

. u8 {3 [+ j/ G
) m6 i4 ^* x% K' V3 N8 {- ^+ F9 D  页编程时间：典型值0.4ms，最大值3ms。
  扇区擦除时间（4KB）：典型值45ms，最大值400ms。
  块擦除时间（32KB）：典型值120ms，最大值1600ms。
7 `: b* e4 s2 Y  块擦除时间（64KB）：典型值150ms，最大值2000ms。
) S$ w& b5 B0 P7 U, u. m' }  整个芯片擦除时间：典型值20s，最大值100s。

+ y, C) D; b: A7 F: ^! ]) y
支持的速度参数如下：

* D8 B4 M& }6 b% g

" }  J$ I9 n& M' x0 }6 M7 C
. `# g  [& d: P# X4 T' P! f可以看到最高支持的读时钟（使用命令03H）速度是50MHz，其它命令速度可以做到133MHz。

' V/ g# P* Q* Q: v/ I73.4 W25QXX驱动设计
W25QXX的程序驱动框架设计如下：

1 G2 q% ~6 q5 g. {7 E+ _
9 l/ D# P9 U; ^' Y. z) l0 j有了这个框图，程序设计就比较好理解了。
4 R6 N4 I8 O& E6 J% a' q# z5 i
  v0 f5 M9 U" m' b6 p73.4.1 第1步：SPI总线配置
6 l4 D% \+ \& D7 L; Yspi总线配置通过如下两个函数实现：
$ B& |7 y. v! Y

1. /*
   ! L" r& V; {( Y. Q
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_InitSPIBus
   
4. *    功能说明: 配置SPI总线。
   1 R; Q! C! [+ F+ }
5. *    形    参: 无
   1 y2 P# X$ n& ]  o* r# m2 D
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitSPIBus(void)
   & H; y2 I3 n" a4 [
10. {   
    1 ~" T, i- o' c0 L3 A
11.     g_spi_busy = 0;
    " d- n" z( e' o8 [1 a; E/ t
12. 
    
13.     bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_8, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);
    9 `4 m$ [2 K* w( v  Z
14. }
    - g& _: P) ~4 H- t5 ~- b
15. 
    * ]: j/ ^; [1 B" ~! U8 F' V% ]
16. /*
    
17. *********************************************************************************************************
    7 @& h- i+ f' v3 w0 t; B6 j
18. *    函 数 名: bsp_InitSPIParam
    & |6 d; d7 s5 g' ?
19. *    功能说明: 配置SPI总线参数，时钟分频，时钟相位和时钟极性。
    
20. *    形    参: _BaudRatePrescaler  SPI总线时钟分频设置，支持的参数如下：
    
21. *                                 SPI_BAUDRATEPRESCALER_2    2分频
    
22. *                                 SPI_BAUDRATEPRESCALER_4    4分频
    
23. *                                 SPI_BAUDRATEPRESCALER_8    8分频
    7 U- q/ g7 N' ^4 I0 V9 F
24. *                                 SPI_BAUDRATEPRESCALER_16   16分频
    
25. *                                 SPI_BAUDRATEPRESCALER_32   32分频
    * i' T, v% D2 a
26. *                                 SPI_BAUDRATEPRESCALER_64   64分频
      _9 \. e( a% T) G, e
27. *                                 SPI_BAUDRATEPRESCALER_128  128分频
    
28. *                                 SPI_BAUDRATEPRESCALER_256  256分频
    
29. *                                                        
    . N1 _8 m" b" o( C
30. *             _CLKPhase           时钟相位，支持的参数如下：
    
31. *                                 SPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
    
32. *                                 SPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
    7 A8 t! n- S$ X: v2 ?: K
33. *                                 
    ' z2 ]! V0 ]# o6 `
34. *             _CLKPolarity        时钟极性，支持的参数如下：
    
35. *                                 SPI_POLARITY_LOW    SCK引脚在空闲状态处于低电平
    4 V4 v6 X% o' d7 M, O
36. *                                 SPI_POLARITY_HIGH   SCK引脚在空闲状态处于高电平
    ) N% ?" V2 A) R: N/ M; S; y- S
37. *
    
38. *    返 回 值: 无
    , ]7 _" x2 b2 j3 l! O/ }  c
39. *********************************************************************************************************
    ! C) c1 Z! r+ D
40. */
    
41. void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)
    2 D4 I5 E% ~8 ?- A& M9 M
42. {
    5 H3 A& `8 d: g
43.     /* 提高执行效率，只有在SPI硬件参数发生变化时，才执行HAL_Init */
    
44.     if (s_BaudRatePrescaler == _BaudRatePrescaler && s_CLKPhase == _CLKPhase && s_CLKPolarity == _CLKPolarity)
    
45.     {        
    " m; v1 V9 M. H% i6 P
46.         return;
    * P/ S* F5 G! O4 I5 F! b) k& z
47.     }
    : @4 X9 E3 P" x
48. 
    
49.     s_BaudRatePrescaler = _BaudRatePrescaler;   
    
50.     s_CLKPhase = _CLKPhase;
    ! D) e, `) ^' K( M' K8 u
51.     s_CLKPolarity = _CLKPolarity;
    1 B- }4 ]3 \6 [& a9 e" X
52. 
    , ?* H1 v1 Z8 @$ K4 g  ]
53. 
    5 |  U  q; v) m/ z! [- H' z
54.     /* 设置SPI参数 */
    
55.     hspi.Instance               = SPIx;                   /* 例化SPI */
    ! R9 z& y% u( o$ v8 L) Y
56.     hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
    / T, g; y* _. Q9 Z( d9 L
57.     hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
    . ~5 Z+ R! m- u' ~
58.     hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
    
59.     hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
    5 T9 B2 ^2 j0 y
60.     hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
    6 E3 R1 V1 D; d8 s) U
61.     hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    6 }/ e0 m5 @, z, v' F2 s2 b+ l2 D
62.     hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    2 s( G% s+ Z( y  O+ C, a# |
63.     hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE; /* 禁止CRC */
    9 F+ J5 m1 @9 G
64.     hspi.Init.CRCPolynomial     = 7;                       /* 禁止CRC后，此位无效 */
    
65.     hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;     /* 禁止CRC后，此位无效 */
    
66.     hspi.Init.NSS               = SPI_NSS_SOFT;               /* 使用软件方式管理片选引脚 */
    6 R; f# d  x  N+ @4 S  U$ Z0 _
67.     hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;  /* 设置FIFO大小是一个数据项 */
    
68.     hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;      /* 禁止脉冲输出 */
    ; {& I. Z$ Z7 d# b- O  u3 ^( o& C
69.     hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    
70.     hspi.Init.Mode             = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    . j9 n* \8 ^8 R" N8 R
71. 
    
72.     /* 复位配置 */
    + l  i( u# F& _! a4 _
73.     if (HAL_SPI_DeInit(&hspi) != HAL_OK)
    " X0 R9 Q+ C2 N- Q% e6 \" {) c
74.     {
    
75.         Error_Handler(__FILE__, __LINE__);
    9 A( q) h* `+ t" a
76.     }   
    
77. 
    
78.     /* 初始化配置 */
    
79.     if (HAL_SPI_Init(&hspi) != HAL_OK)
    
80.     {
    
81.         Error_Handler(__FILE__, __LINE__);
    8 e( N% Y7 s  K  t0 {8 f( c- n( Z( g
82.     }   
    - }, t$ {" |6 ]$ n6 r6 X; w
83. }

复制代码

# f3 B/ b1 R" L) ^) g  y( n" w关于这两个函数有以下两点要做个说明：

) t  {4 q4 T" g* B  d  函数bsp_InitSPIBus里面的配置是个初始设置。实际驱动芯片时，会通过函数bsp_InitSPIParam做再配置。
, a5 C8 o  P7 H+ C8 N  函数bsp_InitSPIParam提供了时钟分频，时钟相位和时钟极性配置。驱动不同外设芯片时，基本上调整这三个参数就够。当SPI接口上接了多个不同类型的芯片时，通过此函数可以方便的切换配置。
2 h& U5 c9 l3 x, f& e0 \73.4.2 第2步：SPI总线的查询，中断和DMA方式设置
SPI驱动的查询，中断和DMA方式主要通过函数bsp_spiTransfer实现数据传输：

/ K- I, a& b" O; T" t

1. /*
   
2. *********************************************************************************************************
   $ w9 E4 b3 J# E
3. *                                 选择DMA，中断或者查询方式
   $ p$ r  R* O6 \2 y6 Y  `, {. ~) n
4. *********************************************************************************************************
   ( X) d* u: `7 ]& q
5. */
   0 J( |$ R7 s" M3 J/ \
6. //#define USE_SPI_DMA    /* DMA方式  */
   
7. //#define USE_SPI_INT    /* 中断方式 */
   $ q  h9 |: e% m) O: E! k
8. #define USE_SPI_POLL   /* 查询方式 */
   $ H2 P5 b+ }! u7 r) C6 O
9. 
   
10. /* 查询模式 */
    
11. #if defined (USE_SPI_POLL)
    
12. 
    
13. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];  
    
14. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    5 }  E( s3 f, `" V, ?& D
15. 
    
16. /* 中断模式 */
    
17. #elif defined (USE_SPI_INT)
    3 A! n/ A: r2 a( O8 L
18. 
    # b5 M% |# C% O; p! X3 |/ A% \
19. uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
20. uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    
21. 
    
22. /* DMA模式使用的SRAM4 */
    & Z" m. E% E; P% C/ J' W
23. #elif defined (USE_SPI_DMA)
    . _+ o5 g$ [" ]2 V2 d7 R# @) j
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];
    # e( D! G$ @4 f3 I* v2 A2 \9 |
27.     #elif defined (__ICCARM__)   /* MDK ********/
    ) {) ?0 Q: W4 N8 }
28.         #pragma location = ".RAM_D3"
    3 ^. {1 G* e2 N$ t, |
29.         uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];   
    
30.         #pragma location = ".RAM_D3"
    
31.         uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    3 p, n6 S* d7 K8 i5 r( V
32.     #endif
    
33. #endif
    
34. 
    ) [' b5 u, f& n3 c
35. /*
    & B5 |8 m; d1 u; O
36. *********************************************************************************************************
    # {7 ~$ x* g3 q' [' n
37. *    函 数 名: bsp_spiTransfer
      w( H! F/ u! W7 ?& y- y
38. *    功能说明: 启动数据传输
    & X: Y) o+ M1 |; W
39. *    形    参: 无
    
40. *    返 回 值: 无
    5 w- E6 s: s( _2 G* |$ L$ f% }
41. *********************************************************************************************************
    
42. */
    
43. void bsp_spiTransfer(void)
    - g1 v# W9 N) u
44. {
    % N7 y/ o. _, ~# t! w* ~; u
45.     if (g_spiLen > SPI_BUFFER_SIZE)
    
46.     {
    4 _) F+ M( ]3 T/ f' j2 c4 U
47.         return;
    
48.     }
    
49. 
    
50.     /* DMA方式传输 */
    / n5 A* j& k6 M2 _% Q' S# J  r
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)   
      g& `# _) ~/ F) y9 C$ ^
55.     {
    $ i. `, p3 ?' }, G9 g8 h
56.         Error_Handler(__FILE__, __LINE__);
    0 b3 n+ q# `& z/ t4 _0 L! C, J. a
57.     }
    % @! ?, O9 C6 X5 D* s
58. 
    ! \: k5 m) w6 e5 |- E
59.     while (wTransferState == TRANSFER_WAIT)
    
60.     {
    7 c( r1 Q% R3 v, s0 M' p
61.         ;
    
62.     }
    
63. #endif
    
64. 
    
65.     /* 中断方式传输 */   
    . \$ ~& W$ x) r8 A! K
66. #ifdef USE_SPI_INT
    . V* e% B; ]1 C2 C4 r' ?( o1 a
67.     wTransferState = TRANSFER_WAIT;
    # B1 _' }: p) m) i* [# {
68. 
    
69.     if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
    ! m5 j+ M' Y! ~7 u9 @2 q: X- j
70.     {
    
71.         Error_Handler(__FILE__, __LINE__);
    6 D# }3 M8 n$ S9 r1 @
72.     }
    ( _' C9 v, {, R$ J
73. 
    ! |- f# K' o! j( Q
74.     while (wTransferState == TRANSFER_WAIT)
    
75.     {
    
76.         ;
    
77.     }
    
78. #endif
    ' {. b7 I4 o: D) ^; K8 ^+ {
79. 
    ; W* S2 N4 E$ V( z! }$ x0 {7 X
80.     /* 查询方式传输 */   
    
81. #ifdef USE_SPI_POLL
    : B* r+ U- q2 ]  D* K
82.     if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)   
    
83.     {
    
84.         Error_Handler(__FILE__, __LINE__);
    
85.     }   
    6 R: I( I) F; q# L0 a/ O
86. #endif
    & T7 `  m" @: R8 U
87. }
    $ A" U, N) W" w1 C; C  t

复制代码

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

, e. P/ R6 @" P6 u( B+ N  通过本手册第26章的内存块超方便使用方式，将DMA缓冲定义到SRAM4上。因为本工程是用的DTCM做的主RAM空间，这个空间无法使用通用DMA1和DMA2。
  由于程序里面开启了数据Cache，会造成DMA和CPU访问SRAM4数据不一致的问题，特此将SRAM4空间关闭Cache。
  a! q/ N0 U  |3 ?( u# O& c3 @

1.     /* 配置SRAM4的MPU属性为Non-cacheable */
   5 R& `2 t8 L) V( N/ Y' Y+ Z3 J
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;
   4 i- S) Z: b) j
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;
   5 A) x, {* Q1 W3 w  Q4 q) l
10.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
11.     MPU_InitStruct.SubRegionDisable = 0x00;
    
12.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
13. 
    4 d' q- O4 i1 u2 r% K& p
14.     HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

9 t7 e1 L4 G4 ]% w- b73.4.3 第3步：W25QXX的时钟极性和时钟相位配置
& o1 |* |' T7 s% v首先回忆下STM32H7支持的4种时序配置。
# @7 E( q  v5 ^4 V3 S
  当CPOL = 1， CPHA = 1时

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

6 J5 s5 n: x' @" S$ i! h; R  当CPOL = 0， CPHA = 1时

4 c3 k* b% P' m1 K" ESCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。
; C" R; f% J* E. k! V
  当CPOL = 1， CPHA = 0时
7 A2 M! ?3 W) H4 F2 m
SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

0 y. _4 V0 P) e 当CPOL = 1， CPHA = 0时
. g6 E: d+ m8 d- ?+ }9 D' V
SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
+ T: Y. I- e5 R0 n  I" R; b

有了H7支持的时序配置，再来看下W25Q的时序图：

! |  s9 {8 v5 N: ZMode0 ： 空闲状态的sck是低电平。

5 e- M7 V) R1 \Mode1 ： 空闲状态的sck是高电平。
: d: U: Z2 i, [& y3 m) l
% I3 S: ~& f; y. g3 ?

首先W25Q是上升沿做数据采集，所以STM32H7的可选的配置就是：
$ L) _4 P1 d' o3 l
) {' i" G2 v2 i' y  A5 {CHOL = 1,  CPHA = 1

CHOL = 0,  CPHA = 0
+ U3 ]* l6 J/ ^0 C1 a' W7 M
对于这两种情况，具体选择哪种，继续往下看。W25Q有两种SCK模式，分别是Mode0和Mode3，也就是空闲状态下，SCK既可以是高电平也可以是低电平。这样的话，这两种情况都可以使用，经过实际测试，STM32H7使用这两个配置均可以配置驱动W25Q。
4 ^3 l( S" g+ ]/ C: Y! k- ]
/ J2 F% c5 _5 f- C73.4.4 第4步：单SPI接口管理多个SPI设备的切换机制
单SPI接口管理多个SPI设备最麻烦的地方是不同设备的时钟分配，时钟极性和时钟相位并不相同。对此的解决解决办法是在片选阶段配置切换，比如SPI Flash的片选：

4 D9 ~) n( N: s+ o

1. /*
   
2. *********************************************************************************************************
   . P0 R$ W* j8 b  B
3. *    函 数 名: sf_SetCS
   & R- e% n, f7 q) n- k
4. *    功能说明: 串行FALSH片选控制函数
   
5. *    形    参: 无
   $ R' j1 ~2 `* D& J2 r$ ^; o
6. *    返 回 值: 无
   % }9 m. ~7 ^0 x" B
7. *********************************************************************************************************
   + l& U& k3 V( u: a! q" ^
8. */
   + z& A! v% [, ~0 e7 o! y
9. void sf_SetCS(uint8_t _Level)
   
10. {
    7 P% q! }6 X7 s% |6 f, f
11.     if (_Level == 0)
    
12.     {
    + q8 D+ y6 X: R
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    / R* c6 Q- ^$ h- H1 f5 s7 g
15.         SF_CS_0();
    1 i2 Z: l+ {' A  ]" S
16.     }
    * }3 A# b; u# U1 Y$ I
17.     else
    
18.     {        
    
19.         SF_CS_1();   
      y: s7 G  o5 H# {
20.         bsp_SpiBusExit();        
    3 q% P5 ?6 U/ E! w: s
21.     }
    
22. }
    

复制代码

* r- {( Y% T' @# Z) o" s% d
& H( n4 c1 {! I  K3 Q2 n通过这种方式就有效的解决了单SPI接口管理多设备的问题。因为给每个设备都配了一个独立的片选引脚，这样就可以为每个设备都配置这么一个片选配置。

但是频繁配置也比较繁琐，所以函数bsp_InitSPIParam里面做了特别处理。当前配置与之前配置相同的情况下无需重复配置。
" \8 b& J' Q$ M
8 l- E. [: o9 y73.4.5 第5步：W25QXX的读取实现
W25QXX的读取功能比较好实现，发送03H命令后，设置任意地址都可以读取数据，只要不超过芯片容量即可。
3 E  _6 V5 x1 _3 {0 f; Y! A: \: C
) T0 d4 p5 G# \2 F

1. /*
   , p( v" F, I" ~  `: O, _* A
2. *********************************************************************************************************
   % s  N: h! {/ u( f. W
3. *    函 数 名: sf_ReadBuffer
   ! t# C5 b, u0 m( d
4. *    功能说明: 连续读取若干字节，字节个数不能超出芯片容量。
   6 x# o3 G; v: B* I
5. *    形    参:      _pBuf : 数据源缓冲区；
   4 z  k  |0 C$ W- V; I8 Z( E4 C
6. *                _uiReadAddr ：首地址
   : ~; ^. B% C0 U" X( t$ ?( j0 c/ j( g
7. *                _usSize ：数据个数, 不能超出芯片总容量
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    ; Y' m8 p0 A; }: E. }0 O! Y% M
11. void sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)
    
12. {
    
13.     uint16_t rem;
    
14.     uint16_t i;
    # M- A% n0 s, Y  D
15. 
    ) P+ O8 I' M. o+ D( |( h
16.     /* 如果读取的数据长度为0或者超出串行Flash地址空间，则直接返回 */
    
17.     if ((_uiSize == 0) ||(_uiReadAddr + _uiSize) > g_tSF.TotalSize)
    , T" `" u' c. L5 j7 o
18.     {
    , L8 H& w) y2 B; b6 v5 G
19.         return;
    & m& O7 t  `% n* r$ t" V4 T
20.     }
    
21. 
    ; }6 X/ ]2 p: Y# R; J; q
22.     /* 擦除扇区操作 */
    4 |' o7 r6 t6 \9 b5 S: B7 x2 Z
23.     sf_SetCS(0);                                    /* 使能片选 */
    
24.     g_spiLen = 0;
    " p2 W8 e- h2 T* L
25.     g_spiTxBuf[g_spiLen++] = (CMD_READ);                            /* 发送读命令 */
    : \0 N8 c' f& M6 ~
26.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    
27.     g_spiTxBuf[g_spiLen++] = ((_uiReadAddr & 0xFF00) >> 8);        /* 发送扇区地址中间8bit */
    
28.     g_spiTxBuf[g_spiLen++] = (_uiReadAddr & 0xFF);                /* 发送扇区地址低8bit */
    
29.     bsp_spiTransfer();
    
30. 
    
31.     /* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
    
32.     for (i = 0; i < _uiSize / SPI_BUFFER_SIZE; i++)
    : A, y" m* t$ C) M
33.     {
    
34.         g_spiLen = SPI_BUFFER_SIZE;
    
35.         bsp_spiTransfer();
    
36. 
    
37.         memcpy(_pBuf, g_spiRxBuf, SPI_BUFFER_SIZE);
    : c# v  z0 ^8 ^( D
38.         _pBuf += SPI_BUFFER_SIZE;
    
39.     }
    
40. 
    # B( \  }$ I: v* Z: p1 m, _. K) V
41.     rem = _uiSize % SPI_BUFFER_SIZE;    /* 剩余字节 */
      v) Q# V- P/ S: t
42.     if (rem > 0)
    
43.     {
    8 `4 l& e& I6 c  v8 @% U: E: R
44.         g_spiLen = rem;
    6 E) m9 y& e6 z
45.         bsp_spiTransfer();
    
46. 
    
47.         memcpy(_pBuf, g_spiRxBuf, rem);
    ' b8 f8 ~# p6 L0 R( |  i+ f6 t
48.     }
    
49. 
    8 I- [5 V& Z4 f6 ?
50.     sf_SetCS(1);                                    /* 禁能片选 */
    - M9 u/ a; @# i
51. }

复制代码

: x; @* T& C0 N: _- h5 M! }$ A+ P这个函数对DMA传输做了特别处理，方便分包进行。
* w: o6 E3 p; y. K* V
- y$ K8 Z& U% ]1 N, T$ T73.4.6 第6步：W25QXX的扇区擦除实现
扇区擦除的实现也比较简单，发送“扇区擦除命令+扇区地址”即可完成相应扇区的擦除。擦除的扇区大小是4KB。

3 k  j2 y' J- \( ?( E

1. /*
   4 c# V2 Q( I& S/ t# a
2. *********************************************************************************************************
   . \) C( e9 n  d' ^& _
3. *    函 数 名: sf_EraseSector
   
4. *    功能说明: 擦除指定的扇区
   
5. *    形    参: _uiSectorAddr : 扇区地址
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   # {% d" z3 P( A+ a+ |5 `
8. */
   
9. void sf_EraseSector(uint32_t _uiSectorAddr)
   
10. {
    
11.     sf_WriteEnable();                            /* 发送写使能命令 */
    
12. 
    5 u! p6 M$ H+ v; c3 K& D% G
13.     /* 擦除扇区操作 */
    & L4 m# T, T' p, T" _
14.     sf_SetCS(0);                                /* 使能片选 */
    7 H& U( p2 Q/ o* t  w; f9 ]
15.     g_spiLen = 0;
    
16.     g_spiTxBuf[g_spiLen++] = CMD_SE;                /* 发送擦除命令 */
    
17.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF0000) >> 16);    /* 发送扇区地址的高8bit */
    2 @$ z8 z5 Y4 V( e* J' J
18.     g_spiTxBuf[g_spiLen++] = ((_uiSectorAddr & 0xFF00) >> 8);    /* 发送扇区地址中间8bit */
    ! L. k: O* ^1 f' a) X. v
19.     g_spiTxBuf[g_spiLen++] = (_uiSectorAddr & 0xFF);            /* 发送扇区地址低8bit */   
    
20.     bsp_spiTransfer();
    / Z( g. }$ w0 V3 n$ {/ t, f- s. S9 G" J
21.     sf_SetCS(1);                                    /* 禁能片选 */
    8 v* |( O6 J& m- t; y
22. 
    
23.     sf_WaitForWriteEnd();                            /* 等待串行Flash内部写操作完成 */
    ; o7 V" ^! E3 `
24. }
    8 H7 E) T, I+ n9 n+ A  R  q

复制代码

整个芯片的擦除更省事些，仅发送整个芯片擦除命令即可：
/ w/ l$ p! D6 Q

1. /*
   , Q+ }0 \8 ^  G0 @; p/ q* Z) s9 v" @$ t
2. *********************************************************************************************************
   ! K8 Y2 z1 p( o
3. *    函 数 名: sf_EraseChip
     t. N3 x' j* f7 T. L  f7 \
4. *    功能说明: 擦除整个芯片
   8 D6 T) y; d* `& S5 Y
5. *    形    参:  无
   
6. *    返 回 值: 无
   ; d; N) T& F4 J; w
7. *********************************************************************************************************
   
8. */
   9 y  X! H- U* I# S
9. void sf_EraseChip(void)
   
10. {   
    
11.     sf_WriteEnable();                                /* 发送写使能命令 */
    
12. 
    
13.     /* 擦除扇区操作 */
    
14.     sf_SetCS(0);        /* 使能片选 */
    ' a- _& x  W$ n5 p2 C
15.     g_spiLen = 0;
    % ~6 T$ A$ j3 V  _" N6 R, H9 R
16.     g_spiTxBuf[g_spiLen++] = CMD_BE;        /* 发送整片擦除命令 */
    + e/ H9 |1 J0 L) a9 q
17.     bsp_spiTransfer();
    
18.     sf_SetCS(1);                        /* 禁能片选 */
    
19. 
    
20.     sf_WaitForWriteEnd();                /* 等待串行Flash内部写操作完成 */
    + C9 Q- `& G. M& v, J
21. }
    

复制代码

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

8 \; @! k! u4 g. s& f

1. /*
   
2. *********************************************************************************************************
   & D# S/ y% o+ |; @
3. *    函 数 名: sf_WriteBuffer
   ; B2 C* |% L) W+ t
4. *    功能说明: 写1个扇区并校验,如果不正确则再重写两次，本函数自动完成擦除操作。
   
5. *    形    参:  _pBuf : 数据源缓冲区；
   
6. *               _uiWrAddr ：目标区域首地址
   6 U, [* N1 A0 `* l5 J6 e
7. *               _usSize ：数据个数，任意大小，但不能超过芯片容量。
   . J3 N  p9 n4 n+ L
8. *    返 回 值: 1 : 成功， 0 ： 失败
   
9. *********************************************************************************************************
   ; c. B/ o* S6 u; x0 ^8 Z
10. */
    , u- d# b5 A# G
11. uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)
    * k2 c& H9 R$ I' J9 U+ [
12. {
    
13.     uint32_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
    
14. 
      M' W6 t! [* K2 Z- X
15.     Addr = _uiWriteAddr % g_tSF.SectorSize;
    
16.     count = g_tSF.SectorSize - Addr;
    9 h) b. k; `3 w: `8 _
17.     NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    
18.     NumOfSingle = _usWriteSize % g_tSF.SectorSize;
      t/ E9 v* b: a/ j! d/ w( c
19. 
    
20.     if (Addr == 0) /* 起始地址是扇区首地址  */
    . P- i. A. l2 z# x% h
21.     {
    9 m, y0 a& L9 |6 X( m( U4 y) z
22.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
23.         {
    9 |% h: u5 I+ t$ c- K% c
24.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    
25.             {
    
26.                 return 0;
    * ]. |$ m* l4 d- G& P7 S: P
27.             }
    
28.         }
    
29.         else     /* 数据长度大于等于扇区大小 */
    
30.         {
    
31.             while (NumOfPage--)
    8 T% Y/ g' S/ w0 ?8 h
32.             {
    
33.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    ! k( G2 y7 u9 z! L3 \
34.                 {
    & Q3 t4 p" y1 V7 p2 [' I2 g# W, \
35.                     return 0;
    : z! A2 \/ f$ A- M; {' L' h9 R
36.                 }
    6 g% n* ~! h4 z5 y# L) i8 a1 m3 @
37.                 _uiWriteAddr +=  g_tSF.SectorSize;
    
38.                 _pBuf += g_tSF.SectorSize;
    
39.             }
    ( y% t8 Y' ^! V" \
40.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
    ! i1 p; ~! o9 W7 \) K- p+ \  s2 y9 A
41.             {
    
42.                 return 0;
    
43.             }
    
44.         }
    ) ?' v  K9 J! o. C! @4 D/ g3 {
45.     }
    . p1 g+ i! X: H3 D
46.     else  /* 起始地址不是扇区首地址  */
    
47.     {
    
48.         if (NumOfPage == 0) /* 数据长度小于扇区大小 */
    
49.         {
    
50.             if (NumOfSingle > count)  /* (_usWriteSize + _uiWriteAddr) > SPI_FLASH_PAGESIZE */
    * w7 w) Q4 h5 e2 L  P6 s2 K2 h
51.             {
    2 \  X9 s3 q  l: {$ x2 N: P4 F, B
52.                 temp = NumOfSingle - count;
    
53. 
    * @% Z# j5 W+ O0 n; U
54.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
      v1 K& U" e! B8 l& h
55.                 {
    
56.                     return 0;
    
57.                 }
    6 B6 w; V" q& K9 b; n0 W/ f. ?
58. 
    
59.                 _uiWriteAddr +=  count;
    
60.                 _pBuf += count;
    7 U' s5 l* ^4 }0 g
61. 
    
62.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, temp) == 0)
    
63.                 {
    % |9 t" x. k: W
64.                     return 0;
    3 m8 }7 {% m0 d% G; w
65.                 }
    7 a) P+ x' _. U, F* P, N
66.             }
    / Q2 ~5 l6 r3 n# J, W
67.             else
    ' Y, q* D$ v5 O+ c' j; Q
68.             {
    
69.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, _usWriteSize) == 0)
    " j) J# @; j+ d2 N: s) f
70.                 {
    
71.                     return 0;
    
72.                 }
    1 Y5 f/ A- J& N; u' _  S6 J
73.             }
    
74.         }
    / k& G$ C  c# t' O
75.         else    /* 数据长度大于等于扇区大小 */
    
76.         {
    ) L( b8 l3 |6 L
77.             _usWriteSize -= count;
    # {1 n' w7 V9 W9 n
78.             NumOfPage =  _usWriteSize / g_tSF.SectorSize;
    5 k9 \( h+ r) A( x/ N1 H: G, w
79.             NumOfSingle = _usWriteSize % g_tSF.SectorSize;
    7 q2 t" ^# U# s0 \  ~
80.             if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, count) == 0)
      G6 P1 [2 C3 [. `: C
81.             {
    
82.                 return 0;
    & ~* J7 T7 ]) g& i9 k2 f5 E  ^
83.             }
    : w. w4 }0 ~: Z& p- \$ i' f
84. 
    
85.             _uiWriteAddr +=  count;
      L* f2 [! z1 f5 s3 F
86.             _pBuf += count;
    
87. 
    
88.             while (NumOfPage--)
    * O* e9 B5 x, ~$ v8 J: N% v: \" Y
89.             {
    : J5 w' j- f) Y; k. R
90.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, g_tSF.SectorSize) == 0)
    9 S( f( c. Y# l2 ?9 c
91.                 {
    2 z6 V/ K  a8 i. }2 P; [2 c
92.                     return 0;
    
93.                 }
    / |/ F$ r: r# e$ X% k! o3 J
94.                 _uiWriteAddr +=  g_tSF.SectorSize;
    
95.                 _pBuf += g_tSF.SectorSize;
    
96.             }
    7 t: a& G& o6 K8 U. l$ h, O
97. 
    
98.             if (NumOfSingle != 0)
    . W9 h/ N0 x& O, F( H6 }
99.             {
    
100.                 if (sf_AutoWriteSector(_pBuf, _uiWriteAddr, NumOfSingle) == 0)
     
101.                 {
       W  L" P% H, V3 U
102.                     return 0;
     * ?7 n/ V+ ]! T) Z, o  ~- b
103.                 }
     
104.             }
     
105.         }
     - v( P9 N# X$ e+ d2 n
106.     }
     2 A4 E$ g3 x, m# ~1 s  C. J+ Q
107.     return 1;    /* 成功 */
     $ D  w5 u- m2 S" q4 Z
108. }

复制代码

73.5 SPI总线板级支持包（bsp_spi_bus.c）
8 U$ L5 R3 \+ rSPI总线驱动文件bsp_spi_bus.c主要实现了如下几个API供用户调用：
+ q$ k; `# k2 T& Z3 ~
# p' `. A- i! P& J1 {  bsp_InitSPIBus
  bsp_InitSPIParam
5 H9 }& [6 @' \8 O+ k2 m  p$ T  bsp_spiTransfer
73.5.1 函数bsp_InitSPIBus
函数原型：

void bsp_InitSPIBus(void)
! F7 T* R1 |% w1 Z
; `6 T! y) w- ?4 f. C3 `- a函数描述：
: F8 _; V% a- r$ K! M0 j& _0 `; q' L# f
3 h  e! b) r/ X) a( R- P+ h此函数主要用于SPI总线的初始化，在bsp.c文件调用一次即可。
0 g& O" i1 @0 u5 c
73.5.2 函数bsp_InitSPIParam
函数原型：
. o0 h  R5 p* ~" x
void bsp_InitSPIParam(uint32_t _BaudRatePrescaler, uint32_t _CLKPhase, uint32_t _CLKPolarity)

函数描述：

此函数用于SPI总线的配置。
$ [, O! V& l: O* n8 S! `8 n
函数参数：

  第1个参数SPI总线的分频设置，支持的参数如下：
SPI_BAUDRATEPRESCALER_2    2分频
' _- ]( |( ?# L4 V; Y
SPI_BAUDRATEPRESCALER_4    4分频

SPI_BAUDRATEPRESCALER_8    8分频

SPI_BAUDRATEPRESCALER_16   16分频

' h7 D! C8 ^' R: {9 Y5 gSPI_BAUDRATEPRESCALER_32   32分频

SPI_BAUDRATEPRESCALER_64   64分频

SPI_BAUDRATEPRESCALER_128  128分频
) x: b6 k4 h' f+ {4 S. t* `
1 o) R0 P. g3 V; F: TSPI_BAUDRATEPRESCALER_256  256分频

  第2个参数用于时钟相位配置，支持的参数如下：
0 A& V- ?  l! u2 I$ \8 S, TSPI_PHASE_1EDGE     SCK引脚的第1个边沿捕获传输的第1个数据
% F, K! E0 h8 }. H9 `5 r! V' z
" j7 i- ~1 S; ?) vSPI_PHASE_2EDGE     SCK引脚的第2个边沿捕获传输的第1个数据
+ U1 c8 c6 d8 Y/ D0 Q
. k# e- Q9 F! H( u& s/ ^! ?  第3个参数是时钟极性配置，支持的参数如下：
* v8 e6 E8 K: t2 Z4 V! P( ^+ ESPI_POLARITY_LOW   SCK引脚在空闲状态处于低电平

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

4 T% g: @) o' o. ~( V6 H  ~; Z* V& P73.5.3 函数bsp_spiTransfer
) U( U1 j/ D0 }函数原型：

9 X  o/ V# p3 W* M; j9 Qvoid bsp_spiTransfer(void)

1 x- n$ F: F  w/ W! ?2 j! l6 g/ C- ?( J函数描述：

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

73.6 W25QXX板级支持包（bsp_spi_flash.c）
7 D1 @9 Q8 `6 r3 }/ S8 h8 IW25QXX驱动文件bsp_spi_flash.c主要实现了如下几个API供用户调用：

; N/ N5 g; Z4 v- Q# Q1 I0 B7 n  sf_ReadBuffer
  sf_WriteBuffer
, X9 Q- e  X! t3 ^$ _4 E  sf_EraseSector
  sf_EraseChip
  sf_EraseSector
$ J5 z$ s1 U) G9 K& J73.6.1 函数sf_ReadBuffer
函数原型：
$ w, ?. g5 o6 u3 [$ ?) @% A! L
- K9 W, y( W8 w$ f7 x3 C- a- s, svoid sf_ReadBuffer(uint8_t * _pBuf, uint32_t _uiReadAddr, uint32_t _uiSize)

函数描述：
* i4 h1 V0 g; q
9 I# z6 `0 S6 m- t此函数主要用于从SPI Flash读取数据，支持任意大小，任意地址，不超过芯片容量即可。

9 H7 w4 a, j1 A/ l函数参数：
8 J. [! `# Y; n- N7 I9 X* X' R
  第1个参数用于存储从SPI Flash读取的数据。
/ `, L  O: O! d6 K  第2个参数是读取地址，不可以超过芯片容量。
  第3个参数是读取的数据大小，读取范围不可以超过芯片容量。
; z) ]+ C5 R) ]- n7 E( K6 a73.6.2 函数sf_WriteBuffer（自动执行擦除）
函数原型：
# h1 ~( v, Y& ?. M6 e3 j7 [
: y: g  q4 ?" x% N. u/ ~uint8_t sf_WriteBuffer(uint8_t* _pBuf, uint32_t _uiWriteAddr, uint32_t _usWriteSize)
8 A/ s5 o) U5 T* @6 X5 D
% S3 R8 l+ ]0 o3 a$ B+ ^( I7 t! e函数描述：

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

# V  n# y1 Z+ w# X# O函数参数：
9 U. j" N$ c8 z/ G
# M, w4 }- k& H  第1个参数是源数据缓冲区。
" n4 s8 j4 ^% A0 N" ^4 K0 o) m  第2个参数是目标区域首地址。
4 j, |! M! P. o0 T  n. u$ l" q  第3个参数是数据个数，支持任意大小，但不能超过芯片容量。单位字节个数。
* {# U# u- A1 _0 `) Y' _4 l' i; T  返回值，返回1表示成功，返回0表示失败。
73.6.3 函数sf_EraseSector
函数原型：

9 y0 k8 Y( L$ J# e4 W* G6 Y$ _6 fvoid sf_EraseSector(uint32_t _uiSectorAddr)
/ `: d1 m! R$ A& `6 d
# a4 v) t0 X4 H% }函数描述：
9 C% |- r8 m* H3 h+ G& i
此函数主要用于扇区擦除，一个扇区大小是4KB。

9 {2 o2 Z4 H- K函数参数：
! _7 U. P& L7 z2 a3 |
  第1个参数是扇区地址，比如擦除扇区0，此处填0x0000，擦除扇区1，此处填0x1000，擦除扇区2，此处填0x2000，以此类推。
73.6.4 函数sf_EraseChip
5 V# h& f( k. k3 y2 {4 a函数原型：
. s2 Q6 O# s( _& P) E- ^6 K. R
void sf_EraseChip(void)

函数描述：
- p; n! ?0 T* s* l
此函数主要用于整个芯片擦除。

6 ^5 K+ f+ o7 g2 n0 O7 t73.6.5 函数sf_PageWrite（不推荐）
2 x' D3 H' N: x* ?) q% O3 v函数原型：

3 q8 H, Q( T2 Z/ K6 b  w% _void sf_PageWrite(uint8_t * _pBuf, uint32_t _uiWriteAddr, uint16_t _usSize)

函数描述：
2 h5 d5 c" G+ Z
7 {- u: O5 E1 m; e( k/ H/ ^+ R此函数主要用于页编程，一次可以编程多个页，只要不超过芯片容量即可。不推荐大家调用此函数，因为调用这个函数前，需要大家调用函数sf_EraseSector进行扇区擦除。
3 E! @8 D2 U' F) K! V" t% W
函数参数：

9 {, C& e- K' X( N- `  第1个参数是数据源缓冲区。
- Z1 R9 a+ W/ i/ I# H1 X! T  第2个参数目标区域首地址，比如编程页0，此处填0x0000，编程页1，此处填0x0100，编程页2，此处填0x0200，以此类推。
3 @! \& ~7 Y8 b$ U( O- v0 ~  第3个参数是编程的数据大小，务必是256字节的整数倍，单位字节个数。
: |* S8 r9 [8 ?7 w/ H* G73.7 W25QXX驱动移植和使用
W25QXX移植步骤如下：

  第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文件开头的宏定义
" D6 E. U) L2 ~  W

1. /*
   0 ]! E  z  X: I
2. *********************************************************************************************************
   , M5 t5 ^( X) W
3. *                                时钟，引脚，DMA，中断等宏定义
   9 \9 Y/ T/ C: m/ C* v
4. *********************************************************************************************************
   
5. */
   
6. #define SPIx                            SPI1
   
7. #define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
   8 J. D6 j- J. L% P% w/ z6 ~
8. #define DMAx_CLK_ENABLE()                __HAL_RCC_DMA2_CLK_ENABLE()
   * u8 E& D) e( @( H5 L8 Z( K, t! p
9. 
   
10. #define SPIx_FORCE_RESET()                __HAL_RCC_SPI1_FORCE_RESET()
    
11. #define SPIx_RELEASE_RESET()            __HAL_RCC_SPI1_RELEASE_RESET()
    
12. 
    " g7 r9 n8 K4 d4 _( r, B1 w& ]9 r( z
13. #define SPIx_SCK_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    5 p6 o$ Y- M' Q8 k( W
14. #define SPIx_SCK_GPIO                    GPIOB
    % a7 @; A; G9 W" F8 q
15. #define SPIx_SCK_PIN                    GPIO_PIN_3
    
16. #define SPIx_SCK_AF                        GPIO_AF5_SPI1
    
17. 
    $ Y) [. O0 L: D% R
18. #define SPIx_MISO_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    
19. #define SPIx_MISO_GPIO                    GPIOB
    4 y, `" S! o4 f! V
20. #define SPIx_MISO_PIN                     GPIO_PIN_4
    * o6 f/ P5 g! K2 I2 P( \
21. #define SPIx_MISO_AF                    GPIO_AF5_SPI1
    9 i% {1 @9 s& o& @: ~9 O
22. 
    
23. #define SPIx_MOSI_CLK_ENABLE()            __HAL_RCC_GPIOB_CLK_ENABLE()
    
24. #define SPIx_MOSI_GPIO                    GPIOB
      \4 {0 d( z0 d' N. u
25. #define SPIx_MOSI_PIN                     GPIO_PIN_5
    
26. #define SPIx_MOSI_AF                    GPIO_AF5_SPI1
    
27. 
    
28. #define SPIx_TX_DMA_STREAM               DMA2_Stream3
    7 r/ a3 _( {1 {* l" a
29. #define SPIx_RX_DMA_STREAM               DMA2_Stream2
    ; [: Q$ O9 t' q5 u: X
30. 
    # F3 I7 ]0 G8 H; z4 V, k/ b0 ]6 F+ d0 Y
31. #define SPIx_TX_DMA_REQUEST              DMA_REQUEST_SPI1_TX
    1 ]" v- L# d# r' Z5 O3 E9 t1 h% e9 r
32. #define SPIx_RX_DMA_REQUEST              DMA_REQUEST_SPI1_RX
    % a) R7 `. G. ~& Q8 Y5 h- e
33. 
    1 p5 ~; V! _' r" @5 d9 P
34. #define SPIx_DMA_TX_IRQn                 DMA2_Stream3_IRQn
    ! }: {, C0 m9 ]  P- ?* [) v
35. #define SPIx_DMA_RX_IRQn                 DMA2_Stream2_IRQn
    + {& n# N2 o* \; ~; E  C3 U
36. 
    7 V, j+ u5 _3 i3 x' k6 l
37. #define SPIx_DMA_TX_IRQHandler           DMA2_Stream3_IRQHandler
    : \6 J5 @$ `5 z) ?
38. #define SPIx_DMA_RX_IRQHandler           DMA2_Stream2_IRQHandler
    0 h. u- z4 W  ^5 w  b1 ~
39. 
    7 L* S6 i1 F% W6 o; c
40. #define SPIx_IRQn                        SPI1_IRQn
    8 k# h7 g4 A. G3 a3 A
41. #define SPIx_IRQHandler                  SPI1_IRQHandler
    ( Z3 X. F+ N3 i' o3 }4 ^+ a& W

复制代码

  第3步：根据使用的SPI ID，添加定义到文件bsp_spi_flash.h
/ U% k. n* e, ]+ t: T% ]0 H% {$ \5 `

1. /* 定义串行Flash ID */
   % y+ S; T; O1 c& x& z+ p' h& _& a
2. enum
   
3. {
   
4.     SST25VF016B_ID = 0xBF2541,
   " R5 m" S; `* c2 Z' l2 r
5.     MX25L1606E_ID  = 0xC22015,
   
6.     W25Q64BV_ID    = 0xEF4017, /* BV, JV, FV */
   
7.     W25Q128_ID     = 0xEF4018
   ( M5 q8 f  D5 @/ H( Y  l& _+ R9 G9 \
8. };

复制代码

  第4步：添加相应型号到bsp_spi_flash.c文件的函数sf_ReadInfo里面。
/ g! L4 L5 G7 h+ x

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: sf_ReadInfo
   
4. *    功能说明: 读取器件ID,并填充器件参数
   ) D, ^0 T# Q9 l/ U9 R9 F
5. *    形    参: 无
   ; r5 S- w( D  P
6. *    返 回 值: 无
   ) [; h: c9 f' D2 ~5 T5 j5 }+ _2 ^
7. *********************************************************************************************************
   / D( X4 c# \3 P6 E3 A+ r8 P- Z
8. */
   ! o. B/ k( m1 s* Z
9. void sf_ReadInfo(void)
   - u2 e& g1 O1 e  H/ k
10. {
    
11.     /* 自动识别串行Flash型号 */
    + S& v3 F: G9 g3 S
12.     {
    9 R3 y$ m0 R& ]
13.         g_tSF.ChipID = sf_ReadID();    /* 芯片ID */
    ; |. b# ~. L* {& U- T& d2 K
14. 
    % Y, k4 o7 p2 T; {& o% K1 m
15.         switch (g_tSF.ChipID)
    * i. `- y6 R/ a0 ]: l: N" _; j( x1 v
16.         {
    , j! D7 W+ O! e' x1 _
17.             case SST25VF016B_ID:
    
18.                 strcpy(g_tSF.ChipName, "SST25VF016B");
    $ t4 ~- h1 g8 `- x+ b% P% b
19.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    
20.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    ! o* H0 M2 Y9 J- o' Z
21.                 break;
    : N, x- k8 Y  H7 d
22. 
    
23.             case MX25L1606E_ID:
    ; _. X$ m: {7 F4 y5 u6 ?1 P0 R4 Y
24.                 strcpy(g_tSF.ChipName, "MX25L1606E");
    
25.                 g_tSF.TotalSize = 2 * 1024 * 1024;    /* 总容量 = 2M */
    ) G- K$ e: J2 ~  A) l' r! a
26.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
27.                 break;
    
28. 
    
29.             case W25Q64BV_ID:
    
30.                 strcpy(g_tSF.ChipName, "W25Q64");
    2 r- O! n% S/ e$ z$ W' N
31.                 g_tSF.TotalSize = 8 * 1024 * 1024;    /* 总容量 = 8M */
    * k! j" g  S2 ^* o7 h' S5 i  s1 [$ N
32.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
      P1 p7 F8 C$ k- }+ h
33.                 break;
    
34. 
    4 ?3 t6 M( f0 v; ~, x8 I- S* W
35.             case W25Q128_ID:
    
36.                 strcpy(g_tSF.ChipName, "W25Q128");
    
37.                 g_tSF.TotalSize = 16 * 1024 * 1024;    /* 总容量 = 8M */
    7 T; d  P( w5 a& ]0 ]: y
38.                 g_tSF.SectorSize = 4 * 1024;        /* 扇区大小 = 4K */
    
39.                 break;            
    . ~5 e% r; M* t( u$ \+ `3 u
40. 
    ) w8 O8 n9 \. G& u3 P, M2 K& `. p
41.             default:
      W+ R% e+ C& \- {) h  {
42.                 strcpy(g_tSF.ChipName, "Unknow Flash");
    2 A, G. q( e3 U, B( L
43.                 g_tSF.TotalSize = 2 * 1024 * 1024;
    ! e: E" `6 m1 L8 D( t; R. R
44.                 g_tSF.SectorSize = 4 * 1024;
    
45.                 break;
    
46.         }
    
47.     }
    ) V# F3 B0 h- C
48. }

复制代码

( {5 L- ^6 Y$ q, R7 m: L& V  第5步：根据芯片支持的时钟速度，时钟相位和时钟极性配置函数sf_SetCS。

1. /*
   
2. *********************************************************************************************************
   - Z# |' h& L" Y9 R" }, Q
3. *    函 数 名: sf_SetCS
   2 K7 O# ~8 i6 p) d
4. *    功能说明: 串行FALSH片选控制函数
   + v& M6 l: P" ?0 ~7 ?
5. *    形    参: 无
   
6. *    返 回 值: 无
   1 j# \" h# K$ S0 \: E
7. *********************************************************************************************************
   , h, ?6 C* ^) [0 L  y. y1 r8 L
8. */
   
9. void sf_SetCS(uint8_t _Level)
   / P6 F4 m, B! A
10. {
    / w4 ]3 d7 [: f. N& |
11.     if (_Level == 0)
    
12.     {
    
13.         bsp_SpiBusEnter();   
    
14.         bsp_InitSPIParam(SPI_BAUDRATEPRESCALER_4, SPI_PHASE_1EDGE, SPI_POLARITY_LOW);        
    
15.         SF_CS_0();
    * ?7 }7 J: B- n6 u
16.     }
    
17.     else
    ! F: D7 z+ m6 a1 `
18.     {        
    % d( G* U) Q4 T! B
19.         SF_CS_1();   
    
20.         bsp_SpiBusExit();        
    3 z  l$ A/ M+ N. d. _
21.     }
    + J1 C" d$ X* \* B' }3 D# ?
22. }

复制代码

  第6步：根据使用的SPI Flash片选引脚修改bsp_spi_bus.c文件开头的宏定义。
5 p. }4 }4 p, u0 X

1. /* 串行Flash的片选GPIO端口， PD13  */
   & w2 R% I4 h& Y
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. 
   
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 X3 J. c/ q" P

1. /* 配置SRAM4的MPU属性为Non-cacheable */
   + R, x9 O; K- n4 K! L
2. MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
   
3. MPU_InitStruct.BaseAddress      = 0x38000000;
   
4. MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
   2 ]% m' n+ q: Q. U
5. MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   / q1 o) Z: o! l0 ^: D/ u
6. MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
   ' Z. v/ N$ @6 S
7. MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
   & ~8 E& o8 X' M1 `  G2 Q
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;
    / Z0 f/ b* ]2 G2 R' O: |, Q# T0 o
13. 
    
14. HAL_MPU_ConfigRegion(&MPU_InitStruct);

复制代码

0 f5 J1 b" t' U# @) z+ b* |% [0 n) i( c  第8步：初始化SPI。
+ ?4 L0 J2 [4 u0 ^# d9 h

1. /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
   
2. bsp_InitSPIBus();    /* 配置SPI总线 */        
   : ]/ I2 P2 @& u0 c( [( g
3. bsp_InitSFlash();    /* 初始化SPI 串行Flash */

复制代码

% v! `2 W1 L# I2 K3 @" H; h; M2 G: L* @) T  第9步：SPI Flash驱动主要用到HAL库的SPI驱动文件，简单省事些可以添加所有HAL库C源文件进来。
5 H9 S6 }4 k$ v1 [0 N! @  第10步：应用方法看本章节配套例子即可。
- u' O4 Y& P' r% a+ H3 O/ j% y73.8 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
5 |1 ~) X4 G( [8 w3 P/ b( z0 H  
: C) T6 Q# b- f1 w% k0 [第2阶段，进入main函数：
+ v) K: j" I/ S
: p# I: o  I; p: S* B: T第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
; z  C  i4 X5 U% b, i3 n第2部分，应用程序设计部分，实现SPI Flash的中断，查询和DMA方式操作。

% X' a" Y& D4 b73.9 实验例程说明（MDK）
& Y$ i0 G& ?8 i7 M  Y配套例子：
; ]* c1 J8 ~3 W& ^2 i+ ~8 [
* A/ _0 @0 d1 A$ w0 ^* V0 JV7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）

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

5 r- P5 Q2 y$ B# e2 V0 AV7-051_串行SPI Flash W25QXX读写例程（中断方式）
7 _0 J1 n+ i# @3 P* T  d
- P: ~0 E' I0 O1 z, E0 H) t实验目的：

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

实验操作：
0 E" F) @3 u8 T* y5 _9 t: Z
, Q  u- Q. v% Q支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
% A, a5 T1 g+ c+ j. x( j) a- _9 P3 r" [4 Lprintf("请选择操作命令:\r\n");
printf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
* O0 N: [& T% `  j$ H! Gprintf("【3 - 擦除整个串行Flash】\r\n");
printf("【4 - 写整个串行Flash, 全0x55】\r\n");
. g/ n( X; W* |! F+ u2 Kprintf("【5 - 读整个串行Flash, 测试读速度】\r\n");
) a7 H+ M# j: ?% S. xprintf("【Z - 读取前1K，地址自动减少】\r\n");
printf("【X - 读取后1K，地址自动增加】\r\n");
) k2 j0 a6 t: f& [$ f2 g3 A5 Sprintf("其他任意键 - 显示命令提示\r\n");
上电后串口打印的信息：
$ n6 M. u( V9 g/ f6 k
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

5 W1 A. u# Z$ W% K2 U3 {7 t" O
程序设计：

7 z" H5 H; Z5 N" R  系统栈大小分配：
# S* |6 ?* `* B4 I
+ x5 f( c/ C- d/ m1 U

  RAM空间用的DTCM：

8 I( h) V% r& w& Y5 t7 ~9 N3 M. g$ x: n  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
) v% D6 b6 e, A# M- I; f" {* B

1. /*
   
2. *********************************************************************************************************
   8 }# D! h" |5 m/ M
3. *    函 数 名: bsp_Init
   % N, L' A7 }, `$ _# R- T4 l
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   + {- l4 A+ |: m" o7 H' T. F
5. *    形    参：无
   9 x, B9 `7 V6 |. \- ~  h
6. *    返 回 值: 无
   " l2 v. k3 P: N1 u" y' f% I4 a$ K
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    + E. Y1 j4 }9 u, h' L6 F, Q
15.     CPU_CACHE_Enable();
    5 U5 f- n$ j8 D7 Y' f' w5 o
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    7 e/ s- P5 l6 D: O
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    . e  d5 Z: h+ f/ k2 H+ ?9 n2 B3 n& i
22.     HAL_Init();
    0 S4 ^! d# ^  W5 m/ T
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    ! |+ r; F6 p, v! F$ H
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    6 `2 b7 b- d% b1 ^4 w
28.     */
    - _% Y3 ~0 C! B6 e! K: w
29.     SystemClock_Config();
    5 o1 _* O- p, n+ [! o0 Y
30. 
    9 {! X6 r6 @5 X( Q, l- h, l
31.     /*
    % {4 P7 {( j$ E3 X, y
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    : Q; l, v6 o- U- J' }! ?& V' l
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ; j3 E; H9 j8 U8 m! U& W# ]
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    . A* U/ q  F7 m2 L, ^: U% K+ u
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();         /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();       /* 初始化滴答定时器 */
    & ~8 J% V/ t( c; o& V
45.     bsp_InitLPUart();     /* 初始化串口 */
    , I$ c6 L3 J( A6 g: z
46.     bsp_InitExtIO();     /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();         /* 初始化LED */   
    
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    ( l0 Z* H& I- }  G1 e
49. 
    6 `, Z6 I" K' d% Z9 j# d7 e( Z
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    5 u8 D8 H2 D! R1 T6 Q7 _1 A
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    5 _1 r9 q( H; q" w
53. }

复制代码

  MPU配置和Cache配置：

. K. A( S4 R# F9 l# j4 }' p. r数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区以及SRAM4
5 ^' ]" J- ~% P0 M0 b
9 _5 Y3 @/ Z# S

1. /*
   + x+ I4 t' q* T& _
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   ) h# Q: y4 m6 Y' N, W# Y
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   $ H3 b8 r! z3 d1 q# h
7. *********************************************************************************************************
     n, K7 ?3 h/ g* E; V
8. */
   
9. static void MPU_Config( void )
   1 N, m! e; p+ \8 F( j) c  j/ f
10. {
    " d% l/ Y& k$ Y8 T3 n9 Z# G/ C: [
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    2 C. W- h" s# C7 C9 X
12. 
    ; |# {0 C1 C0 A: f! l/ e, Y
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    6 S; s* v% h$ p  p3 f! [0 s( k
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    2 M' [0 k% C) O, v. K2 s2 {7 O
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    % t1 s+ ~. f* m; F, {
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    - Y" |1 v3 D/ w. Q- {# R& k
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    & {, C9 S, p+ t6 Q+ ~& v" Q
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    8 ~% ~& _4 r( z7 C/ ]) W
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    $ ]5 M0 t+ k& a( p
28. 
    ( L  k. W9 e! z7 B5 ?
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 m2 J. r' V2 Z9 r2 f% l  |( B5 e
30. 
    
31. 
    7 [) `* }" W9 o7 |6 F. }4 ]
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    9 [9 l& m. B( m$ H  o' A6 F9 ?: m8 `
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    " G$ ?# ~% U8 i# v0 y+ x! R
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
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;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    : Y9 N' Z4 a' ~$ s  q0 M
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ; u7 ?2 u3 a0 ]) Q7 L8 r
44. 
    3 u# C$ t1 j& g' C& R
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    - W" w9 G, k$ P; u
46. 
    
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    ( G6 |+ W- @0 ?4 B4 U7 n& L5 A
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    1 e, k& b% v; g& x2 G2 \
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    # X; K6 i7 I5 O2 g0 e+ m
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 M8 {) N8 h" x& X0 K2 K
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    ; S8 U3 T. d4 l9 D1 n1 s: y6 N
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    / P+ n: z4 N1 Q& c0 Q& ~1 B
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    ( C: i- a  E5 U3 \% I
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61. 
    3 E" ]- q% y& l& M$ b) _; C
62.     /*使能 MPU */
    9 ?5 ]( A: \" A5 q
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    " j) |' L* a3 f5 @5 @* D/ M
64. }
    
65. 
    
66. /*
    
67. *********************************************************************************************************
    
68. *    函 数 名: CPU_CACHE_Enable
      G. M( y1 Q' K6 _" X( [4 {
69. *    功能说明: 使能L1 Cache
    6 n( U+ K: k8 v& c) m) N
70. *    形    参: 无
    + t0 h; C3 D1 T# {7 r
71. *    返 回 值: 无
    
72. *********************************************************************************************************
    
73. */
    
74. static void CPU_CACHE_Enable(void)
    ' j7 s* Z& b5 `, }% E8 \
75. {
    7 y+ w3 {, D9 o% ]3 h
76.     /* 使能 I-Cache */
    & D- C; Q+ F# Q' d0 T
77.     SCB_EnableICache();
    
78. 
    
79.     /* 使能 D-Cache */
    8 H% c0 W( ^  h, B# V' m% Z
80.     SCB_EnableDCache();
    
81. }

复制代码

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

1 k, j) q) |$ I$ s% M, T4 A, u按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。

7 C1 V: V# x; c7 f/ _

1. /*
   . P# e4 p9 i$ u
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   - s) A; t1 V* r) L$ N' Y# m! s
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   + Z7 E  p% B% c7 r! y( q- i' `1 i
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    * O5 K1 d+ r' u$ S# K8 _$ J; d
11. {
    
12.     bsp_KeyScan10ms();
    ' j- o* i: P, j% ^) H
13. }
    6 ?1 g; @+ d; u& `- h2 i
14. 
    $ R" k( \: F( f/ x; Q

复制代码

  主功能：

7 x* m+ x! X+ q; g8 Q# D主程序实现如下操作：

- ~  t6 f+ s7 B! M  启动一个自动重装软件定时器，每100ms翻转一次LED2。
# I' L6 H2 t. F( f8 d  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
$ q9 W1 h' A3 s( a9 ^9 n9 B3 c  请选择操作命令:
  1 - 读串行Flash
8 N8 T3 S! R  @8 B5 w$ X. p0 [  2 - 写串行Flash
  3 - 擦除整个串行Flash
' P5 [' {: v3 J7 z! q2 s. {  4 - 写整个串行Flash
  5 - 读整个串行Flash
  Z - 读取前1K
  X - 读取后1K
% i, Z4 A  r* f

1. /*
   
2. *********************************************************************************************************
   - A! |. \' w) x  E
3. *    函 数 名: DemoSpiFlash
   7 n, T: H5 c( K
4. *    功能说明: 串行EEPROM读写例程
   
5. *    形    参：无
   
6. *    返 回 值: 无
   : U1 u0 s5 d9 s- e8 @8 G
7. *********************************************************************************************************
   % s: y( s$ r9 E5 M5 [
8. */
   ) T9 l- C  q4 m4 r, P
9. void DemoSpiFlash(void)
   ; a; S' h3 O, ^" \* _1 j4 V
10. {
    5 R4 h, A9 a  B5 `1 E7 |7 k
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0;
    
13. 
    ; ~( L6 @6 q. }& g0 O) T
14. 
    . h1 T# `" i) C/ v; o" S
15.     /* 检测串行Flash OK */
    
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    
18. 
    5 u# h. i6 k! R+ f/ \
19.     sfDispMenu();        /* 打印命令提示 */
    4 A# ^) g! b; D+ |/ k" q( n0 H9 X* ~
20. 
    
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    4 P( u& v" h% p
22. 
    4 X, d# ]/ l( z0 N1 V& ~
23.     while(1)
    
24.     {
    4 A+ b7 @: `6 z6 p& x! R
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    + X4 S6 @3 k8 C* m% W4 r
26. 
    - R1 h" ^" R3 K5 C) f. o) _( q
27.         /* 判断定时器超时时间 */
    
28.         if (bsp_CheckTimer(0))   
    # V5 o- B8 j8 m" j8 ?$ ]( F
29.         {
    ' x) I9 B" B, K* H( S, b# w( o- W! w
30.             /* 每隔100ms 进来一次 */  
    
31.             bsp_LedToggle(2);
    
32.         }
    + z! x0 I. P/ H9 r: O  ?6 Z# v
33. 
    9 i4 n, g; }! r- @
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    0 p. M1 p; J0 P' ^: e- b+ P
35.         {
    
36.             switch (cmd)
    - C( X% N/ T* b2 m' F
37.             {
    
38.                 case '1':
    
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    
41.                     break;
    
42. 
    
43.                 case '2':
    
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    9 r9 ^4 T+ L8 T; H# P
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    ( s/ F- V) f, b& D+ g' M
46.                     break;
    9 S4 d, F! g: B
47. 
    
48.                 case '3':
    $ R/ b/ t! T6 X$ y, `: o! F
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    1 u: ]4 g; a  V
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    
52.                     break;
    
53. 
    $ L6 R. j8 ~, R( l9 C9 U" F
54.                 case '4':
    / F& _* x- K+ q: j! q' k
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    . W& E. p. G7 T4 I: \
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    0 p3 Q) A! ^( G/ d' P
59. 
    
60.                 case '5':
    
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    . T2 q3 M5 z1 m. L# F
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    + M. F1 C# J: u: Z# O
63.                     break;
    
64. 
    
65.                 case 'z':
    # b. a' s+ |* C" W' _" l+ P+ J7 @
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
    
68.                     {
    ) M, l- d9 _+ k. N! _7 s4 J
69.                         uiReadPageNo--;
    
70.                     }
    ) C2 ?0 C! f+ R9 U/ L, Z2 I2 {: f
71.                     else
    
72.                     {
    
73.                         printf("已经是最前\r\n");
    # r6 U* j% T9 K8 y/ o7 S
74.                     }
    3 B0 ?4 _! p2 H3 q
75.                     sfViewData(uiReadPageNo * 1024);
    
76.                     break;
    
77. 
    6 y) e1 @. Q6 u! m  g. Z6 f
78.                 case 'x':
    
79.                 case 'X': /* 读取后1K */
    0 z- f" Y' s' D8 a/ @  [6 E# ?2 b
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    9 p2 v: J6 Q! G/ \5 W
81.                     {
    
82.                         uiReadPageNo++;
    
83.                     }
    ' ]% w, N2 s2 H0 L/ t( [
84.                     else
    
85.                     {
    ! ?! g6 j8 A: E
86.                         printf("已经是最后\r\n");
    ! d* \: ^0 c& @3 E6 G/ c: g
87.                     }
    % K5 W1 ]5 |, q! `
88.                     sfViewData(uiReadPageNo * 1024);
    ' O# c. _1 [" Z) }# c  {
89.                     break;
    ! f5 F* b* ?1 Y5 a7 r
90. 
    5 U) e& Y4 x+ J  M, a
91.                 default:
    
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    ' Y$ ]7 E/ S( Y. K3 w
93.                     break;
    ( u% W3 C3 [/ v3 K8 A
94. 
    
95.             }
    * R; H1 w  T$ ?" f/ n0 _! S+ L
96.         }
    
97.     }
    
98. }

复制代码

73.10          实验例程说明（IAR）
配套例子：
7 w% U9 p1 ~3 i% N7 {
V7-028_串行SPI Flash W25QXX读写例程（查询方式 V1.1）

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

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

4 L* D# }# B' m+ W实验目的：

- z- Y4 s1 K" x: @8 ^' w学习SPI Flash的读写实现，支持查询，中断和DMA方式。

9 b2 b7 o: X( J( {. ~9 m实验操作：

支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
printf("请选择操作命令:\r\n");
: U, E4 r1 Z2 ~, Z, c+ Tprintf("【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
printf("【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
- _: ~& F# R$ |printf("【3 - 擦除整个串行Flash】\r\n");
printf("【4 - 写整个串行Flash, 全0x55】\r\n");
printf("【5 - 读整个串行Flash, 测试读速度】\r\n");
printf("【Z - 读取前1K，地址自动减少】\r\n");
( M- C: u8 _5 H. q* \printf("【X - 读取后1K，地址自动增加】\r\n");
printf("其他任意键 - 显示命令提示\r\n");
5 W- r0 c  ^5 Y5 o0 i1 o
上电后串口打印的信息：
; i0 u5 L1 H. _, L
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

7 U7 R* _' [4 n! m, z- U0 B5 h3 O: Q7 k
" |/ [$ W9 {% \7 T$ x3 [程序设计：

  系统栈大小分配：

9 O- @, j4 S/ [1 q0 d5 T/ U0 k

/ e6 L) \# g1 i% \* b% C
5 d1 N( R& e' j) b+ h) q  RAM空间用的DTCM：
0 |2 V1 @9 D7 [8 g! @- {, u
: Q1 L$ G( B: I0 a

$ H/ p* ^* _& L, p. W; Y$ p7 U
  硬件外设初始化
/ ~3 s" b0 R$ E( o
硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   2 G* h1 b9 ?8 W4 f
3. *    函 数 名: bsp_Init
   " T6 I# l/ j8 L5 d9 E1 E
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   # g* Q5 U" x* ~+ Z
5. *    形    参：无
   ; i, N/ L3 s' ]% }
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   . `2 H5 K) f" L
8. */
   7 e6 W7 u' X7 {! \# k' ?
9. void bsp_Init(void)
   ' H8 _9 R, b6 l% V; m/ v
10. {
    
11.     /* 配置MPU */
    8 |1 ]/ ~5 e5 B- F" S6 o
12.     MPU_Config();
    
13. 
    ' A5 J% T# @3 D5 n' X8 G* w
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    ) l# i0 x  V3 [& c5 x, e8 }
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    6 h; G' W# G+ r" I. C" y$ l
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    ( d; {5 R# `1 e$ ~
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ' k, T9 m- C% Y" I+ N
28.     */
    
29.     SystemClock_Config();
    / t' a7 Z* A$ h
30. 
    
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    , k8 c! x. n8 @/ `5 y
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    ! U( L2 s2 p2 I+ q
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    / }# E6 A7 Q( j9 s# L1 F
39.     EventRecorderStart();
    
40. #endif
    ! k1 E8 i/ O; p, p4 P9 P3 c
41. 
    1 b! w9 w; h2 A0 w7 z8 D+ |; [& i
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    ( ]) F7 w, V& G1 C
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    8 _( _  H1 M6 O  p6 _$ R8 A  C7 C
47.     bsp_InitLed();        /* 初始化LED */   
    
48. bsp_InitExtSDRAM(); /* 初始化SDRAM */
    ! ]! M* T2 Z2 {/ ~8 f3 b
49. 
    + I5 _# V+ r3 J0 D3 K! K
50.     /* 针对不同的应用程序，添加需要的底层驱动模块初始化函数 */
    
51.     bsp_InitSPIBus();    /* 配置SPI总线 */        
    
52.     bsp_InitSFlash();    /* 初始化SPI 串行Flash */
    , w/ s% d7 ?9 g. I% [( \# ?
53. }

复制代码

" m* S1 w' u2 |: W  MPU配置和Cache配置：
0 u! z- w% ~' |! ]: d
" o  V1 y% I9 R# [5 F* t) R% R数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

, H3 e0 c  u& x& N! r# X# i

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   : L/ o: E, d6 i% D0 k
7. *********************************************************************************************************
   " E! P# k. L2 V4 j& ~8 B
8. */
   ! I  Z8 l8 t5 s" u3 M+ d1 l7 P
9. static void MPU_Config( void )
   ; i  Q$ j+ f9 K9 U# j# p
10. {
    6 w0 O( ~: l. ~+ G
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    ' H6 P, |! }! I2 C8 j9 F
14.     HAL_MPU_Disable();
    - n$ y, w8 S" f# Z+ F) l
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + R1 J! P% X4 P7 i$ T
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    5 X1 x& J8 V3 k4 {; m
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    9 v6 i+ Z! S0 p, P$ o
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    " u- G- k$ y$ g
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    7 T& h  C0 e( R$ l
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    $ y% J  [/ ~5 Q! \9 O+ b2 n, A
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    3 M: ^) A& T9 g- N1 a0 `
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 U4 Q! A7 K- v! `  n8 u0 g
30. 
    5 T6 T0 g) t3 [, m6 |8 S, }
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    : J. r, ^2 \( g2 M
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    4 ^6 X$ ]/ `1 B) p
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    - Q, f$ l  ]2 ^0 u( ?$ |
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ; G( j  B: B# r* W/ F# |/ d! P# E% p
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ( |# F- M% J3 S, _& P% c4 b+ W
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( [( Y) B9 \% C; f! k  }/ n* k
46. 
    
47.     /* 配置SRAM4的MPU属性为Non-cacheable */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ! L. L3 U, I5 r4 ~8 D
49.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
50.     MPU_InitStruct.Size             = MPU_REGION_SIZE_64KB;
    8 e2 p, E# {7 {3 o
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    # A: J) S1 T8 k! @& c
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    " Z. {: F+ q& M6 w3 }! m
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    & N0 s) p8 a, n4 l* ]
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    9 ^* C9 m% Y" b, \+ z% |/ u* S
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + L& N9 c: `# `( F! K
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # }  `; D0 D. ?4 R
61. 
    
62.     /*使能 MPU */
    ' q+ \7 C' s* \4 x- j- P% R
63.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
64. }
    8 [) q5 X* ^, i" M# R! B
65. 
    6 x+ s  D: {; S8 v
66. /*
    , S7 [+ J( F& N9 f. b6 m' B
67. *********************************************************************************************************
    
68. *    函 数 名: CPU_CACHE_Enable
    2 V0 y+ {: v+ L6 j  b3 F
69. *    功能说明: 使能L1 Cache
      F' e" x8 Y" Y# {! `- X1 [
70. *    形    参: 无
    
71. *    返 回 值: 无
    8 V8 a6 u+ s7 V
72. *********************************************************************************************************
    
73. */
    
74. static void CPU_CACHE_Enable(void)
    + O8 w' E+ L0 }
75. {
    ! J; F' x& G' {8 J* p! t/ g
76.     /* 使能 I-Cache */
    $ A# Y, e# U: K8 ~4 @6 l( I
77.     SCB_EnableICache();
    
78. 
      q- a6 c2 g, V: Y; A
79.     /* 使能 D-Cache */
    
80.     SCB_EnableDCache();
    
81. }
    4 C- u- f1 W. W6 v& v

复制代码

) G; |* D, r' b/ J. x  每10ms调用一次按键处理：
$ p* Q* \5 g( I3 ?- g
按键处理是在滴答定时器中断里面实现，每10ms执行一次检测。
: z- C" ]: H- m$ `
: R: {5 @4 y1 v5 l

1. /*
   
2. *********************************************************************************************************
   " p" V% v7 N6 y0 j* G
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   4 D- v. p) v) n- K5 H( m' c
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    * [# o0 P# x# ?  O" V
12.     bsp_KeyScan10ms();
    ' }$ ]% }1 _: |2 P9 S
13. }

复制代码

  主功能：
: s1 F9 ~3 o7 C/ D3 f4 B8 \7 h, U6 b
/ |) i; l$ E: \8 n主程序实现如下操作：
% S( q  {4 m! ]8 S, D3 W$ V
) R9 F6 a% k$ |% y  启动一个自动重装软件定时器，每100ms翻转一次LED2。
9 T4 t# C+ _' e( u* k. L  支持以下7个功能，用户通过电脑端串口软件发送命令给开发板即可
  请选择操作命令:
  1 - 读串行Flash
  2 - 写串行Flash
  3 - 擦除整个串行Flash
  4 - 写整个串行Flash
- ~0 ~  U- s6 o) [- J6 `, z  5 - 读整个串行Flash
" Q" B) e+ d" j: E7 l$ k3 y  Z - 读取前1K
" V7 y  ]1 z5 z  ]; Z  X - 读取后1K

1. /*
   ( h2 x6 y6 _1 y/ \, Q
2. *********************************************************************************************************
   
3. *    函 数 名: DemoSpiFlash
   
4. *    功能说明: 串行EEPROM读写例程
   . x2 A/ b8 Q1 g# [+ n! E
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   " ]$ ?1 h. E0 W! {( L. K
9. void DemoSpiFlash(void)
   * {& [: K2 P7 k, Z/ {# A& q/ z
10. {
    2 E* O  e9 D# F. y2 g) m" \+ `
11.     uint8_t cmd;
    
12.     uint32_t uiReadPageNo = 0;
    8 L! Y/ h9 K, P: `3 D7 B
13. 
    2 H/ I$ G. @5 D, I. s
14. 
    
15.     /* 检测串行Flash OK */
    / \% n2 i4 i' x# B
16.     printf("检测到串行Flash, ID = %08X, 型号: %s \r\n", g_tSF.ChipID , g_tSF.ChipName);
    $ U& k4 R# u% m/ N" A
17.     printf("    容量 : %dM字节, 扇区大小 : %d字节\r\n", g_tSF.TotalSize/(1024*1024), g_tSF.SectorSize);
    
18. 
    
19.     sfDispMenu();        /* 打印命令提示 */
    9 K% I0 h! m) M
20. 
    
21.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
22. 
    4 {) p- A9 A! D, X0 o" ^
23.     while(1)
    
24.     {
    $ K6 n! e- Y8 S7 J: d8 |( w0 N: }$ T1 Q
25.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
26. 
    / n! G( j  p! H9 n# X3 P
27.         /* 判断定时器超时时间 */
    ; N/ }; `* d, q0 v' k1 u, M9 d
28.         if (bsp_CheckTimer(0))   
    " O: o/ x! e2 m5 W3 n  u8 Y6 Z7 o& R
29.         {
    ; f1 u) x$ w1 R2 F: O  y4 j# t8 H
30.             /* 每隔100ms 进来一次 */  
    ; X8 l' [' u9 E: A
31.             bsp_LedToggle(2);
    0 Q! a5 J6 w% x% O- Q+ ^" Z+ i
32.         }
    
33. 
    + I9 B4 W  O% L* y8 g
34.         if (comGetChar(COM1, &cmd))    /* 从串口读入一个字符(非阻塞方式) */
    1 Z5 F! ~( r" ]5 D
35.         {
    
36.             switch (cmd)
    % ?2 t2 }' w2 S) X5 O+ B
37.             {
    
38.                 case '1':
    % d/ m0 T. A; _: y, X: q
39.                     printf("\r\n【1 - 读串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    
40.                     sfReadTest();    /* 读串行Flash数据，并打印出来数据内容 */
    % ?' H( w8 C+ D) G! Y9 l- Z
41.                     break;
    * V3 M; }7 P! v% N
42. 
    
43.                 case '2':
    : ?* Q! z. `' j! ?1 H
44.                     printf("\r\n【2 - 写串行Flash, 地址:0x%X,长度:%d字节】\r\n", TEST_ADDR, TEST_SIZE);
    : L9 [8 X/ K: K9 _' |
45.                     sfWriteTest();    /* 写串行Flash数据，并打印写入速度 */
    
46.                     break;
    
47. 
    9 f* V2 M% b- T- c1 F  J- ]# q
48.                 case '3':
    
49.                     printf("\r\n【3 - 擦除整个串行Flash】\r\n");
    9 `, L( p5 L9 ~6 G
50.                     printf("整个Flash擦除完毕大概需要20秒左右，请耐心等待");
    
51.                     sfErase();        /* 擦除串行Flash数据，实际上就是写入全0xFF */
    . X7 V( p: `' {9 |
52.                     break;
    9 e% x& l7 u( Z5 D
53. 
    
54.                 case '4':
    
55.                     printf("\r\n【4 - 写整个串行Flash, 全0x55】\r\n");
    
56.                     printf("整个Flash写入完毕大概需要20秒左右，请耐心等待");
    
57.                     sfWriteAll(0x55);/* 擦除串行Flash数据，实际上就是写入全0xFF */
    
58.                     break;
    , }: k4 D5 j. P4 I" k$ t
59. 
    * d9 @, V0 s+ K" [9 E
60.                 case '5':
    
61.                     printf("\r\n【5 - 读整个串行Flash, %dM字节】\r\n", g_tSF.TotalSize/(1024*1024));
    
62.                     sfTestReadSpeed(); /* 读整个串行Flash数据，测试速度 */
    
63.                     break;
    
64. 
    
65.                 case 'z':
    & ^& W! H* S2 a( b. C, l$ b2 L( d
66.                 case 'Z': /* 读取前1K */
    
67.                     if (uiReadPageNo > 0)
      E: `2 l7 s  C3 @8 l7 B. O
68.                     {
    
69.                         uiReadPageNo--;
    
70.                     }
    
71.                     else
    
72.                     {
    
73.                         printf("已经是最前\r\n");
    1 F. m& `/ v. C" o  x; t) ]& \
74.                     }
    
75.                     sfViewData(uiReadPageNo * 1024);
    : ~$ t# |. t3 t7 O
76.                     break;
    0 Q: c0 x2 [  Z! e9 e- e$ R6 [$ }
77. 
    
78.                 case 'x':
    - X# O" n  M2 d+ ]
79.                 case 'X': /* 读取后1K */
    
80.                     if (uiReadPageNo < g_tSF.TotalSize / 1024 - 1)
    
81.                     {
    ) Y; Y, Q) Y6 E  O( f6 l' {" m
82.                         uiReadPageNo++;
    
83.                     }
    
84.                     else
    ) H  F4 ?4 v# h7 V0 L1 e# j9 a
85.                     {
    
86.                         printf("已经是最后\r\n");
    7 L* }1 E, U5 p; Y
87.                     }
    * c9 ~! B- L$ m" w$ E6 E% o5 y
88.                     sfViewData(uiReadPageNo * 1024);
    
89.                     break;
    
90. 
    + B* I" F+ u4 h
91.                 default:
    & I: R% ^/ G: ?/ H2 j7 D( N+ B
92.                     sfDispMenu();    /* 无效命令，重新打印命令提示 */
    
93.                     break;
    
94. 
    
95.             }
    
96.         }
    
97.     }
    
98. }

复制代码

73.11   总结
本章节就为大家讲解这么多，实际应用中根据需要选择DMA，中断和查询方式。
/ [2 ]0 x: x$ F
4 H" x- I0 A1 H7 v' f/ O! j

5 l" t5 t# Q  N1 K9 t" N