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

& X1 U* ]% F& b3 H: x2 X

( t! @+ E; T; V
SPI模式
; c( ^1 p, w4 T! L有只发送、只接收、半双工和全双工模式；
' P- L7 h1 F& t9 x根据自己的需求，和SPI设备支持的类型，这里选择全双工的SPI；
1 K: w; e- `# s% a
片选信号
# c" r2 w' A* Z! P3 e因为我们这个SPI总线上会挂载多个从设备，而且只有一个主机，所以，这里禁用硬件片选，程序里面读写之前使用软件进行片选；
& X  A, p) B/ }% q/ P3 o' I
; x* M' z4 }  p$ Q- M6 t帧格式
2 K# i! O4 Y/ K: W3 M  J% Z这里选择Motorola帧格式；
: k" H3 L& G  ~选择TI格式不能设置CPOL和CPHA，而且必须要开启硬件NSS这里才能选择TI模式。
博主在网上搜了一些关于TI的SSP协议相关的资料，只有简简单单的一句：SSP总线兼容SPI，SSI 和Microwire 总线的接口。
6 D  S& Z  h) a6 j2 B# ~博主又搜了以下Microwire协议，和SPI一样，只不过片选信号是高电平有效。
- i6 x$ ^+ S# {% b- {这是手册里关于TI模式的说明部分和波形图：
8 x' F$ s1 y' J  Z! h9 y- ]

' r. H" U3 b* ]" @7 A! B2 n

, j) H& j1 j) a4 ^) {# }% z也不清楚这个SCK的触发信号是干嘛的，所以这里老老实实选择Motorola就行了。
$ ?5 l& ?2 Q- _+ k6 f" i
数据长度
: T3 a9 L# Z4 O1 ]4 b4-16bit可选，根据实际，选择8bit；
; B( _0 {/ ]/ }; ^  l
数据传输模式
第一个传输的bit是高位还是低位，这里根据设备来选择，好像MSB（先发送高位）的比较多，注意这里的会同时设置发送和接收，如果设置错了，发送的指令对方就无法识别，可能收到的就是0xFF这种值。
" A/ v; r2 }: p! O0 s
SPI速率
SPI的波特率是由时钟分频得到的，CubeMX很方便的还帮我们计算出来了时钟速率，可以根据自己的需求设置。
" h9 c/ {9 X2 h% I) i) V
  W5 C% j/ {3 o& K" o时钟极性和时钟相位
根据极性和相位的不同，可以有4种不同的工作模式，这个根据芯片手册支持的模式选择，注意，一条总线上尽量挂载支持相通模式的设备，这样就不用每次在设备切换之前重新配置SPI外设。

+ n& ?8 P* Y  p1 O& y8 K9 ]CRC校验
暂时还没研究到这里……
/ e+ p% c# h$ c( ~  |8 K
NSS脉冲
参考SPI的NSS 脉冲模式的作用，这里用不到；

9 _1 J4 t9 S2 V: JNSS信号类型
  a& Z3 B5 |3 `) ]5 R因为前面禁用了硬件片选，所以这里只能设置位软件模式。

5 e0 e/ w# b: w2 M除此意外，还需要把连接硬件片选信号的GPIO，设置为输出模式。
CubeMX生成的代码如下：

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   
2. 
   
3. void SPI3_Init(void)
   
4. {
   
5.     SPI3_Handler.Instance = SPI3;
   
6.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
   ! s' _. P1 v. [9 V6 s! W
7.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
   3 A+ U' z! Z4 [& ?( [6 Q" e
8.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
   
9.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
   
10.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    6 j7 [' H8 s- Y$ T) k7 B
11.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    
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;
    ! w0 w- x9 M! J) ?6 @" S
16.     SPI3_Handler.Init.CRCPolynomial = 7;
    3 D8 ~* ^) U  f( [3 o
17.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    
18.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    
19.     HAL_SPI_Init(&SPI3_Handler);
    
20. 
    3 P& N6 d/ i; H& r- o( v
21.     __HAL_SPI_ENABLE(&SPI3_Handler);               
    
22. }
    
23. 
    
24. void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
    # m+ f/ P9 P0 k
25. {
    
26.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    
27.   if(hspi->Instance==SPI3)
    
28.   {
    
29. 
      ~) A6 R6 G( A. m/ S% k
30.     __HAL_RCC_SPI3_CLK_ENABLE();
    / c2 b- J6 C  H2 E
31. 
    
32.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
33. 
    
34.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
35.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    + r( W- A6 l, n
36.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
37.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
38.     GPIO_InitStruct.Alternate = GPIO_AF7_SPI3;
    
39.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    5 ?2 y: d/ s6 c
40. 
    
41.     GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4;
    : h, e* s2 N% B" f% Z- }
42.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
43.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    - d8 Y! E1 `- J" O! V8 z
44.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
45.     GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
    ( j  B* v& g" x7 T! ]
46.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
47.   }
    8 y  f8 e$ ?. k
48. }
    / D/ h2 d& g2 q8 X/ Z' r
49. 
    , K7 `. m8 Q( R1 e7 ~/ d( M
50. 
    ! `" ~3 f* ]. G' e
51. static void MX_GPIO_Init(void)
    4 t1 P1 m4 I9 c0 f+ m& }, y# X9 Q
52. {
    5 k7 D% [$ J: |: R3 e, c
53.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    9 R3 i% w8 H, Z! t9 T2 u- f
54. 
    4 l2 w' b* v- ^9 |% \
55.   /* GPIO Ports Clock Enable */
    , B# Z- G; i/ }/ T+ Z
56.   __HAL_RCC_GPIOA_CLK_ENABLE();
    1 v* Z, Q4 |1 T4 v
57. 
    
58.   /*Configure GPIO pin Output Level */
    + c( x. q, [+ ]4 H/ i9 R& `
59.   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
    7 g8 p- x# }8 K3 T4 D6 @* R( U& _
60. 
    : s* @( P  }* x6 \3 `
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;
    % q% o5 x0 X* H/ Z: t
66.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    : ?) r: f4 B3 m  L5 X
67. 
    % q: c& I& F3 h& L; C1 V7 _3 _
68. }

复制代码

: l( l% H. u; p# r' d# Q# J同一总线上不同设备，工作在不同模式的时候，速率可能不一样，需要一个重新设置速率的函数：

8 u' y- ]2 C' [4 _

1. void SPI3_SetSpeed(u8 SPI_BaudRatePrescaler)
   
2. {
   
3.     assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
   6 z3 j! A( q/ [+ B( _9 Z
4.     __HAL_SPI_DISABLE(&SPI3_Handler);            //关闭SPI
   
5.     SPI3_Handler.Instance->CR1 &= 0XFFC7;        //位3-5清零，用来设置波特率
   : t' ~7 e* P6 g0 e; J
6.     SPI3_Handler.Instance->CR1 |= SPI_BaudRatePrescaler; //设置SPI速度
   2 e* o8 f% s* b) f' \7 `
7.     __HAL_SPI_ENABLE(&SPI3_Handler);             //使能SPI
   
8. 
   
9. }

复制代码

- n' a8 ?8 D7 l1 ]; s因为全双工的读写是同时的，封装一个读写函数：
3 M3 q, c1 l% y8 R1 w4 ^" w+ Z
' w3 @/ d" x3 O9 C; V9 q

1. //SPI2 读写一个字节
   
2. //TxData:要写入的字节
   ) D4 c  m, ]# h' {; c
3. //返回值:读取到的字节
   
4. u8 SPI3_ReadWriteByte(u8 TxData)
   
5. {
   ' R  X) e; D3 _; W
6.     u8 Rxdata;
   
7.     HAL_SPI_TransmitReceive(&SPI3_Handler, &TxData, &Rxdata, 1, 1000);
   8 @9 ?+ A6 G; T& V$ A( M
8.     return Rxdata;                      //返回收到的数据
   
9. }

复制代码

  `  ]# D! c$ p- n根据W25QXX的数据手册，写一个读ID的函数：
* z$ M2 ^" Q! c. L

1. //读取芯片ID
   
2. //返回值如下:                                   
   : k" y' @* y* {  \) ~) S7 N2 R, ^
3. //0XEF13,表示芯片型号为W25Q80  
   1 W: I2 ^% e, J) G* r0 Q1 b
4. //0XEF14,表示芯片型号为W25Q16   
   
5. //0XEF15,表示芯片型号为W25Q32  
   
6. //0XEF16,表示芯片型号为W25Q64
   " p2 L8 x. h+ a8 S" w1 l
7. //0XEF17,表示芯片型号为W25Q128           
   
8. u16 W25QXX_ReadID(void)
   8 c: a3 }; S+ v( O7 m0 S1 C( F
9. {
   9 ]4 }# n! f: f8 H& P9 F7 u. A# A
10.         u16 Temp = 0;         
    ! \5 M- _: U5 Y4 g, H' q" i
11.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_RESET);            
    
12.         SPI3_ReadWriteByte(0x90);//发送读取ID命令            
    4 b" B5 Q& W# M5 \; T) V! k% E$ I7 u
13.         SPI3_ReadWriteByte(0x00);            
    
14.         SPI3_ReadWriteByte(0x00);            
    
15.         SPI3_ReadWriteByte(0x00);                                    
    4 w9 H( L, @, m& k9 h& l2 p+ S, H
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. }  

复制代码

最后写一个在主函数中调用的接口函数。

. Z0 |. N$ N5 S) P

1. void W25QXX_Init(void)
   
2. {
   
3.         MX_GPIO_Init();
   4 w* x& F- Q+ S, n$ p
4.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);
   , V9 f! S* v  ~
5.         SPI3_Init();
   
6.         SPI3_SetSpeed(SPI_BAUDRATEPRESCALER_4);
   % p: q3 p. Y7 Y/ b) u
7.         uint16_t W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
   * R6 R/ U# H5 L9 ?- N" f5 m( B
8.         printf("W25QXX ID:0x%4x\r\n",W25QXX_TYPE);
   # N4 r# T! g$ d
9. }

复制代码

7 ]. L+ K8 m( L8 p下载运行，读取到了芯片ID。
5 h2 w7 z2 A- u" o