72.1 初学者重要提示
( Z+ x0 i, o) t" D  STM32H7的SPI支持4到32bit数据传输，而STM32F1和F4系列仅支持8bit或者16bit。
  STM32H7的主频400MHz时，SPI1, 2, 3最高通信时钟是100MHz，而SPI4, 5, 6是50MHz。
  STM32H7的MISO和MOSI引脚功能可以互换，使用比较灵活。
  SPI总线的片选引脚SS在单一的主从器件配置下是可选的，一般情况下可以不使用。

5 T$ y  A& Y- h: l% t: r72.2 SPI总线基础知识
! q' j0 l2 N( }* J4 q) o0 V4 @& i72.2.1 SPI总线的硬件框图
+ B' M% }  n+ N. L4 U8 U/ u认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SPI的基本功能，然后再看手册了解细节。
1 n# e3 K# V3 ?( P- W
( l" z% f: X: g% T( o  ?  R( P

1 }' }) S( u0 H4 O; d
, E6 x0 T" {' I& g2 ?通过这个框图，我们可以得到如下信息：
. E% v: _8 l0 V  spi_wkup输出

低功耗唤醒信号。
' z8 A2 ~/ ^0 y! ]1 C  spi_it输出

6 W7 G& q1 ~, s
spi的中断请求信号。
  spi_tx_dma
  spi_rx_dma

: w1 ]0 ?, T0 v' ~* Z
7 R2 R. D) |' _) X/ Sspi的DMA发送和接收请求信号。
( k3 [- s! }; i2 f  spi_pclk

! o5 ~- m' k! O) m
; S# j1 ]$ d. H8 q  v为寄存器提供时钟。
  spi_ker_ck


* k5 g7 m8 S2 N0 L; n4 j7 Q为spi内核时钟。
  SCK（CK），Serial Clock
3 e" x3 X  C, x$ x, k) [

此引脚在主机模式下用于时钟输出，从机模式下用于时钟输入。
  MISO（SDI），Master In / Slave Out data
. y' A) ~& ]) c* `) p4 E
; M$ [& }. S' E+ r) f) m3 f" J! o7 j
此引脚在从机模式下用于发送数据，主机模式下接收数据。
  MOSI（SDO）, Master Out / Slave In data
' l6 A- p" S# X# e
9 Z2 ^2 `. Y3 c) K
此引脚在从机模式下用于数据接收，主机模式下发送数据。
# r' U; A& X2 m% A. B4 h1 D  SS（WS）, Slave select pin

; s: B4 W7 {! f9 B
# o) A" m- s( J' S$ i4 g$ y根据SPI和SS设置，此引脚可用于：
0 ]5 ^: m  J% X& ba. 选择三个从器件进行通信。

+ K% \$ d/ a0 E1 y3 V) R1 Mb. 同步数据帧。

4 A' k6 w0 p9 Uc. 检测多个主器件之间是否存在冲突。

- {( J$ ?: O! w2 J) c# X! y通过这个框图还要认识到一点，SPI有三个时钟域，分别是寄存器所在的ABP总线时钟域，内核时钟发生器时钟域以及内核时钟发生器分频后的串行时钟域。

8 J" d: o! w& R, F* O0 O" X0 e72.2.2 SPI接口的区别和时钟源（SPI1到SPI6）
这个知识点在初学的时候容易忽视，所以我们这里整理下。
SPI1到SPI6的区别
+ ^. D3 a$ ^7 ~* N! l  SPI1，SPI2和SPI3支持4到32bit数据传输，SPI4，SPI5和SPI6是4到16bit数据传输。
  SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit。

7 k2 d' Y1 @1 u$ |3 T5 D/ X
3 S+ y9 b( |+ i# p; j: \. B  F  SPI1到SPI6的所在的总线（对应SPI框图的SPI_CLK时钟域）

, K  K2 X0 D; s
6 Y$ u, ^0 T; i3 qSPI1，SPI4和SPI5在APB2总线，SPI2，SPI3在APB1总线，SPI6在APB4总线。注意，SPI的最高时钟不是由这些总线决定的。
/ z0 {- }7 i( n+ F) m
  SPI1到SPI6的支持的最高时钟（对应SPI框图的SPI_KER_CK）


- \* B8 `) e% ?6 DSTM32H7主频在400MHz下，SPI1，SPI2和SPI3的最高时钟是200MHz，而SPI4,5,6是100MHz, 以SPI1为了，可以选择的时钟源如下：
5 n! @5 E9 x, @

7 P3 h# L8 L3 t& x4 {这里特别注意一点，SPI工作时最少选择二分频，也就是说SPI1,2,3实际通信时钟是100MHz，而SPI4,5,6是50MHz。

72.2.3 SPI总线全双工，单工和半双工通信
# d. a! Z9 \$ x+ W片选信号SS在单一的主从器件配置下是可选的，一般情况下可以不使用。但需要同步数据流，或者用于TI模式时需要此信号。

  全双工通信
全双工就是主从器件之间同时互传数据，SPI总线的全双工模式接线方式如下：
5 [5 o( \' l  k( Q" x$ G" a
( J: I% B; a1 R$ e# X4 O  F

, \; T9 P0 h6 q+ n1 `
7 @& {) d. J4 L2 O# A: L# [, {" [" t关于这个接线图要认识到以下几点：
/ e1 ]. `2 W  a5 h  注意接线方式，对于主器件来说MISO引脚就是输入端，从器件的MISO是输出端，即Master In / Slave Out data。MOSI也是同样道理。
5 R; w9 l9 N: u# p+ d3 _  每个时钟信号SCK的作用了，主器件的MISO引脚接收1个bit数据，MOSI引脚输出1个bit数据。
  这种单一的主从接线模式下，SS引脚可以不使用。

半双工通信
半双工就是同一个时刻只能为一个方向传输数据，SPI总线的半工模式接线方式如下：
) x8 O0 y7 t4 b6 n0 G1 i7 A7 A

. V0 R0 k* M1 Q  u( s  r关于这个接线图要认识到以下几点：

( j$ \8 u( X! L! o; s  更改通信方式时，要先禁止SPI。
0 m# _/ Y- C7 X! B0 q( Q  主器件的MISO和从器件的MISO不使用，可以继续用作标准GPIO。
+ f  `! w2 ^" I' _3 T. l  1KΩ的接线电阻很有必要，因为当主器件和从器件的通信方向不是同步变化时，容易出现其中一个输出低电平，另一个输出高电平，造成短路。
  这种单一的主从接线模式下，SS引脚可以不使用。
  
单工模式
- _7 z, x6 R8 ^0 s单工就是只有一种通信方向，即发送或者接收，SPI总线的全双工模式接线方式如下：
. k) E- Q1 a& r3 q& }- p5 Y6 h
: w, U) p- U5 b; ?5 s% b7 ?

& r! E0 I/ ?. W- n% P关于这个接线图要认识到以下几点：

  未用到的MOSI或者MISO可以用作标准GPIO。
+ a5 N$ g# w, T8 o7 V& e  这种单一的主从接线模式下，SS引脚可以不使用。

72.2.4 SPI总线星型拓扑
SPI总线星型拓扑用到的地方比较多，V7开发板就是用的星型拓扑外接多种SPI器件：

; u4 M, v, x( I. X" a0 N- F

; T* q1 l/ m4 a关于这个接线图，有以下几点需要大家了解：
* p% g" R. h8 ]$ j( e6 o& G6 U  t
! h& b1 a. ?( h" @  主器件的SS引脚不使用，使用通用GPIO控制。为每个器件配一个SS引脚，方便单独片选控制。
  从器件的MISO引脚要配置为复用开漏输出（很多外部芯片在未片选时，数据引脚是呈现高阻态）。

% Q% d9 H$ q# H( y
3 q" ?- f9 |) w0 S7 h! t72.2.5 SPI总线通信格式
9 X1 L& Z+ t, Y" ASPI总线主要有四种通信格式，由CPOL时钟极性和CPHA时钟相位控制：
# m+ h* c/ @( n" x9 [; Z" I

四种通信格式如下：
  当CPOL = 1， CPHA = 1时
3 S% g! w" t7 J

SCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
. p  y! S3 q+ `! i% b2 I  当CPOL = 0， CPHA = 1时
3 j! C( V2 `! U; C
4 P7 D. Z: X) ~$ z! s% Q* f
SCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。
+ C1 z6 d; u4 E* [; ^  当CPOL = 1， CPHA = 0时
1 r- E* m! a9 O6 k$ K' ^

SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。
  当CPOL = 1， CPHA = 0时
2 n4 {4 k" S, A( [* Y' p8 i2 P
& H! ~4 Z. X& g- O# P+ Q0 ^0 ^
6 r4 }* Q0 ^# J- [* R1 |SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。

0 Y$ r& {+ [( S/ D3 l# e72.3 SPI总线的HAL库用法
72.3.1 SPI总线结构体SPI_TypeDef
. R9 s* S& C4 FSPI总线相关的寄存器是通过HAL库中的结构体SPI_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
, v  L* v) o7 P1 F
' n" _  s% i$ p; P! U' w

1. typedef struct
   % `& i* n5 I# x
2. {
   
3.   __IO uint32_t CR1;           /*!< SPI/I2S Control register 1,                      Address offset: 0x00 */
   
4.   __IO uint32_t CR2;           /*!< SPI Control register 2,                          Address offset: 0x04 */
   5 l$ M7 k7 j9 e5 Z$ I3 v6 S
5.   __IO uint32_t CFG1;          /*!< SPI Configuration register 1,                    Address offset: 0x08 */
   ! r) J. f& H5 L* M
6.   __IO uint32_t CFG2;          /*!< SPI Configuration register 2,                    Address offset: 0x0C */
   
7.   __IO uint32_t IER;           /*!< SPI/I2S Interrupt Enable register,               Address offset: 0x10 */
   0 Y0 E6 C6 x& n# T& O
8.   __IO uint32_t SR;            /*!< SPI/I2S Status register,                         Address offset: 0x14 */
   
9.   __IO uint32_t IFCR;          /*!< SPI/I2S Interrupt/Status flags clear register,   Address offset: 0x18 */
   ) K4 x/ M# L2 l! _7 m/ O
10.   uint32_t      RESERVED0;     /*!< Reserved, 0x1C                                                        */
    1 [9 r6 T  I3 _3 E
11.   __IO uint32_t TXDR;          /*!< SPI/I2S Transmit data register,                  Address offset: 0x20 */
    
12.   uint32_t      RESERVED1[3];  /*!< Reserved, 0x24-0x2C                                                   */
    ! J. T, p5 E2 `3 d
13.   __IO uint32_t RXDR;          /*!< SPI/I2S Receive data register,                   Address offset: 0x30 */
    
14.   uint32_t      RESERVED2[3];  /*!< Reserved, 0x34-0x3C                                                   */
    
15.   __IO uint32_t CRCPOLY;       /*!< SPI CRC Polynomial register,                     Address offset: 0x40 */
    1 [$ r, j7 |; ]8 I+ |7 c, E
16.   __IO uint32_t TXCRC;         /*!< SPI Transmitter CRC register,                    Address offset: 0x44 */
    
17.   __IO uint32_t RXCRC;         /*!< SPI Receiver CRC register,                       Address offset: 0x48 */
    % |4 ]" [" x( F
18.   __IO uint32_t UDRDR;         /*!< SPI Underrun data register,                      Address offset: 0x4C */
    3 v0 w" H0 ~# s" Z! w
19.   __IO uint32_t I2SCFGR;       /*!< I2S Configuration register,                      Address offset: 0x50 */
    
20. 
    ) L' \+ p1 Y  L4 \1 P. p3 p' y
21. } SPI_TypeDef;

复制代码

+ j5 {% C6 `6 y3 h2 w% h: J% K% f这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。
) X: Y5 |0 W$ q- d; L, r
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
- w4 G& a" q( p+ n; N* v( _

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

下面我们看下SPI的定义，在stm32h743xx.h文件。

1. #define PERIPH_BASE           (0x40000000UL)
   8 A. z$ S) h- C0 ]" a- ]1 }* ^
2. #define D2_APB1PERIPH_BASE     PERIPH_BASE
   . c  C; @( O& K8 i( i
3. #define D2_APB2PERIPH_BASE    (PERIPH_BASE + 0x00010000UL)
   
4. #define D3_APB1PERIPH_BASE    (PERIPH_BASE + 0x18000000UL)
     a$ |: B4 K- N6 S
5. 
   
6. #define SPI2_BASE             (D2_APB1PERIPH_BASE + 0x3800UL)
   $ k; i# m5 C/ o5 O
7. #define SPI3_BASE             (D2_APB1PERIPH_BASE + 0x3C00UL)
   
8. #define SPI1_BASE             (D2_APB2PERIPH_BASE + 0x3000UL)
   
9. #define SPI4_BASE             (D2_APB2PERIPH_BASE + 0x3400UL)
   % s6 L' x& j) w' q( i
10. #define SPI5_BASE             (D2_APB2PERIPH_BASE + 0x5000UL)
    
11. #define SPI6_BASE             (D3_APB1PERIPH_BASE + 0x1400UL)
    , [& i& g; P0 r# w
12. 
    * e- P* L6 }' T( K1 Y
13. #define SPI1                ((SPI_TypeDef *) SPI1_BASE)
    
14. #define SPI2                ((SPI_TypeDef *) SPI2_BASE)
    , k/ c' \5 X; W" P) g3 ~
15. #define SPI3                ((SPI_TypeDef *) SPI3_BASE)
    
16. #define SPI4                ((SPI_TypeDef *) SPI4_BASE)
    8 K* |- h# }0 t2 s5 k' I
17. #define SPI5                ((SPI_TypeDef *) SPI5_BASE)
    
18. #define SPI6                ((SPI_TypeDef *) SPI6_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x58001400

复制代码

: }6 _8 l* V$ j/ }1 h我们访问SPI的CR1寄存器可以采用这种形式：SPI->CR1 = 0。

72.3.2 SPI总线初始化结构体SPI_InitTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：

# h/ e1 {8 t+ R2 x

1. typedef struct
   + D7 j) m0 J8 x8 q1 H4 f
2. {
   6 N! N7 Q( A6 T6 r1 M- i! E1 x
3.   uint32_t Mode;                           
   
4.   uint32_t Direction;                     
   6 g4 V/ b4 C6 S' `0 b7 C* N
5.   uint32_t DataSize;                          
   
6.   uint32_t CLKPolarity;                       
   ; z' C+ j  h! x( v
7.   uint32_t CLKPhase;                        
   2 e5 U* ^. i. L1 q( n8 X9 R
8.   uint32_t NSS;                             
   
9.   uint32_t BaudRatePrescaler;               
   
10.   uint32_t FirstBit;                        
    # b- d5 Z9 q7 u: h3 U
11.   uint32_t TIMode;                          
    2 |3 W) `5 G! `  n1 ^
12.   uint32_t CRCCalculation;                  
    
13.   uint32_t CRCPolynomial;                     
    
14.   uint32_t CRCLength;                        
    # E1 \7 w7 O5 r( R- ?8 O; l; g
15.   uint32_t NSSPMode;                        
    7 l: \4 @& {1 A) e, z# d, {% k
16.   uint32_t NSSPolarity;                    
    2 P1 n2 i6 W& m1 |4 K* B: b7 {" O- U$ B) g
17.   uint32_t TxCRCInitializationPattern;      
    ; i8 R5 S) j5 ]
18.   uint32_t RxCRCInitializationPattern;      
    - ~; e! @% m; |* J! V' ?
19.   uint32_t MasterSSIdleness;                 
    
20.   uint32_t MasterInterDataIdleness;           
    / Q$ w8 m, x5 M* }, Q; @
21.   uint32_t MasterReceiverAutoSusp;         
    ) }, f$ Z3 P( j- Y- V  S: {- O6 C
22.   uint32_t MasterKeepIOState;               
    
23.   uint32_t IOSwap;                          
    9 q4 h0 n% [. ?2 F! V5 C
24. } SPI_InitTypeDef;

复制代码

下面将结构体成员逐一做个说明：
; D# g+ N6 `1 z% W, B5 u# i7 Q: Z  Mode
8 |* R& e8 I1 X
用于设置工作在主机模式还是从机模式。

1. #define SPI_MODE_SLAVE              (0x00000000UL)
   " w& d4 N5 Z9 Y  M! _7 x- e
2. #define SPI_MODE_MASTER             SPI_CFG2_MASTER

复制代码

  Direction
+ z, ?. K; Q8 T. n用于设置SPI工作在全双工，单工，还是半双工模式。
3 s. X2 I. B+ a) b

1. #define SPI_DIRECTION_2LINES           (0x00000000UL)     /* 全双工 */
   5 m$ n; x* f4 O- [- F3 b3 I0 f& S
2. #define SPI_DIRECTION_2LINES_TXONLY     SPI_CFG2_COMM_0   /* 单工，仅发送 */
   2 F; S9 @4 }$ Z* K; x, i# l
3. #define SPI_DIRECTION_2LINES_RXONLY     SPI_CFG2_COMM_1   /* 单工，仅接收 */
   
4. #define SPI_DIRECTION_1LINE             SPI_CFG2_COMM     /* 半双工 */

复制代码

$ [% i1 \; L: a+ O/ [+ l  DataSize
用于设置SPI总线数据收发的位宽，支持4-32bit。

1 W) h8 Z6 D, g7 c$ l; \

1. #define SPI_DATASIZE_4BIT                             (0x00000003UL)
   
2. #define SPI_DATASIZE_5BIT                             (0x00000004UL)
   
3. #define SPI_DATASIZE_6BIT                             (0x00000005UL)
   9 E  I( F  r  ?7 H. r, `6 s
4. #define SPI_DATASIZE_7BIT                             (0x00000006UL)
   0 u  L7 l: x) T2 y) _3 W4 Y1 x
5. #define SPI_DATASIZE_8BIT                             (0x00000007UL)
   ! U) Q: y6 J0 X- e; Z
6. #define SPI_DATASIZE_9BIT                             (0x00000008UL)
   " r; S( ^  \# \6 s; ^4 Q* a
7. #define SPI_DATASIZE_10BIT                            (0x00000009UL)
   + O3 l* t' c- r2 i% [
8. #define SPI_DATASIZE_11BIT                            (0x0000000AUL)
   
9. #define SPI_DATASIZE_12BIT                            (0x0000000BUL)
   
10. #define SPI_DATASIZE_13BIT                            (0x0000000CUL)
    ! F6 J0 F3 G* c. n% {8 y, z
11. #define SPI_DATASIZE_14BIT                            (0x0000000DUL)
    
12. #define SPI_DATASIZE_15BIT                            (0x0000000EUL)
    
13. #define SPI_DATASIZE_16BIT                            (0x0000000FUL)
    2 W0 p$ q( f$ T: r
14. #define SPI_DATASIZE_17BIT                            (0x00000010UL)
    0 l+ Q& |! v& P* W* r4 `: Y/ t
15. #define SPI_DATASIZE_18BIT                            (0x00000011UL)
    5 s2 I" i5 n( n: e% s9 o9 b3 j3 C
16. #define SPI_DATASIZE_19BIT                            (0x00000012UL)
    4 F5 i) {" I+ J" q7 [
17. #define SPI_DATASIZE_20BIT                            (0x00000013UL)
      l0 ?6 Z; g" G
18. #define SPI_DATASIZE_21BIT                            (0x00000014UL)
    
19. #define SPI_DATASIZE_22BIT                            (0x00000015UL)
    ( ^- O& z: @/ }; s: k( h
20. #define SPI_DATASIZE_23BIT                            (0x00000016UL)
    
21. #define SPI_DATASIZE_24BIT                            (0x00000017UL)
    7 h/ [' v  H3 X3 Z/ t5 w% v" w
22. #define SPI_DATASIZE_25BIT                            (0x00000018UL)
    
23. #define SPI_DATASIZE_26BIT                            (0x00000019UL)
    ! ?6 b) N9 U! |
24. #define SPI_DATASIZE_27BIT                            (0x0000001AUL)
    2 k( A% n2 {% D' @) m' W: z
25. #define SPI_DATASIZE_28BIT                            (0x0000001BUL)
    8 z# z5 Y- C4 L4 r: t, J/ v0 ^
26. #define SPI_DATASIZE_29BIT                            (0x0000001CUL)
    
27. #define SPI_DATASIZE_30BIT                            (0x0000001DUL)
    
28. #define SPI_DATASIZE_31BIT                            (0x0000001EUL)
    
29. #define SPI_DATASIZE_32BIT                            (0x0000001FUL)
    

复制代码

) J( k) C6 w. R& W' t+ ]* |: s/ w4 W
8 m% r) F* {: q5 d/ l0 l  CLKPolarity
用于设置空闲状态时，CLK是高电平还是低电平。

1. #define SPI_POLARITY_LOW       (0x00000000UL)
   
2. #define SPI_POLARITY_HIGH      SPI_CFG2_CPOL

复制代码

  NSS
& G' w% W3 G4 X用于设置NSS信号由硬件NSS引脚管理或者软件SSI位管理。
% M' ~: U2 H$ u5 A8 D
! V6 r8 R1 C' ^7 t

1. #define SPI_NSS_SOFT                                  SPI_CFG2_SSM
   
2. #define SPI_NSS_HARD_INPUT                            (0x00000000UL)
   
3. #define SPI_NSS_HARD_OUTPUT                           SPI_CFG2_SSOE

复制代码

$ P: Z8 g+ R- v" t0 c  BaudRatePrescaler
4 E, x% g. P( F& |% E用于设置SPI时钟分频，仅SPI工作在主控模式下起作用，对SPI从机模式不起作用。
" I, C. |* M; v3 W( t" E

1. #define SPI_BAUDRATEPRESCALER_2                       (0x00000000UL)
   0 b4 J% l, @7 q
2. #define SPI_BAUDRATEPRESCALER_4                       (0x10000000UL)
   " O" Q& x0 f; n* |
3. #define SPI_BAUDRATEPRESCALER_8                       (0x20000000UL)
   - V) R+ }1 P( F9 Q6 L
4. #define SPI_BAUDRATEPRESCALER_16                      (0x30000000UL)
   
5. #define SPI_BAUDRATEPRESCALER_32                      (0x40000000UL)
   
6. #define SPI_BAUDRATEPRESCALER_64                      (0x50000000UL)
   & l4 _: c0 q/ N2 r" y7 u* B/ E+ K
7. #define SPI_BAUDRATEPRESCALER_128                     (0x60000000UL)
   
8. #define SPI_BAUDRATEPRESCALER_256                     (0x70000000UL)

复制代码

2 Y" ~0 d% d: M. ]+ k1 o% i  FirstBit
用于设置数据传输从最高bit开始还是从最低bit开始。
5 ~! o& V/ S7 ^+ ^/ O3 R) X

1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
   
2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST

复制代码

6 O! E. Y# p  J: z  TIMode
, C  b4 T% x2 q用于设置是否使能SPI总线的TI模式。
$ {! J& w8 p+ G- k1 l5 h/ H6 A

1. #define SPI_TIMODE_DISABLE               (0x00000000UL)
   
2. #define SPI_TIMODE_ENABLE                SPI_CFG2_SP_0

复制代码

  CRCCalculation
/ D8 @8 H8 M: O8 G4 f. z7 K用于设置是否使能CRC计算。

1. #define SPI_CRCCALCULATION_DISABLE                    (0x00000000UL)
   $ y' r9 q- w/ n) C/ @4 O/ g
2. #define SPI_CRCCALCULATION_ENABLE                     SPI_CFG1_CRCEN

复制代码

  CRCPolynomial
用于设置CRC计算使用的多项式，必须是奇数，范围0到65535。
- W! Y+ H6 j6 w/ W' B: z; c
+ ^4 a7 t4 C6 q; u: c- Q  CRCLength
! W" R& Q7 f9 }2 H用于设置CRC计算时的CRC长度。大小要与同属此结构体的DataSize一致。或是DataSize的整数倍。
: q2 N* |) @  g3 ]& Y
& A, }% l/ s. U

1. #define SPI_CRC_LENGTH_DATASIZE                       (0x00000000UL)
   
2. #define SPI_CRC_LENGTH_4BIT                           (0x00030000UL)
   
3. #define SPI_CRC_LENGTH_5BIT                           (0x00040000UL)
   . h, @' Q$ S+ L- F1 Y
4. #define SPI_CRC_LENGTH_6BIT                           (0x00050000UL)
   
5. #define SPI_CRC_LENGTH_7BIT                           (0x00060000UL)
   ; o- @& R8 q' Y' ?% |
6. #define SPI_CRC_LENGTH_8BIT                           (0x00070000UL)
   4 \5 Y3 f% H8 [
7. #define SPI_CRC_LENGTH_9BIT                           (0x00080000UL)
   
8. #define SPI_CRC_LENGTH_10BIT                          (0x00090000UL)
   
9. #define SPI_CRC_LENGTH_11BIT                          (0x000A0000UL)
   
10. #define SPI_CRC_LENGTH_12BIT                          (0x000B0000UL)
    
11. #define SPI_CRC_LENGTH_13BIT                          (0x000C0000UL)
    ( K* v4 @  q5 p$ [5 J  ?
12. #define SPI_CRC_LENGTH_14BIT                          (0x000D0000UL)
    
13. #define SPI_CRC_LENGTH_15BIT                          (0x000E0000UL)
    1 T$ p  [* @, k( k1 f4 o9 U
14. #define SPI_CRC_LENGTH_16BIT                          (0x000F0000UL)
    
15. #define SPI_CRC_LENGTH_17BIT                          (0x00100000UL)
    $ o$ }4 y8 m& x7 |0 I" V2 E0 f+ s
16. #define SPI_CRC_LENGTH_18BIT                          (0x00110000UL)
    
17. #define SPI_CRC_LENGTH_19BIT                          (0x00120000UL)
    # s/ r1 W1 r1 w$ ~8 e
18. #define SPI_CRC_LENGTH_20BIT                          (0x00130000UL)
    / |, T2 S2 B7 O& E7 o- i; O- {
19. #define SPI_CRC_LENGTH_21BIT                          (0x00140000UL)
    
20. #define SPI_CRC_LENGTH_22BIT                          (0x00150000UL)
    * P5 P- @3 R7 s& ^
21. #define SPI_CRC_LENGTH_23BIT                          (0x00160000UL)
    4 M( m/ U5 D2 ^* w; P$ z% d
22. #define SPI_CRC_LENGTH_24BIT                          (0x00170000UL)
    % p) I; @; {2 m; b9 P' u! ~# E1 E
23. #define SPI_CRC_LENGTH_25BIT                          (0x00180000UL)
    4 k7 M# v3 Z0 j$ m4 J, \/ I6 f2 z
24. #define SPI_CRC_LENGTH_26BIT                          (0x00190000UL)
    
25. #define SPI_CRC_LENGTH_27BIT                          (0x001A0000UL)
    - ~: E- b- Q9 X
26. #define SPI_CRC_LENGTH_28BIT                          (0x001B0000UL)
    ) C, t0 g& \' b, T% C1 f
27. #define SPI_CRC_LENGTH_29BIT                          (0x001C0000UL)
    ) C! K! o/ Z: q) {) ]2 o2 j
28. #define SPI_CRC_LENGTH_30BIT                          (0x001D0000UL)
    0 L; x# }7 J2 m$ f6 R
29. #define SPI_CRC_LENGTH_31BIT                          (0x001E0000UL)
    0 q$ {" B6 y% D5 N3 H. j* b9 |
30. #define SPI_CRC_LENGTH_32BIT                          (0x001F0000UL)
    & F) b, H# X/ {$ D8 W

复制代码

  NSSPMode
/ Z: A& P' b) y. g用于设置是否使能NSSP信号，可以通过SPIx_CR2寄存器的SSOM位使能。注意，只有配置为摩托罗拉SPI主控模式时设置此成员才有用。

1. #define SPI_NSS_PULSE_DISABLE                         (0x00000000UL)
   & i1 z& F  {+ u& v* u
2. #define SPI_NSS_PULSE_ENABLE                          SPI_CFG2_SSOM

复制代码

  NSSPolarity
: h4 X- J( f4 `+ w6 C用于设置NSS引脚上的高电平或者低电平作为激活电平。
4 j; d* `$ S* g' x

1. #define SPI_NSS_POLARITY_LOW                          (0x00000000UL)
   
2. #define SPI_NSS_POLARITY_HIGH                          SPI_CFG2_SSIOP

复制代码

1 y1 T" S4 W1 O/ `  FifoThreshold
1 o. T6 X& M8 x$ }* h用于设置SPI的FIFO阀值。

% `' }9 |& B$ r( p$ h

1. #define SPI_FIFO_THRESHOLD_01DATA                     (0x00000000UL)
   
2. #define SPI_FIFO_THRESHOLD_02DATA                     (0x00000020UL)
   
3. #define SPI_FIFO_THRESHOLD_03DATA                     (0x00000040UL)
   
4. #define SPI_FIFO_THRESHOLD_04DATA                     (0x00000060UL)
   
5. #define SPI_FIFO_THRESHOLD_05DATA                     (0x00000080UL)
   
6. #define SPI_FIFO_THRESHOLD_06DATA                     (0x000000A0UL)
     ^9 d# p: P" q) M# A; S8 Y
7. #define SPI_FIFO_THRESHOLD_07DATA                     (0x000000C0UL)
   
8. #define SPI_FIFO_THRESHOLD_08DATA                     (0x000000E0UL)
   - ?* R7 D  N8 P1 i
9. #define SPI_FIFO_THRESHOLD_09DATA                     (0x00000100UL)
   3 X7 X5 \8 R% v+ }3 v0 G3 K  {
10. #define SPI_FIFO_THRESHOLD_10DATA                     (0x00000120UL)
    
11. #define SPI_FIFO_THRESHOLD_11DATA                     (0x00000140UL)
    ! l+ h1 l, i0 w. c2 o
12. #define SPI_FIFO_THRESHOLD_12DATA                     (0x00000160UL)
    
13. #define SPI_FIFO_THRESHOLD_13DATA                     (0x00000180UL)
    ! J$ n  L: u& v2 S) p
14. #define SPI_FIFO_THRESHOLD_14DATA                     (0x000001A0UL)
    ( q1 B, [2 B7 \: Q  n3 O! ^! h
15. #define SPI_FIFO_THRESHOLD_15DATA                     (0x000001C0UL)
    
16. #define SPI_FIFO_THRESHOLD_16DATA                     (0x000001E0UL)

复制代码

  TxCRCInitializationPattern
发送CRC初始化模式。
) q4 W! R8 L4 j6 U  a9 G
& ?9 [0 A. b1 Y7 j$ A5 U# y

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   ) ~" g. L) I# z, g
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

3 k7 x; G( r& M, \) Z% B2 g0 w! `) u- y  RxCRCInitializationPattern
接收CRC初始化模式
3 d5 }$ U1 Q: f4 C0 V9 j% b4 l

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   - u' y9 }$ V/ i. C& ?0 [
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

3 R# o* t8 g9 J0 g* t4 b MasterSSIdleness
! M: r. L! h7 r8 o在主模式下插入到SS有效边沿和第一个数据开始之间的额外延迟，单位SPI时钟周期个数。

1. #define SPI_MASTER_SS_IDLENESS_00CYCLE                (0x00000000UL)
   + J$ H5 t9 s4 c# i% \
2. #define SPI_MASTER_SS_IDLENESS_01CYCLE                (0x00000001UL)
   3 ~3 j! T& q9 z6 o. r1 U
3. #define SPI_MASTER_SS_IDLENESS_02CYCLE                (0x00000002UL)
   ! y1 E% H% Z" x6 `; S
4. #define SPI_MASTER_SS_IDLENESS_03CYCLE                (0x00000003UL)
   
5. #define SPI_MASTER_SS_IDLENESS_04CYCLE                (0x00000004UL)
   , K) K. f4 h% l7 }
6. #define SPI_MASTER_SS_IDLENESS_05CYCLE                (0x00000005UL)
   : v4 |$ |* F# r+ f# j
7. #define SPI_MASTER_SS_IDLENESS_06CYCLE                (0x00000006UL)
   
8. #define SPI_MASTER_SS_IDLENESS_07CYCLE                (0x00000007UL)
   : A0 O5 L9 ~& O  {
9. #define SPI_MASTER_SS_IDLENESS_08CYCLE                (0x00000008UL)
   ! H8 k+ l  r+ W, r6 l
10. #define SPI_MASTER_SS_IDLENESS_09CYCLE                (0x00000009UL)
    , u( M+ p& l' F- n4 b8 h2 @
11. #define SPI_MASTER_SS_IDLENESS_10CYCLE                (0x0000000AUL)
    ( {3 b" [& y( G  V
12. #define SPI_MASTER_SS_IDLENESS_11CYCLE                (0x0000000BUL)
    
13. #define SPI_MASTER_SS_IDLENESS_12CYCLE                (0x0000000CUL)
    3 |* |# r' [. Z; z5 e
14. #define SPI_MASTER_SS_IDLENESS_13CYCLE                (0x0000000DUL)
    
15. #define SPI_MASTER_SS_IDLENESS_14CYCLE                (0x0000000EUL)
    
16. #define SPI_MASTER_SS_IDLENESS_15CYCLE                (0x0000000FUL)
    * H+ r0 }1 Q5 K& N1 F2 U, M, u

复制代码

" U" w' [* B" A# i6 l  MasterInterDataIdleness
! X1 w2 c1 S/ E' E9 v9 b主模式下在两个连续数据帧之间插入的最小时间延迟，单位SPI时钟周期个数。
( {! }" s  G% G- b+ h
0 y# r* L6 t$ B0 F

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX

复制代码

, h! R' ?* h- ]( Y  MasterReceiverAutoSusp
) K% ^; l' @2 z$ g用于控制主器件接收器模式下的连续 SPI 传输以及自动管理，以避免出现上溢情况。
% A" [. e2 z1 W2 m6 r- y( O
1 S( o8 E8 ]7 m

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX
   3 n0 c1 J. J, }) t8 K+ t) k

复制代码

  MasterKeepIOState
禁止SPI后，SPI相关引脚保持当前状态，以防止出现毛刺。在从模式下，该位不应该使用。

1. #define SPI_MASTER_KEEP_IO_STATE_DISABLE              (0x00000000UL)
   . A0 D  g# D/ E' M) r, f$ m. V3 M
2. #define SPI_MASTER_KEEP_IO_STATE_ENABLE               SPI_CFG2_AFCNTR

复制代码

  IOSwap
用于交换MISO和MOSI引脚。
& V, C8 `1 A# x" [
+ R$ a! F! `& m; z; c) e; ~

1. #define SPI_IO_SWAP_DISABLE                           (0x00000000UL)
   ' T! T8 k" U! m4 W7 ]9 u" G
2. #define SPI_IO_SWAP_ENABLE                            SPI_CFG2_IOSWP

复制代码

72.3.3 SPI总线句柄结构体SPI_HandleTypeDef
; o4 N* q. u- W下面是SPI总线的初始化结构体，用到的地方比较多：

1. typedef struct __SPI_HandleTypeDef
   
2. {
   
3.   SPI_TypeDef                *Instance;                 
   
4.   SPI_InitTypeDef            Init;                        
   ; Z8 p- A0 d' e7 q
5.   uint8_t                    *pTxBuffPtr;                 
     L5 a" J# Y# u  v% a# n7 _* ~; `" K
6.   uint16_t                   TxXferSize;                  
   
7.   __IO uint16_t              TxXferCount;                  
   . p" t; _# ]$ r
8.   uint8_t                    *pRxBuffPtr;               
   4 S7 \6 ?) L) b  w, {
9.   uint16_t                   RxXferSize;                  
   
10.   __IO uint16_t              RxXferCount;                 
    ' a7 ]6 S' [4 p. Q# ?
11.   uint32_t                   CRCSize;                     
    
12.   void (*RxISR)(struct __SPI_HandleTypeDef *hspi);      
    . K3 _* s/ H( l, U3 l
13.   void (*TxISR)(struct __SPI_HandleTypeDef *hspi);        
    + w2 S4 f7 x1 d) t# O5 Q
14.   DMA_HandleTypeDef          *hdmatx;                     
    " j7 x0 i1 _) X; c6 Q! D
15.   DMA_HandleTypeDef          *hdmarx;                     
    * _* e0 I- e. {1 h2 i+ v
16.   HAL_LockTypeDef            Lock;                        
    + \0 o% x, r9 Z' T1 O) S
17.   __IO HAL_SPI_StateTypeDef  State;                        
    ) t9 O8 l5 Y/ q& S1 @- S  u
18.   __IO uint32_t              ErrorCode;                  
    7 `5 j8 z; q# [. _- x' f' s
19. #if defined(USE_SPI_RELOAD_TRANSFER)
    
20.   SPI_ReloadTypeDef          Reload;                     
    * f) a* o) M9 S0 o+ a
21. #endif
    ! t, E" a; W3 q, W
22. 
    
23. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
24.   void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
25.   void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
26.   void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    4 F% N0 Y, b$ I0 @* g* t. x& `
27.   void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    
28.   void (* RxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    
29.   void (* TxRxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);
    
30.   void (* ErrorCallback)(struct __SPI_HandleTypeDef *hspi);      
    
31.   void (* AbortCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
      k9 |4 y6 F, W$ X1 h# l
32.   void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);   
    - c& o+ s) J5 U
33.   void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);
    
34. #endif  
    
35. } SPI_HandleTypeDef;
    

复制代码

8 v( t( G4 _, l& m8 C/ k4 d注意事项：

9 @9 j8 o) _9 F+ V2 u" H" R9 [条件编译USE_HAL_SPI_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：
1 v- N2 u1 I# |! u
  #define   USE_HAL_SPI_REGISTER_CALLBACKS   1

通过函数HAL_SPI_RegisterCallback注册回调，取消注册使用函数HAL_SPI_UnRegisterCallback。
5 U/ S  b* l  L) w' {
这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。

  SPI_TypeDef   *Instance
6 e2 W' L3 Q. {2 A, N这个参数是寄存器的例化，方便操作寄存器，比如使能SPI1。
3 r! w/ p8 b- u$ a/ s: a2 Q0 S& I
4 j+ w& M. g. n8 Z7 ySET_BIT(SPI1 ->CR1,  SPI_CR1_SPE)。

  SPI_InitTypeDef  Init
这个参数是用户接触最多的，在本章节3.2小节已经进行了详细说明。

1 ]: v- l* s) Z/ U  DMA_HandleTypeDef          *hdmatx               
  DMA_HandleTypeDef          *hdmarx
, i' B% ~6 H- z& i- [& \" Y! p用于SPI句柄关联DMA句柄，方便操作调用。

72.4 SPI总线源文件stm32h7xx_hal_spi.c
7 ~: H/ h- ^& k: e此文件涉及到的函数较多，这里把几个常用的函数做个说明：
* k9 d" M. E1 l9 n
" H0 G8 A; D& R7 k) D  HAL_SPI_Init
+ N8 ~( b) n$ {6 J6 l  HAL_SPI_DeInit
0 u& @! |1 W. ?( t  HAL_SPI_TransmitReceive
  HAL_SPI_TransmitReceive_IT
# y" m; J0 k. ]- m! S! L( m  HAL_SPI_TransmitReceive_DMA
* [' P6 h3 X- M, M: D) f, b
) h7 J: p0 q( x1 }4 n0 s$ ]72.4.1 函数HAL_SPI_Init
$ `' Z9 i7 x0 d/ v: j函数原型：

1. HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
   + J5 i% V( W3 f/ z9 m4 Y" i0 w" G
2. {
   $ i0 ?& j9 b& s( O7 [; y2 D  @, q
3.   uint32_t crc_length = 0UL;
   
4.   uint32_t packet_length;
   
5. 
   , N$ c3 ~# E+ O% U* A
6.   /* 省略未写 */
   : j" o0 K' D  v. m
7. 
   
8.   /* 如果数据位宽大于16bit，必须是SPI1，SPI2或者SPI3，而SPI4，SPI5和SPI6不支持大于16bit */
   $ I! m, e' a3 m6 R. s$ K
9.   if ((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (hspi->Init.DataSize > SPI_DATASIZE_16BIT))
   
10.   {
    9 J1 |* X# I1 p% V& r; }
11.     return HAL_ERROR;
    
12.   }
    
13. 
    . K. V3 P0 Z# L
14.   /* SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit
    2 b% b# @" p2 j  N# \; p& r. X# g8 b
15.      这里是查看设置的缓冲大小是否超出了FIFO支持的大小。
    ' I, {% H7 s- a
16. */
    
17.   packet_length = SPI_GetPacketSize(hspi);
    
18.   if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_LOWEND_FIFO_SIZE)) ||
    $ b9 X( |9 E1 P" _6 A
19.       ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_HIGHEND_FIFO_SIZE)))
    
20.   {
    5 r- f- d, I% W) |- g  v; {' T
21.     return HAL_ERROR;
    
22.   }
    
23. 
    
24. #if (USE_SPI_CRC != 0UL)
    1 y$ e" x) J2 X3 p. z3 `
25.     /* 省略未写 */
    - Z+ C* Y% n3 {. v4 h. E
26. #endif
    
27. 
    
28.   if (hspi->State == HAL_SPI_STATE_RESET)
    2 a7 M5 Z  z& v/ A2 Q
29.   {
    - w( ~8 H  w8 Z) k4 Z: x) z% P( {
30.     /* 解锁 */
    * u' y  U! F/ T' c) Z
31.     hspi->Lock = HAL_UNLOCKED;
    
32. 
    
33.     /* 使用自定义回调 */
    
34. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    5 m  k9 G# `: J- j- X6 p7 Y
35.     /* 设置默认回调函数 */
    
36.     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */
    
37.     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */
    8 A9 Z* r/ n1 h+ R5 K
38.     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */
    
39.     hspi->TxHalfCpltCallback   = HAL_SPI_TxHalfCpltCallback;   /* Legacy weak TxHalfCpltCallback   */
    
40.     hspi->RxHalfCpltCallback   = HAL_SPI_RxHalfCpltCallback;   /* Legacy weak RxHalfCpltCallback   */
    
41.     hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */
    * a3 L4 I6 M1 o. n$ C2 P5 m
42.     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */
    
43.     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */
    * r5 ]) u5 I2 k  k) c
44. 
    ) r" g. F3 }+ y) E( K: }# h0 W# U
45.     if (hspi->MspInitCallback == NULL)
    
46.     {
    $ C2 h$ v6 V, r4 s" ~2 Q
47.       hspi->MspInitCallback = HAL_SPI_MspInit;
    ( b0 A. Y! R7 T3 J! h: D
48.     }
    
49. 
    
50.     /* 初始化地址硬件: GPIO, CLOCK, NVIC... */
    
51.     hspi->MspInitCallback(hspi);
    
52. #else
    . }, E5 w; W& T& `. t: k/ _
53.     /* 初始化底层硬件: GPIO, CLOCK, NVIC... */
    
54.     HAL_SPI_MspInit(hspi);
    
55. #endif
    ' D- b" _# X! h  R
56.   }
    ) j* W* F5 o0 J
57. 
    
58.   hspi->State = HAL_SPI_STATE_BUSY;
    & I: s. Y) `3 z7 m' d
59. 
    6 W! `' }+ `- F- Y8 ?
60.   /* 禁止SPI外设 */
    
61.   __HAL_SPI_DISABLE(hspi);
    
62. 
    & a+ S* z* g9 M/ g/ A- J
63.   /*----------------------- SPIx CR1 & CR2 配置---------------------*/
    , f' x# i! ~$ e$ |
64.   if ((hspi->Init.NSS == SPI_NSS_SOFT) && (hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.NSSPolarity ==
    , c8 w' i, y1 p: x
65. SPI_NSS_POLARITY_LOW))
    
66.   {
    
67.       SET_BIT(hspi->Instance->CR1, SPI_CR1_SSI);
    1 t' ]+ l2 D  r& z/ Y
68.   }
    
69. 
    6 W* x$ x8 j0 ^& b6 @5 K" M
70.   /* SPIx CFG1配置 */
    ; Z  A* |5 ~  [3 O% @  G' Z/ o' e
71.   WRITE_REG(hspi->Instance->CFG1, (hspi->Init.BaudRatePrescaler | hspi->Init.CRCCalculation | crc_length |
    - D9 p; o+ v: f1 c( T" r$ v/ z
72.                                    hspi->Init.FifoThreshold     | hspi->Init.DataSize));
    , u  g' T9 v2 c
73. 
    
74.   /* SPIx CFG2配置 */
    ( M: K( l% o' p
75.   WRITE_REG(hspi->Instance->CFG2, (hspi->Init.NSSPMode     | hspi->Init.TIMode           | hspi->Init.NSSPolarity  |
    4 D+ @* e/ I3 m& w
76.                                    hspi->Init.NSS          | hspi->Init.CLKPolarity      | hspi->Init.CLKPhase     |
    
77.                                    hspi->Init.FirstBit     | hspi->Init.Mode             | hspi->Init.MasterInterDataIdleness |
      H6 c5 B6 U% A' O( ?
78.                                    hspi->Init.Direction    | hspi->Init.MasterSSIdleness | hspi->Init.IOSwap));
    
79. 
    ! Q9 a, G* F, Z+ a
80. #if (USE_SPI_CRC != 0UL)
    
81.   /*---------------------------- SPIx CRC配置 ------------------*/
    8 b+ F. |4 ]# @3 Y4 ^; _
82.   /* 配置SPI CRC */
    & z6 }6 M  g' B7 u# W
83.   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    0 s& {# w* c, }, l
84.   {
    1 V4 h3 l6 Y- H
85.     /* 初始化TX CRC初始值 */
    3 {& r  {; y& W! q% M2 H
86.     if (hspi->Init.TxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    2 v! j! E1 t( F( ?, w3 d
87.     {
    0 D0 p& m8 g1 W- w! O5 Q( V
88.       SET_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    9 F, l/ D: u4 w1 ^5 A
89.     }
    $ f# X7 I$ u9 y; v" {
90.     else
    
91.     {
    7 M1 B/ s5 X" k$ J( i, {' t% d
92.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    3 c$ x+ O8 m* f
93.     }
    / E  C8 S. _1 G* o8 z
94. 
    
95.     /* 初始化RXCRC初始值 */
    9 A9 z+ N) }' M; p) [
96.     if (hspi->Init.RxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    / Y! x5 v2 ]: Y# p
97.     {
    4 i7 d3 @5 M0 M! @" h
98.       SET_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
    
99.     }
    
100.     else
     : g# _$ ~$ y8 q7 m& u+ Y/ N
101.     {
     9 Y. ?  Y& e$ r. ^7 h, f! L2 C. K
102.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
     
103.     }
     6 O2 L7 y) Y$ w$ O5 |2 P6 P# ~
104. 
     7 r2 U' U$ ^8 J" Z$ u
105.     /* 使能 33/17 bit CRC计算 */
     / U2 u0 K- z! ?0 M' T
106.     if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (crc_length == SPI_CRC_LENGTH_16BIT)) ||
     : Y% z! D/ G: K  W' S
107.         ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance))  && (crc_length == SPI_CRC_LENGTH_32BIT)))
     9 ?5 o3 W& ^- x+ n  r# v
108.     {
     2 I9 O4 X# E. g
109.       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     
110.     }
     4 |$ M5 }9 B) U  }6 r/ U0 T
111.     else
     8 _' O+ V# ?' [5 v
112.     {
     & t% p+ ], u+ W# j
113.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     # Y% {5 {5 \- _$ |5 l# \
114.     }
     
115. 
     
116.     /* 写CRC多项式到SPI寄存器 */
     
117.     WRITE_REG(hspi->Instance->CRCPOLY, hspi->Init.CRCPolynomial);
     + W4 E& {8 T% h0 c2 `0 r
118.   }
     
119. #endif
     ) m/ o7 a% A5 Q: m& M
120. 
     
121.   /* SPI从模式，下溢配置 */
     + k- {; V0 e! E! w! t# ?
122.   if (hspi->Init.Mode == SPI_MODE_SLAVE)
     0 o4 @( h! v0 p& G9 b2 ?
123.   {
     
124.     /* 设置默认下溢配置 */
       D" _  P. U, d7 E
125. #if (USE_SPI_CRC != 0UL)
     8 L" {, x) K1 Y
126.     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_DISABLE)
     1 I3 N2 E8 J, U7 [/ t8 O
127. #endif
     * O$ \0 ^9 p: p) F5 `9 Q, {4 I% ~
128.     {
     ( b/ \7 r. W' b2 |* b
129.       MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, SPI_CFG1_UDRDET_0);
     $ J4 Q# ~, a+ e! t  q* a+ n) Y
130.     }
     
131.     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRCFG, SPI_CFG1_UDRCFG_1);
     
132.   }
     
133. 
     
134. #if defined(SPI_I2SCFGR_I2SMOD)
     
135.   CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);
     
136. #endif
     
137. 
     9 w$ [1 {5 D  |* N9 L2 P4 `
138.   /* 确保AFCNTR bit由SPI主机模式管理 */
     ' \7 C/ q; m( {! P# J. L1 _
139.   if ((hspi->Init.Mode & SPI_MODE_MASTER) == SPI_MODE_MASTER)
     4 L- p* H6 Y' Z
140.   {
     
141.     /* Alternate function GPIOs control */
     " w# z1 ]/ d2 ]% c8 D
142.     MODIFY_REG(hspi->Instance->CFG2, SPI_CFG2_AFCNTR, (hspi->Init.MasterKeepIOState));
     . P0 a8 X) B/ r8 z6 b2 O
143.   }
     + |1 f1 o/ L! U% _3 R0 w
144. 
     $ _" `2 A& p% E+ ^( }: v
145.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
     3 c3 P, q9 P1 o8 }
146.   hspi->State     = HAL_SPI_STATE_READY;
     
147. 
     
148.   return HAL_OK;
     
149. }
     , s3 I' j, U' {6 h. K9 z$ O1 w

复制代码

0 O7 u# g+ p7 M; S, Q0 `函数描述：

此函数用于初始化SPI。
+ J7 `3 Y3 j8 ^
; h: n9 C# t5 C+ q( `6 \# z函数参数：
+ g% U. O7 O/ K
  第1个参数是SPI_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

7 c1 m. g8 c& O; t' }7 }
' K  d- E& y' C) n0 U$ x2 ?注意事项：
; S' w* {2 g2 \& Q2 |& d% K函数HAL_SPI_MspInit用于初始化SPI的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hspi的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SPI_HandleTypeDef SpiHandle。
. l1 C5 }) p8 N* n& L对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SPI_STATE_RESET  = 0x00U。
: ~6 d: U# X- m, k- c
$ x; @6 V8 c% P  a$ G解决办法有三
: m! \1 e3 t/ P% |( k- A) L$ o+ X0 T9 [
9 k1 p" R8 H4 q  c方法1：用户自己初始化SPI和涉及到的GPIO等。
5 Z& F$ m/ y4 W; R& E. b9 @( `
方法2：定义SPI_HandleTypeDef SpiHandle为全局变量。
( Z) z" C: I/ S
方法3：下面的方法
5 e" o0 H3 e8 o9 i7 d8 n
9 B9 [2 b+ @5 O2 U, Y

1. if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK)
   * j$ _' N, M& Q  |4 m2 `
2. {
   
3.     Error_Handler();
   
4. }  
   8 p5 i7 C2 j, o2 B& \, y
5. if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
   9 A& e0 {1 m5 Y& W  R  g  u* d5 A
6. {
   1 Q2 _: c- d1 m& T2 e
7.     Error_Handler();
   ! m. ?/ \8 p( F' j$ W2 i! t/ y
8. }

复制代码

+ ~* t4 P3 C' n使用举例：

: `" m7 ^6 [! j9 f9 T# e5 G$ {8 N

1. SPI_HandleTypeDef hspi = {0};
   & B1 g) I& O9 m( i, O
2. 
   % M* _0 h# |) p2 q, [/ L
3. /* 设置SPI参数 */
   
4. hspi.Instance               = SPIx;                   /* 例化SPI */
   
5. hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
   7 G; v7 h. h' {# b
6. hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
   
7. hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
   
8. hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
   9 j/ C  {2 t. a- A, c3 ~$ V
9. hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
   
10. hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    5 U1 W& @4 P& Z' T6 Z/ O. n
11. hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    : [- ~; q+ m7 `
12. hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;      /* 禁止CRC */
    
13. hspi.Init.CRCPolynomial     = 7;                               /* 禁止CRC后，此位无效 */
    " s' _% r2 K6 }( ]; _
14. hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;             /* 禁止CRC后，此位无效 */
    8 ~9 g+ m; u4 o7 j/ M& A5 |2 I1 P) P
15. hspi.Init.NSS               = SPI_NSS_SOFT;                    /* 使用软件方式管理片选引脚 */
    3 N( R, G0 @7 W7 g% o
16. hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;       /* 设置FIFO大小是一个数据项 */
    * ]5 b2 g3 a+ x4 ]$ I9 a8 @
17. hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;           /* 禁止脉冲输出 */
    
18. hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    
19. hspi.Init.Mode                  = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    % A4 _( {. b% ?" [
20. 
    # y4 Z  G; h/ \/ p
21. if (HAL_SPI_Init(&hspi) != HAL_OK)
    
22. {
    " J% e2 @8 V2 o. [/ U
23.     Error_Handler(__FILE__, __LINE__);
    
24. }

复制代码

72.4.2 函数HAL_SPI_DeInit
+ |2 v& l& n0 p+ s函数原型：

1. HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
   
2. {
   
3. /* 检测SPI句柄是否有效 */
   , W: u# `0 d/ E- \
4.   if (hspi == NULL)
   ! W3 s' ?$ g6 ^  o
5.   {
   
6.     return HAL_ERROR;
   " [  U7 D' _, r1 Q3 Q2 {4 x
7.   }
   
8. 
   ; e) \: H4 w" L
9. /* 检查SPI例化参数 */
   
10.   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
    
11. 
    
12.   hspi->State = HAL_SPI_STATE_BUSY;
    2 L" H2 j3 l% ^1 C
13. 
    
14.   /* 禁止SPI外设时钟 */
    * D3 s2 |: g$ ?
15.   __HAL_SPI_DISABLE(hspi);
    
16. 
    
17. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    , C& R, y& f. S2 t
18.   if (hspi->MspDeInitCallback == NULL)
    
19.   {
    
20.     hspi->MspDeInitCallback = HAL_SPI_MspDeInit;
    
21.   }
    
22. 
    4 T4 K- Q' ~$ o2 A
23.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    * j8 P: D+ E) x) e: ]2 `; B) V
24.   hspi->MspDeInitCallback(hspi);
    
25. #else
    1 o) Y/ e3 p7 }4 C& M9 O; e
26.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    
27.   HAL_SPI_MspDeInit(hspi);
    
28. #endif
    / E9 Q7 {6 y; C, {
29. 
    ( Z* g" F5 T# Y+ f2 {
30.   /* 设置无错误，复位状态标记 */
    
31.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
    
32.   hspi->State = HAL_SPI_STATE_RESET;
    
33. 
    / ^7 Z" ]1 C" W4 c
34.   /* 解锁SPI */
    
35.   __HAL_UNLOCK(hspi);
    
36. 
    + I4 R! v; A+ X9 }4 p9 \- J1 ^0 ~$ `
37.   return HAL_OK;
    , ?- F! ^' W  J8 e% ]
38. }

复制代码

2 c( w+ Y( Y. o. N, @) l3 U, \函数描述：
4 w" K3 J5 w: X- i, c8 R9 k
用于复位SPI总线初始化。
8 w8 `: c+ ^, _
函数参数：
- x% |8 P( Z8 |0 I6 N
. e+ n% Z# y: C  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  r  M7 e, b" d9 k! s$ \  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中

( H' B  @/ P" w, Y/ a  G) m1 b
( N6 J0 V  v8 D$ b72.4.3 函数HAL_SPI_TransmitReceive
& A3 m3 t/ ~. r6 s$ Y! |函数原型：

+ _0 p- Q  X# I

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
   ) J1 j4 |" a0 n0 `; r& T, F
2. {
   
3. 
   
4.    /* 省略未写 */
   . @' _6 ?: Q. c+ o
5. 
   
6.   /* 大于16bit的数据收发 */
   - u0 z. J# n) Q7 k4 h
7.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
   5 \7 T- F5 q. `0 X
8.   {
   
9.        /* 省略未写 */
   - j1 k( O2 \& z5 V6 ^
10.   }
      E& \% q. j# T( W: d! O
11.   /* 大于8bit，小于16bi的数据收发 */
    5 K; @; W, W" a* j0 k; N7 \
12.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    : f3 w7 y) M) v8 S
13.   {
    # D0 a8 E. ]) W
14.       /* 省略未写 */
    
15.   }
    # p2 q' j7 F9 F
16.   /* 小于等于8bit的数据收发 */
    ! D0 c0 {2 f( Y5 p& a* U9 j6 {
17.   else
    ; Y/ j$ t) @( D
18.   {
    9 B7 F9 \+ b4 }- `2 d5 ^) R/ @
19.        /* 省略未写 */
    
20.   }
    
21. 
    
22. }

复制代码

* a6 A8 T8 `  r8 n; u' B  p函数描述：
+ N7 E9 I+ C% |2 a
9 U" A* ]# t; I4 Z$ D  c- |& }6 Z  P此函数主要用于SPI数据收发，全双工查询方式。

( \  n% y. F# X函数参数：
4 t: k9 f; z, n1 [1 a
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
# @9 w5 z, D/ n/ H# b4 P  第3个参数是接收数据缓冲地址。
& g: b" Y: n4 j( ?; z+ d+ i  第4个参数是传输的数据大小，单位字节个数。
  第5个参数是传输过程的溢出时间，单位ms。
8 I0 z, B2 Y) a$ p0 j& [. m) @* ^  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
6 B" D. s1 L7 Y

使用举例：
. G" i+ r) n/ `" ?+ @0 f" x0 `# `4 {; \) Q
3 g! E4 @, u. n

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   
3. if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)
   
4. {
   
5.     Error_Handler(__FILE__, __LINE__);
   3 P: q( N; q2 o; O& e& V, P
6. }

复制代码

72.4.4 函数HAL_SPI_TransmitReceive_IT
函数原型：
8 c, ^* ^5 g6 k* k) P% m% s

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
   
2. {
   
3.    /* 省略未写 */
   
4. 
   1 ?2 Q' a+ E  q3 b( Y( W
5.   /* 设置传输参数 */
   - K4 N1 r5 P" t% f: _/ t, W
6.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   
7.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
   ; M# p! z$ n# @5 U$ S8 g7 K! H. y3 I: G
8.   hspi->TxXferSize  = Size;
   " T# n4 U3 K- ^5 W) C; ?3 p
9.   hspi->TxXferCount = Size;
   
10.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
    
11.   hspi->RxXferSize  = Size;
    
12.   hspi->RxXferCount = Size;
    
13. 
    
14.   /* 设置中断处理 */
    
15.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    - ]: ~3 `5 u/ L$ J$ l# E
16.   {
    
17.     hspi->TxISR     = SPI_TxISR_32BIT;
    
18.     hspi->RxISR     = SPI_RxISR_32BIT;
    
19.   }
    
20.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    9 T' |8 E8 T4 o9 c: B( G( S  p& Y
21.   {
    ' p1 m1 W& [" M7 V( O
22.     hspi->RxISR     = SPI_RxISR_16BIT;
    
23.     hspi->TxISR     = SPI_TxISR_16BIT;
    
24.   }
    
25.   else
    
26.   {
    : `# ^. B0 S4 p3 i6 A- [
27.     hspi->RxISR     = SPI_RxISR_8BIT;
    
28.     hspi->TxISR     = SPI_TxISR_8BIT;
    
29.   }
    
30. 
    
31.   /* 设置当前传输数据大小 */
    4 L- A' }. t4 {9 w
32.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    
33. 
    
34.   /* 使能SPI外设 */
    
35.   __HAL_SPI_ENABLE(hspi);
    7 f$ T8 N- M" B1 F. @, I
36. 
    
37.   /* 使能各种中断标志 */
    
38.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_EOT | SPI_IT_RXP | SPI_IT_TXP | SPI_IT_DXP | SPI_IT_UDR | SPI_IT_OVR |
    3 z0 m+ q: k& X1 e- G: {
39. SPI_IT_FRE | SPI_IT_MODF | SPI_IT_TSERF));
    2 c8 _; Y% K- ]' M$ O( R
40. 
    * g7 H' j. p# k2 l
41.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    
42.   {
    7 O7 S, L6 b2 W4 B3 x
43.     /* 启动传输 */
    4 I; S* [* N2 d  f
44.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
    # T0 O4 a( u: r; P6 A6 ?6 G8 w: A. Z3 i
45.   }
    7 D" u2 `3 Y) [- ?
46. 
    ' z! _, x' D) s7 R  f, M
47.   /* 解锁 */
    
48.   __HAL_UNLOCK(hspi);
    5 x0 U: ~  [* B9 C+ |$ w
49.   return errorcode;
    
50. }
    

复制代码

函数描述：
2 W! {2 O2 Q/ U9 t: W
# t; c) M; k. ^此函数主要用于SPI数据收发，全双工中断方式。
4 _, c$ w  q& Z! }2 P( M
函数参数：

6 T/ {& t3 o2 A  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
8 i) r( E+ P  D* j/ J9 b# `  第2个参数是发送数据缓冲地址。
  第3个参数是接收数据缓冲地址。
1 A* @% A4 y9 Y' X  _  第4个参数是传输的数据大小，单位字节个数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。


% e0 v0 `2 S% _使用举例：

3 ~3 O& R3 i# }, y& t

1. SPI_HandleTypeDef hspi = {0};
     T8 l$ n/ P% M
2. 
   / i: n) C2 n. o: A- Q7 C! ]
3. if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   ; @% b9 f0 ]# i. N* E8 J
4. {
   0 y( j7 _5 O# ?0 h2 f( m
5.     Error_Handler(__FILE__, __LINE__);
   9 ~. _1 z. e( c+ i5 ^
6. }

复制代码

' t) b8 @* o+ x3 {  G1 @72.4.5 函数HAL_SPI_TransmitReceive_DMA
5 K5 o# y( I% {8 I% M. H- ?& o函数原型：

1 q; j7 _* x3 F3 ^1 R

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,
   
2.                                               uint16_t Size)
   ; a2 W: l8 X. b+ Q; k9 z
3. {
     E! n7 a$ k; }5 u, `9 {" J$ |: d1 y
4.    /* 省略未写 */
   $ |& K/ q+ a/ v
5. 
   ! ]. [- d. x9 Y1 Z# ?
6. /* 注意DMA的位宽和对齐设置 */
   
7.   if (((hspi->Init.DataSize > SPI_DATASIZE_16BIT) && (hspi->hdmarx->Init.MemDataAlignment !=
   # j/ I! p- F: N/ z- g
8. DMA_MDATAALIGN_WORD))  ||
   
9.       ((hspi->Init.DataSize > SPI_DATASIZE_8BIT) && ((hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_HALFWORD) && (hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_WORD))))
   9 r; i7 c5 u. Y; N7 M" c
10.   {
    
11.   }
    3 }/ L$ j3 b: {5 M
12. 
    ) w/ p7 T/ v4 I4 z# j7 B% A: P$ H
13. /* 调整DMA对齐和数据大小 */
    / E& U, J4 C7 @
14.   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)
    
15.   {
    $ G6 x0 z: q! A1 D$ q- b
16.      /* 省略未写 */
    
17.   }
    % Q+ u7 A) N$ l9 g, |
18.   else if (hspi->Init.DataSize <= SPI_DATASIZE_16BIT)
    
19.   {
    
20.      /* 省略未写 */
      n* ?: R0 w5 |
21.   }
    2 y. ], i$ ^4 c. b
22.   else
    1 P( B+ ?4 Z" \6 p- k
23.   {
    ! q6 J% I# T8 n
24.       /* 省略未写 */
    
25.   }
    
26. 
    
27. /*  DMA接收配置 */
    * M4 o5 k. R# `+ a% u
28.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->RXDR, (uint32_t)hspi->pRxBuffPtr,
    3 C4 l0 A: q8 [, Y. [: ]1 s
29. hspi->RxXferCount))
    
30.   {
    . f- R- a6 V& H. X9 E8 ^( \
31. 
    
32.   }
    & n) {3 d) D+ C. \' D  @& _
33. 
    4 `! u; |9 o( {
34. /* DMA发送配置 */
    
35.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->TXDR,
    + ^& F0 ~2 P/ y% n* }
36. hspi->TxXferCount))
    
37.   {
    
38.   }
    
39. 
    
40.   /* 省略未写 */
    
41. }
    / a3 B2 G; d  G' ^

复制代码

函数描述：

  D. E4 @% `  s+ E- P8 v" X* s6 x此函数主要用于SPI数据收发，全双工DMA方式。

4 R. f) B  \" @% W! f+ f8 P$ o函数参数：

) w' U) P8 O' |* P; @  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
: i8 \' u8 b) j  w* C  第2个参数是发送数据缓冲地址。
* M2 f8 I! H) i- |, V9 p  第3个参数是接收数据缓冲地址。
8 \8 u1 Z" q# o8 ^+ v0 v  第4个参数是传输的数据大小，单位字节个数。
. B9 ~$ t, s" d. E2 F  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

! u, B9 h& g5 m! @
1 e+ r; h/ S& o5 W) t  f使用举例：
( V, T& a( Q3 ~4 h' ?( M
5 f+ s5 W$ y/ z

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   
3. if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   
4. {
   
5.     Error_Handler(__FILE__, __LINE__);
   + _8 g( [% o! c4 l4 P# h0 e
6. }
   

复制代码

# ^& y3 p' k) w7 n6 T; o72.5 总结
本章节就为大家讲解这么多，要熟练掌握SPI总线的查询，中断和DMA方式的实现，因为基于SPI接口的外设芯片很多，熟练后，可以方便的驱动各种SPI接口芯片，以便选择合适的驱动方式。
; A* f; z3 M. n

) y/ j! w# C' d/ }; T3 w
6 w0 S8 G0 `* b  q& n% s0 z6 t