72.1 初学者重要提示
  STM32H7的SPI支持4到32bit数据传输，而STM32F1和F4系列仅支持8bit或者16bit。
: \. ?) l& f( m  f: s( R8 a; i  STM32H7的主频400MHz时，SPI1, 2, 3最高通信时钟是100MHz，而SPI4, 5, 6是50MHz。
  STM32H7的MISO和MOSI引脚功能可以互换，使用比较灵活。
/ ]7 o4 w; F8 S3 }. f  SPI总线的片选引脚SS在单一的主从器件配置下是可选的，一般情况下可以不使用。
& n" d3 K( k7 a$ T" v! |( E! B
0 c4 v) O- J, J5 Y( V! C, H* j, ]72.2 SPI总线基础知识
72.2.1 SPI总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SPI的基本功能，然后再看手册了解细节。

" g! S6 f8 b; M

1 c% K" B+ @0 g& f# }: ^% y- |通过这个框图，我们可以得到如下信息：

  spi_wkup输出
# y% V& [6 U6 `+ T/ X低功耗唤醒信号。

  spi_it输出
spi的中断请求信号。
) N, P0 g' `4 {( ~# j5 P" e
8 _$ X/ X( h, G" j2 d0 m, [  spi_tx_dma
spi_rx_dma
4 _/ V' O; b! O3 W" @% j4 z6 q5 A6 kspi的DMA发送和接收请求信号。
6 p' \2 h) E! ~  o9 }' x0 z
1 ]# \- y" e- i6 P  spi_pclk
为寄存器提供时钟。
* e5 @7 L" l7 |/ I" t4 O) r6 o' R
  spi_ker_ck
% {. {: S2 a* Y# W  K5 ?9 Z为spi内核时钟。
  J7 F  d6 r& Z6 N4 H7 S% d
  SCK（CK），Serial Clock
) H' R* L! ~+ a# r5 w5 h  ~# J此引脚在主机模式下用于时钟输出，从机模式下用于时钟输入。

  MISO（SDI），Master In / Slave Out data
* Z* B! g2 I: z3 b( ]6 b此引脚在从机模式下用于发送数据，主机模式下接收数据。

- @" U( G) w9 D5 L7 ~  MOSI（SDO）, Master Out / Slave In data
; g5 R! r; e9 V此引脚在从机模式下用于数据接收，主机模式下发送数据。
/ S6 |; d: R+ p% Q, z% }" {
% T- ]9 u$ b! Y4 J" G: |' c8 T  SS（WS）, Slave select pin
" C4 C$ X3 m$ U. V# A! K根据SPI和SS设置，此引脚可用于：

a. 选择三个从器件进行通信。

b. 同步数据帧。

2 q6 T6 s9 o# h# j) o; }c. 检测多个主器件之间是否存在冲突。

8 U- d. h2 K3 ^. O- R通过这个框图还要认识到一点，SPI有三个时钟域，分别是寄存器所在的ABP总线时钟域，内核时钟发生器时钟域以及内核时钟发生器分频后的串行时钟域。
. V  v  N0 D5 a& Z% [8 |( G
72.2.2 SPI接口的区别和时钟源（SPI1到SPI6）
这个知识点在初学的时候容易忽视，所以我们这里整理下。

  SPI1到SPI6的区别
  SPI1，SPI2和SPI3支持4到32bit数据传输，SPI4，SPI5和SPI6是4到16bit数据传输。
7 i3 t" S$ J) i9 f% f$ R0 |' u  SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit。

  SPI1到SPI6的所在的总线（对应SPI框图的SPI_CLK时钟域）
' q0 g# H& ~! m; L1 D' jSPI1，SPI4和SPI5在APB2总线，SPI2，SPI3在APB1总线，SPI6在APB4总线。注意，SPI的最高时钟不是由这些总线决定的。
  ~; o3 f( s7 q1 W4 D; Y5 a0 s2 J
  SPI1到SPI6的支持的最高时钟（对应SPI框图的SPI_KER_CK）
STM32H7主频在400MHz下，SPI1，SPI2和SPI3的最高时钟是200MHz，而SPI4,5,6是100MHz, 以SPI1为了，可以选择的时钟源如下：

  a3 b- |% @5 h5 l

3 w# v5 G4 j5 U. d, g. a
这里特别注意一点，SPI工作时最少选择二分频，也就是说SPI1,2,3实际通信时钟是100MHz，而SPI4,5,6是50MHz。
  {! P$ e' b+ |% ]& n
72.2.3 SPI总线全双工，单工和半双工通信
片选信号SS在单一的主从器件配置下是可选的，一般情况下可以不使用。但需要同步数据流，或者用于TI模式时需要此信号。

  全双工通信
2 C4 X9 d. |  M2 d8 I0 u( E+ k全双工就是主从器件之间同时互传数据，SPI总线的全双工模式接线方式如下：

  P8 M8 Q8 T  l% ~# P& Y关于这个接线图要认识到以下几点：

( a9 `* g3 |" G' q4 d- N/ Z% I  注意接线方式，对于主器件来说MISO引脚就是输入端，从器件的MISO是输出端，即Master In / Slave Out data。MOSI也是同样道理。
) z5 I% Z  [0 O0 g2 F  每个时钟信号SCK的作用了，主器件的MISO引脚接收1个bit数据，MOSI引脚输出1个bit数据。
  这种单一的主从接线模式下，SS引脚可以不使用。
2 S- k1 s7 _* f# a0 }$ q& K; |  半双工通信
半双工就是同一个时刻只能为一个方向传输数据，SPI总线的半工模式接线方式如下：

0 o& ]5 b& |) {' A  @

1 h5 a. N% x  P9 a
关于这个接线图要认识到以下几点：

  更改通信方式时，要先禁止SPI。
  主器件的MISO和从器件的MISO不使用，可以继续用作标准GPIO。
  1KΩ的接线电阻很有必要，因为当主器件和从器件的通信方向不是同步变化时，容易出现其中一个输出低电平，另一个输出高电平，造成短路。
6 s% o6 I' j; X  这种单一的主从接线模式下，SS引脚可以不使用。
! l9 u& U7 \( B. |- O' B  单工模式
单工就是只有一种通信方向，即发送或者接收，SPI总线的全双工模式接线方式如下：

$ g8 L! a8 U- _  D# E, i

9 B+ C$ n2 Y7 T* X: y7 z关于这个接线图要认识到以下几点：

  未用到的MOSI或者MISO可以用作标准GPIO。
  这种单一的主从接线模式下，SS引脚可以不使用。
# x7 y9 O6 M3 [: H4 Y, h72.2.4 SPI总线星型拓扑
SPI总线星型拓扑用到的地方比较多，V7开发板就是用的星型拓扑外接多种SPI器件：

& m. v( O$ ^  a! u  {+ ^  T关于这个接线图，有以下几点需要大家了解：

  主器件的SS引脚不使用，使用通用GPIO控制。为每个器件配一个SS引脚，方便单独片选控制。
9 x; I, k+ j+ {  从器件的MISO引脚要配置为复用开漏输出（很多外部芯片在未片选时，数据引脚是呈现高阻态）。
/ `6 J2 C6 w$ l7 m2 Q$ n7 ~72.2.5 SPI总线通信格式
/ m! V( v9 F2 A1 A# k$ r3 @SPI总线主要有四种通信格式，由CPOL时钟极性和CPHA时钟相位控制：

3 |* q2 k+ }9 j4 F! H
4 s: h& ]4 c& w" e6 P4 W四种通信格式如下：
9 m+ H( p! h' j# S2 J
/ b& v$ ~2 |% g6 G# [  当CPOL = 1， CPHA = 1时
7 h7 l% J& z+ ]0 n7 G, OSCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
1 R+ Z8 k, u$ z- R7 X, f9 x
! l, b0 z2 ]9 @- {: z4 o* ]! T  当CPOL = 0， CPHA = 1时
SCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。

  当CPOL = 1， CPHA = 0时
! ]7 I1 h8 G) p/ ^SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。
4 r  {* S% J& k
  当CPOL = 1， CPHA = 0时
SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。

72.3 SPI总线的HAL库用法
72.3.1 SPI总线结构体SPI_TypeDef
  [. r4 }& u% n: zSPI总线相关的寄存器是通过HAL库中的结构体SPI_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
- o0 J' _7 R% [/ C8 T' d

1. typedef struct
   
2. {
   5 U+ h( O% Q6 b* j
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 */
   
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 */
   ( L: a, K* `, z5 M( V1 h
8.   __IO uint32_t SR;            /*!< SPI/I2S Status register,                         Address offset: 0x14 */
   & ]9 {, R/ n8 X0 X( S4 b& v$ a" u
9.   __IO uint32_t IFCR;          /*!< SPI/I2S Interrupt/Status flags clear register,   Address offset: 0x18 */
   - i2 g' B; d8 s2 t  F2 Z
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                                                   */
    - [7 V) _$ N8 t! |9 }$ ~
13.   __IO uint32_t RXDR;          /*!< SPI/I2S Receive data register,                   Address offset: 0x30 */
    . X' A3 Q% |  x8 D
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 */
    
17.   __IO uint32_t RXCRC;         /*!< SPI Receiver CRC register,                       Address offset: 0x48 */
    0 q1 l% s* a0 r# G" d0 {
18.   __IO uint32_t UDRDR;         /*!< SPI Underrun data register,                      Address offset: 0x4C */
    
19.   __IO uint32_t I2SCFGR;       /*!< I2S Configuration register,                      Address offset: 0x50 */
    * \# A# V* `8 `, I
20. 
    - ?& U4 G6 I% Y, a$ g
21. } SPI_TypeDef;

复制代码

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

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   8 |. M& ?" l9 ?% s9 A  s
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

6 C- U; c; b, a" U: ?- h( @; }下面我们看下SPI的定义，在stm32h743xx.h文件。
' w' z/ u* [7 [, H
5 E. R" {1 y$ M

1. #define PERIPH_BASE           (0x40000000UL)
   
2. #define D2_APB1PERIPH_BASE     PERIPH_BASE
   
3. #define D2_APB2PERIPH_BASE    (PERIPH_BASE + 0x00010000UL)
   
4. #define D3_APB1PERIPH_BASE    (PERIPH_BASE + 0x18000000UL)
   " \3 N$ |8 G- a! m$ {
5. 
   
6. #define SPI2_BASE             (D2_APB1PERIPH_BASE + 0x3800UL)
   
7. #define SPI3_BASE             (D2_APB1PERIPH_BASE + 0x3C00UL)
   & D) N2 v+ h* a
8. #define SPI1_BASE             (D2_APB2PERIPH_BASE + 0x3000UL)
   
9. #define SPI4_BASE             (D2_APB2PERIPH_BASE + 0x3400UL)
   
10. #define SPI5_BASE             (D2_APB2PERIPH_BASE + 0x5000UL)
    * ~3 r/ L5 z+ }2 T( F+ R
11. #define SPI6_BASE             (D3_APB1PERIPH_BASE + 0x1400UL)
    , K5 F( I. n: R$ a- ^  x6 }
12. 
    
13. #define SPI1                ((SPI_TypeDef *) SPI1_BASE)
    / J- m& t' w* N4 Q2 h" Y
14. #define SPI2                ((SPI_TypeDef *) SPI2_BASE)
    , O* \+ v8 V8 J6 Q
15. #define SPI3                ((SPI_TypeDef *) SPI3_BASE)
    
16. #define SPI4                ((SPI_TypeDef *) SPI4_BASE)
    
17. #define SPI5                ((SPI_TypeDef *) SPI5_BASE)
    & h! v8 T% i& c' c2 g/ c
18. #define SPI6                ((SPI_TypeDef *) SPI6_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x58001400

复制代码

我们访问SPI的CR1寄存器可以采用这种形式：SPI->CR1 = 0。

. I0 e, u) p; q4 z1 W72.3.2 SPI总线初始化结构体SPI_InitTypeDef
( J+ p' \  v$ v4 \3 b4 i3 K( x; D下面是SPI总线的初始化结构体，用到的地方比较多：

1. typedef struct
   
2. {
   . Z$ k) z; t* }4 i/ d
3.   uint32_t Mode;                           
   0 _/ c0 h+ a( t8 I# _/ x
4.   uint32_t Direction;                     
   
5.   uint32_t DataSize;                          
   # E, |& f; B! t
6.   uint32_t CLKPolarity;                       
   7 ^8 k+ e" C6 v* v
7.   uint32_t CLKPhase;                        
   
8.   uint32_t NSS;                             
   - E- c# a! A. r, M4 }$ E
9.   uint32_t BaudRatePrescaler;               
   3 u9 p! m7 [9 n( I/ k! {2 A
10.   uint32_t FirstBit;                        
    4 a0 w3 {3 ^: w! u& [- n2 x
11.   uint32_t TIMode;                          
    
12.   uint32_t CRCCalculation;                  
    
13.   uint32_t CRCPolynomial;                     
    
14.   uint32_t CRCLength;                        
    3 D" {6 v5 `' N& b1 h2 Z# _9 G  }
15.   uint32_t NSSPMode;                        
    
16.   uint32_t NSSPolarity;                    
    # V4 G8 M/ A* ~6 e4 Q, O; r
17.   uint32_t TxCRCInitializationPattern;      
    
18.   uint32_t RxCRCInitializationPattern;      
    ) `! x0 }- j4 p0 Z' P( l
19.   uint32_t MasterSSIdleness;                 
    
20.   uint32_t MasterInterDataIdleness;           
    9 z; L' {2 h& M) n, z, j) @
21.   uint32_t MasterReceiverAutoSusp;         
    1 R- i; q0 E3 g/ i$ }8 P3 w
22.   uint32_t MasterKeepIOState;               
    - e* k4 @0 y& F: O
23.   uint32_t IOSwap;                          
    
24. } SPI_InitTypeDef;

复制代码

下面将结构体成员逐一做个说明：
, O. D2 f$ ]( M# f3 L9 M. c
* Y3 ~; @' S0 ^- C  Mode
用于设置工作在主机模式还是从机模式。
6 I" |" P0 Y, E- v

1. #define SPI_MODE_SLAVE              (0x00000000UL)
   ; I" e! s/ s  S& ]+ v3 U
2. #define SPI_MODE_MASTER             SPI_CFG2_MASTER

复制代码

  T$ X- `  A; s1 }8 ]" o  Direction
; q6 I- L. c$ c6 \% Z! s. A% }用于设置SPI工作在全双工，单工，还是半双工模式。
0 a* Q+ W2 n* \) L/ p% b+ L* _% I

1. #define SPI_DIRECTION_2LINES           (0x00000000UL)     /* 全双工 */
   9 c  ?2 R! u2 l# W) S$ \
2. #define SPI_DIRECTION_2LINES_TXONLY     SPI_CFG2_COMM_0   /* 单工，仅发送 */
   3 n' D$ o; C- m2 a# w. J
3. #define SPI_DIRECTION_2LINES_RXONLY     SPI_CFG2_COMM_1   /* 单工，仅接收 */
   * i4 C/ X% K& g$ x1 V. D
4. #define SPI_DIRECTION_1LINE             SPI_CFG2_COMM     /* 半双工 */

复制代码

! y( p7 O* U( I$ w4 p, z  DataSize
用于设置SPI总线数据收发的位宽，支持4-32bit。
+ J" ~: g5 L( g- `3 ^

1. #define SPI_DATASIZE_4BIT                             (0x00000003UL)
   4 F) V6 s7 L& [/ g
2. #define SPI_DATASIZE_5BIT                             (0x00000004UL)
   7 p: P% G# V5 W7 x7 X, C  }# B/ e
3. #define SPI_DATASIZE_6BIT                             (0x00000005UL)
   
4. #define SPI_DATASIZE_7BIT                             (0x00000006UL)
   
5. #define SPI_DATASIZE_8BIT                             (0x00000007UL)
   * C/ t# c# ]* |2 Y& b
6. #define SPI_DATASIZE_9BIT                             (0x00000008UL)
   7 W* |8 j  ?/ Y- P% G. ]. E6 O
7. #define SPI_DATASIZE_10BIT                            (0x00000009UL)
   
8. #define SPI_DATASIZE_11BIT                            (0x0000000AUL)
   
9. #define SPI_DATASIZE_12BIT                            (0x0000000BUL)
   , J! k! u! B$ H& b5 i1 @
10. #define SPI_DATASIZE_13BIT                            (0x0000000CUL)
    
11. #define SPI_DATASIZE_14BIT                            (0x0000000DUL)
    9 [9 A: ]* }0 ~  e  Q* d- u
12. #define SPI_DATASIZE_15BIT                            (0x0000000EUL)
    
13. #define SPI_DATASIZE_16BIT                            (0x0000000FUL)
    
14. #define SPI_DATASIZE_17BIT                            (0x00000010UL)
    
15. #define SPI_DATASIZE_18BIT                            (0x00000011UL)
    
16. #define SPI_DATASIZE_19BIT                            (0x00000012UL)
    # C" w) S8 f0 Z9 u. r; R
17. #define SPI_DATASIZE_20BIT                            (0x00000013UL)
    
18. #define SPI_DATASIZE_21BIT                            (0x00000014UL)
    
19. #define SPI_DATASIZE_22BIT                            (0x00000015UL)
    ) c( u/ n' Y/ v- P# n5 X0 y
20. #define SPI_DATASIZE_23BIT                            (0x00000016UL)
      f/ n+ e/ i3 W2 F* k
21. #define SPI_DATASIZE_24BIT                            (0x00000017UL)
    2 A1 d4 p; X0 b: W' I& T: v
22. #define SPI_DATASIZE_25BIT                            (0x00000018UL)
    + L2 x; Q( C7 I9 E( h
23. #define SPI_DATASIZE_26BIT                            (0x00000019UL)
    
24. #define SPI_DATASIZE_27BIT                            (0x0000001AUL)
    6 ]3 n# T4 S: T1 \0 U6 W* [
25. #define SPI_DATASIZE_28BIT                            (0x0000001BUL)
    8 V. A; M5 W: h/ l
26. #define SPI_DATASIZE_29BIT                            (0x0000001CUL)
    
27. #define SPI_DATASIZE_30BIT                            (0x0000001DUL)
    3 l; }! ]; Q( u4 x, H1 n+ Q: x& e
28. #define SPI_DATASIZE_31BIT                            (0x0000001EUL)
    ( @& z1 k3 O& V# Y/ d$ S
29. #define SPI_DATASIZE_32BIT                            (0x0000001FUL)

复制代码

4 ^" _: O& L5 V5 c  CLKPolarity
用于设置空闲状态时，CLK是高电平还是低电平。
8 k. D* a1 \7 ~  B$ x
; M2 s9 t8 V2 b& E, M1 j

1. #define SPI_POLARITY_LOW       (0x00000000UL)
   2 E) B/ Y, k' J' N* C* A: ^
2. #define SPI_POLARITY_HIGH      SPI_CFG2_CPOL

复制代码

- }8 [' V3 f$ z3 o% E$ {. r  NSS
用于设置NSS信号由硬件NSS引脚管理或者软件SSI位管理。
1 Q9 ^' k& Y9 d7 I$ W% c

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

复制代码

  BaudRatePrescaler
用于设置SPI时钟分频，仅SPI工作在主控模式下起作用，对SPI从机模式不起作用。

1. #define SPI_BAUDRATEPRESCALER_2                       (0x00000000UL)
     i0 N( y) U; Q! m: \# s
2. #define SPI_BAUDRATEPRESCALER_4                       (0x10000000UL)
   
3. #define SPI_BAUDRATEPRESCALER_8                       (0x20000000UL)
   / J8 u3 n+ e7 @  N2 [( a- ?
4. #define SPI_BAUDRATEPRESCALER_16                      (0x30000000UL)
   2 E$ y6 h' o/ w# L6 O
5. #define SPI_BAUDRATEPRESCALER_32                      (0x40000000UL)
   0 w. ^* \6 y8 ]" g* K7 K; J
6. #define SPI_BAUDRATEPRESCALER_64                      (0x50000000UL)
   
7. #define SPI_BAUDRATEPRESCALER_128                     (0x60000000UL)
   
8. #define SPI_BAUDRATEPRESCALER_256                     (0x70000000UL)

复制代码

, f' u, D$ M* E* @: o4 y" g  FirstBit
9 Y- S: c  b& Z1 T5 J5 r" y5 L用于设置数据传输从最高bit开始还是从最低bit开始。

2 P4 ]: t# K) c7 L% b. r) d' z

1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
   
2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST
   5 z) q; ?. q+ q( l

复制代码

* M5 j( P1 V( e5 O5 ?1 `$ \. }. e  TIMode
" n+ t8 N! k; d9 N* r& t1 r用于设置是否使能SPI总线的TI模式。

0 Q0 ~5 }  I+ u2 G7 Z# r$ Y

1. #define SPI_TIMODE_DISABLE               (0x00000000UL)
   9 P* D, |! d* }% C. |* y2 o
2. #define SPI_TIMODE_ENABLE                SPI_CFG2_SP_0

复制代码

) T1 t/ E" C; d6 }  CRCCalculation
+ h( o" y* @) j1 q9 |, s" i/ @; C用于设置是否使能CRC计算。
! o! Q$ e) s- G0 K: I5 ]
8 Q+ b, V. j0 B3 k9 `% v

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

复制代码

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

2 Y$ w( v' N" V1 ~  CRCLength
- {1 {$ [, N6 K0 j用于设置CRC计算时的CRC长度。大小要与同属此结构体的DataSize一致。或是DataSize的整数倍。

$ t! ~/ K; g& W

1. #define SPI_CRC_LENGTH_DATASIZE                       (0x00000000UL)
   
2. #define SPI_CRC_LENGTH_4BIT                           (0x00030000UL)
   & G. U, l% k/ ~: s2 s( z
3. #define SPI_CRC_LENGTH_5BIT                           (0x00040000UL)
   
4. #define SPI_CRC_LENGTH_6BIT                           (0x00050000UL)
   + [) j5 Z+ g% L  G3 f
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)
   8 ~2 V# v2 E2 i
9. #define SPI_CRC_LENGTH_11BIT                          (0x000A0000UL)
   
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)
    1 G: H! c* w- G! g
14. #define SPI_CRC_LENGTH_16BIT                          (0x000F0000UL)
    + l- T% k  `3 a( d' K7 a% g
15. #define SPI_CRC_LENGTH_17BIT                          (0x00100000UL)
    
16. #define SPI_CRC_LENGTH_18BIT                          (0x00110000UL)
    
17. #define SPI_CRC_LENGTH_19BIT                          (0x00120000UL)
    
18. #define SPI_CRC_LENGTH_20BIT                          (0x00130000UL)
    
19. #define SPI_CRC_LENGTH_21BIT                          (0x00140000UL)
    
20. #define SPI_CRC_LENGTH_22BIT                          (0x00150000UL)
    * I6 Y1 q" a7 M, s$ X
21. #define SPI_CRC_LENGTH_23BIT                          (0x00160000UL)
    . b! |" _# W8 l
22. #define SPI_CRC_LENGTH_24BIT                          (0x00170000UL)
    % C7 _3 C3 z- Y) E
23. #define SPI_CRC_LENGTH_25BIT                          (0x00180000UL)
    ) k. K+ ]2 C; `5 `9 u3 ?
24. #define SPI_CRC_LENGTH_26BIT                          (0x00190000UL)
    
25. #define SPI_CRC_LENGTH_27BIT                          (0x001A0000UL)
    
26. #define SPI_CRC_LENGTH_28BIT                          (0x001B0000UL)
    0 }) A5 n: Z, |& s$ i7 G
27. #define SPI_CRC_LENGTH_29BIT                          (0x001C0000UL)
    + @% f- h' O, ^5 t  U7 i$ y7 u. |
28. #define SPI_CRC_LENGTH_30BIT                          (0x001D0000UL)
    % P, T( Q3 k4 K1 f
29. #define SPI_CRC_LENGTH_31BIT                          (0x001E0000UL)
    
30. #define SPI_CRC_LENGTH_32BIT                          (0x001F0000UL)

复制代码

6 f! p4 \  q3 {& M) _7 l. g  NSSPMode
( y+ o: C+ Y) y用于设置是否使能NSSP信号，可以通过SPIx_CR2寄存器的SSOM位使能。注意，只有配置为摩托罗拉SPI主控模式时设置此成员才有用。

7 Q, j  @6 ^) Y+ u

1. #define SPI_NSS_PULSE_DISABLE                         (0x00000000UL)
   # S& d- R# y. P% y$ j$ D3 y( Z4 n
2. #define SPI_NSS_PULSE_ENABLE                          SPI_CFG2_SSOM

复制代码

  NSSPolarity
用于设置NSS引脚上的高电平或者低电平作为激活电平。
& a) N6 a. [' c9 C5 M
" l% M; {5 K. \5 F3 }

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

复制代码

! [3 u0 W1 x0 y7 Z8 ^  FifoThreshold
用于设置SPI的FIFO阀值。
* ~1 T, |! t: ]2 s$ x
% j) m+ {: Z. O

1. #define SPI_FIFO_THRESHOLD_01DATA                     (0x00000000UL)
   ! Q8 g* ^+ l7 x
2. #define SPI_FIFO_THRESHOLD_02DATA                     (0x00000020UL)
   " P- M7 D' ?! ], T
3. #define SPI_FIFO_THRESHOLD_03DATA                     (0x00000040UL)
   ! o  u0 J2 I& o" y
4. #define SPI_FIFO_THRESHOLD_04DATA                     (0x00000060UL)
   : T+ V$ i1 K9 g2 L
5. #define SPI_FIFO_THRESHOLD_05DATA                     (0x00000080UL)
   * K! n+ G8 q  ]. A1 X% U
6. #define SPI_FIFO_THRESHOLD_06DATA                     (0x000000A0UL)
   
7. #define SPI_FIFO_THRESHOLD_07DATA                     (0x000000C0UL)
   . k0 Y. _$ v! q; W) P
8. #define SPI_FIFO_THRESHOLD_08DATA                     (0x000000E0UL)
   
9. #define SPI_FIFO_THRESHOLD_09DATA                     (0x00000100UL)
   
10. #define SPI_FIFO_THRESHOLD_10DATA                     (0x00000120UL)
    
11. #define SPI_FIFO_THRESHOLD_11DATA                     (0x00000140UL)
    * @$ Y- P. r0 m& i, v  \, O
12. #define SPI_FIFO_THRESHOLD_12DATA                     (0x00000160UL)
    : I/ [! F4 W3 z7 z! [
13. #define SPI_FIFO_THRESHOLD_13DATA                     (0x00000180UL)
    1 E9 Q% d* w+ m% b" b. f* e
14. #define SPI_FIFO_THRESHOLD_14DATA                     (0x000001A0UL)
    : m' I4 d# m% m
15. #define SPI_FIFO_THRESHOLD_15DATA                     (0x000001C0UL)
    
16. #define SPI_FIFO_THRESHOLD_16DATA                     (0x000001E0UL)
    

复制代码

3 X% x5 L& X" o: Z2 Q" {  TxCRCInitializationPattern
7 s, x' i: q" z, ~+ B/ q7 U发送CRC初始化模式。
" {& c; C) \9 S, D$ S6 i

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   4 n0 ?& r. k2 G" f: S/ `& o
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)
   

复制代码

9 o# b$ o! r5 Q- v5 t/ E  RxCRCInitializationPattern
接收CRC初始化模式

' \7 {1 x" E" t* x7 y0 z  @6 e* x

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   $ Y% S/ ?- D2 F
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

MasterSSIdleness
' }3 Z7 h  Z& N+ |在主模式下插入到SS有效边沿和第一个数据开始之间的额外延迟，单位SPI时钟周期个数。

; Q$ X* X% u, u* m+ b, w% x

1. #define SPI_MASTER_SS_IDLENESS_00CYCLE                (0x00000000UL)
   
2. #define SPI_MASTER_SS_IDLENESS_01CYCLE                (0x00000001UL)
   + Y9 [9 ^$ k# E2 |7 O
3. #define SPI_MASTER_SS_IDLENESS_02CYCLE                (0x00000002UL)
   
4. #define SPI_MASTER_SS_IDLENESS_03CYCLE                (0x00000003UL)
   
5. #define SPI_MASTER_SS_IDLENESS_04CYCLE                (0x00000004UL)
   7 s* t' R) _+ j
6. #define SPI_MASTER_SS_IDLENESS_05CYCLE                (0x00000005UL)
   
7. #define SPI_MASTER_SS_IDLENESS_06CYCLE                (0x00000006UL)
   ! }- u. ?( y8 ~2 f- f* T4 o
8. #define SPI_MASTER_SS_IDLENESS_07CYCLE                (0x00000007UL)
   
9. #define SPI_MASTER_SS_IDLENESS_08CYCLE                (0x00000008UL)
   
10. #define SPI_MASTER_SS_IDLENESS_09CYCLE                (0x00000009UL)
    - Y# N+ ]% E7 q' d( u
11. #define SPI_MASTER_SS_IDLENESS_10CYCLE                (0x0000000AUL)
    7 |2 r: u8 o2 u! ]* X
12. #define SPI_MASTER_SS_IDLENESS_11CYCLE                (0x0000000BUL)
    9 S3 e0 W1 h# |( _. z: T7 O5 A' u
13. #define SPI_MASTER_SS_IDLENESS_12CYCLE                (0x0000000CUL)
    " g. f$ M0 X) t
14. #define SPI_MASTER_SS_IDLENESS_13CYCLE                (0x0000000DUL)
    8 ^: u2 |5 p/ e% W8 }6 W! K. G
15. #define SPI_MASTER_SS_IDLENESS_14CYCLE                (0x0000000EUL)
    
16. #define SPI_MASTER_SS_IDLENESS_15CYCLE                (0x0000000FUL)
    

复制代码

! R9 B8 Z* G* u5 O' W; ?8 t  MasterInterDataIdleness
- a0 b/ b- V* X* t1 o/ v主模式下在两个连续数据帧之间插入的最小时间延迟，单位SPI时钟周期个数。

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   ; t5 f! ^/ v9 z, d+ p( W: H9 a
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX

复制代码

# _% s; f7 Z) h5 G( E5 ?( I& Q  MasterReceiverAutoSusp
, o5 ~+ U0 S: [# F5 _5 ^0 c用于控制主器件接收器模式下的连续 SPI 传输以及自动管理，以避免出现上溢情况。
/ G" M/ ?! e' u

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX
   + [) q" K6 n* t! W$ X' H: {# J

复制代码

  MasterKeepIOState
4 ]- t9 D9 o* v6 M' d& \禁止SPI后，SPI相关引脚保持当前状态，以防止出现毛刺。在从模式下，该位不应该使用。

1 C5 `! U' j8 O" U  V: f* j

1. #define SPI_MASTER_KEEP_IO_STATE_DISABLE              (0x00000000UL)
   ) r" @0 u- F9 }3 O9 Z) {: |
2. #define SPI_MASTER_KEEP_IO_STATE_ENABLE               SPI_CFG2_AFCNTR

复制代码

3 ~# G* a. V, L% ~6 M/ ^  t  IOSwap
用于交换MISO和MOSI引脚。

: V+ E$ @, U1 w) P' Q0 n

1. #define SPI_IO_SWAP_DISABLE                           (0x00000000UL)
   + \! M6 z$ R  n* p
2. #define SPI_IO_SWAP_ENABLE                            SPI_CFG2_IOSWP

复制代码

( g; F6 n+ |; }; O. h72.3.3 SPI总线句柄结构体SPI_HandleTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：
7 U3 t3 h$ \6 v" V

1. typedef struct __SPI_HandleTypeDef
   3 w4 g) U7 y* c8 Z% d4 N/ K
2. {
   
3.   SPI_TypeDef                *Instance;                 
   ' o  P1 f$ H( z+ k
4.   SPI_InitTypeDef            Init;                        
   
5.   uint8_t                    *pTxBuffPtr;                 
   
6.   uint16_t                   TxXferSize;                  
   0 a" i- a( c9 j4 [; \5 Q4 l
7.   __IO uint16_t              TxXferCount;                  
   
8.   uint8_t                    *pRxBuffPtr;               
   
9.   uint16_t                   RxXferSize;                  
   
10.   __IO uint16_t              RxXferCount;                 
    ; v1 W% c' |6 |* s+ ]& T
11.   uint32_t                   CRCSize;                     
    - }5 z# e( Q  v
12.   void (*RxISR)(struct __SPI_HandleTypeDef *hspi);      
    
13.   void (*TxISR)(struct __SPI_HandleTypeDef *hspi);        
    
14.   DMA_HandleTypeDef          *hdmatx;                     
      J2 h2 n8 F. Q  |- y
15.   DMA_HandleTypeDef          *hdmarx;                     
    
16.   HAL_LockTypeDef            Lock;                        
    
17.   __IO HAL_SPI_StateTypeDef  State;                        
    7 ]: R) F2 K4 U& e  \+ u; z: D
18.   __IO uint32_t              ErrorCode;                  
    
19. #if defined(USE_SPI_RELOAD_TRANSFER)
    : Q3 m# Q' g4 S8 \8 }) E5 {# k7 n
20.   SPI_ReloadTypeDef          Reload;                     
    / y' ^7 o8 v0 _2 _7 }& R3 t/ z
21. #endif
    $ C) v0 N* C  p) m9 ^% r
22. 
    0 l3 b, j( n+ I- J- Q: ^
23. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
24.   void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    - B% Q7 `3 b) X% b; K% M" g) Q2 o
25.   void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
26.   void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    5 o5 K# b( ~6 O
27.   void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    " q! k: G: B1 M  ~  G+ v% s
28.   void (* RxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    
29.   void (* TxRxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);
    4 O( R5 ~' Z* y; V# ~3 O- g, {
30.   void (* ErrorCallback)(struct __SPI_HandleTypeDef *hspi);      
    
31.   void (* AbortCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    
32.   void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);   
    
33.   void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);
    0 }3 x. l6 q$ @0 p' x0 x. p2 V
34. #endif  
    
35. } SPI_HandleTypeDef;
    * c7 }: S2 L& j, D$ c8 F" K

复制代码

/ N$ B/ S9 a2 U  [( P注意事项：

条件编译USE_HAL_SPI_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：
- }  ^# L2 d, B# N
4 Q" I6 j9 O+ b& q  @( F  Q8 k6 H/ N  #define   USE_HAL_SPI_REGISTER_CALLBACKS   1
5 f. W( w8 Y0 q3 J' n% m  ?
; f. \  B% P% I. F! `  c0 }通过函数HAL_SPI_RegisterCallback注册回调，取消注册使用函数HAL_SPI_UnRegisterCallback。

这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。
) f' t& `7 v- m: J" v& k8 S" y
  SPI_TypeDef   *Instance
( `. l( f2 F6 K& g: |这个参数是寄存器的例化，方便操作寄存器，比如使能SPI1。

5 d5 @- T! m9 B8 d% ~; pSET_BIT(SPI1 ->CR1,  SPI_CR1_SPE)。

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

  DMA_HandleTypeDef          *hdmatx               
' @% q' e  z* D  DMA_HandleTypeDef          *hdmarx
- P* K5 c' d, R5 A7 z: E) u) J用于SPI句柄关联DMA句柄，方便操作调用。

72.4 SPI总线源文件stm32h7xx_hal_spi.c
- Q0 g. j1 p- c: s& w& u此文件涉及到的函数较多，这里把几个常用的函数做个说明：
0 t' l5 V  D1 F5 J3 {2 j" I
  HAL_SPI_Init
  HAL_SPI_DeInit
) H0 I0 N! p7 |  HAL_SPI_TransmitReceive
  HAL_SPI_TransmitReceive_IT
  HAL_SPI_TransmitReceive_DMA
72.4.1 函数HAL_SPI_Init
8 l, H7 d; e/ J' x$ s函数原型：

- G  ]# p6 V# F0 ~- ^/ H4 K

1. HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
   
2. {
   
3.   uint32_t crc_length = 0UL;
   / H% D+ x' w5 U) X
4.   uint32_t packet_length;
     V( A5 f8 Z7 X5 B6 M& i) `: C
5. 
   
6.   /* 省略未写 */
   
7. 
   & e. Y5 [& |, z7 P$ Q
8.   /* 如果数据位宽大于16bit，必须是SPI1，SPI2或者SPI3，而SPI4，SPI5和SPI6不支持大于16bit */
   
9.   if ((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (hspi->Init.DataSize > SPI_DATASIZE_16BIT))
     U! z6 T% q2 G9 U. w$ L3 V" e
10.   {
    
11.     return HAL_ERROR;
    
12.   }
    
13. 
    
14.   /* SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit
    
15.      这里是查看设置的缓冲大小是否超出了FIFO支持的大小。
    - V. N$ a3 ^# S5 M: m2 h
16. */
    , {+ a7 I, S# a
17.   packet_length = SPI_GetPacketSize(hspi);
    3 I: z& d1 y/ ?* H* l5 J
18.   if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_LOWEND_FIFO_SIZE)) ||
    
19.       ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_HIGHEND_FIFO_SIZE)))
    
20.   {
    / ^" V/ y; h7 c4 h
21.     return HAL_ERROR;
    * D' S& }. W: f% R. v9 c
22.   }
    , Z$ }1 P7 G* h& x1 e
23. 
    2 ]2 z& W& |2 h3 P6 [$ D
24. #if (USE_SPI_CRC != 0UL)
    - w! c8 b6 A* R' U8 \5 ?7 @, V
25.     /* 省略未写 */
    
26. #endif
    ' _% k9 @7 b4 R% U& X8 y% }, N
27. 
    
28.   if (hspi->State == HAL_SPI_STATE_RESET)
    * s2 g1 X# r. y! i, B
29.   {
    
30.     /* 解锁 */
    ' K# Z$ h  c; t8 v3 V+ c
31.     hspi->Lock = HAL_UNLOCKED;
    
32. 
    
33.     /* 使用自定义回调 */
    
34. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
35.     /* 设置默认回调函数 */
    
36.     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */
    
37.     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */
    3 u6 l; i: M2 u( [
38.     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */
    " c' c0 f6 @+ ~- S# \/ }
39.     hspi->TxHalfCpltCallback   = HAL_SPI_TxHalfCpltCallback;   /* Legacy weak TxHalfCpltCallback   */
      e2 F6 T! {' M$ {7 P) S
40.     hspi->RxHalfCpltCallback   = HAL_SPI_RxHalfCpltCallback;   /* Legacy weak RxHalfCpltCallback   */
    
41.     hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */
    2 |' Z8 a  C4 p4 |. J' K5 r
42.     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */
    + Q# p5 H# Y0 R; n( s
43.     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */
    
44. 
    
45.     if (hspi->MspInitCallback == NULL)
    
46.     {
    * z* G- z2 T  c3 v9 @1 w( o
47.       hspi->MspInitCallback = HAL_SPI_MspInit;
    / z! l, G' g$ t" \! z; o
48.     }
    
49. 
    ( ?$ g+ d, ]# P; d# S
50.     /* 初始化地址硬件: GPIO, CLOCK, NVIC... */
    
51.     hspi->MspInitCallback(hspi);
    1 q/ O/ C; P/ W1 Q9 y4 O* C
52. #else
    
53.     /* 初始化底层硬件: GPIO, CLOCK, NVIC... */
    
54.     HAL_SPI_MspInit(hspi);
    2 O- e% r, A1 X" [2 ^( ?: q3 L% t
55. #endif
    
56.   }
    
57. 
    , O  b. I9 Z( V' c
58.   hspi->State = HAL_SPI_STATE_BUSY;
    
59. 
    5 b! C" q, l6 _& V+ V) O) _0 q  B
60.   /* 禁止SPI外设 */
    
61.   __HAL_SPI_DISABLE(hspi);
    
62. 
    2 R  n  F" N+ E+ x, r" v
63.   /*----------------------- SPIx CR1 & CR2 配置---------------------*/
    ) h+ [2 P" {. C. ^
64.   if ((hspi->Init.NSS == SPI_NSS_SOFT) && (hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.NSSPolarity ==
    
65. SPI_NSS_POLARITY_LOW))
    
66.   {
    
67.       SET_BIT(hspi->Instance->CR1, SPI_CR1_SSI);
    1 ?: o6 X" f! W: k# h6 @
68.   }
    
69. 
    / x0 \. O- S' y' r2 ^
70.   /* SPIx CFG1配置 */
    
71.   WRITE_REG(hspi->Instance->CFG1, (hspi->Init.BaudRatePrescaler | hspi->Init.CRCCalculation | crc_length |
    
72.                                    hspi->Init.FifoThreshold     | hspi->Init.DataSize));
    ; K$ L+ g, k2 h5 z" _/ x$ Z
73. 
    
74.   /* SPIx CFG2配置 */
    
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     |
    * m6 ]4 f& h3 r/ e
77.                                    hspi->Init.FirstBit     | hspi->Init.Mode             | hspi->Init.MasterInterDataIdleness |
    , e$ {. l" @8 @
78.                                    hspi->Init.Direction    | hspi->Init.MasterSSIdleness | hspi->Init.IOSwap));
    . T0 ]8 ^; J3 F# N  \' p. r7 C
79. 
    
80. #if (USE_SPI_CRC != 0UL)
    , A& g6 G- u0 X8 c- i* S
81.   /*---------------------------- SPIx CRC配置 ------------------*/
    
82.   /* 配置SPI CRC */
    
83.   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    7 J9 w6 b# a( g: y. o7 [. A) q) ^
84.   {
    * h+ J. _) d  l- V; T' ~
85.     /* 初始化TX CRC初始值 */
    
86.     if (hspi->Init.TxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    ! ]. C( j  x7 }: l& ]
87.     {
    $ E3 \  t3 [" u" B  I
88.       SET_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    - f7 Z7 q# p) x$ {. O
89.     }
    % O) w, v2 J5 ^+ p; ^
90.     else
    
91.     {
    
92.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    % ]9 j2 a: p7 b
93.     }
    + D% j( }! N0 c5 L) c' I
94. 
    
95.     /* 初始化RXCRC初始值 */
    4 H4 K9 y0 ?3 T1 {3 K/ [6 w8 _& b
96.     if (hspi->Init.RxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    ( ?6 a( G" A- Y  Y3 b: f* R0 i
97.     {
    
98.       SET_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
    ( X# ]9 z  I! b2 Q2 N" [6 J
99.     }
    
100.     else
     1 j2 G$ w; P$ C6 a$ M1 y& Q
101.     {
     : _1 |8 A# Q2 c) S2 p' F
102.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
     
103.     }
     
104. 
     7 k0 `) b# F8 e. z0 y5 B, _0 `
105.     /* 使能 33/17 bit CRC计算 */
     
106.     if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (crc_length == SPI_CRC_LENGTH_16BIT)) ||
     
107.         ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance))  && (crc_length == SPI_CRC_LENGTH_32BIT)))
     : }* P% w1 U. ^* t) @# f
108.     {
     
109.       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     
110.     }
     
111.     else
     ) J, h0 q: G% {5 t6 \% l  N
112.     {
     * B1 o* ]+ D. |9 {- ~7 Z: A9 O% I6 |7 w- d
113.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     
114.     }
     ) g5 A0 }; u( n7 U8 F. l; I  M& M
115. 
     
116.     /* 写CRC多项式到SPI寄存器 */
     
117.     WRITE_REG(hspi->Instance->CRCPOLY, hspi->Init.CRCPolynomial);
     " P, L4 W) F" _0 B9 ]2 C; ?# [
118.   }
     5 Q8 S% o6 H6 ?4 _+ ^, Z
119. #endif
     
120. 
     
121.   /* SPI从模式，下溢配置 */
     / W' c; A# ^: ]) [
122.   if (hspi->Init.Mode == SPI_MODE_SLAVE)
     % D* o/ c4 j+ x4 C  X  L6 o# P
123.   {
     
124.     /* 设置默认下溢配置 */
     # q7 z* X, ?! i# b' F# u
125. #if (USE_SPI_CRC != 0UL)
     
126.     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_DISABLE)
     
127. #endif
     # x- B1 M# t  u( u
128.     {
     & D4 I/ t$ G3 m6 @! L
129.       MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, SPI_CFG1_UDRDET_0);
     
130.     }
     
131.     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRCFG, SPI_CFG1_UDRCFG_1);
     0 i3 d& Y/ R# C7 U" m# Y: F" k
132.   }
     6 {5 h$ o! ?( p. g
133. 
     + J# `4 ?) s6 Z3 g7 n
134. #if defined(SPI_I2SCFGR_I2SMOD)
     2 T3 W0 F1 J8 z# N6 w. S. d
135.   CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);
     
136. #endif
     
137. 
     
138.   /* 确保AFCNTR bit由SPI主机模式管理 */
     : B$ f; {& {8 |( u7 `  J
139.   if ((hspi->Init.Mode & SPI_MODE_MASTER) == SPI_MODE_MASTER)
     7 P/ [& S+ z  _; ~& X- D% M
140.   {
     
141.     /* Alternate function GPIOs control */
     
142.     MODIFY_REG(hspi->Instance->CFG2, SPI_CFG2_AFCNTR, (hspi->Init.MasterKeepIOState));
     8 Q9 t3 Y; r( V8 G0 S  g. k
143.   }
     
144. 
     ( n5 H) O% |1 m8 p
145.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
     
146.   hspi->State     = HAL_SPI_STATE_READY;
     , ~/ B1 a& Y) t
147. 
     
148.   return HAL_OK;
     
149. }
     

复制代码

2 K% H4 K7 t, E. n9 ?1 l
# v4 E1 j) q; {9 u+ d  [$ U函数描述：

此函数用于初始化SPI。
& B& H- D$ f% i( M1 Z8 W( E; O
; ~. ?' d: V# A# I* G函数参数：

1 n8 X- v' ]& g1 P& }  第1个参数是SPI_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
* z" r6 z3 ?- D注意事项：

& A  n4 D2 ^: G) a7 a2 t函数HAL_SPI_MspInit用于初始化SPI的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hspi的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SPI_HandleTypeDef SpiHandle。
; F. @) D1 T6 T7 c: P: p对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SPI_STATE_RESET  = 0x00U。

解决办法有三

$ x# R" T8 a5 Z/ a7 G. j方法1：用户自己初始化SPI和涉及到的GPIO等。
  q2 F3 g6 c/ O8 Z& P; M! }
方法2：定义SPI_HandleTypeDef SpiHandle为全局变量。
3 u. D* ^+ {3 n  |, }8 A
1 r- b: S# W! ^9 ?2 N8 U' o$ `! k, Q4 b! F方法3：下面的方法
/ G9 O, C( S. _' J, H( s( R
2 }3 y& e2 A2 E0 L6 \

1. if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK)
   1 k6 ~- p& `+ T
2. {
   
3.     Error_Handler();
   
4. }  
   
5. if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
   
6. {
   % l0 N% |# a! z2 B
7.     Error_Handler();
   7 z) C' h. ], b, ~) }  O! g
8. }

复制代码

3 O1 o* [  k2 ?8 S  T9 }使用举例：

1. SPI_HandleTypeDef hspi = {0};
   ; c% L2 O- A% b2 {7 d( s' Q! j
2. 
   
3. /* 设置SPI参数 */
   
4. hspi.Instance               = SPIx;                   /* 例化SPI */
   
5. hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
   
6. hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
   + o$ o) s) Z+ r3 s9 b+ _
7. hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
   $ j/ G+ i# c/ g2 x  R3 N7 d5 k
8. hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
   , f9 s& N8 b( u1 _: e
9. hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
   
10. hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    
11. hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    
12. hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;      /* 禁止CRC */
    3 n, B8 u4 F# o* b# g
13. hspi.Init.CRCPolynomial     = 7;                               /* 禁止CRC后，此位无效 */
    
14. hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;             /* 禁止CRC后，此位无效 */
    
15. hspi.Init.NSS               = SPI_NSS_SOFT;                    /* 使用软件方式管理片选引脚 */
    7 \3 q* v& E7 t8 J; }
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相关引脚保持当前状态 */  
    . H% _$ o# P4 |4 B
19. hspi.Init.Mode                  = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    - B7 Y# G, R: G8 O$ V
20. 
    2 Z- D" m2 w& Y: `( l3 Y' h3 b
21. if (HAL_SPI_Init(&hspi) != HAL_OK)
    
22. {
    # e6 e, Z7 n' K5 {8 t; v
23.     Error_Handler(__FILE__, __LINE__);
    
24. }

复制代码

, K3 y' V0 B( Y$ q4 R2 S. {. X, n72.4.2 函数HAL_SPI_DeInit
函数原型：

9 N  I( h# @; [4 p; C- k

1. HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
   
2. {
   
3. /* 检测SPI句柄是否有效 */
   
4.   if (hspi == NULL)
   : B/ d8 w7 s' `  Z; W- K8 S
5.   {
   . n+ L- `5 a) M; y
6.     return HAL_ERROR;
   
7.   }
   
8. 
   % G) D& U6 H: `. s) o
9. /* 检查SPI例化参数 */
   / F: X% H5 ^) Y2 l5 g2 d& }
10.   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
    - o8 k6 s& c  p/ y) i
11. 
    7 I" J- M* t( Y
12.   hspi->State = HAL_SPI_STATE_BUSY;
    
13. 
    
14.   /* 禁止SPI外设时钟 */
    
15.   __HAL_SPI_DISABLE(hspi);
    # o& `1 T7 E: q9 @3 O+ ]4 i/ Y
16. 
    1 W' c! x5 `% R
17. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
18.   if (hspi->MspDeInitCallback == NULL)
    
19.   {
    
20.     hspi->MspDeInitCallback = HAL_SPI_MspDeInit;
    2 k% X. B2 B7 G1 N5 F0 K7 h3 d
21.   }
    & k# D0 d5 i  b* m
22. 
    
23.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    
24.   hspi->MspDeInitCallback(hspi);
    ( i8 w' A  l4 P  M# A2 j" ~) @! Z
25. #else
    
26.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    
27.   HAL_SPI_MspDeInit(hspi);
    
28. #endif
    
29. 
    
30.   /* 设置无错误，复位状态标记 */
    
31.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
    
32.   hspi->State = HAL_SPI_STATE_RESET;
    
33. 
    : T( w& L0 n. P" s9 h( L0 x3 R" n
34.   /* 解锁SPI */
    ( v2 G" n' R# I7 s/ O7 @2 T
35.   __HAL_UNLOCK(hspi);
    # H( R" ~. f  g, u2 a( D
36. 
    - \  U$ |' X: ~2 S$ L6 M" e/ u
37.   return HAL_OK;
    
38. }

复制代码

: ?  r$ V7 r( z函数描述：
. ^# ~; A9 e+ |
用于复位SPI总线初始化。
4 u( y/ z. {7 f6 q* J
函数参数：

  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中
' I$ n3 t# g/ x) ?4 @( m72.4.3 函数HAL_SPI_TransmitReceive
& \9 T% L* W. Y# P" L5 k; v函数原型：
9 _* J" p% K/ E4 Y$ |. N: L
: L% N# ~1 ]2 x/ `$ O2 u0 I- q

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
   
2. {
   
3. 
   + |6 D, e+ U. C& G& I) s$ Q
4.    /* 省略未写 */
   $ q2 Y" z' n: V9 C; @
5. 
   . r5 m) k- c* O
6.   /* 大于16bit的数据收发 */
   : T( w) _; |* @; G
7.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
   2 C6 ^+ Y7 s7 V8 Y/ e
8.   {
   
9.        /* 省略未写 */
   
10.   }
    
11.   /* 大于8bit，小于16bi的数据收发 */
    : B' V/ K4 d$ m& I* p  ?& d; m
12.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
      @$ c+ r, R! I; M/ P# J# Y
13.   {
    
14.       /* 省略未写 */
    , C' k6 m! g/ V3 O
15.   }
    
16.   /* 小于等于8bit的数据收发 */
    ; e. k5 D6 t0 _2 P
17.   else
    0 C# R1 g4 O" V& F" f
18.   {
    
19.        /* 省略未写 */
    ( D' x+ T3 k" F2 Y4 G
20.   }
    
21. 
    
22. }
    

复制代码

( y: y- h# y8 \! J
% m: A# i5 w% V- t& t% @函数描述：

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

函数参数：

" S6 m0 Y2 m4 j0 e$ E$ G  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
  第5个参数是传输过程的溢出时间，单位ms。
, {0 k. i+ c( `+ j, W1 {! n8 @  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

: S% j' V7 m7 u$ `3 Y8 ?# h' O! Q& P

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   # m% E: [, |  p! K+ [7 x3 \
3. if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)
   & Q# `* Y8 Q/ t
4. {
   
5.     Error_Handler(__FILE__, __LINE__);
   
6. }

复制代码

72.4.4 函数HAL_SPI_TransmitReceive_IT
$ O  D; C8 e: t5 r函数原型：
$ }* z- Z6 f' }! t9 {$ q
8 b) _. y6 B/ b' P  v  ~2 [

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
   
2. {
   4 l! D* r( S) ^8 I( i: e
3.    /* 省略未写 */
   
4. 
   
5.   /* 设置传输参数 */
   * q5 V" p: T4 M$ u4 J
6.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   * F$ Q) |8 Q, t, l
7.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
   0 x" @* C) O0 N3 _
8.   hspi->TxXferSize  = Size;
   
9.   hspi->TxXferCount = Size;
   
10.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
    
11.   hspi->RxXferSize  = Size;
    : _$ r" X- c4 g* F
12.   hspi->RxXferCount = Size;
    
13. 
    " ~0 W3 `" X4 j' b) b
14.   /* 设置中断处理 */
    6 V) e$ F7 Y9 V& B3 h6 n
15.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    
16.   {
    / L9 Q$ t5 d# h# h; `" u
17.     hspi->TxISR     = SPI_TxISR_32BIT;
    
18.     hspi->RxISR     = SPI_RxISR_32BIT;
    
19.   }
    
20.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    ) G2 B% h' {+ Z
21.   {
    ( w* y% o! u- M8 y+ d5 F$ W0 T
22.     hspi->RxISR     = SPI_RxISR_16BIT;
    
23.     hspi->TxISR     = SPI_TxISR_16BIT;
    * d, J/ H( y" F/ r
24.   }
    
25.   else
      x1 \& C8 }: t8 l' d' P# b
26.   {
    
27.     hspi->RxISR     = SPI_RxISR_8BIT;
    
28.     hspi->TxISR     = SPI_TxISR_8BIT;
    * M: p/ q( p( c% c- Y
29.   }
    
30. 
    - m, h( K( Y  x5 f) Y4 ]. G  B
31.   /* 设置当前传输数据大小 */
    6 W' T5 {% E% P: y
32.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    6 L% |) x3 F. n! B& k
33. 
    # N/ A$ R! Q( k' w1 {: x
34.   /* 使能SPI外设 */
    
35.   __HAL_SPI_ENABLE(hspi);
    
36. 
    
37.   /* 使能各种中断标志 */
    : V8 o7 a; t2 @  ]4 Y2 Q, z
38.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_EOT | SPI_IT_RXP | SPI_IT_TXP | SPI_IT_DXP | SPI_IT_UDR | SPI_IT_OVR |
    + z1 Y2 u, {, k; w
39. SPI_IT_FRE | SPI_IT_MODF | SPI_IT_TSERF));
    ; @! P; O$ w4 X3 \8 \, s3 M
40. 
    
41.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    4 n# l  {! a; @
42.   {
    
43.     /* 启动传输 */
    ; }. |# B' N& q8 U4 C+ ^7 [/ a6 c, j9 _
44.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
    8 s! m  A7 @1 Y
45.   }
    ' u/ C% i: f' }, ~4 \: ~1 E6 u
46. 
    9 V1 s" p- Y" k
47.   /* 解锁 */
    " g! F8 z- Z0 U0 W4 L5 L
48.   __HAL_UNLOCK(hspi);
    4 C+ P( ]! v% z1 t: h, {
49.   return errorcode;
    $ Z0 Q0 a% d1 X7 Y5 \: e
50. }

复制代码

; l5 U) o$ w$ M6 v& @* ]! z
: W* Q! n1 G3 |7 v
. u/ z7 \) |% Q: |8 [函数描述：

0 S& H9 i) d: W% Q( n3 }: |此函数主要用于SPI数据收发，全双工中断方式。
7 a. O( ?" y& P1 `9 w# Z! R
" e1 l8 x- O# B# B5 w$ ~/ K- c1 h函数参数：
8 M8 C; P1 C' o7 g5 V$ u
. S% q0 O. g9 P# T, c  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
4 Q* L' |( \5 m7 c) Y8 k  第3个参数是接收数据缓冲地址。
" E( O, s! K& j% D! a  第4个参数是传输的数据大小，单位字节个数。
0 \; O  r) C! {5 j/ ?% R" _/ R  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
  M" z6 T% F6 E' |; X. `使用举例：
" f- ~) i/ T, J; J$ N  Q8 N

1. SPI_HandleTypeDef hspi = {0};
   / ~) T7 J. m+ {- g) H! v3 [
2. 
   4 s1 ?6 Y8 u( N- u1 n
3. if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   
4. {
   
5.     Error_Handler(__FILE__, __LINE__);
   ! }- R$ P# T, J1 \- h8 L( i( f& t- E
6. }
   
7. 
   
8. 
   $ _( A: ?3 v" Z$ ^$ D* P
9. 72.4.5 函数HAL_SPI_TransmitReceive_DMA
   
10. 函数原型：
    
11. 
    
12. HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,
    
13.                                               uint16_t Size)
    ! j% _6 X# @8 T9 @
14. {
      M/ U; S+ _- \$ h% e- P) g* x+ ]2 ?
15.    /* 省略未写 */
    3 |/ ], y1 p8 C3 ~: a' l" |: i, j
16. 
    ( `* X' }" H( ~/ ~: T% c, P% q
17. /* 注意DMA的位宽和对齐设置 */
    3 w) u# a( e: c
18.   if (((hspi->Init.DataSize > SPI_DATASIZE_16BIT) && (hspi->hdmarx->Init.MemDataAlignment !=
    
19. DMA_MDATAALIGN_WORD))  ||
    3 T9 z# u- k$ f9 p7 l9 C
20.       ((hspi->Init.DataSize > SPI_DATASIZE_8BIT) && ((hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_HALFWORD) && (hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_WORD))))
    * X) b/ l7 F: [: v
21.   {
    
22.   }
    
23. 
    + T: B7 P# B$ u' y5 |
24. /* 调整DMA对齐和数据大小 */
    
25.   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)
    . u7 q1 ]1 m5 D' r' J% L
26.   {
    8 B8 W4 d& w9 f! y+ k0 k, }
27.      /* 省略未写 */
    
28.   }
    
29.   else if (hspi->Init.DataSize <= SPI_DATASIZE_16BIT)
    
30.   {
    
31.      /* 省略未写 */
    
32.   }
    
33.   else
    
34.   {
    
35.       /* 省略未写 */
    
36.   }
    3 L4 r4 l& H& e$ b) d
37. 
    - x8 W; r/ g. \
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.   {
    ; ~' m, Z8 A' ]( W
42. 
    
43.   }
    . ~/ Z/ H- z  ]' m! G% ]/ l, D3 w
44. 
    
45. /* DMA发送配置 */
    ! Y$ r) w( @" |  L  }" v/ v( R
46.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->TXDR,
      l# E% y9 Y1 z) Z: `2 n
47. hspi->TxXferCount))
      O& G/ O1 h' U* f1 Y; {, M: \
48.   {
    ( M5 H( b' Q2 L) C0 D
49.   }
    ! U- C2 Q. j3 C- o
50. 
    
51.   /* 省略未写 */
    , {: H+ H4 E  {+ p( }' O3 C
52. }
    9 F: V0 d1 |) a- q

复制代码

函数描述：

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

函数参数：
2 k/ P0 P8 \: i, L& S
% _4 B6 U: x* n4 A' `% d; f  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  Z0 K5 q; J4 ?/ L2 L  第2个参数是发送数据缓冲地址。
$ T  v# f! o9 n% Z  g2 r' y  第3个参数是接收数据缓冲地址。
4 x2 f5 q% ?6 J( b4 q$ X' K7 |  第4个参数是传输的数据大小，单位字节个数。
3 n8 x$ o5 p; A! y5 `  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
$ y4 a2 G" b: P4 `$ D3 z使用举例：

1. SPI_HandleTypeDef hspi = {0};
   9 `4 K7 `/ U! c- Z
2. 
   
3. if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   
4. {
   : [3 e' _7 B' C+ m
5.     Error_Handler(__FILE__, __LINE__);
   
6. }

复制代码

% s2 s( X3 f/ Y; S. Q

8 I' x/ B4 {1 x72.5 总结
0 }$ w; T4 M9 z  C, f" w% }0 g0 d本章节就为大家讲解这么多，要熟练掌握SPI总线的查询，中断和DMA方式的实现，因为基于SPI接口的外设芯片很多，熟练后，可以方便的驱动各种SPI接口芯片，以便选择合适的驱动方式。
/ @$ }' v5 G( H' R