SPI协议的原理，网上大把的资料可以找到，这里记录一下SPI的初始化过程，以即以读取W25Q16型号为例的一个简单的SPI读写过程。
6 J/ W+ n9 g/ T$ _. [CubeMX配置：
0 S1 K6 Z/ }) g' h6 K# B
! g/ G8 U. U7 J6 ~

. k. a1 ?2 z, f% y: S6 l% N8 tSPI模式
* _7 }& e( ?% B. `2 s有只发送、只接收、半双工和全双工模式；
根据自己的需求，和SPI设备支持的类型，这里选择全双工的SPI；

7 b' n. r- {0 S. M& g7 {8 o片选信号
% ^  g5 G, h; Y, M: u/ }+ h因为我们这个SPI总线上会挂载多个从设备，而且只有一个主机，所以，这里禁用硬件片选，程序里面读写之前使用软件进行片选；

帧格式
$ }% h) e1 w+ ]  n6 e# y. m% i这里选择Motorola帧格式；
选择TI格式不能设置CPOL和CPHA，而且必须要开启硬件NSS这里才能选择TI模式。
/ Q2 o' D- l. d& E博主在网上搜了一些关于TI的SSP协议相关的资料，只有简简单单的一句：SSP总线兼容SPI，SSI 和Microwire 总线的接口。
( b8 q6 v+ ~" J. A0 o1 Y/ j. @博主又搜了以下Microwire协议，和SPI一样，只不过片选信号是高电平有效。
9 p5 ?! ]) K, b. y! O& Q5 ^/ }这是手册里关于TI模式的说明部分和波形图：

5 t& m; R( j6 P也不清楚这个SCK的触发信号是干嘛的，所以这里老老实实选择Motorola就行了。

数据长度
4-16bit可选，根据实际，选择8bit；

, l4 u2 `9 @9 U2 \' c数据传输模式
第一个传输的bit是高位还是低位，这里根据设备来选择，好像MSB（先发送高位）的比较多，注意这里的会同时设置发送和接收，如果设置错了，发送的指令对方就无法识别，可能收到的就是0xFF这种值。
! O% O( Z6 i2 T8 R
SPI速率
SPI的波特率是由时钟分频得到的，CubeMX很方便的还帮我们计算出来了时钟速率，可以根据自己的需求设置。
: ^0 ?  C8 O2 F. n, D0 G, b
时钟极性和时钟相位
% p2 o4 K% V/ q0 S$ \, C根据极性和相位的不同，可以有4种不同的工作模式，这个根据芯片手册支持的模式选择，注意，一条总线上尽量挂载支持相通模式的设备，这样就不用每次在设备切换之前重新配置SPI外设。
6 X& m9 ]! H! ?) o
CRC校验
暂时还没研究到这里……

NSS脉冲
! a/ _4 E1 W) D  T) _% A参考SPI的NSS 脉冲模式的作用，这里用不到；

NSS信号类型
) F) Z+ z" R6 D) f! c因为前面禁用了硬件片选，所以这里只能设置位软件模式。

0 |7 m. E0 T  u) n' {/ E% J) \除此意外，还需要把连接硬件片选信号的GPIO，设置为输出模式。
CubeMX生成的代码如下：
0 E# ^2 Q# u! ]

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   2 {& J: K7 {  m3 v
2. 
   
3. void SPI3_Init(void)
   ! q+ Y2 Q: c! z2 k! M8 ^3 K
4. {
   4 U& @- D; ?; E9 J! L
5.     SPI3_Handler.Instance = SPI3;
   1 t0 i& N; `$ j: u
6.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
   
7.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
   8 K4 ^$ M5 O0 q$ s# f% |
8.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
   6 F  _; J* d( k  ?
9.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
   
10.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    ) O7 |6 }/ d4 }, _* ^
11.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    & F% T- v4 q9 [6 R4 o
12.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    
13.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    
14.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    
15.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    7 j2 @# j; c( E, o' a3 x" u9 v
16.     SPI3_Handler.Init.CRCPolynomial = 7;
    9 S$ |% Y  J; f
17.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    5 w% C" z  f+ P5 S( h
18.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    - U+ u, |. l2 b
19.     HAL_SPI_Init(&SPI3_Handler);
    
20. 
    
21.     __HAL_SPI_ENABLE(&SPI3_Handler);               
    / G8 d6 E. U& J1 H" s
22. }
    
23. 
    $ X  X; ~; u6 V- S6 L: v
24. void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
    2 l4 B; r8 W; F3 D+ c+ c0 i
25. {
    7 Q9 b& g( l" @* a
26.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    
27.   if(hspi->Instance==SPI3)
    
28.   {
    ' A- {& q4 L9 @; z) x" T
29. 
    5 [1 j6 U# g8 q
30.     __HAL_RCC_SPI3_CLK_ENABLE();
    : a& k8 w6 f) r2 N, P
31. 
    $ r/ k  c# s8 ~" ], P' u
32.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
33. 
    
34.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    $ ~0 a/ n: q% g- d) L5 z
35.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ; m1 D# N: `3 z. A
36.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    $ s' m9 s5 Q6 Z8 f9 R8 n3 n
37.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
38.     GPIO_InitStruct.Alternate = GPIO_AF7_SPI3;
    + d/ Z+ _4 P4 k8 Z* Z( P
39.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
40. 
    
41.     GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4;
    5 l4 I8 P3 Y5 o, v1 t/ A, e' v( d2 R
42.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ' Z; L1 D6 ^+ n) D6 j& ?' N
43.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    ! K* Q) f: m8 J- h/ f' z
44.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
45.     GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
    + c7 i" X8 l5 q! m! M
46.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
47.   }
    , I6 W0 J/ |* U0 s( P
48. }
    3 W( l, R  B3 [1 u- ]! ^1 R
49. 
    " h$ O, I" k! A6 ?( p: F
50. 
    
51. static void MX_GPIO_Init(void)
    1 ~/ e' T8 E1 u) ^4 d
52. {
    
53.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    % E$ J$ V3 s; Z9 K
54. 
    
55.   /* GPIO Ports Clock Enable */
    
56.   __HAL_RCC_GPIOA_CLK_ENABLE();
    
57. 
    
58.   /*Configure GPIO pin Output Level */
    9 C' T! {4 F9 n4 o1 s
59.   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
    5 s9 [! {+ d& }7 D; v+ {
60. 
    
61.   /*Configure GPIO pin : PA4 */
    
62.   GPIO_InitStruct.Pin = GPIO_PIN_4;
    
63.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
64.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
65.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    & B7 r6 [% D6 T1 e5 i9 T' j7 K
66.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
67. 
    
68. }

复制代码

3 c4 B, x) ?! E8 Q$ i  `% a同一总线上不同设备，工作在不同模式的时候，速率可能不一样，需要一个重新设置速率的函数：
! D. X$ N* y. W" F5 u4 E" `8 V! ^

1. void SPI3_SetSpeed(u8 SPI_BaudRatePrescaler)
   3 F6 B8 i2 l$ @# C7 j
2. {
   2 }/ N* h$ y2 E: M7 }' W! j
3.     assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
   
4.     __HAL_SPI_DISABLE(&SPI3_Handler);            //关闭SPI
   
5.     SPI3_Handler.Instance->CR1 &= 0XFFC7;        //位3-5清零，用来设置波特率
   9 d2 z% x; _# n% c, c5 N5 y6 P
6.     SPI3_Handler.Instance->CR1 |= SPI_BaudRatePrescaler; //设置SPI速度
   
7.     __HAL_SPI_ENABLE(&SPI3_Handler);             //使能SPI
   $ o- }  v8 k, k3 w# m
8. 
   
9. }

复制代码

4 F4 c/ w* o0 p9 L' l因为全双工的读写是同时的，封装一个读写函数：
; s3 d# U4 s" X8 m" R  Z) f' z

1. //SPI2 读写一个字节
   
2. //TxData:要写入的字节
   
3. //返回值:读取到的字节
   % d. M6 e2 C  T4 }7 e, g5 C
4. u8 SPI3_ReadWriteByte(u8 TxData)
   
5. {
   
6.     u8 Rxdata;
   6 }+ d( j9 d" Q. v. U
7.     HAL_SPI_TransmitReceive(&SPI3_Handler, &TxData, &Rxdata, 1, 1000);
   
8.     return Rxdata;                      //返回收到的数据
   ! s1 n7 `* q: m8 |, C8 k
9. }

复制代码

根据W25QXX的数据手册，写一个读ID的函数：
3 z6 c7 _' p0 q* F5 a" t& T

1. //读取芯片ID
   
2. //返回值如下:                                   
   7 w: i7 w$ ?9 H7 T5 e
3. //0XEF13,表示芯片型号为W25Q80  
   
4. //0XEF14,表示芯片型号为W25Q16   
   
5. //0XEF15,表示芯片型号为W25Q32  
   
6. //0XEF16,表示芯片型号为W25Q64
   3 C9 Z8 o+ n& p
7. //0XEF17,表示芯片型号为W25Q128           
   0 E' K. _! q0 @
8. u16 W25QXX_ReadID(void)
   
9. {
   ; K6 e% X" J3 U7 b
10.         u16 Temp = 0;         
    
11.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_RESET);            
    
12.         SPI3_ReadWriteByte(0x90);//发送读取ID命令            
    
13.         SPI3_ReadWriteByte(0x00);            
    " l3 y/ K5 s5 k4 p+ Y: I
14.         SPI3_ReadWriteByte(0x00);            
    3 h! I5 O4 v" C# }  z, {& p. c' J
15.         SPI3_ReadWriteByte(0x00);                                    
    
16.         Temp|=SPI3_ReadWriteByte(0xFF)<<8;  
    
17.         Temp|=SPI3_ReadWriteByte(0xFF);         
    7 V$ u7 E' Y4 G* p% {
18.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);  
    
19.         return Temp;
    
20. }  

复制代码

+ g- v7 p9 A3 \, I3 _  |最后写一个在主函数中调用的接口函数。

1 I6 ]7 k+ A/ y6 W/ I: w' O. c

1. void W25QXX_Init(void)
   3 J* }2 t" ?" Y& t; V
2. {
   
3.         MX_GPIO_Init();
   1 z; P2 A% H8 ~. \
4.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);
   
5.         SPI3_Init();
   
6.         SPI3_SetSpeed(SPI_BAUDRATEPRESCALER_4);
   3 x) p# \' T, F0 h; N
7.         uint16_t W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
   * U# B& L; [/ F$ N3 ]0 ~* x! b! C
8.         printf("W25QXX ID:0x%4x\r\n",W25QXX_TYPE);
   0 `  u3 t0 l. \
9. }

复制代码

下载运行，读取到了芯片ID。
# i2 ~! h( ^- z7 g" ]