SPI协议的原理，网上大把的资料可以找到，这里记录一下SPI的初始化过程，以即以读取W25Q16型号为例的一个简单的SPI读写过程。
CubeMX配置：

: b/ }5 u# R4 b

6 N2 h- E+ D1 y3 o/ X$ N: d
) x% J/ t$ @9 V7 S0 DSPI模式
有只发送、只接收、半双工和全双工模式；
2 ~$ v& o3 u/ P" |1 y1 o. B/ E根据自己的需求，和SPI设备支持的类型，这里选择全双工的SPI；
5 Q0 U. Q* B' w' _9 B+ V
片选信号
因为我们这个SPI总线上会挂载多个从设备，而且只有一个主机，所以，这里禁用硬件片选，程序里面读写之前使用软件进行片选；
! ~/ v) ?& M+ q5 a6 i& M" T
帧格式
这里选择Motorola帧格式；
0 g3 y: O) h/ u  A' a* c选择TI格式不能设置CPOL和CPHA，而且必须要开启硬件NSS这里才能选择TI模式。
博主在网上搜了一些关于TI的SSP协议相关的资料，只有简简单单的一句：SSP总线兼容SPI，SSI 和Microwire 总线的接口。
7 B, e- }0 l' v0 _7 N" s3 j博主又搜了以下Microwire协议，和SPI一样，只不过片选信号是高电平有效。
6 _3 f9 ?# K' Q6 ~0 V: H+ U8 R这是手册里关于TI模式的说明部分和波形图：

也不清楚这个SCK的触发信号是干嘛的，所以这里老老实实选择Motorola就行了。

  Y, e9 J2 I. P; N数据长度
5 a. `3 m4 p, t0 p1 y4 p% Q4-16bit可选，根据实际，选择8bit；
: a9 |2 b% c1 m5 {4 I
数据传输模式
第一个传输的bit是高位还是低位，这里根据设备来选择，好像MSB（先发送高位）的比较多，注意这里的会同时设置发送和接收，如果设置错了，发送的指令对方就无法识别，可能收到的就是0xFF这种值。
  L9 Y- D: q* A( ~. M0 M
SPI速率
SPI的波特率是由时钟分频得到的，CubeMX很方便的还帮我们计算出来了时钟速率，可以根据自己的需求设置。
6 [) e# e  k: i) j8 X9 |
时钟极性和时钟相位
" T  A# y9 I& w2 i* C9 F根据极性和相位的不同，可以有4种不同的工作模式，这个根据芯片手册支持的模式选择，注意，一条总线上尽量挂载支持相通模式的设备，这样就不用每次在设备切换之前重新配置SPI外设。

CRC校验
2 p2 m" L+ c) J8 }3 |暂时还没研究到这里……
" `1 v, L) R' Y  I! k
4 {# B8 G- B# P$ \0 L- C9 x: p; pNSS脉冲
参考SPI的NSS 脉冲模式的作用，这里用不到；
4 J0 |( s9 m. ]% f( a/ T' |
NSS信号类型
因为前面禁用了硬件片选，所以这里只能设置位软件模式。

除此意外，还需要把连接硬件片选信号的GPIO，设置为输出模式。
CubeMX生成的代码如下：

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   * t4 G+ H* Y, k3 k
2. 
   & Z) S9 d8 Z* E) D/ b
3. void SPI3_Init(void)
   ' p8 F) I/ V% G/ X0 s# m7 O) J
4. {
   6 p& G% P! K5 X9 w" Q, c
5.     SPI3_Handler.Instance = SPI3;
   2 p6 X4 z# b* G
6.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
   # ?  m2 I. c+ l0 ?
7.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
   $ _0 O6 X4 A* ~* A7 Y! b
8.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
   
9.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
   
10.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    
11.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    
12.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    
13.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    - S9 ?& x( ?" C/ q
14.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    ) r% I& ~2 Z/ M+ c; ^* ]
15.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    9 _  {$ D. u# K# f) T4 s
16.     SPI3_Handler.Init.CRCPolynomial = 7;
    
17.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    
18.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    & ]# q% A+ \) G# n0 \, l* y8 x, K
19.     HAL_SPI_Init(&SPI3_Handler);
    & x6 p9 ^+ I' _& t
20. 
    , |$ {4 T" v2 w1 u  s% t5 F
21.     __HAL_SPI_ENABLE(&SPI3_Handler);               
    : F1 a/ x( n, q6 V, k; g
22. }
    % S0 C2 O7 I5 M5 h. a
23. 
    # |7 Y& ?# t$ c- b
24. void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
    3 e+ C0 W8 z- D+ |7 V
25. {
    * C4 }3 o; B2 y' C2 N
26.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    
27.   if(hspi->Instance==SPI3)
    ( k$ _; `0 A4 F; l* P
28.   {
    
29. 
    - `% W' H8 X( X% p& h/ W
30.     __HAL_RCC_SPI3_CLK_ENABLE();
    6 X# {% J$ R- l9 z2 d0 s% d
31. 
    ' Q, ^, ]6 ?+ I0 z. Q. `7 L# e" M
32.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
33. 
    
34.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
35.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
36.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
37.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
38.     GPIO_InitStruct.Alternate = GPIO_AF7_SPI3;
    ) c: Z0 @# j  G: ]/ l! L3 H: Y
39.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    8 H: Y& b! V4 W' S
40. 
    
41.     GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4;
    
42.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
43.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    4 l+ K7 c/ x& j. E& i, Y
44.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
45.     GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
    
46.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    & C8 J. K$ g$ b7 R
47.   }
    ; H6 g6 a% n9 F% g
48. }
    
49. 
    
50. 
    1 ]2 _* O" e' L. x7 ^
51. static void MX_GPIO_Init(void)
    
52. {
    
53.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    2 M; Z- w& E+ U/ V7 g
54. 
    9 L) c+ }+ s3 y) N) A5 G* Q* z
55.   /* GPIO Ports Clock Enable */
    
56.   __HAL_RCC_GPIOA_CLK_ENABLE();
    % k' o, _/ ^0 W  W% L' {& R+ F
57. 
    4 _0 G! V- Z  C7 b1 i3 }
58.   /*Configure GPIO pin Output Level */
    
59.   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
    
60. 
    5 F  G9 w# Z, g$ X! r# F" \
61.   /*Configure GPIO pin : PA4 */
    3 @6 r4 d$ B6 o5 E  q
62.   GPIO_InitStruct.Pin = GPIO_PIN_4;
    
63.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    4 [2 Y& S% y3 c) S
64.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
65.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
66.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ! M6 h9 W5 O* ?
67. 
      [+ y* K8 k) e
68. }

复制代码

  Y3 V0 s9 R1 `8 h6 ?* T同一总线上不同设备，工作在不同模式的时候，速率可能不一样，需要一个重新设置速率的函数：

- [: `& c9 [' u( p( x! j0 Z

1. void SPI3_SetSpeed(u8 SPI_BaudRatePrescaler)
   
2. {
   
3.     assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
   
4.     __HAL_SPI_DISABLE(&SPI3_Handler);            //关闭SPI
   + k3 B) m* z; ^5 N$ `4 l2 [$ F
5.     SPI3_Handler.Instance->CR1 &= 0XFFC7;        //位3-5清零，用来设置波特率
   , b+ y. u+ w9 O% H, Y! E. m3 v
6.     SPI3_Handler.Instance->CR1 |= SPI_BaudRatePrescaler; //设置SPI速度
   0 ^" G& ?  L( x1 i+ }5 f  r
7.     __HAL_SPI_ENABLE(&SPI3_Handler);             //使能SPI
   
8. 
   * V' `+ @9 O2 h. A: f
9. }

复制代码

因为全双工的读写是同时的，封装一个读写函数：

1. //SPI2 读写一个字节
   ' Q& I" T" x3 U3 y; Q6 T
2. //TxData:要写入的字节
   " b/ u) b' U2 c+ h
3. //返回值:读取到的字节
   
4. u8 SPI3_ReadWriteByte(u8 TxData)
   6 x& p5 K/ o+ U9 |( ], C5 o
5. {
   
6.     u8 Rxdata;
   
7.     HAL_SPI_TransmitReceive(&SPI3_Handler, &TxData, &Rxdata, 1, 1000);
   , u8 j% q6 T  v' ~9 Z; C! ~
8.     return Rxdata;                      //返回收到的数据
   2 |8 }" y' J! k- a' j2 s5 g
9. }

复制代码

根据W25QXX的数据手册，写一个读ID的函数：
+ D) V6 H1 o# f$ u2 K" W/ m5 ~

1. //读取芯片ID
   
2. //返回值如下:                                   
   7 t4 B3 t) w& J8 c
3. //0XEF13,表示芯片型号为W25Q80  
   , A$ J3 V) R/ `" E
4. //0XEF14,表示芯片型号为W25Q16   
   
5. //0XEF15,表示芯片型号为W25Q32  
   
6. //0XEF16,表示芯片型号为W25Q64
   $ o, r6 H. o3 ]) U( ~
7. //0XEF17,表示芯片型号为W25Q128           
   0 [, l4 C8 V/ s& ?7 B5 L) H
8. u16 W25QXX_ReadID(void)
   
9. {
   & Q' }( F% F0 e: |/ I# E6 n8 G+ J
10.         u16 Temp = 0;         
    
11.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_RESET);            
    + t8 m9 v4 K5 S) R' n
12.         SPI3_ReadWriteByte(0x90);//发送读取ID命令            
    9 P2 i# M, l( T0 d* C+ G' I
13.         SPI3_ReadWriteByte(0x00);            
    
14.         SPI3_ReadWriteByte(0x00);            
    
15.         SPI3_ReadWriteByte(0x00);                                    
    
16.         Temp|=SPI3_ReadWriteByte(0xFF)<<8;  
    
17.         Temp|=SPI3_ReadWriteByte(0xFF);         
    
18.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);  
    
19.         return Temp;
    
20. }  

复制代码

  A* ^; Y, i: ]6 D+ t8 s最后写一个在主函数中调用的接口函数。

3 ]2 V; ^7 D: k! w

1. void W25QXX_Init(void)
   
2. {
   : w4 d8 A( `% Z% q& [  i( r
3.         MX_GPIO_Init();
   
4.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);
   
5.         SPI3_Init();
   
6.         SPI3_SetSpeed(SPI_BAUDRATEPRESCALER_4);
   2 v) c3 q8 [% i0 B- y
7.         uint16_t W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
   
8.         printf("W25QXX ID:0x%4x\r\n",W25QXX_TYPE);
   
9. }

复制代码

下载运行，读取到了芯片ID。

& W5 G1 B( C3 S

8 D  W8 [, W' d+ s6 c" c: d$ Z