72.1 初学者重要提示
  STM32H7的SPI支持4到32bit数据传输，而STM32F1和F4系列仅支持8bit或者16bit。
2 ?7 ~& g$ w( \; [9 s  STM32H7的主频400MHz时，SPI1, 2, 3最高通信时钟是100MHz，而SPI4, 5, 6是50MHz。
  STM32H7的MISO和MOSI引脚功能可以互换，使用比较灵活。
  SPI总线的片选引脚SS在单一的主从器件配置下是可选的，一般情况下可以不使用。
/ a6 g  X. h. `4 X2 B
72.2 SPI总线基础知识
7 Q% w& s4 B4 ?72.2.1 SPI总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SPI的基本功能，然后再看手册了解细节。
% n$ v9 }% Q8 i. E

4 m" n0 n9 X. d9 C( @5 P  G
通过这个框图，我们可以得到如下信息：

9 I7 S7 Y+ k9 {5 ^  spi_wkup输出
- l8 U& K0 |# H! E, v3 t4 z4 ~5 K低功耗唤醒信号。

2 Q1 K3 ?4 I8 e( P$ _  spi_it输出
$ ]5 Q" I' [2 s; ]! Wspi的中断请求信号。
# f) J9 i* g+ e( R( a( y. M. S
  spi_tx_dma
9 d: }$ w: _* F+ d8 kspi_rx_dma
spi的DMA发送和接收请求信号。
/ o+ b4 G/ H( q
9 V0 t5 x9 Z1 h2 U# x6 F$ |& s6 E  spi_pclk
# x* ^" N4 y6 D- m5 G为寄存器提供时钟。
  a5 a! \8 N' V3 _0 `
  spi_ker_ck
为spi内核时钟。

- l1 B7 Q5 z# v. m7 N  SCK（CK），Serial Clock
此引脚在主机模式下用于时钟输出，从机模式下用于时钟输入。

  MISO（SDI），Master In / Slave Out data
此引脚在从机模式下用于发送数据，主机模式下接收数据。

( t  }) b0 A1 p' p% C/ w5 X  MOSI（SDO）, Master Out / Slave In data
7 E3 Y: D/ {0 ~* h% S2 w8 `此引脚在从机模式下用于数据接收，主机模式下发送数据。
/ m5 C. h5 h: \2 [
  SS（WS）, Slave select pin
9 o; Q9 z  ?4 |' Y, C$ j根据SPI和SS设置，此引脚可用于：
  _" l7 U6 Q. z# {2 r6 I2 {0 d
a. 选择三个从器件进行通信。

, Q2 Y! C! N- v; ~5 `b. 同步数据帧。
9 R2 l9 X0 G/ x0 V
# S2 t2 Z# `, Z* T( u; I, h( rc. 检测多个主器件之间是否存在冲突。
$ s7 ~+ F' e( v: O* s5 t
通过这个框图还要认识到一点，SPI有三个时钟域，分别是寄存器所在的ABP总线时钟域，内核时钟发生器时钟域以及内核时钟发生器分频后的串行时钟域。

72.2.2 SPI接口的区别和时钟源（SPI1到SPI6）
/ `$ Z+ \# q8 [1 y2 `- ]1 x  p这个知识点在初学的时候容易忽视，所以我们这里整理下。

2 K, v! u: }$ Q! d; W  SPI1到SPI6的区别
  SPI1，SPI2和SPI3支持4到32bit数据传输，SPI4，SPI5和SPI6是4到16bit数据传输。
  SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit。

4 ?. Q4 P3 l5 @

+ Y& ^% m" r6 Z; a
0 d3 c9 X+ y- t) E- t  SPI1到SPI6的所在的总线（对应SPI框图的SPI_CLK时钟域）
2 M, |" z6 b) a. H+ P! ASPI1，SPI4和SPI5在APB2总线，SPI2，SPI3在APB1总线，SPI6在APB4总线。注意，SPI的最高时钟不是由这些总线决定的。
* y$ {; y) J0 P8 ]  ^; l: ~, @
  SPI1到SPI6的支持的最高时钟（对应SPI框图的SPI_KER_CK）
STM32H7主频在400MHz下，SPI1，SPI2和SPI3的最高时钟是200MHz，而SPI4,5,6是100MHz, 以SPI1为了，可以选择的时钟源如下：
5 ?7 T7 T- V& t# S( M. E
9 m2 R9 f" z; }; p% Q

这里特别注意一点，SPI工作时最少选择二分频，也就是说SPI1,2,3实际通信时钟是100MHz，而SPI4,5,6是50MHz。
3 \! j& \: p( s4 @
72.2.3 SPI总线全双工，单工和半双工通信
片选信号SS在单一的主从器件配置下是可选的，一般情况下可以不使用。但需要同步数据流，或者用于TI模式时需要此信号。
2 M( ~9 r: A# Y& d
  全双工通信
! v7 I  N: Q7 n* n全双工就是主从器件之间同时互传数据，SPI总线的全双工模式接线方式如下：

( H+ k: p* T# W& O) c# z, j关于这个接线图要认识到以下几点：
9 }  N- ]$ Q2 M7 L# G% H. L
" q+ W. U/ T9 Q( ]  注意接线方式，对于主器件来说MISO引脚就是输入端，从器件的MISO是输出端，即Master In / Slave Out data。MOSI也是同样道理。
& i) [( d# l: I- g* K  每个时钟信号SCK的作用了，主器件的MISO引脚接收1个bit数据，MOSI引脚输出1个bit数据。
  这种单一的主从接线模式下，SS引脚可以不使用。
  半双工通信
2 _4 o; V0 j1 V; ]6 o! S3 G; T4 k半双工就是同一个时刻只能为一个方向传输数据，SPI总线的半工模式接线方式如下：

  g4 y) }' L" R! A$ \+ ^

& `4 @* A8 o- v0 `
5 z  r, g* p1 s# B关于这个接线图要认识到以下几点：

5 t! c* o9 m" _$ p/ i  更改通信方式时，要先禁止SPI。
  主器件的MISO和从器件的MISO不使用，可以继续用作标准GPIO。
1 M; S0 b+ N7 e, w  1KΩ的接线电阻很有必要，因为当主器件和从器件的通信方向不是同步变化时，容易出现其中一个输出低电平，另一个输出高电平，造成短路。
  这种单一的主从接线模式下，SS引脚可以不使用。
+ Q" Y$ q* F6 u# q! {0 a* c  单工模式
单工就是只有一种通信方向，即发送或者接收，SPI总线的全双工模式接线方式如下：

" X  P2 x5 D* }0 i" @- C* m

. z1 z, J) `) R$ F% Q) I- L
4 m) |/ [# [  e- {关于这个接线图要认识到以下几点：
+ F1 u5 W6 v! O! J0 B
0 N4 K) P- b" z& R3 K8 q  未用到的MOSI或者MISO可以用作标准GPIO。
0 V7 J* v: W# ]2 p) d! N  这种单一的主从接线模式下，SS引脚可以不使用。
72.2.4 SPI总线星型拓扑
SPI总线星型拓扑用到的地方比较多，V7开发板就是用的星型拓扑外接多种SPI器件：

; Z/ J8 E+ B( Q5 q! g- l' B
关于这个接线图，有以下几点需要大家了解：

  f6 u( K+ \" H. [6 d! l+ q  主器件的SS引脚不使用，使用通用GPIO控制。为每个器件配一个SS引脚，方便单独片选控制。
  从器件的MISO引脚要配置为复用开漏输出（很多外部芯片在未片选时，数据引脚是呈现高阻态）。
72.2.5 SPI总线通信格式
* I% \2 u# `) f  v* m2 sSPI总线主要有四种通信格式，由CPOL时钟极性和CPHA时钟相位控制：
. s2 ]/ V6 H! g
/ m! [+ e! L7 I! Z! J4 F6 i0 g: z

$ m* a1 Y) [, O- l3 |: g! Z四种通信格式如下：

  当CPOL = 1， CPHA = 1时
, g. x' D8 ^* b3 W8 A( ASCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
5 X% E) J( m% Y( w9 H; q# X' J
  当CPOL = 0， CPHA = 1时
SCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。

  {( t/ I- f+ W: g  当CPOL = 1， CPHA = 0时
* x( B. W0 @( k! F3 WSCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

6 S& v% F. w6 [  当CPOL = 1， CPHA = 0时
SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
( w  M5 M& L' Q- Y( O
72.3 SPI总线的HAL库用法
7 j4 p& Y. R+ `1 t72.3.1 SPI总线结构体SPI_TypeDef
! k- v( c, R3 Q* h5 b4 C# b. qSPI总线相关的寄存器是通过HAL库中的结构体SPI_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
4 C0 q$ Y" u8 W% ~+ U$ j& Q
: g7 D4 a& b) @. Z

1. typedef struct
   
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.   __IO uint32_t CFG1;          /*!< SPI Configuration register 1,                    Address offset: 0x08 */
   ' _" f$ M' {( I. W8 o1 W
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 a% ~8 Q4 \5 ?
9.   __IO uint32_t IFCR;          /*!< SPI/I2S Interrupt/Status flags clear register,   Address offset: 0x18 */
   
10.   uint32_t      RESERVED0;     /*!< Reserved, 0x1C                                                        */
    
11.   __IO uint32_t TXDR;          /*!< SPI/I2S Transmit data register,                  Address offset: 0x20 */
    % _  q8 a. @% e: r- C
12.   uint32_t      RESERVED1[3];  /*!< Reserved, 0x24-0x2C                                                   */
    + Z1 H# m; r0 s8 a: @
13.   __IO uint32_t RXDR;          /*!< SPI/I2S Receive data register,                   Address offset: 0x30 */
    6 O5 F3 O1 T$ B& \2 w. o
14.   uint32_t      RESERVED2[3];  /*!< Reserved, 0x34-0x3C                                                   */
    
15.   __IO uint32_t CRCPOLY;       /*!< SPI CRC Polynomial register,                     Address offset: 0x40 */
    
16.   __IO uint32_t TXCRC;         /*!< SPI Transmitter CRC register,                    Address offset: 0x44 */
    5 \1 U4 w0 {5 D( M' e" Q
17.   __IO uint32_t RXCRC;         /*!< SPI Receiver CRC register,                       Address offset: 0x48 */
    8 P! U& [* T# u. y" b5 z5 g5 ~# W
18.   __IO uint32_t UDRDR;         /*!< SPI Underrun data register,                      Address offset: 0x4C */
    
19.   __IO uint32_t I2SCFGR;       /*!< I2S Configuration register,                      Address offset: 0x50 */
    / Y0 |2 N1 g% E& I- R
20. 
    
21. } SPI_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
, P0 B: l6 v: `" Y. n
7 Z" {, i( t+ ^" ?5 Z

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   ' x& d3 L( l% f1 v) |) }
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

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

1. #define PERIPH_BASE           (0x40000000UL)
   / B8 M0 |$ O6 T' e( E
2. #define D2_APB1PERIPH_BASE     PERIPH_BASE
   9 f$ Z% J* O! F
3. #define D2_APB2PERIPH_BASE    (PERIPH_BASE + 0x00010000UL)
   0 I! m0 Z! r7 U# x, j; m  M! n& R
4. #define D3_APB1PERIPH_BASE    (PERIPH_BASE + 0x18000000UL)
   7 h5 `: Q0 E! a/ n2 u
5. 
   
6. #define SPI2_BASE             (D2_APB1PERIPH_BASE + 0x3800UL)
   
7. #define SPI3_BASE             (D2_APB1PERIPH_BASE + 0x3C00UL)
   6 G$ O+ U3 g8 G# s1 K% v
8. #define SPI1_BASE             (D2_APB2PERIPH_BASE + 0x3000UL)
   / R0 r9 v6 e3 A6 G, E0 z9 q
9. #define SPI4_BASE             (D2_APB2PERIPH_BASE + 0x3400UL)
   
10. #define SPI5_BASE             (D2_APB2PERIPH_BASE + 0x5000UL)
    
11. #define SPI6_BASE             (D3_APB1PERIPH_BASE + 0x1400UL)
    - V) i+ B  Y3 C3 F$ L) T/ V
12. 
    : s7 L6 J( ^# e- U0 h3 R- u1 N
13. #define SPI1                ((SPI_TypeDef *) SPI1_BASE)
    
14. #define SPI2                ((SPI_TypeDef *) SPI2_BASE)
    
15. #define SPI3                ((SPI_TypeDef *) SPI3_BASE)
    
16. #define SPI4                ((SPI_TypeDef *) SPI4_BASE)
    0 r9 N4 M' s: L# x) o
17. #define SPI5                ((SPI_TypeDef *) SPI5_BASE)
    
18. #define SPI6                ((SPI_TypeDef *) SPI6_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x58001400

复制代码

" w1 }  i# [. T5 V6 Y: E我们访问SPI的CR1寄存器可以采用这种形式：SPI->CR1 = 0。
4 h. {0 {1 E& o! J; S
72.3.2 SPI总线初始化结构体SPI_InitTypeDef
- a+ u5 A; S& O6 z) k- X下面是SPI总线的初始化结构体，用到的地方比较多：
$ j6 q( U" y: s% Z

1. typedef struct
   4 x9 c( x5 O0 N6 j
2. {
   2 o/ a' v$ m/ M
3.   uint32_t Mode;                           
   0 K! g& S' N! y$ ]
4.   uint32_t Direction;                     
   ) f: P3 M; x. ]3 e' f! r+ Z
5.   uint32_t DataSize;                          
   3 o# R( T9 t! L% T0 ?
6.   uint32_t CLKPolarity;                       
   8 m- O+ E. q% u4 F
7.   uint32_t CLKPhase;                        
   
8.   uint32_t NSS;                             
   
9.   uint32_t BaudRatePrescaler;               
   ( r& C" W" G! p7 _4 I: z6 B$ N
10.   uint32_t FirstBit;                        
    
11.   uint32_t TIMode;                          
    6 a6 s$ Y# p& }& J0 V: p
12.   uint32_t CRCCalculation;                  
    4 X- u% q( |% E: c/ j. K. \! _4 y
13.   uint32_t CRCPolynomial;                     
    ! M2 ^- s; r6 J" v
14.   uint32_t CRCLength;                        
    
15.   uint32_t NSSPMode;                        
    8 p/ I! ?+ f* E4 k0 s2 k3 y# ]
16.   uint32_t NSSPolarity;                    
    2 I$ \' R- y# v2 t
17.   uint32_t TxCRCInitializationPattern;      
    , p) b. u" G8 \. q9 s7 B' l  c8 w' R
18.   uint32_t RxCRCInitializationPattern;      
    - ~" ^$ {9 K: U4 ]
19.   uint32_t MasterSSIdleness;                 
    
20.   uint32_t MasterInterDataIdleness;           
    
21.   uint32_t MasterReceiverAutoSusp;         
    
22.   uint32_t MasterKeepIOState;               
    * \+ ^1 d% `/ ]5 f" f
23.   uint32_t IOSwap;                          
    
24. } SPI_InitTypeDef;

复制代码

下面将结构体成员逐一做个说明：
, ]0 h' ?$ u) g4 e+ `: ^4 L
. k6 [. ?3 J% o5 ^4 @5 p4 U  Mode
. m& G- B- U2 g, `用于设置工作在主机模式还是从机模式。

1. #define SPI_MODE_SLAVE              (0x00000000UL)
   + {  L" Z- f& t3 F; {  g3 q$ A- ?
2. #define SPI_MODE_MASTER             SPI_CFG2_MASTER

复制代码

  Direction
$ l, {3 [, m& U1 V! j用于设置SPI工作在全双工，单工，还是半双工模式。
% {! g: }( ^1 i  W

1. #define SPI_DIRECTION_2LINES           (0x00000000UL)     /* 全双工 */
   ) B' c* B1 Q9 e# E' `5 ?- I
2. #define SPI_DIRECTION_2LINES_TXONLY     SPI_CFG2_COMM_0   /* 单工，仅发送 */
   
3. #define SPI_DIRECTION_2LINES_RXONLY     SPI_CFG2_COMM_1   /* 单工，仅接收 */
   " @+ @7 R5 k/ `, k: \: O) m1 S
4. #define SPI_DIRECTION_1LINE             SPI_CFG2_COMM     /* 半双工 */

复制代码

  DataSize
6 [5 G8 n4 n3 c2 u8 Y, K& Y用于设置SPI总线数据收发的位宽，支持4-32bit。
3 W, e# g3 e1 J, k" H; r* ~

1. #define SPI_DATASIZE_4BIT                             (0x00000003UL)
   
2. #define SPI_DATASIZE_5BIT                             (0x00000004UL)
   ' g# i: y2 L% E
3. #define SPI_DATASIZE_6BIT                             (0x00000005UL)
   " U: `1 X" k# b! w9 @
4. #define SPI_DATASIZE_7BIT                             (0x00000006UL)
   3 k+ t" i" ~+ S& \6 q7 ]$ Z
5. #define SPI_DATASIZE_8BIT                             (0x00000007UL)
   ! w! q" k$ a( Q- o
6. #define SPI_DATASIZE_9BIT                             (0x00000008UL)
   % Y6 ]  r2 V( b' Y1 k- h
7. #define SPI_DATASIZE_10BIT                            (0x00000009UL)
   
8. #define SPI_DATASIZE_11BIT                            (0x0000000AUL)
   ! v; h3 l) A' c  C; Z
9. #define SPI_DATASIZE_12BIT                            (0x0000000BUL)
   
10. #define SPI_DATASIZE_13BIT                            (0x0000000CUL)
    
11. #define SPI_DATASIZE_14BIT                            (0x0000000DUL)
    
12. #define SPI_DATASIZE_15BIT                            (0x0000000EUL)
    4 O  [% D* F" T% P  {$ T, i
13. #define SPI_DATASIZE_16BIT                            (0x0000000FUL)
    
14. #define SPI_DATASIZE_17BIT                            (0x00000010UL)
    
15. #define SPI_DATASIZE_18BIT                            (0x00000011UL)
    ) R/ v7 j- G' a' c1 e5 F  n/ d" e
16. #define SPI_DATASIZE_19BIT                            (0x00000012UL)
    - b* w7 |; X; m- x( O1 o; B, L
17. #define SPI_DATASIZE_20BIT                            (0x00000013UL)
    3 v3 F: T; b& j; Z
18. #define SPI_DATASIZE_21BIT                            (0x00000014UL)
    3 T% }3 G& ^6 R3 x% q: ]  P8 S
19. #define SPI_DATASIZE_22BIT                            (0x00000015UL)
    
20. #define SPI_DATASIZE_23BIT                            (0x00000016UL)
    ( d' e0 a! ~  _* i/ B& t7 I/ }  S
21. #define SPI_DATASIZE_24BIT                            (0x00000017UL)
    
22. #define SPI_DATASIZE_25BIT                            (0x00000018UL)
    ; b& M" W% t7 |- Q7 e
23. #define SPI_DATASIZE_26BIT                            (0x00000019UL)
    & M7 P/ `/ x5 ?. O
24. #define SPI_DATASIZE_27BIT                            (0x0000001AUL)
    
25. #define SPI_DATASIZE_28BIT                            (0x0000001BUL)
    
26. #define SPI_DATASIZE_29BIT                            (0x0000001CUL)
    
27. #define SPI_DATASIZE_30BIT                            (0x0000001DUL)
    
28. #define SPI_DATASIZE_31BIT                            (0x0000001EUL)
    
29. #define SPI_DATASIZE_32BIT                            (0x0000001FUL)

复制代码

  CLKPolarity
用于设置空闲状态时，CLK是高电平还是低电平。
# B( `, f3 ~3 u0 k
3 s+ d3 W4 B2 {4 G

1. #define SPI_POLARITY_LOW       (0x00000000UL)
   , R5 S/ a8 ~0 a5 y6 [
2. #define SPI_POLARITY_HIGH      SPI_CFG2_CPOL

复制代码

  NSS
用于设置NSS信号由硬件NSS引脚管理或者软件SSI位管理。
( J/ G1 X  ^8 z! l

1. #define SPI_NSS_SOFT                                  SPI_CFG2_SSM
   3 S) C* h8 {# x1 O7 @; A# T. O
2. #define SPI_NSS_HARD_INPUT                            (0x00000000UL)
   
3. #define SPI_NSS_HARD_OUTPUT                           SPI_CFG2_SSOE

复制代码

) x. z4 `* [8 B( v2 W: v$ w  BaudRatePrescaler
# _! F  z0 c1 J& {6 L0 g用于设置SPI时钟分频，仅SPI工作在主控模式下起作用，对SPI从机模式不起作用。

1. #define SPI_BAUDRATEPRESCALER_2                       (0x00000000UL)
   % A, b8 W3 k- A  Q% \! {
2. #define SPI_BAUDRATEPRESCALER_4                       (0x10000000UL)
   
3. #define SPI_BAUDRATEPRESCALER_8                       (0x20000000UL)
   ; o0 L2 j0 a7 M7 e- q
4. #define SPI_BAUDRATEPRESCALER_16                      (0x30000000UL)
   
5. #define SPI_BAUDRATEPRESCALER_32                      (0x40000000UL)
   7 D% ^  Q" P' A* ~# e
6. #define SPI_BAUDRATEPRESCALER_64                      (0x50000000UL)
   4 c* ^. [* x: k' s" J3 P
7. #define SPI_BAUDRATEPRESCALER_128                     (0x60000000UL)
   5 a' X' |7 r( n/ ^$ N
8. #define SPI_BAUDRATEPRESCALER_256                     (0x70000000UL)

复制代码

  FirstBit
: Z1 @/ y, R/ f. {1 Q: N: @* Q5 d用于设置数据传输从最高bit开始还是从最低bit开始。
! K; d! X7 J8 d& T% }- P

1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
   8 ^7 \  U# ]$ R" i: H
2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST
   5 M% z+ ^+ c" G8 v

复制代码

  TIMode
用于设置是否使能SPI总线的TI模式。

1. #define SPI_TIMODE_DISABLE               (0x00000000UL)
   0 W6 D( e5 V8 @" @
2. #define SPI_TIMODE_ENABLE                SPI_CFG2_SP_0

复制代码

$ x" a8 }7 F  I* w: M  CRCCalculation
* ~$ J$ l0 k7 M) L: b用于设置是否使能CRC计算。
3 c+ x+ p, ?# ?! o9 e' \

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

复制代码

  CRCPolynomial
用于设置CRC计算使用的多项式，必须是奇数，范围0到65535。
3 H' c2 F" m5 S- D) l  A
1 u" v& H6 e# N$ `4 X  CRCLength
用于设置CRC计算时的CRC长度。大小要与同属此结构体的DataSize一致。或是DataSize的整数倍。

1. #define SPI_CRC_LENGTH_DATASIZE                       (0x00000000UL)
   7 o# R! [$ B) ]
2. #define SPI_CRC_LENGTH_4BIT                           (0x00030000UL)
   
3. #define SPI_CRC_LENGTH_5BIT                           (0x00040000UL)
   7 e( q; M2 s& w; p9 N) C
4. #define SPI_CRC_LENGTH_6BIT                           (0x00050000UL)
   
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)
   6 o; O+ W4 H1 W. }* s/ B1 _
9. #define SPI_CRC_LENGTH_11BIT                          (0x000A0000UL)
   3 T+ t) O: u* q3 y9 e; M/ \
10. #define SPI_CRC_LENGTH_12BIT                          (0x000B0000UL)
    
11. #define SPI_CRC_LENGTH_13BIT                          (0x000C0000UL)
    
12. #define SPI_CRC_LENGTH_14BIT                          (0x000D0000UL)
    
13. #define SPI_CRC_LENGTH_15BIT                          (0x000E0000UL)
    2 j  ^" C/ K+ l5 [# j0 X- h7 B3 g
14. #define SPI_CRC_LENGTH_16BIT                          (0x000F0000UL)
    
15. #define SPI_CRC_LENGTH_17BIT                          (0x00100000UL)
    . E! ^& B7 v1 a  H% X
16. #define SPI_CRC_LENGTH_18BIT                          (0x00110000UL)
    
17. #define SPI_CRC_LENGTH_19BIT                          (0x00120000UL)
    
18. #define SPI_CRC_LENGTH_20BIT                          (0x00130000UL)
    3 O# Z5 a  R6 p. j
19. #define SPI_CRC_LENGTH_21BIT                          (0x00140000UL)
    
20. #define SPI_CRC_LENGTH_22BIT                          (0x00150000UL)
    
21. #define SPI_CRC_LENGTH_23BIT                          (0x00160000UL)
    
22. #define SPI_CRC_LENGTH_24BIT                          (0x00170000UL)
    # R8 d0 _  f* s
23. #define SPI_CRC_LENGTH_25BIT                          (0x00180000UL)
    
24. #define SPI_CRC_LENGTH_26BIT                          (0x00190000UL)
    
25. #define SPI_CRC_LENGTH_27BIT                          (0x001A0000UL)
    : D) _6 \1 X' O+ d
26. #define SPI_CRC_LENGTH_28BIT                          (0x001B0000UL)
    
27. #define SPI_CRC_LENGTH_29BIT                          (0x001C0000UL)
    
28. #define SPI_CRC_LENGTH_30BIT                          (0x001D0000UL)
    / |- n" ]& H! p* v0 q  O
29. #define SPI_CRC_LENGTH_31BIT                          (0x001E0000UL)
    
30. #define SPI_CRC_LENGTH_32BIT                          (0x001F0000UL)

复制代码

' ]7 p& ?1 v; k, M! I

  NSSPMode
用于设置是否使能NSSP信号，可以通过SPIx_CR2寄存器的SSOM位使能。注意，只有配置为摩托罗拉SPI主控模式时设置此成员才有用。
; l' O5 }3 Q9 [3 W1 A9 \

1. #define SPI_NSS_PULSE_DISABLE                         (0x00000000UL)
   1 w0 `# O0 @& @. c& W) X- O7 |
2. #define SPI_NSS_PULSE_ENABLE                          SPI_CFG2_SSOM

复制代码

  NSSPolarity
用于设置NSS引脚上的高电平或者低电平作为激活电平。

1. #define SPI_NSS_POLARITY_LOW                          (0x00000000UL)
   4 {" B) N5 v" @  d
2. #define SPI_NSS_POLARITY_HIGH                          SPI_CFG2_SSIOP

复制代码

  FifoThreshold
用于设置SPI的FIFO阀值。

* Z$ r" t) c6 y+ L2 p5 k1 w

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)
   # B/ |( M5 x, E/ Y
6. #define SPI_FIFO_THRESHOLD_06DATA                     (0x000000A0UL)
   5 J* W/ v( a( A5 z3 v
7. #define SPI_FIFO_THRESHOLD_07DATA                     (0x000000C0UL)
   1 p% |* Q5 E' A: P5 J
8. #define SPI_FIFO_THRESHOLD_08DATA                     (0x000000E0UL)
   
9. #define SPI_FIFO_THRESHOLD_09DATA                     (0x00000100UL)
   7 L$ r  {, j- V. }5 L
10. #define SPI_FIFO_THRESHOLD_10DATA                     (0x00000120UL)
    0 k! G6 C; H* m/ w4 N
11. #define SPI_FIFO_THRESHOLD_11DATA                     (0x00000140UL)
    * D. u$ o* Y" X- D) J
12. #define SPI_FIFO_THRESHOLD_12DATA                     (0x00000160UL)
    * [0 m3 G. w. m  R# x( B5 W9 d
13. #define SPI_FIFO_THRESHOLD_13DATA                     (0x00000180UL)
    1 G) O+ F% B" K/ ^; l* z/ o* S- K
14. #define SPI_FIFO_THRESHOLD_14DATA                     (0x000001A0UL)
    4 m5 F7 |& T7 @6 m, a
15. #define SPI_FIFO_THRESHOLD_15DATA                     (0x000001C0UL)
    
16. #define SPI_FIFO_THRESHOLD_16DATA                     (0x000001E0UL)
    ( O2 Q8 D# F9 i. \

复制代码

$ O, r; a) ]' |' j  K
  TxCRCInitializationPattern
发送CRC初始化模式。
( r1 T& q( p* Q
( ^* j. K9 r& W" A/ u

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

复制代码

  RxCRCInitializationPattern
接收CRC初始化模式
4 ], z0 U- Z* N& I. Q  K# w

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   ) C) g. G) N3 L/ Y* b6 y
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

6 ~5 k! h5 f: T/ |& t MasterSSIdleness
( M2 R6 L) |6 e7 ?! a) n! L在主模式下插入到SS有效边沿和第一个数据开始之间的额外延迟，单位SPI时钟周期个数。
' ^1 s7 o  ]& D7 I+ O6 B
1 A) ]9 m7 j' y

1. #define SPI_MASTER_SS_IDLENESS_00CYCLE                (0x00000000UL)
   
2. #define SPI_MASTER_SS_IDLENESS_01CYCLE                (0x00000001UL)
   
3. #define SPI_MASTER_SS_IDLENESS_02CYCLE                (0x00000002UL)
   2 V, U0 M2 f9 w/ _
4. #define SPI_MASTER_SS_IDLENESS_03CYCLE                (0x00000003UL)
   
5. #define SPI_MASTER_SS_IDLENESS_04CYCLE                (0x00000004UL)
   # v. l& a; Y6 b+ I
6. #define SPI_MASTER_SS_IDLENESS_05CYCLE                (0x00000005UL)
   
7. #define SPI_MASTER_SS_IDLENESS_06CYCLE                (0x00000006UL)
   1 G! U) T" m; d0 s/ V2 d) Z
8. #define SPI_MASTER_SS_IDLENESS_07CYCLE                (0x00000007UL)
   4 a3 d2 [( s+ U0 F2 B% N% R; v! ^. e
9. #define SPI_MASTER_SS_IDLENESS_08CYCLE                (0x00000008UL)
   
10. #define SPI_MASTER_SS_IDLENESS_09CYCLE                (0x00000009UL)
    
11. #define SPI_MASTER_SS_IDLENESS_10CYCLE                (0x0000000AUL)
    
12. #define SPI_MASTER_SS_IDLENESS_11CYCLE                (0x0000000BUL)
    ( w7 w: v) d. f1 }
13. #define SPI_MASTER_SS_IDLENESS_12CYCLE                (0x0000000CUL)
    ; L1 n6 [: }- \) k
14. #define SPI_MASTER_SS_IDLENESS_13CYCLE                (0x0000000DUL)
    * g* D# Z7 t$ e; [! b9 U
15. #define SPI_MASTER_SS_IDLENESS_14CYCLE                (0x0000000EUL)
    * j( x* @% d2 h+ W7 p  z, @/ \
16. #define SPI_MASTER_SS_IDLENESS_15CYCLE                (0x0000000FUL)
    

复制代码

2 w7 ^3 A9 m- o, x+ U. \$ O
  MasterInterDataIdleness
9 }: H  h/ |8 v, l6 e主模式下在两个连续数据帧之间插入的最小时间延迟，单位SPI时钟周期个数。
" Q# [* l/ _0 b; d8 |  x' j+ H9 _

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

复制代码

  MasterReceiverAutoSusp
) ?  W/ Q' ~5 z; Y3 d5 O9 ^用于控制主器件接收器模式下的连续 SPI 传输以及自动管理，以避免出现上溢情况。

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   & e* b  l: z( u2 C# g
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX
   2 S4 K: X6 J  h6 o0 R6 m& }

复制代码

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

+ m' N, f4 ]0 G8 h- u: o. T1 K9 V

1. #define SPI_MASTER_KEEP_IO_STATE_DISABLE              (0x00000000UL)
   
2. #define SPI_MASTER_KEEP_IO_STATE_ENABLE               SPI_CFG2_AFCNTR

复制代码

2 {5 Z3 n7 W( N  IOSwap
* q. U5 \* G8 J4 b) l# @5 b用于交换MISO和MOSI引脚。

) F2 Y1 X4 L4 i" D

1. #define SPI_IO_SWAP_DISABLE                           (0x00000000UL)
   ' \2 k3 k7 r% r- i$ f, y
2. #define SPI_IO_SWAP_ENABLE                            SPI_CFG2_IOSWP

复制代码

  O0 B+ v! [2 e72.3.3 SPI总线句柄结构体SPI_HandleTypeDef
* |# d5 ?; ?& G6 U7 q下面是SPI总线的初始化结构体，用到的地方比较多：
# I% v* r" u3 O

1. typedef struct __SPI_HandleTypeDef
   8 ?& ^2 m. y; \& C! b/ t
2. {
   
3.   SPI_TypeDef                *Instance;                 
   
4.   SPI_InitTypeDef            Init;                        
   ) Y# @" o+ }5 D0 J
5.   uint8_t                    *pTxBuffPtr;                 
   ( H3 p- r! k+ s6 @+ _7 l
6.   uint16_t                   TxXferSize;                  
   
7.   __IO uint16_t              TxXferCount;                  
   
8.   uint8_t                    *pRxBuffPtr;               
   ) Y: M; H# M8 U1 c) W& m+ M
9.   uint16_t                   RxXferSize;                  
   
10.   __IO uint16_t              RxXferCount;                 
    & x3 F8 }4 U$ C( k
11.   uint32_t                   CRCSize;                     
    9 a. m# h5 Y  R: @( W5 E8 {- |" {7 ]3 y2 k
12.   void (*RxISR)(struct __SPI_HandleTypeDef *hspi);      
    
13.   void (*TxISR)(struct __SPI_HandleTypeDef *hspi);        
    ! n* @: J# @) P9 }
14.   DMA_HandleTypeDef          *hdmatx;                     
    3 \  E5 |' f. H1 O# \
15.   DMA_HandleTypeDef          *hdmarx;                     
    ; f: H) o' q+ g! X. @7 x; D
16.   HAL_LockTypeDef            Lock;                        
    
17.   __IO HAL_SPI_StateTypeDef  State;                        
    
18.   __IO uint32_t              ErrorCode;                  
    
19. #if defined(USE_SPI_RELOAD_TRANSFER)
    3 p# z7 i" Y2 X% @) k0 S
20.   SPI_ReloadTypeDef          Reload;                     
    
21. #endif
    
22. 
    : O3 P$ a6 ]( I1 t: b0 Y( j, @
23. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    $ A/ _3 ]5 e3 L5 B* [
24.   void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    , w: f: F, a& v) z4 a$ f7 `, S/ G
25.   void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
26.   void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    # S! q0 ?: z0 q4 t% H+ n7 `
27.   void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    ' x+ d" X/ r$ p( i5 ~
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);   
    2 y4 t2 }1 x! b( }9 v! C* N+ W* ]
32.   void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);   
    
33.   void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);
    
34. #endif  
    
35. } SPI_HandleTypeDef;
    

复制代码

7 D, |7 h  R" P
/ k4 J7 U( F4 ?. {% }4 u" p注意事项：
) w$ V; v  \. Q: i
条件编译USE_HAL_SPI_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：
! C, {$ J! M( Y
  #define   USE_HAL_SPI_REGISTER_CALLBACKS   1

" x. t3 i0 t2 t* q& Y7 u通过函数HAL_SPI_RegisterCallback注册回调，取消注册使用函数HAL_SPI_UnRegisterCallback。

& b# X6 b* D3 U' Q( K: B. F这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。
' }, `: Y' @: ~4 d) Z( i- b
  SPI_TypeDef   *Instance
4 L# i$ W0 k7 G# d这个参数是寄存器的例化，方便操作寄存器，比如使能SPI1。
) c& R. d$ k5 [6 Z0 f% z
SET_BIT(SPI1 ->CR1,  SPI_CR1_SPE)。
* D5 x9 N& q+ R2 c% N8 [' U3 j
0 @& u. |, H/ ^1 @  SPI_InitTypeDef  Init
这个参数是用户接触最多的，在本章节3.2小节已经进行了详细说明。

  DMA_HandleTypeDef          *hdmatx               
8 k- A: H" \# y0 b# v( a  DMA_HandleTypeDef          *hdmarx
; L" t; I$ K2 Q/ p7 h" n用于SPI句柄关联DMA句柄，方便操作调用。

72.4 SPI总线源文件stm32h7xx_hal_spi.c
! f7 ~* F& R" l. e; p- v$ r此文件涉及到的函数较多，这里把几个常用的函数做个说明：

  HAL_SPI_Init
& f! }' d- {. c- `  HAL_SPI_DeInit
  HAL_SPI_TransmitReceive
  HAL_SPI_TransmitReceive_IT
  HAL_SPI_TransmitReceive_DMA
0 H% K7 G1 H! f% |72.4.1 函数HAL_SPI_Init
8 a; o& v, `: i2 I# H2 _函数原型：

1. HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
   0 V- P8 o1 r0 U: r
2. {
   
3.   uint32_t crc_length = 0UL;
   
4.   uint32_t packet_length;
   - ~( p+ d3 [3 O0 d6 }* s6 q
5. 
   
6.   /* 省略未写 */
   
7. 
   
8.   /* 如果数据位宽大于16bit，必须是SPI1，SPI2或者SPI3，而SPI4，SPI5和SPI6不支持大于16bit */
   ) H% C$ N' Y' U+ r
9.   if ((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (hspi->Init.DataSize > SPI_DATASIZE_16BIT))
   " ?# a4 j- v; W" S' O; d# E( S
10.   {
    
11.     return HAL_ERROR;
    2 b7 L# g  W' Q- k5 N# r9 k5 m& n
12.   }
    
13. 
    
14.   /* SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit
    
15.      这里是查看设置的缓冲大小是否超出了FIFO支持的大小。
    
16. */
    
17.   packet_length = SPI_GetPacketSize(hspi);
    8 F0 }% w% _) Z9 e9 ?
18.   if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_LOWEND_FIFO_SIZE)) ||
    8 U% ]) G7 r. b- r: I* B9 `; N
19.       ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_HIGHEND_FIFO_SIZE)))
    
20.   {
    5 n: ]: r2 c0 Q; Z7 Z" C
21.     return HAL_ERROR;
    
22.   }
    
23. 
    
24. #if (USE_SPI_CRC != 0UL)
    : ^3 H4 w% O4 f: C0 A1 T* g5 q  `
25.     /* 省略未写 */
    
26. #endif
    ! n+ j* O- N4 ^$ r
27. 
    % e! F  g+ }! _& ?: W) s
28.   if (hspi->State == HAL_SPI_STATE_RESET)
    2 l9 s. f% z* U" z
29.   {
    / ^& R5 _* U' u+ V: Q
30.     /* 解锁 */
    * O% L& s" u9 G( G
31.     hspi->Lock = HAL_UNLOCKED;
    % N/ a% I+ v  f
32. 
    . g$ S  r! X3 ?; h3 p; G6 {9 S
33.     /* 使用自定义回调 */
    
34. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    2 U. R. J5 k4 n6 [# ?
35.     /* 设置默认回调函数 */
    
36.     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */
    * ?8 b* F& Z( X; V
37.     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */
    
38.     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */
    7 q8 Z& l( Z5 h- R
39.     hspi->TxHalfCpltCallback   = HAL_SPI_TxHalfCpltCallback;   /* Legacy weak TxHalfCpltCallback   */
    0 R6 u, |) G& W6 i& J5 u+ x; E+ z0 d! N
40.     hspi->RxHalfCpltCallback   = HAL_SPI_RxHalfCpltCallback;   /* Legacy weak RxHalfCpltCallback   */
    
41.     hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */
    
42.     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */
    ; |6 d1 f0 u/ C2 F9 Q  S$ m' Q5 u
43.     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */
    
44. 
    
45.     if (hspi->MspInitCallback == NULL)
    
46.     {
    $ z$ U. @" t# L5 ^& V+ H# T2 M: W# Q
47.       hspi->MspInitCallback = HAL_SPI_MspInit;
      V% L) H1 B9 |9 i
48.     }
    : \: i. _) S% F! w5 W
49. 
    
50.     /* 初始化地址硬件: GPIO, CLOCK, NVIC... */
    - }, q6 `: X1 R, R, d7 q+ ]
51.     hspi->MspInitCallback(hspi);
    
52. #else
    2 f2 W9 R* v( K- \1 H+ E. e6 g
53.     /* 初始化底层硬件: GPIO, CLOCK, NVIC... */
    9 L7 H  _2 q3 ^/ F( i* O
54.     HAL_SPI_MspInit(hspi);
    , T6 ~9 Z1 W1 J3 o
55. #endif
    1 u6 _8 E/ U3 s7 d2 o0 `
56.   }
    
57. 
    * K% q8 z: }! h1 \; l7 Z
58.   hspi->State = HAL_SPI_STATE_BUSY;
    
59. 
    
60.   /* 禁止SPI外设 */
    
61.   __HAL_SPI_DISABLE(hspi);
    7 P2 x. f% m4 |  j" @, R# U
62. 
    # p) P; ~0 T8 i. \9 O) o
63.   /*----------------------- SPIx CR1 & CR2 配置---------------------*/
    
64.   if ((hspi->Init.NSS == SPI_NSS_SOFT) && (hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.NSSPolarity ==
    " G9 c% e8 P1 l7 A' s- S
65. SPI_NSS_POLARITY_LOW))
    
66.   {
    
67.       SET_BIT(hspi->Instance->CR1, SPI_CR1_SSI);
    2 O$ x3 z* h: B4 y" N; S* M
68.   }
    
69. 
    
70.   /* SPIx CFG1配置 */
    
71.   WRITE_REG(hspi->Instance->CFG1, (hspi->Init.BaudRatePrescaler | hspi->Init.CRCCalculation | crc_length |
    4 I/ o* Z; c  x  E0 d4 r
72.                                    hspi->Init.FifoThreshold     | hspi->Init.DataSize));
    
73. 
    ! M3 c+ w) m+ `
74.   /* SPIx CFG2配置 */
    - V% `2 H7 ^+ c0 v) n
75.   WRITE_REG(hspi->Instance->CFG2, (hspi->Init.NSSPMode     | hspi->Init.TIMode           | hspi->Init.NSSPolarity  |
    
76.                                    hspi->Init.NSS          | hspi->Init.CLKPolarity      | hspi->Init.CLKPhase     |
    7 m4 \( @- x! l( Y
77.                                    hspi->Init.FirstBit     | hspi->Init.Mode             | hspi->Init.MasterInterDataIdleness |
    
78.                                    hspi->Init.Direction    | hspi->Init.MasterSSIdleness | hspi->Init.IOSwap));
    - s+ s* @+ x! C" x+ m/ l
79. 
    
80. #if (USE_SPI_CRC != 0UL)
    
81.   /*---------------------------- SPIx CRC配置 ------------------*/
    
82.   /* 配置SPI CRC */
    
83.   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    
84.   {
    
85.     /* 初始化TX CRC初始值 */
    % k3 ?8 @$ d* C
86.     if (hspi->Init.TxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    " o4 z. w4 f$ j
87.     {
    
88.       SET_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    
89.     }
    3 C4 g$ G0 J% |" q9 ?7 N
90.     else
    
91.     {
    0 N+ P! S+ D* b, i" A4 l. U
92.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    : x, r( y9 N) ]( G3 J: p- {
93.     }
    
94. 
    8 I/ T) ?) A5 F" y3 l$ {  X
95.     /* 初始化RXCRC初始值 */
    
96.     if (hspi->Init.RxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    
97.     {
    / x- O! @4 m6 w- G4 n
98.       SET_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
    
99.     }
    # h9 y6 `6 ~# \% \/ S8 r( o) [( B
100.     else
     6 g& X+ |/ y8 R! \
101.     {
     
102.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
     / O- S/ D" I4 P7 D. V2 p- L
103.     }
     " y7 Q6 d* U; Z; W! |- X
104. 
     
105.     /* 使能 33/17 bit CRC计算 */
     " q3 n) s( B! }7 }
106.     if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (crc_length == SPI_CRC_LENGTH_16BIT)) ||
     + V' O& c! x! t5 y
107.         ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance))  && (crc_length == SPI_CRC_LENGTH_32BIT)))
     + i- C2 r  B! Q# T
108.     {
     1 D) Q0 f  Q; ?  U/ q
109.       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     6 N, u- \% H+ R" I/ Y& J1 A9 ^
110.     }
     
111.     else
     % d" n9 w6 `: f. A8 p
112.     {
     
113.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     3 L" R0 S0 Y: P5 V8 j. z+ j
114.     }
     
115. 
     ( s, U& [5 f& S( `/ B4 s* C; S
116.     /* 写CRC多项式到SPI寄存器 */
     
117.     WRITE_REG(hspi->Instance->CRCPOLY, hspi->Init.CRCPolynomial);
     5 Z% j; j- j+ P3 [# D2 j5 k
118.   }
     
119. #endif
     ; h9 R- |% l) {
120. 
     
121.   /* SPI从模式，下溢配置 */
     5 w4 I8 O* k! A* C
122.   if (hspi->Init.Mode == SPI_MODE_SLAVE)
     , {- T9 \1 q* N: _2 j0 ~$ n
123.   {
     9 W+ S5 A* e7 h! m
124.     /* 设置默认下溢配置 */
     5 S( F# J/ I, m7 B# M( W
125. #if (USE_SPI_CRC != 0UL)
     $ B3 t$ j1 b2 o+ {
126.     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_DISABLE)
     5 e' s2 L2 F' O  `8 G4 T
127. #endif
     
128.     {
     ' F8 u2 A6 Q. D" K8 s
129.       MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, SPI_CFG1_UDRDET_0);
     ! |: M, G( m2 W4 N
130.     }
     
131.     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRCFG, SPI_CFG1_UDRCFG_1);
     
132.   }
     
133. 
     ( U# r! `% d5 P1 x
134. #if defined(SPI_I2SCFGR_I2SMOD)
     ) R8 ?' J( ]  ^% l
135.   CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);
     
136. #endif
     
137. 
     ( V  J! Q  B7 l- W
138.   /* 确保AFCNTR bit由SPI主机模式管理 */
     
139.   if ((hspi->Init.Mode & SPI_MODE_MASTER) == SPI_MODE_MASTER)
     7 A% [. b. \$ s
140.   {
     
141.     /* Alternate function GPIOs control */
     
142.     MODIFY_REG(hspi->Instance->CFG2, SPI_CFG2_AFCNTR, (hspi->Init.MasterKeepIOState));
     & O% t, r8 C: m' Y9 d
143.   }
     
144. 
     # l7 U/ p, d9 V" v9 l$ ~& t. [# t1 {
145.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
     
146.   hspi->State     = HAL_SPI_STATE_READY;
     * U0 N& z( I, J0 B
147. 
     * v4 @% Z4 m& ?# C5 F$ i- c9 Z
148.   return HAL_OK;
     
149. }
     / q( V! g; y/ _; m. ~: V

复制代码

- X1 S5 r( i' L: @& h  G
5 ~5 N- N3 m6 z9 b函数描述：

此函数用于初始化SPI。
$ j1 v/ |" d" ]' v  J
; m: Z5 M) H# P$ k$ {7 f/ p0 T2 b函数参数：

  第1个参数是SPI_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  K' j& @5 p% f* v4 X2 v  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
& M$ W+ p2 m2 H2 ]注意事项：

函数HAL_SPI_MspInit用于初始化SPI的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
* |5 e+ j" O: u9 H如果形参hspi的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SPI_HandleTypeDef SpiHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SPI_STATE_RESET  = 0x00U。
1 x" ?1 g3 t8 T( m& Y  F" C
9 r) M& q3 u* Q# k解决办法有三

方法1：用户自己初始化SPI和涉及到的GPIO等。
. K9 c" ~9 y4 t
方法2：定义SPI_HandleTypeDef SpiHandle为全局变量。
8 A6 I( P' C1 Q) f
方法3：下面的方法
$ g3 C4 g3 T" {0 C: U( S
# A! Y7 T/ B, W  S' ?

1. if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK)
   
2. {
   
3.     Error_Handler();
   
4. }  
   4 Q/ Q2 x8 ?0 q, k
5. if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
   ( {: H1 J0 P( U( `6 s+ F
6. {
   
7.     Error_Handler();
   ) G* m, f6 }0 k' b& z; @5 }; }" N5 Q
8. }

复制代码

# @$ A" V5 ?( k! b$ y: K使用举例：
1 D* J, t2 e4 v& e

1. SPI_HandleTypeDef hspi = {0};
   0 F9 ]) P9 V# p% q
2. 
   
3. /* 设置SPI参数 */
   / A$ e# }* n& D2 r- Y0 S. x
4. hspi.Instance               = SPIx;                   /* 例化SPI */
   4 H0 d+ i; d& B" |1 v0 T
5. hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
   , C( |+ c- a7 v' X  ^* p, B# Y
6. hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
   
7. hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
   
8. hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
   - a. w+ Q- z" A+ E. P
9. hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
   
10. hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    : m1 v! I2 _& v) D, H7 J' |1 H
11. hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    
12. hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;      /* 禁止CRC */
    
13. hspi.Init.CRCPolynomial     = 7;                               /* 禁止CRC后，此位无效 */
    
14. hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;             /* 禁止CRC后，此位无效 */
    
15. hspi.Init.NSS               = SPI_NSS_SOFT;                    /* 使用软件方式管理片选引脚 */
    # S9 t/ j7 Q8 o
16. hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;       /* 设置FIFO大小是一个数据项 */
    
17. hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;           /* 禁止脉冲输出 */
    
18. hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    / n! o. F1 i2 o. n
19. hspi.Init.Mode                  = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    
20. 
    
21. if (HAL_SPI_Init(&hspi) != HAL_OK)
    
22. {
    
23.     Error_Handler(__FILE__, __LINE__);
    
24. }

复制代码

72.4.2 函数HAL_SPI_DeInit
0 _" n9 d& I, I, ?6 @$ n8 q函数原型：

1. HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
   
2. {
   
3. /* 检测SPI句柄是否有效 */
   3 G3 M, s4 {# g3 K
4.   if (hspi == NULL)
   * Y! l( {3 d4 P* C
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   
8. 
   
9. /* 检查SPI例化参数 */
   
10.   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
    5 h, X; M' [! }9 `- J/ `# g
11. 
    4 B1 j( b4 m$ f( g
12.   hspi->State = HAL_SPI_STATE_BUSY;
    
13. 
    ! C  r$ [* A- V
14.   /* 禁止SPI外设时钟 */
    % ^4 H7 q- j. c+ u2 Y, J: a6 d
15.   __HAL_SPI_DISABLE(hspi);
    
16. 
    
17. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    7 |9 u$ f8 P6 V* Z1 R4 v
18.   if (hspi->MspDeInitCallback == NULL)
    ) j0 r9 c$ y' W7 \
19.   {
    
20.     hspi->MspDeInitCallback = HAL_SPI_MspDeInit;
    ) }% c/ R8 Q/ V& D9 W
21.   }
    
22. 
    # P, P2 W$ a% w& T+ U
23.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    + k9 @1 S( |+ |7 a
24.   hspi->MspDeInitCallback(hspi);
    0 w' u7 @$ [) C% s/ a
25. #else
    9 `+ S) S" R. j& g( @
26.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    
27.   HAL_SPI_MspDeInit(hspi);
    1 U+ L" L1 W+ H
28. #endif
    
29. 
    3 `" E0 B  x5 k; I  K; N2 K
30.   /* 设置无错误，复位状态标记 */
    ; ~) s0 \; @7 M9 s. r2 R7 F
31.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
    
32.   hspi->State = HAL_SPI_STATE_RESET;
    
33. 
    - }% m0 q5 B! a6 F2 N
34.   /* 解锁SPI */
    " ^; j3 \, J* p6 k: v
35.   __HAL_UNLOCK(hspi);
    
36. 
    3 Z9 R( Z, v5 F) v4 C
37.   return HAL_OK;
    
38. }

复制代码

0 T3 Q( \$ l) |6 n7 Z: {, F# ~函数描述：
) [0 u+ k$ N8 e6 P1 v. @! |
! U& Q; w( {# ]) A- H/ I用于复位SPI总线初始化。

函数参数：

  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中
72.4.3 函数HAL_SPI_TransmitReceive
函数原型：
6 x, Q7 b- ^+ w+ X& c
2 s; ~- ~/ q, u) F- s

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
   
2. {
   ! ?/ ?) A9 y$ c. W+ H: W9 R) r
3. 
   : B. H& h, ?+ }. F( n7 G
4.    /* 省略未写 */
   3 F7 l) P% d3 ^3 u/ I% S' f
5. 
   
6.   /* 大于16bit的数据收发 */
   
7.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
   
8.   {
   $ K( Y6 y# \0 @# b5 A
9.        /* 省略未写 */
   ; p. E& T* v7 A" ^% Z
10.   }
    . d# ]  u* X, t; S- l
11.   /* 大于8bit，小于16bi的数据收发 */
    # D( v5 ~# ]8 m  r& i8 a1 ]
12.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    
13.   {
    $ B* d5 `) y* D& m7 \0 P% \1 x
14.       /* 省略未写 */
    $ F% B1 s/ Q% v" P/ V& U" x
15.   }
    
16.   /* 小于等于8bit的数据收发 */
    
17.   else
    ) F5 ?" h5 n1 X5 ^1 j* E8 m9 s1 m
18.   {
    / j5 i5 G4 {) k- ]& S: r. Q" F8 T. B6 \
19.        /* 省略未写 */
    4 l( }, m, J4 o: T$ c
20.   }
    ' w4 F9 |7 u" v; F$ |  X* d$ C
21. 
    
22. }
    

复制代码

$ z3 ~. U, Z9 ]  Y5 `& O
6 l1 J; y) q. [: A函数描述：

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

( H0 m1 B' ^! @6 K; M% W" C函数参数：
$ M" ]& L6 G$ m+ ?- Q+ J
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
: _0 L! g3 D6 G. I3 j  第2个参数是发送数据缓冲地址。
, s+ Q; q! x4 S  第3个参数是接收数据缓冲地址。
& s% K( G5 S3 C" w  第4个参数是传输的数据大小，单位字节个数。
% G. L2 Z- |, i: L# G' O4 Q  第5个参数是传输过程的溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

6 s! k  T9 Z2 `

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__);
   8 s/ O6 U4 I8 E" x4 M/ E
6. }

复制代码

72.4.4 函数HAL_SPI_TransmitReceive_IT
函数原型：
& {. {  J; Y5 g7 n) B2 i

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
   . o, {# p" F! s
2. {
   , ~, |) A4 G3 B% `
3.    /* 省略未写 */
   # J8 ^7 U- T* a2 T; |7 m) f0 |3 I+ S
4. 
   ! [# Z+ F, H0 o/ s& N! Q0 b8 B/ F
5.   /* 设置传输参数 */
   
6.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   
7.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
   ) o. \# d; m4 l% z! a; C3 C/ g
8.   hspi->TxXferSize  = Size;
   
9.   hspi->TxXferCount = Size;
   , F) G4 s. n" [- n0 Y
10.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
    " w; s( @7 ]$ t0 J4 `
11.   hspi->RxXferSize  = Size;
    7 E( ^% i3 \: g* g
12.   hspi->RxXferCount = Size;
    
13. 
    
14.   /* 设置中断处理 */
    
15.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    
16.   {
    ) A5 m9 C) o, D# @6 X$ R
17.     hspi->TxISR     = SPI_TxISR_32BIT;
    & R) c4 ?5 L3 S" |
18.     hspi->RxISR     = SPI_RxISR_32BIT;
    8 g9 ~% i; e0 E1 c
19.   }
    / C+ y( i0 U* G- x: _( J" |. |
20.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    ) b4 ]8 y% Q/ f2 ~$ B5 t3 ]: b
21.   {
    
22.     hspi->RxISR     = SPI_RxISR_16BIT;
    
23.     hspi->TxISR     = SPI_TxISR_16BIT;
    
24.   }
    
25.   else
    
26.   {
    
27.     hspi->RxISR     = SPI_RxISR_8BIT;
    & ^& m  [& l0 }
28.     hspi->TxISR     = SPI_TxISR_8BIT;
    8 {& s5 `) k/ W6 g
29.   }
    
30. 
    
31.   /* 设置当前传输数据大小 */
    
32.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    . d& k. W6 T% ?0 o8 C
33. 
    3 y+ M/ Q' }, e2 T, Q8 T
34.   /* 使能SPI外设 */
    # E. V  o: H% v' }2 l/ I5 g" n  m
35.   __HAL_SPI_ENABLE(hspi);
    7 p* L- C/ o- z8 J. B: L* L  q1 y
36. 
    $ R! F/ t6 B& w& }
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));
    0 d4 I) y# H1 N, [. x
40. 
    
41.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    2 }. D' N- ]+ |, d$ j/ F# l
42.   {
    3 D; l4 E! V6 `& o6 C7 h' s
43.     /* 启动传输 */
    - G0 c5 i* {# b) v$ b1 d$ m8 F
44.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
    7 y7 [# z* }9 V3 X! |6 |( s6 H( T. q
45.   }
    2 Y+ _8 L/ {% r! p; X) N
46. 
    
47.   /* 解锁 */
    
48.   __HAL_UNLOCK(hspi);
    # s, B5 a* G+ l+ O: D! b
49.   return errorcode;
    
50. }

复制代码

$ r/ W7 e( G# o4 ^6 Y, F5 x
% K4 ?: w" _5 q5 M) u
  B+ l; C! u' M' [  f' A+ J! N函数描述：
6 B. W1 V. P+ e/ T
此函数主要用于SPI数据收发，全双工中断方式。

" L: M8 J7 C# R- @" K函数参数：
, P7 z1 ~9 n$ A
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
4 |" ?4 l8 H4 `) a: C8 `, Q* Z  第2个参数是发送数据缓冲地址。
7 z. [* f9 `( i1 F! j5 H3 a  第3个参数是接收数据缓冲地址。
$ v4 z2 \2 Q# v) |: f  第4个参数是传输的数据大小，单位字节个数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：
3 Q" F2 B, _  E' A
3 F! v" f9 \- Q% L

1. SPI_HandleTypeDef hspi = {0};
   & L! l0 M; M; V6 E2 R0 v3 n: {
2. 
   
3. if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   
4. {
   3 M. z+ A1 X; T% Y
5.     Error_Handler(__FILE__, __LINE__);
   
6. }
   % y5 p0 o; z, S- x( A6 r& J
7. 
   # _* g4 @. F$ _% \$ l( a' ^
8. 
   2 O2 y) |; q, o7 t6 W) ~
9. 72.4.5 函数HAL_SPI_TransmitReceive_DMA
   + [! `2 C" B! o
10. 函数原型：
    & s5 a5 L+ v8 Z. y5 o1 |
11. 
    
12. HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,
    
13.                                               uint16_t Size)
    
14. {
    
15.    /* 省略未写 */
    & g& W# G1 L+ E6 e" ]0 q1 P
16. 
    $ ~9 u/ k- ]7 @0 W
17. /* 注意DMA的位宽和对齐设置 */
    1 M) y7 _' p, e$ e- \3 L
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))))
    . B, E- f. y' [$ V% k6 ^# S3 a
21.   {
    
22.   }
    8 p$ j# I) h( e& j) o
23. 
    
24. /* 调整DMA对齐和数据大小 */
    ! J, }* M" c5 [4 S  \$ f
25.   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)
    
26.   {
    0 p8 ]7 N: Y$ k* {/ @1 p5 s; v  \
27.      /* 省略未写 */
    . I8 A  M8 }6 b" r5 j
28.   }
    , w4 @& _% J" M
29.   else if (hspi->Init.DataSize <= SPI_DATASIZE_16BIT)
    , S1 r: d+ J1 ?- ^+ q7 v+ H
30.   {
    
31.      /* 省略未写 */
    5 \5 x2 v! a9 V; d) e/ M4 r
32.   }
    
33.   else
    
34.   {
    
35.       /* 省略未写 */
    & m4 B# h; k' l6 M; M0 g. t; d
36.   }
    3 ]. S: h8 ?! n9 a
37. 
    : ~! e0 u7 E; f; C) Z) i1 h5 L
38. /*  DMA接收配置 */
    3 c: O/ `7 C  V; S# d5 j! i
39.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->RXDR, (uint32_t)hspi->pRxBuffPtr,
    1 s. z% a, q: ~- C5 D! O
40. hspi->RxXferCount))
    
41.   {
    
42. 
    
43.   }
    
44. 
    ) a, k3 i2 Q! v0 A$ Q* m2 C5 j' O/ t
45. /* DMA发送配置 */
    
46.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->TXDR,
    
47. hspi->TxXferCount))
    
48.   {
    
49.   }
    & m: t( W' e6 o( X0 N; O
50. 
    2 F: E7 Y& U6 r$ F4 u) ?' S
51.   /* 省略未写 */
    , t& G  e  ^: J0 B) q, [1 I
52. }
    - t. g; R/ x6 d1 F0 P8 M

复制代码

1 K2 Z' q4 n. @* r" Z% T( e0 f
, K( U+ Y8 ?; I8 i& y函数描述：
7 i) |5 `" K* [8 x2 f* u
# a# ], C/ O1 R* v5 W此函数主要用于SPI数据收发，全双工DMA方式。

函数参数：
, B( j* c, i$ \- r/ D8 \& k
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
% L* _' N( V, p4 i) b7 t  第2个参数是发送数据缓冲地址。
* A0 n3 P+ p8 v7 h  第3个参数是接收数据缓冲地址。
8 A! H) Z) d" b  第4个参数是传输的数据大小，单位字节个数。
! B' h& X& y6 N$ t  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

- h: z) J% X& O0 W1 I6 B; _

1. SPI_HandleTypeDef hspi = {0};
   , g9 Y3 V' s6 i- ^$ e
2. 
   " \6 V6 y* z5 L4 f7 n$ f) k
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__);
   
6. }

复制代码

' D# x2 e5 K3 s4 Y6 w' |& [

72.5 总结
/ V* b9 r- z, u3 D( [本章节就为大家讲解这么多，要熟练掌握SPI总线的查询，中断和DMA方式的实现，因为基于SPI接口的外设芯片很多，熟练后，可以方便的驱动各种SPI接口芯片，以便选择合适的驱动方式。
( L0 C1 V, e: X: D: V. N. B

# Q* p* q  s" Y0 Y: l