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


4 M; x8 A) q, c7 ~- `0 g

" x/ E7 A$ u, tSPI模式
  h; S" \  q( ]有只发送、只接收、半双工和全双工模式；
- _( u6 V' }- i7 q, c) o根据自己的需求，和SPI设备支持的类型，这里选择全双工的SPI；
9 S( C, C# s, z* s2 p0 a
片选信号
" T  v2 r) ~4 S$ C8 e  h2 q因为我们这个SPI总线上会挂载多个从设备，而且只有一个主机，所以，这里禁用硬件片选，程序里面读写之前使用软件进行片选；
/ O/ p% U! k' \0 J) V" C# h* @
帧格式
这里选择Motorola帧格式；
选择TI格式不能设置CPOL和CPHA，而且必须要开启硬件NSS这里才能选择TI模式。
) z; E/ |5 z' b1 f- N- v6 I博主在网上搜了一些关于TI的SSP协议相关的资料，只有简简单单的一句：SSP总线兼容SPI，SSI 和Microwire 总线的接口。
7 Y1 w5 [1 W+ I3 d( E博主又搜了以下Microwire协议，和SPI一样，只不过片选信号是高电平有效。
6 ?4 C" C9 w4 V/ m这是手册里关于TI模式的说明部分和波形图：
! l) f8 o* `; d
; m5 t) n9 ~: s3 [
2 W% n+ q, y" A* L


也不清楚这个SCK的触发信号是干嘛的，所以这里老老实实选择Motorola就行了。
% T9 H2 O+ R/ |
# f5 n7 r2 ?+ p" M1 I数据长度
4-16bit可选，根据实际，选择8bit；

数据传输模式
第一个传输的bit是高位还是低位，这里根据设备来选择，好像MSB（先发送高位）的比较多，注意这里的会同时设置发送和接收，如果设置错了，发送的指令对方就无法识别，可能收到的就是0xFF这种值。

2 T) {! z" L) F6 T' wSPI速率
2 @0 @7 W' N9 CSPI的波特率是由时钟分频得到的，CubeMX很方便的还帮我们计算出来了时钟速率，可以根据自己的需求设置。
5 T& M& g' c% ~
时钟极性和时钟相位
0 F- x9 \. u. r3 `# m* x' f根据极性和相位的不同，可以有4种不同的工作模式，这个根据芯片手册支持的模式选择，注意，一条总线上尽量挂载支持相通模式的设备，这样就不用每次在设备切换之前重新配置SPI外设。

1 R- {2 g4 {6 J  D0 q) S8 V% u% a) ~CRC校验
3 V. {) t5 A. z+ ^# a3 j暂时还没研究到这里……
3 z; i5 R* d0 _9 J
# P% h8 ]3 u3 K+ j+ f& q3 A6 GNSS脉冲
, s0 ~( e  c/ ?3 z$ U- p5 H) K参考SPI的NSS 脉冲模式的作用，这里用不到；
5 y$ Z; R5 J4 `8 y7 o0 X
/ x0 e8 ?7 z# o1 j% [8 K( |2 [NSS信号类型
" _( U- R4 t1 ^因为前面禁用了硬件片选，所以这里只能设置位软件模式。

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

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   
2. 
   
3. void SPI3_Init(void)
   % v! K4 Y+ K5 K; q  K
4. {
   : Z3 \  ^  Z4 I& f/ @. b9 O; H
5.     SPI3_Handler.Instance = SPI3;
   , B2 Q% a+ ]. D; [0 p. O- i
6.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
   
7.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
   2 ?( f* p5 C1 b) v+ _# r, c
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;
      Z: q/ I3 @* s: H
12.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    3 ?8 E0 V" v3 l% U; `& ^2 o
13.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    . _7 K! }" V0 K
14.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    
15.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    4 D" [4 V' j* t2 j: r! j
16.     SPI3_Handler.Init.CRCPolynomial = 7;
    # M3 D# H4 d( k+ B# }/ p5 f
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. 
    
21.     __HAL_SPI_ENABLE(&SPI3_Handler);               
    ( \2 o& k2 C0 O0 N3 }/ {  \" X
22. }
    
23. 
    
24. void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
    0 R  s$ w5 s( f+ w; d$ Q  d
25. {
    
26.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    1 l+ _7 a5 @, S4 x
27.   if(hspi->Instance==SPI3)
    4 i4 O7 I$ z; I) t  F% o. P5 r
28.   {
    ' g& C1 C& m1 m3 f* c" B1 ^
29. 
    , @0 ~/ {/ i' |
30.     __HAL_RCC_SPI3_CLK_ENABLE();
    
31.   
    
32.     __HAL_RCC_GPIOB_CLK_ENABLE();
    3 r, |0 ~2 H* }
33. 
    2 d% _) h/ r" @5 U1 i! J
34.     GPIO_InitStruct.Pin = GPIO_PIN_2;
    
35.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    1 t  v/ H, A: O
36.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
37.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    3 }2 b* ~" r: N- j5 B! O5 f$ w9 _! i
38.     GPIO_InitStruct.Alternate = GPIO_AF7_SPI3;
    
39.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
40. 
    / ]8 k, ^' J) p
41.     GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4;
    & H8 p: o! H6 M. x' k! q" |
42.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    ) w4 n0 n- p  f/ P' S; @, S
43.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    9 J! G" U7 {( I2 Z) e! D% I& ^
44.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    
45.     GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
    - u+ D: C3 A( @9 K$ l. e. K9 K8 {! H
46.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
47.   }
    ( o% e1 [# Q& ^5 `
48. }
    
49. 
    
50. 
    
51. static void MX_GPIO_Init(void)
    
52. {
    
53.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    
54. 
    6 E' J, q' e/ w- y. P# H
55.   /* GPIO Ports Clock Enable */
    ' v, P+ c% ?* ^, m2 e3 U
56.   __HAL_RCC_GPIOA_CLK_ENABLE();
    
57. 
    
58.   /*Configure GPIO pin Output Level */
    
59.   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
    
60. 
    
61.   /*Configure GPIO pin : PA4 */
    . x0 @, B5 j$ B  w* `
62.   GPIO_InitStruct.Pin = GPIO_PIN_4;
    
63.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    0 w5 Q/ L- I& D! u3 N
64.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
65.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
66.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
67. 
    ( W6 h3 r2 X; v, `0 C7 [
68. }
    

复制代码

同一总线上不同设备，工作在不同模式的时候，速率可能不一样，需要一个重新设置速率的函数：
  L8 s% z% W! `) o6 x2 l

1. void SPI3_SetSpeed(u8 SPI_BaudRatePrescaler)
   3 Z( ]( o# L0 ]  @* S0 Q3 V& g8 \, ?/ x
2. {
   
3.     assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
   
4.     __HAL_SPI_DISABLE(&SPI3_Handler);            //关闭SPI
   
5.     SPI3_Handler.Instance->CR1 &= 0XFFC7;        //位3-5清零，用来设置波特率
   / O" V$ V" W4 A6 D. [# N3 S
6.     SPI3_Handler.Instance->CR1 |= SPI_BaudRatePrescaler; //设置SPI速度
   3 X4 k& y; ~* ^+ H8 ~# k
7.     __HAL_SPI_ENABLE(&SPI3_Handler);             //使能SPI
   8 L* k# P; K& ]# m
8. 
   
9. }
   ' B% I5 r9 ~8 b3 c% P: ~  p

复制代码

5 ?, N8 k+ T; m" V% V6 ~因为全双工的读写是同时的，封装一个读写函数：

1. //SPI2 读写一个字节
   
2. //TxData:要写入的字节
   
3. //返回值:读取到的字节
   - L9 T% r# q6 m4 W
4. u8 SPI3_ReadWriteByte(u8 TxData)
   
5. {
   ' ]$ `& `1 A8 z+ ?; @, z: N4 V! v
6.     u8 Rxdata;
   
7.     HAL_SPI_TransmitReceive(&SPI3_Handler, &TxData, &Rxdata, 1, 1000);
   , c3 g8 x) r$ t) s
8.     return Rxdata;                      //返回收到的数据
   - p: _( J/ {  _6 p2 t
9. }
   

复制代码

" a1 j, B  y5 L% r2 Y% k( u$ L! [. e根据W25QXX的数据手册，写一个读ID的函数：

1. //读取芯片ID
   
2. //返回值如下:                                  
   - G, o- y- S# k9 w2 v0 @8 j
3. //0XEF13,表示芯片型号为W25Q80  
   6 Q' r' m! s0 q2 ^; H$ V- ~( o: C
4. //0XEF14,表示芯片型号为W25Q16   
   
5. //0XEF15,表示芯片型号为W25Q32  
   
6. //0XEF16,表示芯片型号为W25Q64
   
7. //0XEF17,表示芯片型号为W25Q128           
   
8. u16 W25QXX_ReadID(void)
   . H! L( [; ^1 S. ?2 Z9 w
9. {
   
10.         u16 Temp = 0;          
    ) F; m6 W' Y% i& k% Y
11.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_RESET);            
    
12.         SPI3_ReadWriteByte(0x90);//发送读取ID命令            
    ; v7 a( w+ E5 F
13.         SPI3_ReadWriteByte(0x00);             
    $ r7 |* g$ z7 I. K) z
14.         SPI3_ReadWriteByte(0x00);             
    
15.         SPI3_ReadWriteByte(0x00);                                    
    1 S" d6 T! C0 L
16.         Temp|=SPI3_ReadWriteByte(0xFF)<<8;  
    & w% X4 N( u# k- E6 e: i) H
17.         Temp|=SPI3_ReadWriteByte(0xFF);         
    + S: t2 _0 J7 K4 o
18.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);  
    
19.         return Temp;
    
20. }   
    

复制代码

, ~' B" @# C$ T4 F  v+ y( E; s最后写一个在主函数中调用的接口函数。
* U; \' {, M. S% V5 G- v0 r9 x

1. void W25QXX_Init(void)
   ) k: [0 D$ Y1 P, x; w
2. {
   
3.         MX_GPIO_Init();
   / v; e9 m) Y2 ?$ ]% y# p
4.         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);
   
5.         SPI3_Init();
   8 h: I# u- L. i/ B, Z6 Z. I
6.         SPI3_SetSpeed(SPI_BAUDRATEPRESCALER_4);
   
7.         uint16_t W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
   - G5 d) u2 r8 a% L
8.         printf("W25QXX ID:0x%4x\r\n",W25QXX_TYPE);
   " l) y$ _: B) b7 v  H
9. }
   / r+ _8 G& G5 v2 y1 O, v

复制代码

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

! z3 B7 S3 z7 c) i/ j0 a

, ~, ^5 p5 ?3 j! O1 K/ n————————————————
版权声明：小盼你最萌哒