72.1 初学者重要提示
1 q! A+ @% E3 c- I+ ~# P' Q  STM32H7的SPI支持4到32bit数据传输，而STM32F1和F4系列仅支持8bit或者16bit。
  STM32H7的主频400MHz时，SPI1, 2, 3最高通信时钟是100MHz，而SPI4, 5, 6是50MHz。
4 ]( X- h# q; i( h5 G2 S  STM32H7的MISO和MOSI引脚功能可以互换，使用比较灵活。
  SPI总线的片选引脚SS在单一的主从器件配置下是可选的，一般情况下可以不使用。
: D2 j, J& s# F: X( C# m- U. j
, Y; F! O. f1 a9 Z  _' ~# Q& N9 G4 o72.2 SPI总线基础知识
72.2.1 SPI总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SPI的基本功能，然后再看手册了解细节。

1 L4 F0 l6 c; f; D* ~
通过这个框图，我们可以得到如下信息：
2 D$ R* Y5 z$ A
  p: q/ _2 p( |" `7 e  spi_wkup输出
) k/ w  B$ w: v  {1 f低功耗唤醒信号。
% z4 U7 b9 V) Y+ m5 \
. {& j7 k8 d5 W; c1 v( q, Z& F  spi_it输出
% F; n* |) X' gspi的中断请求信号。
0 ?% Y; W8 }$ o: B' X' N, Q# ], r
  spi_tx_dma
% U8 E, C0 s( [& x5 ^, T; |- Vspi_rx_dma
4 [9 j( b4 G5 b0 l( \spi的DMA发送和接收请求信号。
) P0 o3 y2 d. ^
0 D. Y3 t! F$ V6 @; W  spi_pclk
6 r! v" Q8 E. C' U( ]) y为寄存器提供时钟。
! L% v+ e) D* |& K+ ]
  spi_ker_ck
  ~0 {! k& k" L' r为spi内核时钟。

/ A( l1 Y5 J: r, s; o  SCK（CK），Serial Clock
1 Q. Y5 u- _8 \) j此引脚在主机模式下用于时钟输出，从机模式下用于时钟输入。
3 ], I( N! @* g8 d
  MISO（SDI），Master In / Slave Out data
( R. e2 p8 `5 @4 \此引脚在从机模式下用于发送数据，主机模式下接收数据。
" k6 T! x+ [( \' L: w- i
  MOSI（SDO）, Master Out / Slave In data
此引脚在从机模式下用于数据接收，主机模式下发送数据。

- v5 t2 e+ R1 H  R( G; O: ?# J& b  SS（WS）, Slave select pin
7 }6 q' W% x9 L: E% i( Z根据SPI和SS设置，此引脚可用于：

a. 选择三个从器件进行通信。
9 }5 i7 M" u& p4 G  J) M
+ ?& Q4 K4 M6 Y# gb. 同步数据帧。

c. 检测多个主器件之间是否存在冲突。

- Y* ]0 i% h' V+ l: K' _/ \/ P3 _- i通过这个框图还要认识到一点，SPI有三个时钟域，分别是寄存器所在的ABP总线时钟域，内核时钟发生器时钟域以及内核时钟发生器分频后的串行时钟域。

3 s/ U) Q) u% Y; p+ V72.2.2 SPI接口的区别和时钟源（SPI1到SPI6）
这个知识点在初学的时候容易忽视，所以我们这里整理下。
( x  t3 N8 |! a9 V8 D. Z+ B
  SPI1到SPI6的区别
4 J8 u1 i5 o+ I0 E4 p. z  SPI1，SPI2和SPI3支持4到32bit数据传输，SPI4，SPI5和SPI6是4到16bit数据传输。
2 h% }! }% k) E# G( o8 T4 |- E  SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit。
' I! q, U1 H7 k; `% z  h

* ^. Z9 ?7 X# T- t' K! |& G5 Z
  SPI1到SPI6的所在的总线（对应SPI框图的SPI_CLK时钟域）
SPI1，SPI4和SPI5在APB2总线，SPI2，SPI3在APB1总线，SPI6在APB4总线。注意，SPI的最高时钟不是由这些总线决定的。
7 h3 L/ o5 u0 d& o; p
1 C! {  S$ D3 u0 w6 m1 M  SPI1到SPI6的支持的最高时钟（对应SPI框图的SPI_KER_CK）
" o3 A6 q: R+ F# X( G( ?STM32H7主频在400MHz下，SPI1，SPI2和SPI3的最高时钟是200MHz，而SPI4,5,6是100MHz, 以SPI1为了，可以选择的时钟源如下：
6 A* v$ C2 G0 a# D9 F# j, N2 z

$ s# x/ y, R- R1 F% m: V+ i1 P
' z- M- a0 {! e% {) W这里特别注意一点，SPI工作时最少选择二分频，也就是说SPI1,2,3实际通信时钟是100MHz，而SPI4,5,6是50MHz。

6 r: Z2 f: D2 }' H/ X+ Z& |72.2.3 SPI总线全双工，单工和半双工通信
片选信号SS在单一的主从器件配置下是可选的，一般情况下可以不使用。但需要同步数据流，或者用于TI模式时需要此信号。

* ^: r* ?3 g8 @. I  全双工通信
全双工就是主从器件之间同时互传数据，SPI总线的全双工模式接线方式如下：
, p+ O, p$ i3 ~' ]* V8 s% U
4 |. G. W, v; e6 D) S+ h7 z' F

3 U$ J- d( L9 V/ o) d
' P: @$ _8 `) u9 W: e/ ]/ Y关于这个接线图要认识到以下几点：
8 Y! D& G. T7 n* _& T1 ^; }
  注意接线方式，对于主器件来说MISO引脚就是输入端，从器件的MISO是输出端，即Master In / Slave Out data。MOSI也是同样道理。
  每个时钟信号SCK的作用了，主器件的MISO引脚接收1个bit数据，MOSI引脚输出1个bit数据。
  这种单一的主从接线模式下，SS引脚可以不使用。
; `# k1 C1 j6 G( c: l4 R  半双工通信
2 S: v  J' ~/ I: f8 A* y( H半双工就是同一个时刻只能为一个方向传输数据，SPI总线的半工模式接线方式如下：
6 q. r/ o9 d# b( t  @1 o) N, V
% D4 G! W% M" _! [2 n

关于这个接线图要认识到以下几点：

, r, g* Y. U9 u/ l, A  更改通信方式时，要先禁止SPI。
  主器件的MISO和从器件的MISO不使用，可以继续用作标准GPIO。
  1KΩ的接线电阻很有必要，因为当主器件和从器件的通信方向不是同步变化时，容易出现其中一个输出低电平，另一个输出高电平，造成短路。
  这种单一的主从接线模式下，SS引脚可以不使用。
  单工模式
单工就是只有一种通信方向，即发送或者接收，SPI总线的全双工模式接线方式如下：
% z8 a7 z) C4 @2 X5 a( j' {
1 |2 h) z4 @0 t9 e

. g9 \# O9 Z- h5 D4 i关于这个接线图要认识到以下几点：
4 q6 G/ T) j# @) @
1 w- C3 v1 f- K' W# V  未用到的MOSI或者MISO可以用作标准GPIO。
+ g7 C/ c! y6 J! e5 b; v  这种单一的主从接线模式下，SS引脚可以不使用。
' D+ f1 g+ Y$ i. L& m1 @& x6 y' [2 U72.2.4 SPI总线星型拓扑
SPI总线星型拓扑用到的地方比较多，V7开发板就是用的星型拓扑外接多种SPI器件：

* }$ Y) p8 z( h' e
关于这个接线图，有以下几点需要大家了解：

  主器件的SS引脚不使用，使用通用GPIO控制。为每个器件配一个SS引脚，方便单独片选控制。
  从器件的MISO引脚要配置为复用开漏输出（很多外部芯片在未片选时，数据引脚是呈现高阻态）。
72.2.5 SPI总线通信格式
9 k+ S' f/ e0 F  b7 P3 f" xSPI总线主要有四种通信格式，由CPOL时钟极性和CPHA时钟相位控制：

6 s, {4 L4 ^, U4 r2 y! l/ j

- h! o; Z- @6 u# w" g# H- A7 B
四种通信格式如下：
7 _; O. B. R' [9 D- d5 V& A
$ G+ O& K; L+ r  I: x  当CPOL = 1， CPHA = 1时
SCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
, ^1 ~$ g  Q( A$ f
  当CPOL = 0， CPHA = 1时
SCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。
" S' ?* a' K, b: s1 n4 A$ c
  `9 N7 j: ?  I& w$ S8 m  当CPOL = 1， CPHA = 0时
' [. ?1 G* D  J$ T- B( gSCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

  当CPOL = 1， CPHA = 0时
SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
1 h) x! ]# b; M
& c0 j5 o* A4 e& ?/ T% ?, i7 f72.3 SPI总线的HAL库用法
72.3.1 SPI总线结构体SPI_TypeDef
SPI总线相关的寄存器是通过HAL库中的结构体SPI_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

1. typedef struct
   # @7 ~6 f; e( c) ]* r/ \4 a
2. {
   9 N( B, I; r) R1 F! E& }
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 */
   2 T  j$ T9 e( U2 ^& C
5.   __IO uint32_t CFG1;          /*!< SPI Configuration register 1,                    Address offset: 0x08 */
   
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 */
   
8.   __IO uint32_t SR;            /*!< SPI/I2S Status register,                         Address offset: 0x14 */
   2 u1 {2 W/ \3 h7 z2 v% E
9.   __IO uint32_t IFCR;          /*!< SPI/I2S Interrupt/Status flags clear register,   Address offset: 0x18 */
   4 P( S+ ?1 i% N; E& }2 T. U3 {
10.   uint32_t      RESERVED0;     /*!< Reserved, 0x1C                                                        */
    
11.   __IO uint32_t TXDR;          /*!< SPI/I2S Transmit data register,                  Address offset: 0x20 */
    
12.   uint32_t      RESERVED1[3];  /*!< Reserved, 0x24-0x2C                                                   */
      P) a6 d5 T% U
13.   __IO uint32_t RXDR;          /*!< SPI/I2S Receive data register,                   Address offset: 0x30 */
    . Y/ m( f/ O, c+ J$ j; t
14.   uint32_t      RESERVED2[3];  /*!< Reserved, 0x34-0x3C                                                   */
    
15.   __IO uint32_t CRCPOLY;       /*!< SPI CRC Polynomial register,                     Address offset: 0x40 */
    4 [: a& ^; ?! d! i
16.   __IO uint32_t TXCRC;         /*!< SPI Transmitter CRC register,                    Address offset: 0x44 */
    3 R+ |8 i9 D* R2 G+ G
17.   __IO uint32_t RXCRC;         /*!< SPI Receiver CRC register,                       Address offset: 0x48 */
    
18.   __IO uint32_t UDRDR;         /*!< SPI Underrun data register,                      Address offset: 0x4C */
    
19.   __IO uint32_t I2SCFGR;       /*!< I2S Configuration register,                      Address offset: 0x50 */
    . O( ^' L6 P/ \" r
20. 
    2 X- }1 ^2 d, \' \; n; L
21. } SPI_TypeDef;

复制代码

2 n4 k9 P" ~- b' f# Y- h这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
& A7 w- e! R& P+ D8 _4 O

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   ; r6 d" E  _, C
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

. A. o# Q8 I5 ~下面我们看下SPI的定义，在stm32h743xx.h文件。

! u4 w# J$ s# U" _

1. #define PERIPH_BASE           (0x40000000UL)
   ) u9 n8 G9 Y# z$ k' c0 \( B0 y: _
2. #define D2_APB1PERIPH_BASE     PERIPH_BASE
   
3. #define D2_APB2PERIPH_BASE    (PERIPH_BASE + 0x00010000UL)
   
4. #define D3_APB1PERIPH_BASE    (PERIPH_BASE + 0x18000000UL)
   
5. 
   ( t" ]( Y$ S; E$ n; S5 [
6. #define SPI2_BASE             (D2_APB1PERIPH_BASE + 0x3800UL)
   
7. #define SPI3_BASE             (D2_APB1PERIPH_BASE + 0x3C00UL)
   
8. #define SPI1_BASE             (D2_APB2PERIPH_BASE + 0x3000UL)
   
9. #define SPI4_BASE             (D2_APB2PERIPH_BASE + 0x3400UL)
   
10. #define SPI5_BASE             (D2_APB2PERIPH_BASE + 0x5000UL)
    
11. #define SPI6_BASE             (D3_APB1PERIPH_BASE + 0x1400UL)
    5 }( [6 G8 L! R. |6 C4 ~
12. 
    + O) X2 n+ O7 _% n; e) G9 ]5 X
13. #define SPI1                ((SPI_TypeDef *) SPI1_BASE)
    ! [. o* Z  [5 F2 T- ^
14. #define SPI2                ((SPI_TypeDef *) SPI2_BASE)
    
15. #define SPI3                ((SPI_TypeDef *) SPI3_BASE)
    
16. #define SPI4                ((SPI_TypeDef *) SPI4_BASE)
    : Y; n5 d' g# v9 ?
17. #define SPI5                ((SPI_TypeDef *) SPI5_BASE)
    
18. #define SPI6                ((SPI_TypeDef *) SPI6_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x58001400

复制代码

5 M6 o4 z2 {6 ]7 C我们访问SPI的CR1寄存器可以采用这种形式：SPI->CR1 = 0。
7 O0 E% O7 v' k% L0 @: E2 o
9 p: |# x1 V  N" i72.3.2 SPI总线初始化结构体SPI_InitTypeDef
/ `4 `+ F5 S' F7 E( C下面是SPI总线的初始化结构体，用到的地方比较多：

1. typedef struct
   - U/ _& M- ?+ t) u+ m7 _8 d9 g* |% J
2. {
   * N0 \& t3 k: T
3.   uint32_t Mode;                           
   - l1 K2 @1 O* M& N
4.   uint32_t Direction;                     
   
5.   uint32_t DataSize;                          
   2 v2 |- I6 W. D$ Z- @  d' Y
6.   uint32_t CLKPolarity;                       
   ; Z" n) a5 `. h6 F2 o
7.   uint32_t CLKPhase;                        
   / l6 F# K! S% a! n% N
8.   uint32_t NSS;                             
   
9.   uint32_t BaudRatePrescaler;               
   : K  [4 A4 z6 c$ e
10.   uint32_t FirstBit;                        
    
11.   uint32_t TIMode;                          
    
12.   uint32_t CRCCalculation;                  
    
13.   uint32_t CRCPolynomial;                     
    1 z) f' m! v9 o
14.   uint32_t CRCLength;                        
    
15.   uint32_t NSSPMode;                        
    ) q. D: F5 T* J$ k
16.   uint32_t NSSPolarity;                    
    
17.   uint32_t TxCRCInitializationPattern;      
    ) v4 W. X9 h. e1 f- z& b4 G; e1 ^
18.   uint32_t RxCRCInitializationPattern;      
    
19.   uint32_t MasterSSIdleness;                 
    3 f: T8 R- G/ y, V
20.   uint32_t MasterInterDataIdleness;           
    
21.   uint32_t MasterReceiverAutoSusp;         
    
22.   uint32_t MasterKeepIOState;               
    + T" K0 a( l" ?# c
23.   uint32_t IOSwap;                          
      p7 |" p7 r% E" g& p0 l
24. } SPI_InitTypeDef;

复制代码

下面将结构体成员逐一做个说明：

! T2 Z, ?, j  k: s: {  Mode
用于设置工作在主机模式还是从机模式。

1. #define SPI_MODE_SLAVE              (0x00000000UL)
   
2. #define SPI_MODE_MASTER             SPI_CFG2_MASTER

复制代码

  Direction
用于设置SPI工作在全双工，单工，还是半双工模式。

1. #define SPI_DIRECTION_2LINES           (0x00000000UL)     /* 全双工 */
   
2. #define SPI_DIRECTION_2LINES_TXONLY     SPI_CFG2_COMM_0   /* 单工，仅发送 */
   # L5 X/ c- A1 k. ^) w" J
3. #define SPI_DIRECTION_2LINES_RXONLY     SPI_CFG2_COMM_1   /* 单工，仅接收 */
   " e" i1 g4 o) T+ d; r
4. #define SPI_DIRECTION_1LINE             SPI_CFG2_COMM     /* 半双工 */

复制代码

  DataSize
: ]0 W8 @; B) {4 a用于设置SPI总线数据收发的位宽，支持4-32bit。
6 M. c  \' R& f6 D1 {; ?
: |5 i8 P; z* c+ q# `

1. #define SPI_DATASIZE_4BIT                             (0x00000003UL)
   
2. #define SPI_DATASIZE_5BIT                             (0x00000004UL)
   
3. #define SPI_DATASIZE_6BIT                             (0x00000005UL)
   
4. #define SPI_DATASIZE_7BIT                             (0x00000006UL)
   
5. #define SPI_DATASIZE_8BIT                             (0x00000007UL)
   2 \& ~5 f7 _  Z) s+ e$ z$ b
6. #define SPI_DATASIZE_9BIT                             (0x00000008UL)
   - e; ^' V5 M8 u
7. #define SPI_DATASIZE_10BIT                            (0x00000009UL)
   
8. #define SPI_DATASIZE_11BIT                            (0x0000000AUL)
   
9. #define SPI_DATASIZE_12BIT                            (0x0000000BUL)
   
10. #define SPI_DATASIZE_13BIT                            (0x0000000CUL)
    
11. #define SPI_DATASIZE_14BIT                            (0x0000000DUL)
    
12. #define SPI_DATASIZE_15BIT                            (0x0000000EUL)
    
13. #define SPI_DATASIZE_16BIT                            (0x0000000FUL)
    ; m9 T5 c2 F& D  M% F3 O3 O# q$ M; m
14. #define SPI_DATASIZE_17BIT                            (0x00000010UL)
    
15. #define SPI_DATASIZE_18BIT                            (0x00000011UL)
    
16. #define SPI_DATASIZE_19BIT                            (0x00000012UL)
    : \+ P6 O+ p1 J0 Y
17. #define SPI_DATASIZE_20BIT                            (0x00000013UL)
    / x0 a. t3 p: d7 ]
18. #define SPI_DATASIZE_21BIT                            (0x00000014UL)
    ( K8 S5 C* M+ R0 s
19. #define SPI_DATASIZE_22BIT                            (0x00000015UL)
    
20. #define SPI_DATASIZE_23BIT                            (0x00000016UL)
    0 S  O6 T4 W6 n# D: B, m% g( y( X$ p  v
21. #define SPI_DATASIZE_24BIT                            (0x00000017UL)
    # Z7 P# I* z9 H( d
22. #define SPI_DATASIZE_25BIT                            (0x00000018UL)
    9 s9 S6 S+ d3 C- ~: O
23. #define SPI_DATASIZE_26BIT                            (0x00000019UL)
    6 @( @1 ^3 r- `/ f) r4 o8 M/ X
24. #define SPI_DATASIZE_27BIT                            (0x0000001AUL)
    ' \4 @) Z9 t( F+ `8 K
25. #define SPI_DATASIZE_28BIT                            (0x0000001BUL)
    
26. #define SPI_DATASIZE_29BIT                            (0x0000001CUL)
    / [& v, ?- O" l) `! u
27. #define SPI_DATASIZE_30BIT                            (0x0000001DUL)
    
28. #define SPI_DATASIZE_31BIT                            (0x0000001EUL)
    
29. #define SPI_DATASIZE_32BIT                            (0x0000001FUL)

复制代码

& z. o- J" G1 ?. o% V  CLKPolarity
用于设置空闲状态时，CLK是高电平还是低电平。
- f% N8 a/ q0 ]( \
( y! \5 A( b3 y2 L

1. #define SPI_POLARITY_LOW       (0x00000000UL)
     {- A9 J, \- @. H2 V! ^% e: A
2. #define SPI_POLARITY_HIGH      SPI_CFG2_CPOL

复制代码

  NSS
用于设置NSS信号由硬件NSS引脚管理或者软件SSI位管理。

, v! \5 S; h+ P4 [% ^7 M

1. #define SPI_NSS_SOFT                                  SPI_CFG2_SSM
   4 x& {) ]; j" ^/ U& u+ c4 `
2. #define SPI_NSS_HARD_INPUT                            (0x00000000UL)
   
3. #define SPI_NSS_HARD_OUTPUT                           SPI_CFG2_SSOE

复制代码

  BaudRatePrescaler
用于设置SPI时钟分频，仅SPI工作在主控模式下起作用，对SPI从机模式不起作用。
) q2 h7 q3 j" r
9 k& d* `+ y9 f4 _

1. #define SPI_BAUDRATEPRESCALER_2                       (0x00000000UL)
   
2. #define SPI_BAUDRATEPRESCALER_4                       (0x10000000UL)
   
3. #define SPI_BAUDRATEPRESCALER_8                       (0x20000000UL)
   $ g4 \9 G" u/ F* a  C7 R
4. #define SPI_BAUDRATEPRESCALER_16                      (0x30000000UL)
   
5. #define SPI_BAUDRATEPRESCALER_32                      (0x40000000UL)
   
6. #define SPI_BAUDRATEPRESCALER_64                      (0x50000000UL)
   
7. #define SPI_BAUDRATEPRESCALER_128                     (0x60000000UL)
   , O9 J% r: h& b" T
8. #define SPI_BAUDRATEPRESCALER_256                     (0x70000000UL)

复制代码

  FirstBit
用于设置数据传输从最高bit开始还是从最低bit开始。
" T9 {0 F$ h/ Q6 H) I

1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
   0 d, b8 g5 r- R+ d* v
2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST
   

复制代码

4 t" d6 R" N% ~$ V, D% n  TIMode
2 c" @  `# D4 R用于设置是否使能SPI总线的TI模式。
& Y1 h$ W! O1 n. s$ J3 J) n, C
+ }6 y+ E; E! r/ \- p- E

1. #define SPI_TIMODE_DISABLE               (0x00000000UL)
   ( g, M4 z/ I) d: N# s/ s" a7 T
2. #define SPI_TIMODE_ENABLE                SPI_CFG2_SP_0

复制代码

) a! c3 r  D9 `0 K& |8 E  CRCCalculation
2 s# J+ u) Q% j3 q+ @# K用于设置是否使能CRC计算。
. m1 @7 |& h% M  y' }( O

1. #define SPI_CRCCALCULATION_DISABLE                    (0x00000000UL)
   
2. #define SPI_CRCCALCULATION_ENABLE                     SPI_CFG1_CRCEN

复制代码

  CRCPolynomial
用于设置CRC计算使用的多项式，必须是奇数，范围0到65535。

  CRCLength
$ q* ?1 M, a/ A* ~0 e2 h! c用于设置CRC计算时的CRC长度。大小要与同属此结构体的DataSize一致。或是DataSize的整数倍。

1. #define SPI_CRC_LENGTH_DATASIZE                       (0x00000000UL)
   3 _* J; R" s# X% T3 s2 T8 z
2. #define SPI_CRC_LENGTH_4BIT                           (0x00030000UL)
   
3. #define SPI_CRC_LENGTH_5BIT                           (0x00040000UL)
   9 z2 H; r& ~* E* v1 r1 k# z
4. #define SPI_CRC_LENGTH_6BIT                           (0x00050000UL)
   4 X+ E$ y5 I+ [, H, C6 a
5. #define SPI_CRC_LENGTH_7BIT                           (0x00060000UL)
   
6. #define SPI_CRC_LENGTH_8BIT                           (0x00070000UL)
   
7. #define SPI_CRC_LENGTH_9BIT                           (0x00080000UL)
   
8. #define SPI_CRC_LENGTH_10BIT                          (0x00090000UL)
   
9. #define SPI_CRC_LENGTH_11BIT                          (0x000A0000UL)
   " x6 J. O5 c% Z( z
10. #define SPI_CRC_LENGTH_12BIT                          (0x000B0000UL)
    5 e! F$ `: K! W5 f( P( S
11. #define SPI_CRC_LENGTH_13BIT                          (0x000C0000UL)
    
12. #define SPI_CRC_LENGTH_14BIT                          (0x000D0000UL)
    
13. #define SPI_CRC_LENGTH_15BIT                          (0x000E0000UL)
    
14. #define SPI_CRC_LENGTH_16BIT                          (0x000F0000UL)
    2 u6 p8 C8 S5 X3 H" A: m
15. #define SPI_CRC_LENGTH_17BIT                          (0x00100000UL)
    9 I7 r# V  f+ V: c
16. #define SPI_CRC_LENGTH_18BIT                          (0x00110000UL)
    + i6 i. K! Y: B/ G' e; M7 c
17. #define SPI_CRC_LENGTH_19BIT                          (0x00120000UL)
    / Q% N, Z  c5 \$ V2 H# d
18. #define SPI_CRC_LENGTH_20BIT                          (0x00130000UL)
    5 K& O/ F8 a8 R* h& ?. e6 b! r
19. #define SPI_CRC_LENGTH_21BIT                          (0x00140000UL)
    # Q, U1 ?7 Q) j4 U
20. #define SPI_CRC_LENGTH_22BIT                          (0x00150000UL)
    1 Y7 k; f# p9 W; ]# n/ u
21. #define SPI_CRC_LENGTH_23BIT                          (0x00160000UL)
    0 L  p" n% p4 ^
22. #define SPI_CRC_LENGTH_24BIT                          (0x00170000UL)
    $ I) Y2 k3 @: G; K! V: h( R
23. #define SPI_CRC_LENGTH_25BIT                          (0x00180000UL)
    
24. #define SPI_CRC_LENGTH_26BIT                          (0x00190000UL)
    # C) I  [$ t  b; A
25. #define SPI_CRC_LENGTH_27BIT                          (0x001A0000UL)
    
26. #define SPI_CRC_LENGTH_28BIT                          (0x001B0000UL)
    
27. #define SPI_CRC_LENGTH_29BIT                          (0x001C0000UL)
    
28. #define SPI_CRC_LENGTH_30BIT                          (0x001D0000UL)
    , O+ K1 C  O  \
29. #define SPI_CRC_LENGTH_31BIT                          (0x001E0000UL)
    
30. #define SPI_CRC_LENGTH_32BIT                          (0x001F0000UL)

复制代码

1 m  f9 B2 d  n

  NSSPMode
用于设置是否使能NSSP信号，可以通过SPIx_CR2寄存器的SSOM位使能。注意，只有配置为摩托罗拉SPI主控模式时设置此成员才有用。
1 k$ p$ `! x4 M  h

1. #define SPI_NSS_PULSE_DISABLE                         (0x00000000UL)
   
2. #define SPI_NSS_PULSE_ENABLE                          SPI_CFG2_SSOM

复制代码

  NSSPolarity
用于设置NSS引脚上的高电平或者低电平作为激活电平。
) }) W- s/ S. J% \$ f3 f
3 e7 y+ j% j+ \# Q/ V

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

复制代码

6 Z9 y5 |: t* m) D& c/ r! p  FifoThreshold
2 l2 `- s) h  t用于设置SPI的FIFO阀值。
) T  p$ H7 k' X$ G( |

1. #define SPI_FIFO_THRESHOLD_01DATA                     (0x00000000UL)
   
2. #define SPI_FIFO_THRESHOLD_02DATA                     (0x00000020UL)
   
3. #define SPI_FIFO_THRESHOLD_03DATA                     (0x00000040UL)
   $ ^: u  W1 {7 W
4. #define SPI_FIFO_THRESHOLD_04DATA                     (0x00000060UL)
   
5. #define SPI_FIFO_THRESHOLD_05DATA                     (0x00000080UL)
   
6. #define SPI_FIFO_THRESHOLD_06DATA                     (0x000000A0UL)
   
7. #define SPI_FIFO_THRESHOLD_07DATA                     (0x000000C0UL)
   ( J# c! X) R. @2 R
8. #define SPI_FIFO_THRESHOLD_08DATA                     (0x000000E0UL)
   
9. #define SPI_FIFO_THRESHOLD_09DATA                     (0x00000100UL)
   2 p6 o9 C5 h% d. {8 Y
10. #define SPI_FIFO_THRESHOLD_10DATA                     (0x00000120UL)
    
11. #define SPI_FIFO_THRESHOLD_11DATA                     (0x00000140UL)
    + ^3 ]5 J- n9 i- t' O) P
12. #define SPI_FIFO_THRESHOLD_12DATA                     (0x00000160UL)
    
13. #define SPI_FIFO_THRESHOLD_13DATA                     (0x00000180UL)
    $ m+ q- o/ ^; Y! L/ C; M
14. #define SPI_FIFO_THRESHOLD_14DATA                     (0x000001A0UL)
    
15. #define SPI_FIFO_THRESHOLD_15DATA                     (0x000001C0UL)
      Y4 C- l6 E: c+ j$ _% y( {
16. #define SPI_FIFO_THRESHOLD_16DATA                     (0x000001E0UL)
    

复制代码

  TxCRCInitializationPattern
3 T  V1 X2 P8 P% j9 }* Q发送CRC初始化模式。

2 J8 M7 g6 b$ c/ r( Q3 g8 {

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)
   " ~6 I1 e1 X  i" ?

复制代码

  RxCRCInitializationPattern
接收CRC初始化模式

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

) F- S# D2 J4 }) N3 q) n6 Y0 z MasterSSIdleness
在主模式下插入到SS有效边沿和第一个数据开始之间的额外延迟，单位SPI时钟周期个数。
8 E4 S6 P" I0 Q* `9 p, d5 G# A
+ F8 x4 C0 |2 S7 U

1. #define SPI_MASTER_SS_IDLENESS_00CYCLE                (0x00000000UL)
   4 k% I; m& g1 X: S( D5 g, w% o
2. #define SPI_MASTER_SS_IDLENESS_01CYCLE                (0x00000001UL)
   ) d; S! I1 ?5 }* H
3. #define SPI_MASTER_SS_IDLENESS_02CYCLE                (0x00000002UL)
   3 X% x8 M" p  j9 {, S
4. #define SPI_MASTER_SS_IDLENESS_03CYCLE                (0x00000003UL)
   
5. #define SPI_MASTER_SS_IDLENESS_04CYCLE                (0x00000004UL)
   
6. #define SPI_MASTER_SS_IDLENESS_05CYCLE                (0x00000005UL)
   
7. #define SPI_MASTER_SS_IDLENESS_06CYCLE                (0x00000006UL)
   
8. #define SPI_MASTER_SS_IDLENESS_07CYCLE                (0x00000007UL)
   
9. #define SPI_MASTER_SS_IDLENESS_08CYCLE                (0x00000008UL)
   . ]0 H2 P, c4 n0 t6 @# z" o' {) H4 B
10. #define SPI_MASTER_SS_IDLENESS_09CYCLE                (0x00000009UL)
    9 s6 \. I+ `. n2 J7 O
11. #define SPI_MASTER_SS_IDLENESS_10CYCLE                (0x0000000AUL)
    " B) `/ D7 c! C. H3 _
12. #define SPI_MASTER_SS_IDLENESS_11CYCLE                (0x0000000BUL)
    ! U9 i$ H" p4 t1 F7 [2 h) k4 A4 L
13. #define SPI_MASTER_SS_IDLENESS_12CYCLE                (0x0000000CUL)
    
14. #define SPI_MASTER_SS_IDLENESS_13CYCLE                (0x0000000DUL)
    1 ?9 S8 I) o  k( _) q5 q! S
15. #define SPI_MASTER_SS_IDLENESS_14CYCLE                (0x0000000EUL)
    
16. #define SPI_MASTER_SS_IDLENESS_15CYCLE                (0x0000000FUL)
    

复制代码

8 g5 K) B: j9 P, v! |5 D+ a
  MasterInterDataIdleness
主模式下在两个连续数据帧之间插入的最小时间延迟，单位SPI时钟周期个数。

6 Q6 [. J8 o$ |- d) w

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

复制代码

  MasterReceiverAutoSusp
9 V- j# e7 K& K/ e; ~用于控制主器件接收器模式下的连续 SPI 传输以及自动管理，以避免出现上溢情况。

% W4 X  ?/ J5 U( v4 n8 @

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

复制代码

0 P% Y/ T( |& O1 }  MasterKeepIOState
" K% ?8 A" k! f' e& W禁止SPI后，SPI相关引脚保持当前状态，以防止出现毛刺。在从模式下，该位不应该使用。
& j7 U0 t- C9 V6 p/ O

1. #define SPI_MASTER_KEEP_IO_STATE_DISABLE              (0x00000000UL)
   $ X* F: r/ V$ F1 }- w/ L
2. #define SPI_MASTER_KEEP_IO_STATE_ENABLE               SPI_CFG2_AFCNTR

复制代码

, ]2 V; L8 K' n# Y  IOSwap
用于交换MISO和MOSI引脚。

7 b- u* W: v" `4 r

1. #define SPI_IO_SWAP_DISABLE                           (0x00000000UL)
   
2. #define SPI_IO_SWAP_ENABLE                            SPI_CFG2_IOSWP

复制代码

6 ~+ i4 X! @; f+ M/ `; `72.3.3 SPI总线句柄结构体SPI_HandleTypeDef
: C7 y( ~6 b6 i下面是SPI总线的初始化结构体，用到的地方比较多：
# b) ]) K7 i: x" D
- _4 V: v1 Q/ d) Q% C

1. typedef struct __SPI_HandleTypeDef
   
2. {
   # l( |$ W, Z6 J" Z( r
3.   SPI_TypeDef                *Instance;                 
   
4.   SPI_InitTypeDef            Init;                        
   ; Q: H; ~, T) L) N8 k+ H5 y- N
5.   uint8_t                    *pTxBuffPtr;                 
   5 E3 ], R( t: g8 Q8 Z4 t; q& i
6.   uint16_t                   TxXferSize;                  
   
7.   __IO uint16_t              TxXferCount;                  
   
8.   uint8_t                    *pRxBuffPtr;               
   + [- q0 B2 o4 ?- x+ }2 R% b! i2 X
9.   uint16_t                   RxXferSize;                  
   ; z+ a) g8 K5 v( Y
10.   __IO uint16_t              RxXferCount;                 
    3 p0 p7 ]) q. H
11.   uint32_t                   CRCSize;                     
    
12.   void (*RxISR)(struct __SPI_HandleTypeDef *hspi);      
    
13.   void (*TxISR)(struct __SPI_HandleTypeDef *hspi);        
    
14.   DMA_HandleTypeDef          *hdmatx;                     
    & H5 p, G1 Q7 Y1 ?  |
15.   DMA_HandleTypeDef          *hdmarx;                     
    
16.   HAL_LockTypeDef            Lock;                        
    
17.   __IO HAL_SPI_StateTypeDef  State;                        
    
18.   __IO uint32_t              ErrorCode;                  
    1 y2 O1 |* A+ f
19. #if defined(USE_SPI_RELOAD_TRANSFER)
    
20.   SPI_ReloadTypeDef          Reload;                     
    5 Q' `( ^4 V$ h& o
21. #endif
    4 M. D0 Q3 U8 a, P7 W
22. 
    
23. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
24.   void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    - o, S! @! \( S4 M- a& B4 N! G
25.   void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    2 j$ E' x% o; z  {1 M8 c& S
26.   void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    
27.   void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    
28.   void (* RxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    0 z5 @1 z! V. o- }! p. h+ b" ~4 \
29.   void (* TxRxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);
    
30.   void (* ErrorCallback)(struct __SPI_HandleTypeDef *hspi);      
    4 E& _; E8 ~: J. z& ]. r$ t0 o# a" A
31.   void (* AbortCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    
32.   void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);   
    : F( @3 G4 u# T5 O( D9 h
33.   void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);
    % f4 q# C9 U4 U7 w
34. #endif  
    ( I( w; L6 `& c9 c
35. } SPI_HandleTypeDef;
    + E% V$ |* h% U; T

复制代码

9 O6 |5 @2 J. \0 `7 m9 T! X+ A
( `+ J- n* h1 g. V* l( V注意事项：

' {" s$ m1 d( f3 k- n条件编译USE_HAL_SPI_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

) C3 Q% d; f7 m( X  #define   USE_HAL_SPI_REGISTER_CALLBACKS   1

$ m2 G/ v5 [! v* o# S; O通过函数HAL_SPI_RegisterCallback注册回调，取消注册使用函数HAL_SPI_UnRegisterCallback。

( S5 `$ J/ t- H0 n8 g这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。

  SPI_TypeDef   *Instance
) e( d1 r6 \+ j! e: Y1 E0 C这个参数是寄存器的例化，方便操作寄存器，比如使能SPI1。

6 X4 }) G9 I8 c" d# ~) H8 C8 BSET_BIT(SPI1 ->CR1,  SPI_CR1_SPE)。

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

  DMA_HandleTypeDef          *hdmatx               
0 e- D* R1 m# G, G. A  DMA_HandleTypeDef          *hdmarx
用于SPI句柄关联DMA句柄，方便操作调用。
8 I: B9 h# U0 Y+ g, c& i
4 J7 X- y6 o% b, m- s72.4 SPI总线源文件stm32h7xx_hal_spi.c
. A1 ?6 A. g, b) C此文件涉及到的函数较多，这里把几个常用的函数做个说明：

4 ?% p! O" w4 Q$ X3 H; j4 z  HAL_SPI_Init
  HAL_SPI_DeInit
  HAL_SPI_TransmitReceive
) ]* w4 c8 U/ D- S  HAL_SPI_TransmitReceive_IT
% S0 k% V& {) Q' V, W' d  HAL_SPI_TransmitReceive_DMA
72.4.1 函数HAL_SPI_Init
函数原型：

4 c0 M8 m" x/ K5 y# k7 N3 f% m

1. HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
   
2. {
   8 ^! k. g( G  ~+ F
3.   uint32_t crc_length = 0UL;
   
4.   uint32_t packet_length;
   
5. 
   
6.   /* 省略未写 */
   ; Z, Z* A3 B! R0 y
7. 
   % }- s. C) h. o$ a
8.   /* 如果数据位宽大于16bit，必须是SPI1，SPI2或者SPI3，而SPI4，SPI5和SPI6不支持大于16bit */
   3 A. B. j: M; @* `- R: e8 J
9.   if ((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (hspi->Init.DataSize > SPI_DATASIZE_16BIT))
   
10.   {
    3 n: y8 }" D! S  `. J% N' H
11.     return HAL_ERROR;
    " p. x5 t+ |& I: R0 Z" F& D/ M
12.   }
    & f- v( ^3 R) H% j
13. 
    & D9 E) l0 Y3 g# w
14.   /* SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit
    
15.      这里是查看设置的缓冲大小是否超出了FIFO支持的大小。
    7 m2 q8 }0 U; j( f. n
16. */
    2 v) k' m4 n9 d: ~& L1 N1 Q
17.   packet_length = SPI_GetPacketSize(hspi);
    
18.   if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_LOWEND_FIFO_SIZE)) ||
    0 F6 U3 d9 s4 G# Q
19.       ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_HIGHEND_FIFO_SIZE)))
    
20.   {
    7 ~% z: A5 W) E; @( l% B$ e
21.     return HAL_ERROR;
    ; ?, Y& \  A( C' J4 ^5 r0 Y2 B: J/ e
22.   }
    
23. 
    
24. #if (USE_SPI_CRC != 0UL)
    ) ]8 b" m- _; g5 P$ }1 w
25.     /* 省略未写 */
    
26. #endif
    6 {( J% L( e. I6 |/ A: \9 Y
27. 
    
28.   if (hspi->State == HAL_SPI_STATE_RESET)
    ) A5 Q5 h9 Z. _0 `9 \# F5 V
29.   {
    
30.     /* 解锁 */
    3 j3 u5 c( s+ O. Y" I  P
31.     hspi->Lock = HAL_UNLOCKED;
    % Y7 e! p$ N* o- Q% u4 n5 i
32. 
    
33.     /* 使用自定义回调 */
    ! E% ^# G/ E7 X6 Z
34. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    9 \  Z/ B9 z: k( e
35.     /* 设置默认回调函数 */
    
36.     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */
    
37.     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */
    , [& o# p' y+ |5 J0 U
38.     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */
    
39.     hspi->TxHalfCpltCallback   = HAL_SPI_TxHalfCpltCallback;   /* Legacy weak TxHalfCpltCallback   */
    & k; H8 Y2 m. z8 c9 E! q
40.     hspi->RxHalfCpltCallback   = HAL_SPI_RxHalfCpltCallback;   /* Legacy weak RxHalfCpltCallback   */
    + Z/ j: @, K" p" y# O, B9 Z% x
41.     hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */
    
42.     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */
    : d9 a3 s* q" V) ]- x
43.     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */
    
44. 
    8 s" [4 x1 e; L2 t. N
45.     if (hspi->MspInitCallback == NULL)
    
46.     {
    . v1 v2 G1 L/ I: h) `. `# Q) [3 n8 P
47.       hspi->MspInitCallback = HAL_SPI_MspInit;
    ) o% m( n8 q5 v3 S
48.     }
    
49. 
    ! h/ V4 _5 X. }& b! C8 U
50.     /* 初始化地址硬件: GPIO, CLOCK, NVIC... */
    
51.     hspi->MspInitCallback(hspi);
    
52. #else
    
53.     /* 初始化底层硬件: GPIO, CLOCK, NVIC... */
    4 o2 O$ M+ r% F' C) K: o" x2 O
54.     HAL_SPI_MspInit(hspi);
    ) s% N# F, [5 A& F
55. #endif
    
56.   }
    
57. 
    + M; G5 ?. F8 S# R
58.   hspi->State = HAL_SPI_STATE_BUSY;
    5 W7 v' y0 q9 Y  t- e
59. 
    2 g9 g3 h- r1 O/ W
60.   /* 禁止SPI外设 */
    9 G* w; {) H% Q) u" Y) C
61.   __HAL_SPI_DISABLE(hspi);
    ! @( ^; R# |4 z8 d
62. 
    
63.   /*----------------------- SPIx CR1 & CR2 配置---------------------*/
    
64.   if ((hspi->Init.NSS == SPI_NSS_SOFT) && (hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.NSSPolarity ==
    / b% h$ k1 K5 p( F4 e
65. SPI_NSS_POLARITY_LOW))
    . ~. Z6 a- U" M' S. m
66.   {
    & Y# L2 C# R# ]( ~
67.       SET_BIT(hspi->Instance->CR1, SPI_CR1_SSI);
    ) E  Z8 p. {  N' F
68.   }
    
69. 
    0 O" _! @. O6 J7 T0 @
70.   /* SPIx CFG1配置 */
    
71.   WRITE_REG(hspi->Instance->CFG1, (hspi->Init.BaudRatePrescaler | hspi->Init.CRCCalculation | crc_length |
    ' k% H; u$ @# K1 Y% x- [
72.                                    hspi->Init.FifoThreshold     | hspi->Init.DataSize));
    
73. 
    
74.   /* SPIx CFG2配置 */
    $ O- d. l6 y! q' a
75.   WRITE_REG(hspi->Instance->CFG2, (hspi->Init.NSSPMode     | hspi->Init.TIMode           | hspi->Init.NSSPolarity  |
    1 w2 c6 X: S' |& ~
76.                                    hspi->Init.NSS          | hspi->Init.CLKPolarity      | hspi->Init.CLKPhase     |
    - Q! R3 I8 J  b! h! G
77.                                    hspi->Init.FirstBit     | hspi->Init.Mode             | hspi->Init.MasterInterDataIdleness |
    
78.                                    hspi->Init.Direction    | hspi->Init.MasterSSIdleness | hspi->Init.IOSwap));
    ' q- k% C/ r. C+ Y# U. }( y
79. 
    
80. #if (USE_SPI_CRC != 0UL)
    
81.   /*---------------------------- SPIx CRC配置 ------------------*/
    
82.   /* 配置SPI CRC */
    
83.   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    + d: H* ^2 e1 l
84.   {
    
85.     /* 初始化TX CRC初始值 */
    9 U  I, n7 {3 @
86.     if (hspi->Init.TxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    
87.     {
    1 N$ V! P9 Q7 \$ _( [% Y! \. G' E; {
88.       SET_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    
89.     }
    " R* j$ e3 t# {- z4 l2 d+ w( a1 o0 S3 Z
90.     else
    
91.     {
    
92.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    $ s, L6 Q: c5 e, `" t9 [* l2 Q
93.     }
    . N9 u, ]/ E. ]! A7 f) L+ v# s
94. 
    
95.     /* 初始化RXCRC初始值 */
    
96.     if (hspi->Init.RxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    
97.     {
    - s5 x. }. W- L
98.       SET_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
    
99.     }
    2 L7 m, a; A3 W6 F% N
100.     else
     & {5 H0 O5 g2 Q/ W/ m( n' I
101.     {
     ) O  {9 X! [# v- U. Z$ P  U
102.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
     
103.     }
     
104. 
     
105.     /* 使能 33/17 bit CRC计算 */
     
106.     if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (crc_length == SPI_CRC_LENGTH_16BIT)) ||
     5 ^( _9 y/ e+ N3 k
107.         ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance))  && (crc_length == SPI_CRC_LENGTH_32BIT)))
     
108.     {
     # \! \2 [$ |5 Y* ~! t. x( Y5 C1 ~
109.       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     
110.     }
     , Z/ e) a5 _8 z. V5 l! r% L
111.     else
     - E' [: b, E3 V1 g4 L
112.     {
     2 ~% ~9 ^1 R3 ?6 }8 A
113.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     
114.     }
     
115. 
     $ i) @# x8 `, F7 L
116.     /* 写CRC多项式到SPI寄存器 */
     
117.     WRITE_REG(hspi->Instance->CRCPOLY, hspi->Init.CRCPolynomial);
     
118.   }
     ; N8 B$ w( I; `  F2 N5 T: l7 H7 }
119. #endif
     4 X* G2 r/ P4 U/ Z7 A- q+ u+ ^/ h% _
120. 
     
121.   /* SPI从模式，下溢配置 */
     $ w0 F$ I+ b6 ~5 f% g5 E  t# l
122.   if (hspi->Init.Mode == SPI_MODE_SLAVE)
     % K4 m/ q' r/ x* r4 F0 C
123.   {
     % ?, A& C" J1 s/ f' _
124.     /* 设置默认下溢配置 */
     ' m: {3 _, F. w8 b3 R
125. #if (USE_SPI_CRC != 0UL)
     6 u* j& {, G+ k1 ^
126.     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_DISABLE)
     
127. #endif
     ( k. W$ d) D* X
128.     {
     ; `8 t) x; c3 x% H" w6 a" O
129.       MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, SPI_CFG1_UDRDET_0);
     " }. c1 Q" y  B' C) w
130.     }
     * _: C( y. f$ ~# ?
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);
     ; W5 W5 Z& K; ~+ l
136. #endif
     
137. 
     6 L# _. \' d! F8 g* P) ?
138.   /* 确保AFCNTR bit由SPI主机模式管理 */
     
139.   if ((hspi->Init.Mode & SPI_MODE_MASTER) == SPI_MODE_MASTER)
     4 I6 Y% ?, H) h" E7 D" v, G
140.   {
     
141.     /* Alternate function GPIOs control */
     
142.     MODIFY_REG(hspi->Instance->CFG2, SPI_CFG2_AFCNTR, (hspi->Init.MasterKeepIOState));
     $ I# n; n( w0 o
143.   }
     
144. 
     
145.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
     
146.   hspi->State     = HAL_SPI_STATE_READY;
     
147. 
     % m" u. B, O$ B2 Q  m0 i: A
148.   return HAL_OK;
     
149. }
     3 H2 ]" _6 x* i" }3 b/ J. k

复制代码

函数描述：

! Y" J; a  v8 k+ I此函数用于初始化SPI。
6 }2 j) q; y& b2 M! Y% O, a
函数参数：

  第1个参数是SPI_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
) n% g# h4 J: }! ]注意事项：

% n. i7 |" L9 I2 Y0 s* G7 t, L函数HAL_SPI_MspInit用于初始化SPI的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hspi的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SPI_HandleTypeDef SpiHandle。
0 l. k( g9 j; J# Q. a对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SPI_STATE_RESET  = 0x00U。

解决办法有三

方法1：用户自己初始化SPI和涉及到的GPIO等。
+ p, D, W9 F7 {' U
" _; w. q, h4 U4 m4 w方法2：定义SPI_HandleTypeDef SpiHandle为全局变量。

方法3：下面的方法
. J" A0 Q% u: y( w

1. if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK)
   ; L$ E( c1 @" I
2. {
     ~5 T, [$ x( w# u4 w$ O
3.     Error_Handler();
   
4. }  
   
5. if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
   
6. {
   ( {. L8 r: R; B/ X( p  Y
7.     Error_Handler();
   
8. }

复制代码

使用举例：

- q+ A0 U; F, Z" h, h$ h

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   % @- @: Z) k) j3 u
3. /* 设置SPI参数 */
   # `' P% E3 D2 ^$ _# j3 H* u
4. hspi.Instance               = SPIx;                   /* 例化SPI */
   4 B/ k# W5 S- a# s: m/ n
5. hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
   
6. hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
   
7. hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
   
8. hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
   , z* l" O4 H7 u! o; ^
9. hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
   ' [# n' b, G( O
10. hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    
11. hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    
12. hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;      /* 禁止CRC */
    1 O. y0 Q/ ]) w# N4 t
13. hspi.Init.CRCPolynomial     = 7;                               /* 禁止CRC后，此位无效 */
    , U7 k; n$ D7 N7 f8 M5 X
14. hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;             /* 禁止CRC后，此位无效 */
    
15. hspi.Init.NSS               = SPI_NSS_SOFT;                    /* 使用软件方式管理片选引脚 */
    ' |  h; {4 j+ m6 ]6 U8 z, [: g$ R0 X
16. hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;       /* 设置FIFO大小是一个数据项 */
    % Y# _* n, c7 v( C! D, ^8 e
17. hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;           /* 禁止脉冲输出 */
    5 r. t" B, @& [) q$ _
18. hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    % l7 r5 v% c/ o4 n6 |1 l" s$ _2 T
19. hspi.Init.Mode                  = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    
20. 
      v9 S& p  F/ [5 Y9 `5 x5 {
21. if (HAL_SPI_Init(&hspi) != HAL_OK)
    
22. {
    
23.     Error_Handler(__FILE__, __LINE__);
    
24. }

复制代码

' T. B) @9 \" C8 b5 f72.4.2 函数HAL_SPI_DeInit
函数原型：

1. HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
   . z" Z! x! Q2 a+ J; j4 |7 o
2. {
   2 ~* f/ j2 H& A* |1 c3 s
3. /* 检测SPI句柄是否有效 */
   
4.   if (hspi == NULL)
   
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   
8. 
   
9. /* 检查SPI例化参数 */
   - A) A% s8 ]- X+ G# n5 o8 c) B
10.   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
    # |+ F6 V% e, F: g& f2 o- J5 A& @
11. 
    7 t4 G$ e* G" j
12.   hspi->State = HAL_SPI_STATE_BUSY;
    6 ^  b) x! }. r% \3 \0 S
13. 
    # w8 U- Q9 J3 [$ {
14.   /* 禁止SPI外设时钟 */
    4 O' }9 A: U+ {, ~
15.   __HAL_SPI_DISABLE(hspi);
    
16. 
    
17. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    " R4 z! W( j6 M' Y2 V  b0 O5 Q% j
18.   if (hspi->MspDeInitCallback == NULL)
    , A5 c( M4 r" b4 q
19.   {
    
20.     hspi->MspDeInitCallback = HAL_SPI_MspDeInit;
    ) B' Z; x/ H6 ^6 H$ i! L7 W4 D
21.   }
    5 ^( ~* l) r. t6 M7 A4 l, w
22. 
    
23.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    7 A9 G; }/ o$ h4 z' |+ _
24.   hspi->MspDeInitCallback(hspi);
    
25. #else
    
26.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    
27.   HAL_SPI_MspDeInit(hspi);
    
28. #endif
    4 D; z. M0 A) i
29. 
    
30.   /* 设置无错误，复位状态标记 */
    5 H' l& }# s0 ?
31.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
    
32.   hspi->State = HAL_SPI_STATE_RESET;
    
33. 
    
34.   /* 解锁SPI */
    
35.   __HAL_UNLOCK(hspi);
    & V1 ?7 i# G9 U3 X/ d: z
36. 
    
37.   return HAL_OK;
    
38. }

复制代码

函数描述：

用于复位SPI总线初始化。
, ?) p, Y1 {7 o5 ^7 F+ F& g
函数参数：

  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中
3 k: M- l# b6 J72.4.3 函数HAL_SPI_TransmitReceive
函数原型：
. d" Q! F" |! L1 b( R+ p5 R

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
   : \9 p) H9 @( A6 z: x
2. {
   
3. 
   * p5 B" ?. b  v# i
4.    /* 省略未写 */
   & V" P' K9 W: r/ [4 {5 u* Y4 w
5. 
   3 W. @: q. `7 e4 `" L2 s
6.   /* 大于16bit的数据收发 */
   ' G8 M6 d# K5 M3 i8 C) D
7.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
   ! w! d8 S5 W' Q( v+ f
8.   {
   " W; p' A7 _( o7 r& m% B
9.        /* 省略未写 */
   
10.   }
    % K/ M4 r2 K$ d* ?6 S
11.   /* 大于8bit，小于16bi的数据收发 */
    
12.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    ( f8 I# R) z8 z% L3 K
13.   {
      ^$ H6 [+ g. \7 F& D0 M: x! K
14.       /* 省略未写 */
    ) T: }' _( j% q( g6 t  `( v' y* `
15.   }
    3 V( I% r6 Q! r% c
16.   /* 小于等于8bit的数据收发 */
    
17.   else
    
18.   {
    ) ?$ A+ X* o  u6 f
19.        /* 省略未写 */
    
20.   }
    ( ^' h5 s9 w2 k
21. 
    
22. }
    

复制代码

函数描述：

此函数主要用于SPI数据收发，全双工查询方式。
$ t: {  M- S, L5 X4 Z
函数参数：

, l6 }1 V- Z) r1 F  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
5 h) u% s" Y6 ~  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
  第5个参数是传输过程的溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
% l2 V" D8 c) `, W使用举例：

$ y# A3 o! N7 k  z+ a

1. SPI_HandleTypeDef hspi = {0};
   ' C2 c! A' F$ ?, s
2. 
   
3. if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)
   
4. {
   0 A$ a$ r( D$ V; }/ A/ ~
5.     Error_Handler(__FILE__, __LINE__);
   
6. }

复制代码

6 j" n6 W0 Y9 y" S$ f2 y72.4.4 函数HAL_SPI_TransmitReceive_IT
函数原型：

) [- }2 [+ Y9 G# t. Z) F- d

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
   6 b: q! W: D/ k9 `* d
2. {
   ) Y% ~: d) M" R
3.    /* 省略未写 */
   - X  x& Y: _% F+ `$ f* ^2 k
4. 
   # R  I) [7 J9 a5 B
5.   /* 设置传输参数 */
   1 k6 I9 c! q! V8 r/ z
6.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   4 F9 h! s( Q- ]8 {
7.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
     N4 z" ~( i+ b! ?8 U) p
8.   hspi->TxXferSize  = Size;
   
9.   hspi->TxXferCount = Size;
     Z5 A( f# e7 \  I2 S0 V
10.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
      E2 K7 ?+ l' n! T+ t
11.   hspi->RxXferSize  = Size;
    & U% y( w- o: I: @( X* q0 y
12.   hspi->RxXferCount = Size;
    " r% \" @) ?8 z7 s. ?2 H8 S$ O
13. 
    
14.   /* 设置中断处理 */
    ; m% N% k, K1 v" X4 @
15.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    % K. R4 X3 S: b8 U4 M
16.   {
    
17.     hspi->TxISR     = SPI_TxISR_32BIT;
    + o* n& W5 H/ z0 ]; t
18.     hspi->RxISR     = SPI_RxISR_32BIT;
    
19.   }
    
20.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    
21.   {
    7 h6 }- Z, U: T1 h8 ~$ y
22.     hspi->RxISR     = SPI_RxISR_16BIT;
    
23.     hspi->TxISR     = SPI_TxISR_16BIT;
    
24.   }
    9 y. D1 W& b! X$ A0 g! j
25.   else
    
26.   {
    
27.     hspi->RxISR     = SPI_RxISR_8BIT;
    
28.     hspi->TxISR     = SPI_TxISR_8BIT;
    
29.   }
    
30. 
    
31.   /* 设置当前传输数据大小 */
    ) R8 r1 J& Z/ w% t1 J2 U
32.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    1 m& p6 B; I2 Y" l6 R0 K% n
33. 
    
34.   /* 使能SPI外设 */
    7 u5 K9 B. b5 R8 m; s8 t
35.   __HAL_SPI_ENABLE(hspi);
    
36. 
    ' V) {3 M- n8 |% p5 y) m2 [7 S4 P- {
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 |
    
39. SPI_IT_FRE | SPI_IT_MODF | SPI_IT_TSERF));
    
40. 
    
41.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    & Z+ V2 u6 N& E8 r
42.   {
    
43.     /* 启动传输 */
    3 o8 M0 R2 |" R! Y# K; K! g" y
44.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
    
45.   }
    
46. 
    2 ?( F% [0 h% u; {) v  v  S; J
47.   /* 解锁 */
    - t7 s1 H" z4 o4 Y; T2 x. n
48.   __HAL_UNLOCK(hspi);
    
49.   return errorcode;
    ( Z7 a/ e+ f* X: g0 k, y, @/ a; U
50. }

复制代码

  }3 m. f. ~2 G, b+ ~函数描述：

此函数主要用于SPI数据收发，全双工中断方式。

8 m, {6 ~( U  p9 y7 O" h8 N# H函数参数：
1 \2 Q& M) H3 v! T( ]( d9 M
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
1 |- w8 C0 k! o) @; |9 P( ^9 G8 k  第2个参数是发送数据缓冲地址。
4 z- u& n3 j8 O, u9 @- r  第3个参数是接收数据缓冲地址。
) y( T, |7 i: p. }# g! p  第4个参数是传输的数据大小，单位字节个数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
  p$ l6 y, g+ N, r" n使用举例：
9 N5 Y" y5 i+ o0 A' Y) _
' T! I' h( F& ~$ o* f, K& ]

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   % K$ U2 b$ A% ~& G  B# ?) t& B
3. if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   " v' T$ y2 V! h% Y& S4 ?
4. {
   - e# ]( V3 o) ~$ M! J
5.     Error_Handler(__FILE__, __LINE__);
   
6. }
   
7. 
   5 T, f2 |+ p( a$ _
8. 
   + M5 l7 |' Z7 ^& {  ]) F
9. 72.4.5 函数HAL_SPI_TransmitReceive_DMA
   
10. 函数原型：
    
11. 
    * ]1 O: |9 ]( N9 U, A* D: {
12. HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,
    
13.                                               uint16_t Size)
    0 @  C# S" j" f3 \/ \: T+ X
14. {
    
15.    /* 省略未写 */
    
16. 
    $ e. u  M( i5 g; m7 }
17. /* 注意DMA的位宽和对齐设置 */
    
18.   if (((hspi->Init.DataSize > SPI_DATASIZE_16BIT) && (hspi->hdmarx->Init.MemDataAlignment !=
    
19. DMA_MDATAALIGN_WORD))  ||
    
20.       ((hspi->Init.DataSize > SPI_DATASIZE_8BIT) && ((hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_HALFWORD) && (hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_WORD))))
    
21.   {
    + D- a# w! ~; y/ Z% ^1 S% ?+ T
22.   }
    
23. 
    # u. A4 n9 d4 s0 ?0 R6 e, c+ x
24. /* 调整DMA对齐和数据大小 */
    
25.   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)
    
26.   {
    
27.      /* 省略未写 */
    ' K0 ]5 {1 s( T1 K: _
28.   }
    9 Z" g" X6 e0 f: U" ?
29.   else if (hspi->Init.DataSize <= SPI_DATASIZE_16BIT)
    
30.   {
    
31.      /* 省略未写 */
    
32.   }
    
33.   else
    
34.   {
    
35.       /* 省略未写 */
    
36.   }
    2 \6 Z, y2 }5 x, @! `
37. 
    
38. /*  DMA接收配置 */
    
39.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->RXDR, (uint32_t)hspi->pRxBuffPtr,
    
40. hspi->RxXferCount))
    
41.   {
    
42. 
    
43.   }
    
44. 
    
45. /* DMA发送配置 */
    / R' U" H- ?+ Z( a8 Z
46.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->TXDR,
    + m: B; ]3 z5 e; n& Y( h
47. hspi->TxXferCount))
    * s, m7 }4 {4 w
48.   {
    & Q/ J. w7 G; o
49.   }
    
50. 
    
51.   /* 省略未写 */
      G3 Z- p# Q, T5 \: B! F
52. }
    

复制代码

* p5 T' J; O/ @% _- ^3 B函数描述：
, Z% p/ ?/ n1 [% T: a1 s
此函数主要用于SPI数据收发，全双工DMA方式。
2 P$ S) [% y0 j' m( }  q$ U% [' @
2 U2 |( R. C: @函数参数：
8 ^) E/ L1 P+ x0 Z' X" K
9 l- B7 A: |- s# t- ]$ y  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
  第3个参数是接收数据缓冲地址。
  f' i5 L6 m/ z2 E  第4个参数是传输的数据大小，单位字节个数。
: q/ B% w8 y. `* q  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
( w& [0 g2 m6 D- {4 Z5 U0 T使用举例：
- x2 }3 O/ U9 R7 X# \/ \

1. SPI_HandleTypeDef hspi = {0};
   2 O8 i- w  @5 G6 k2 \$ a9 B
2. 
   7 n4 A7 @. [, F, }- y& i
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__);
   " D# I# @- v& x) v
6. }

复制代码

6 {  n- y0 ]0 A1 e& D1 G4 H
72.5 总结
本章节就为大家讲解这么多，要熟练掌握SPI总线的查询，中断和DMA方式的实现，因为基于SPI接口的外设芯片很多，熟练后，可以方便的驱动各种SPI接口芯片，以便选择合适的驱动方式。
6 b* b2 Z) J1 i- F1 Z3 a
2 M# |/ z+ b0 O8 ^( y