72.1 初学者重要提示
) I3 T1 W% ?  K2 }, X4 g6 B  STM32H7的SPI支持4到32bit数据传输，而STM32F1和F4系列仅支持8bit或者16bit。
* e7 R. O% H" X& K5 m- i( t9 P  STM32H7的主频400MHz时，SPI1, 2, 3最高通信时钟是100MHz，而SPI4, 5, 6是50MHz。
5 X1 L+ U; N- I8 t& k) r; r2 Y  STM32H7的MISO和MOSI引脚功能可以互换，使用比较灵活。
2 S4 L+ \7 [/ S+ V  SPI总线的片选引脚SS在单一的主从器件配置下是可选的，一般情况下可以不使用。
8 V5 Y: O9 l3 u6 ~
: ?1 m: D* w# o& K( a72.2 SPI总线基础知识
72.2.1 SPI总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SPI的基本功能，然后再看手册了解细节。

! G1 j; o/ T9 v" F

. B) P+ L* f7 K/ }$ D
/ Q1 ], N7 l1 R7 l5 ?' C通过这个框图，我们可以得到如下信息：
  spi_wkup输出

低功耗唤醒信号。
8 `' t1 C3 t  q  spi_it输出

; T# B; I4 ^4 W7 g" e4 d
spi的中断请求信号。
6 v9 x: h4 u3 N/ n  spi_tx_dma
1 ?  V: b' O  H; M/ |; Y  spi_rx_dma


" e! N$ J4 I5 n! N) ]$ n9 ?, i* ^spi的DMA发送和接收请求信号。
  spi_pclk

8 X7 R6 l' p1 L- d
# v. G/ g  n. T6 w为寄存器提供时钟。
  spi_ker_ck
( q- A  P7 }* m/ m' m
$ K0 h3 ~' C) g# Z5 p3 n8 d. r; w
, n8 L8 Y, `5 x# I/ J6 k7 |为spi内核时钟。
- p4 O0 O5 W6 G2 S  SCK（CK），Serial Clock
6 b/ z! c$ l  i: E

此引脚在主机模式下用于时钟输出，从机模式下用于时钟输入。
  MISO（SDI），Master In / Slave Out data


/ M' p, W  J- z" I) ?" d4 w* C此引脚在从机模式下用于发送数据，主机模式下接收数据。
  MOSI（SDO）, Master Out / Slave In data

" [2 C1 L1 @8 ]: Y& a! \
此引脚在从机模式下用于数据接收，主机模式下发送数据。
7 W% {. M2 ^: k9 H! s8 r0 m4 X; `  SS（WS）, Slave select pin


根据SPI和SS设置，此引脚可用于：
- A; S: H- F! ?  E- ha. 选择三个从器件进行通信。

4 d2 b. Z2 a& \2 j* y7 |b. 同步数据帧。
. s' p2 K; K/ l0 J0 y2 w+ B& p. T5 B
4 Z4 M8 E, {# e  i, z7 sc. 检测多个主器件之间是否存在冲突。

通过这个框图还要认识到一点，SPI有三个时钟域，分别是寄存器所在的ABP总线时钟域，内核时钟发生器时钟域以及内核时钟发生器分频后的串行时钟域。

72.2.2 SPI接口的区别和时钟源（SPI1到SPI6）
这个知识点在初学的时候容易忽视，所以我们这里整理下。
SPI1到SPI6的区别
. e9 Z& [3 f# `" s9 z" @  SPI1，SPI2和SPI3支持4到32bit数据传输，SPI4，SPI5和SPI6是4到16bit数据传输。
4 c9 ?$ _8 o0 Y" }* U, T  SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit。

  SPI1到SPI6的所在的总线（对应SPI框图的SPI_CLK时钟域）

- F) N" }8 `; ~: C* G" p1 N/ M
3 R' y' m$ S3 PSPI1，SPI4和SPI5在APB2总线，SPI2，SPI3在APB1总线，SPI6在APB4总线。注意，SPI的最高时钟不是由这些总线决定的。

+ b2 u; R1 s0 e, S" p! Y6 h, q% q  SPI1到SPI6的支持的最高时钟（对应SPI框图的SPI_KER_CK）
( l  f+ n3 q4 s9 C( Z! G' f
, d! C% {: j: u! B* a& e$ k
1 T# T& v4 w: \$ {0 ~; \STM32H7主频在400MHz下，SPI1，SPI2和SPI3的最高时钟是200MHz，而SPI4,5,6是100MHz, 以SPI1为了，可以选择的时钟源如下：
, Z9 K5 H( n0 X( [4 h* G0 l
9 J' l1 {8 K( Z$ Z" g

0 {; K, K! r* e/ j5 D, N" x
这里特别注意一点，SPI工作时最少选择二分频，也就是说SPI1,2,3实际通信时钟是100MHz，而SPI4,5,6是50MHz。
3 J( d% u  b' \& f
% V# _  M, [9 h* D6 E$ \- m$ n72.2.3 SPI总线全双工，单工和半双工通信
; \# H6 H; O! S  J8 X, e6 k: @; x9 l片选信号SS在单一的主从器件配置下是可选的，一般情况下可以不使用。但需要同步数据流，或者用于TI模式时需要此信号。
, a* r& |2 A5 M, p: G& @5 ?! D( T
9 |4 n4 Q, y) ?7 I0 F( s  全双工通信
: T( D5 N4 w: _# F. R2 S全双工就是主从器件之间同时互传数据，SPI总线的全双工模式接线方式如下：

( \9 |' M3 y4 h/ H* y/ u

! W3 N$ [; c7 ~关于这个接线图要认识到以下几点：
  注意接线方式，对于主器件来说MISO引脚就是输入端，从器件的MISO是输出端，即Master In / Slave Out data。MOSI也是同样道理。
3 s5 q/ y* }8 Y1 q+ Y5 v6 _+ t  每个时钟信号SCK的作用了，主器件的MISO引脚接收1个bit数据，MOSI引脚输出1个bit数据。
  这种单一的主从接线模式下，SS引脚可以不使用。

/ J; n7 _  f' b半双工通信
半双工就是同一个时刻只能为一个方向传输数据，SPI总线的半工模式接线方式如下：
1 z. E" |! W# b

- X& ^5 G# h  n9 c' Q0 n: j
关于这个接线图要认识到以下几点：
2 n  s; A# t& U! C- h7 M# ^
  更改通信方式时，要先禁止SPI。
1 W: m* X+ _% J' g# I  主器件的MISO和从器件的MISO不使用，可以继续用作标准GPIO。
2 S/ ?" ?+ G/ r7 c6 H" a  1KΩ的接线电阻很有必要，因为当主器件和从器件的通信方向不是同步变化时，容易出现其中一个输出低电平，另一个输出高电平，造成短路。
  这种单一的主从接线模式下，SS引脚可以不使用。
0 I5 _- f4 X2 q7 T% T# c6 N" G  
单工模式
单工就是只有一种通信方向，即发送或者接收，SPI总线的全双工模式接线方式如下：

8 |( o6 Z: H( l! L) I; ?+ C
关于这个接线图要认识到以下几点：

  未用到的MOSI或者MISO可以用作标准GPIO。
' Z- `  i- q  }  {; E- K5 J  这种单一的主从接线模式下，SS引脚可以不使用。
6 H" H0 j! f; _" T
* Y) Q" t# F% z* T$ n- t72.2.4 SPI总线星型拓扑
# }+ n7 v) w: WSPI总线星型拓扑用到的地方比较多，V7开发板就是用的星型拓扑外接多种SPI器件：

8 @/ u$ s, e: N3 f1 X& x7 X

' k5 y# V9 j' p7 p3 P
2 ~4 \3 M* ]% s4 w& l  E; @关于这个接线图，有以下几点需要大家了解：

  主器件的SS引脚不使用，使用通用GPIO控制。为每个器件配一个SS引脚，方便单独片选控制。
  从器件的MISO引脚要配置为复用开漏输出（很多外部芯片在未片选时，数据引脚是呈现高阻态）。

# {+ V: N: H& B* D# a- B+ H
72.2.5 SPI总线通信格式
0 b1 d3 i: l# [+ y* BSPI总线主要有四种通信格式，由CPOL时钟极性和CPHA时钟相位控制：

3 l. b8 _3 K# X% q( D

四种通信格式如下：
4 D4 b) `1 G) X% g  当CPOL = 1， CPHA = 1时

, A9 a2 E) k  Q# c& g
/ F0 b8 A7 R/ M1 j2 M, d. ^SCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
  当CPOL = 0， CPHA = 1时

' V5 A0 X" A" j7 Q; A; U' B
SCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。
. f% _5 f6 t' f8 k, v: Z  当CPOL = 1， CPHA = 0时

- x/ V( A! z; N! c
SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。
  当CPOL = 1， CPHA = 0时


SCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。

72.3 SPI总线的HAL库用法
72.3.1 SPI总线结构体SPI_TypeDef
9 v( g- }- `6 P, ~# R$ h; @2 B; xSPI总线相关的寄存器是通过HAL库中的结构体SPI_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
7 J! X( {, q0 H
" C) o( z' W8 Q  J$ f* d' o# M

1. typedef struct
   
2. {
   $ g% S) V5 e7 F- n, K
3.   __IO uint32_t CR1;           /*!< SPI/I2S Control register 1,                      Address offset: 0x00 */
   , S2 J  ?1 ~6 H: R
4.   __IO uint32_t CR2;           /*!< SPI Control register 2,                          Address offset: 0x04 */
   . b6 b! B4 |# w" d% m+ \! s
5.   __IO uint32_t CFG1;          /*!< SPI Configuration register 1,                    Address offset: 0x08 */
   % _; K# L0 O8 _4 i
6.   __IO uint32_t CFG2;          /*!< SPI Configuration register 2,                    Address offset: 0x0C */
   " ?# {2 O- C$ }; j5 W. T) J
7.   __IO uint32_t IER;           /*!< SPI/I2S Interrupt Enable register,               Address offset: 0x10 */
   * Y$ G! t9 @2 o. B: g, _5 J
8.   __IO uint32_t SR;            /*!< SPI/I2S Status register,                         Address offset: 0x14 */
   $ a* ?4 Q- Y# |: _4 H+ c4 V, {  H
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 */
    5 n- }# J) O, H+ Q+ x- Q
12.   uint32_t      RESERVED1[3];  /*!< Reserved, 0x24-0x2C                                                   */
    
13.   __IO uint32_t RXDR;          /*!< SPI/I2S Receive data register,                   Address offset: 0x30 */
    ( W0 X% ]& s1 c  }6 s7 x7 H: c
14.   uint32_t      RESERVED2[3];  /*!< Reserved, 0x34-0x3C                                                   */
    
15.   __IO uint32_t CRCPOLY;       /*!< SPI CRC Polynomial register,                     Address offset: 0x40 */
    / e# u& q5 B9 V/ t) ]$ M; L' e
16.   __IO uint32_t TXCRC;         /*!< SPI Transmitter CRC register,                    Address offset: 0x44 */
    
17.   __IO uint32_t RXCRC;         /*!< SPI Receiver CRC register,                       Address offset: 0x48 */
    * V; g8 n% w" e
18.   __IO uint32_t UDRDR;         /*!< SPI Underrun data register,                      Address offset: 0x4C */
    
19.   __IO uint32_t I2SCFGR;       /*!< I2S Configuration register,                      Address offset: 0x50 */
    
20. 
    + n1 `3 k& N1 s1 `
21. } SPI_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。
( J$ o& [6 W/ R2 ]3 D$ X  Z; h5 Q
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
: y  n! i% W  J& \7 y3 {! Z

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

复制代码

' \# r- G; c: j" c+ |% o# F8 r8 u下面我们看下SPI的定义，在stm32h743xx.h文件。
" A3 m7 _% |3 ~3 u3 k

1. #define PERIPH_BASE           (0x40000000UL)
   - n; {) X& v  d) A3 z/ J
2. #define D2_APB1PERIPH_BASE     PERIPH_BASE
   % N, V/ r8 K! P8 I% U) V4 c# F
3. #define D2_APB2PERIPH_BASE    (PERIPH_BASE + 0x00010000UL)
   
4. #define D3_APB1PERIPH_BASE    (PERIPH_BASE + 0x18000000UL)
   . _6 G( M1 L7 {- y
5. 
   
6. #define SPI2_BASE             (D2_APB1PERIPH_BASE + 0x3800UL)
   
7. #define SPI3_BASE             (D2_APB1PERIPH_BASE + 0x3C00UL)
   " y8 y. X# W) L7 q
8. #define SPI1_BASE             (D2_APB2PERIPH_BASE + 0x3000UL)
   & j# W  b" ]1 W3 c+ }! I- J
9. #define SPI4_BASE             (D2_APB2PERIPH_BASE + 0x3400UL)
   0 Z; v: ~- g% J* o  s/ `' W
10. #define SPI5_BASE             (D2_APB2PERIPH_BASE + 0x5000UL)
    , F+ |& f, }; G  f( D
11. #define SPI6_BASE             (D3_APB1PERIPH_BASE + 0x1400UL)
    
12. 
    
13. #define SPI1                ((SPI_TypeDef *) SPI1_BASE)
    
14. #define SPI2                ((SPI_TypeDef *) SPI2_BASE)
    
15. #define SPI3                ((SPI_TypeDef *) SPI3_BASE)
    # j% N: C. U$ \  s9 }8 b) ?/ B
16. #define SPI4                ((SPI_TypeDef *) SPI4_BASE)
    
17. #define SPI5                ((SPI_TypeDef *) SPI5_BASE)
    
18. #define SPI6                ((SPI_TypeDef *) SPI6_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x58001400

复制代码

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

& R/ q, ^% q9 o+ p- k0 Q: \72.3.2 SPI总线初始化结构体SPI_InitTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：
4 c1 {7 N" K5 }

1. typedef struct
   + S# j* |5 Z1 O$ q3 N( ]
2. {
   ) a) Q3 m1 Z& T' u) Q7 |3 t& v
3.   uint32_t Mode;                           
   / K! P7 A$ b2 Z1 U5 z4 A
4.   uint32_t Direction;                     
     G( R4 V1 U8 K) z  T  {) t& r
5.   uint32_t DataSize;                          
   
6.   uint32_t CLKPolarity;                       
   
7.   uint32_t CLKPhase;                        
   
8.   uint32_t NSS;                             
   4 e2 c2 q8 r9 g5 P
9.   uint32_t BaudRatePrescaler;               
   & Y5 N1 A  O$ H
10.   uint32_t FirstBit;                        
    6 e  {; k- S0 \
11.   uint32_t TIMode;                          
    & K; Q8 A# `8 G4 K7 ]+ }
12.   uint32_t CRCCalculation;                  
    ) K9 P: Q. k& Q+ u, u+ g
13.   uint32_t CRCPolynomial;                     
    
14.   uint32_t CRCLength;                        
    
15.   uint32_t NSSPMode;                        
    
16.   uint32_t NSSPolarity;                    
    5 j. g: |8 \0 n4 }8 N
17.   uint32_t TxCRCInitializationPattern;      
    
18.   uint32_t RxCRCInitializationPattern;      
    
19.   uint32_t MasterSSIdleness;                 
    7 h0 i: k1 E' \/ c% S
20.   uint32_t MasterInterDataIdleness;           
    
21.   uint32_t MasterReceiverAutoSusp;         
    , X% l; \' {0 M3 N2 c5 ~$ X9 g6 s
22.   uint32_t MasterKeepIOState;               
    ( J' l8 J0 v9 h
23.   uint32_t IOSwap;                          
    0 U/ r% r9 u& ~7 I& T
24. } SPI_InitTypeDef;

复制代码

+ m7 I! Q$ n; W" H下面将结构体成员逐一做个说明：
% r1 Y4 K% R( N  Mode
. H; V( |8 S8 d+ D
用于设置工作在主机模式还是从机模式。
2 C) {; W0 W4 `" K. p

1. #define SPI_MODE_SLAVE              (0x00000000UL)
   ' G2 e# i, q5 f7 M
2. #define SPI_MODE_MASTER             SPI_CFG2_MASTER

复制代码

  Direction
! a0 u9 _7 z# K4 A  c用于设置SPI工作在全双工，单工，还是半双工模式。

1. #define SPI_DIRECTION_2LINES           (0x00000000UL)     /* 全双工 */
   
2. #define SPI_DIRECTION_2LINES_TXONLY     SPI_CFG2_COMM_0   /* 单工，仅发送 */
   
3. #define SPI_DIRECTION_2LINES_RXONLY     SPI_CFG2_COMM_1   /* 单工，仅接收 */
   
4. #define SPI_DIRECTION_1LINE             SPI_CFG2_COMM     /* 半双工 */

复制代码

  DataSize
2 k8 Y/ c2 ~) Z' P8 c用于设置SPI总线数据收发的位宽，支持4-32bit。

9 P9 E- u/ P$ p5 G3 u, ]) _

1. #define SPI_DATASIZE_4BIT                             (0x00000003UL)
   
2. #define SPI_DATASIZE_5BIT                             (0x00000004UL)
   : j3 p  m/ o4 q& ?7 _; z) o% \
3. #define SPI_DATASIZE_6BIT                             (0x00000005UL)
   
4. #define SPI_DATASIZE_7BIT                             (0x00000006UL)
   % v. }8 q1 `+ U) x* f5 g8 D0 Y
5. #define SPI_DATASIZE_8BIT                             (0x00000007UL)
   ( u6 }/ N( |# V" _3 F6 I
6. #define SPI_DATASIZE_9BIT                             (0x00000008UL)
   # Q9 f; a" r; U6 d- d: r
7. #define SPI_DATASIZE_10BIT                            (0x00000009UL)
   9 t7 z/ b, L( h' c3 w1 A
8. #define SPI_DATASIZE_11BIT                            (0x0000000AUL)
   
9. #define SPI_DATASIZE_12BIT                            (0x0000000BUL)
   
10. #define SPI_DATASIZE_13BIT                            (0x0000000CUL)
    
11. #define SPI_DATASIZE_14BIT                            (0x0000000DUL)
    
12. #define SPI_DATASIZE_15BIT                            (0x0000000EUL)
    
13. #define SPI_DATASIZE_16BIT                            (0x0000000FUL)
    & ?! o! j, R, {5 x4 ~8 M% j. u
14. #define SPI_DATASIZE_17BIT                            (0x00000010UL)
    & \7 c2 [" ?. x4 j* w
15. #define SPI_DATASIZE_18BIT                            (0x00000011UL)
    ; p5 Y' ?) `" X8 J
16. #define SPI_DATASIZE_19BIT                            (0x00000012UL)
    
17. #define SPI_DATASIZE_20BIT                            (0x00000013UL)
    . P6 ]( Y  }# n3 y& v6 |: M
18. #define SPI_DATASIZE_21BIT                            (0x00000014UL)
    & x/ i, P4 h2 @; B  c$ \# K7 Q' G
19. #define SPI_DATASIZE_22BIT                            (0x00000015UL)
    9 U5 k& N; A( _% v2 ~
20. #define SPI_DATASIZE_23BIT                            (0x00000016UL)
    ! l& g' ^6 A9 D) r% O& g& p
21. #define SPI_DATASIZE_24BIT                            (0x00000017UL)
    
22. #define SPI_DATASIZE_25BIT                            (0x00000018UL)
    ) L' l% D, D* l' x( r5 ~% D% Z
23. #define SPI_DATASIZE_26BIT                            (0x00000019UL)
    " L2 M) |; ~, _) `# q3 ?
24. #define SPI_DATASIZE_27BIT                            (0x0000001AUL)
    
25. #define SPI_DATASIZE_28BIT                            (0x0000001BUL)
    : }# u8 C) I3 J
26. #define SPI_DATASIZE_29BIT                            (0x0000001CUL)
    ! Q9 P% R* E' S1 U! _: a0 K; X
27. #define SPI_DATASIZE_30BIT                            (0x0000001DUL)
    , a5 u) k9 L. [5 i/ N% _
28. #define SPI_DATASIZE_31BIT                            (0x0000001EUL)
    
29. #define SPI_DATASIZE_32BIT                            (0x0000001FUL)
    ( x: e# x4 R6 W* P- x

复制代码

& M' l5 E+ n1 I1 y
  CLKPolarity
用于设置空闲状态时，CLK是高电平还是低电平。

1. #define SPI_POLARITY_LOW       (0x00000000UL)
   2 `6 J* f- T4 S
2. #define SPI_POLARITY_HIGH      SPI_CFG2_CPOL

复制代码

( A" @; M; U6 n# q( g1 Z6 P  NSS
2 k: p# \  S+ o/ C. c+ f$ {3 U0 a5 s用于设置NSS信号由硬件NSS引脚管理或者软件SSI位管理。

1. #define SPI_NSS_SOFT                                  SPI_CFG2_SSM
   
2. #define SPI_NSS_HARD_INPUT                            (0x00000000UL)
   9 S" Q) |, y9 |* }, W$ e- _2 ~1 M
3. #define SPI_NSS_HARD_OUTPUT                           SPI_CFG2_SSOE

复制代码

  BaudRatePrescaler
3 i7 a* p! H  ]( s/ }8 C' S6 w用于设置SPI时钟分频，仅SPI工作在主控模式下起作用，对SPI从机模式不起作用。

1. #define SPI_BAUDRATEPRESCALER_2                       (0x00000000UL)
   
2. #define SPI_BAUDRATEPRESCALER_4                       (0x10000000UL)
   1 e5 j( |' k3 w; D# c
3. #define SPI_BAUDRATEPRESCALER_8                       (0x20000000UL)
   ) v/ e: ]6 {& X. S9 C. j0 H. _3 y
4. #define SPI_BAUDRATEPRESCALER_16                      (0x30000000UL)
   
5. #define SPI_BAUDRATEPRESCALER_32                      (0x40000000UL)
   $ T6 j0 h" x) L3 X: n5 s4 g
6. #define SPI_BAUDRATEPRESCALER_64                      (0x50000000UL)
   
7. #define SPI_BAUDRATEPRESCALER_128                     (0x60000000UL)
   7 Y2 n! c7 S8 ~) q: L6 U, N
8. #define SPI_BAUDRATEPRESCALER_256                     (0x70000000UL)

复制代码

  FirstBit
" a! c/ d1 o0 M. O用于设置数据传输从最高bit开始还是从最低bit开始。
9 i% I+ J( a. R, R8 V. Z$ k

1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
   ! Q% `- b* [, N' r2 c0 N
2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST

复制代码

  TIMode
; _% r  v; c% X用于设置是否使能SPI总线的TI模式。

1. #define SPI_TIMODE_DISABLE               (0x00000000UL)
   ! ?  v: ]( ]9 N* |7 G5 A" Y
2. #define SPI_TIMODE_ENABLE                SPI_CFG2_SP_0

复制代码

, g8 T. S$ \4 k! Y  CRCCalculation
4 Z. s9 c: ?6 n用于设置是否使能CRC计算。

1. #define SPI_CRCCALCULATION_DISABLE                    (0x00000000UL)
   ) h3 J2 }2 I% Q' c
2. #define SPI_CRCCALCULATION_ENABLE                     SPI_CFG1_CRCEN

复制代码

$ ~, I* G& {7 l+ ?$ z# k0 g, ^5 X" i9 |  CRCPolynomial
# N. v& g. H4 e; F用于设置CRC计算使用的多项式，必须是奇数，范围0到65535。

  CRCLength
用于设置CRC计算时的CRC长度。大小要与同属此结构体的DataSize一致。或是DataSize的整数倍。

1. #define SPI_CRC_LENGTH_DATASIZE                       (0x00000000UL)
   
2. #define SPI_CRC_LENGTH_4BIT                           (0x00030000UL)
   
3. #define SPI_CRC_LENGTH_5BIT                           (0x00040000UL)
   1 k4 K3 f+ w1 P3 g$ k2 v
4. #define SPI_CRC_LENGTH_6BIT                           (0x00050000UL)
   . U, |7 r( y! |4 p! z! W( _
5. #define SPI_CRC_LENGTH_7BIT                           (0x00060000UL)
   7 D$ y( C& V9 @; U' {
6. #define SPI_CRC_LENGTH_8BIT                           (0x00070000UL)
   $ G0 o, S7 M3 Y# G1 j" d
7. #define SPI_CRC_LENGTH_9BIT                           (0x00080000UL)
   
8. #define SPI_CRC_LENGTH_10BIT                          (0x00090000UL)
   
9. #define SPI_CRC_LENGTH_11BIT                          (0x000A0000UL)
   
10. #define SPI_CRC_LENGTH_12BIT                          (0x000B0000UL)
    
11. #define SPI_CRC_LENGTH_13BIT                          (0x000C0000UL)
    ; @1 p4 _  Y0 i5 s0 Q1 H2 }$ j
12. #define SPI_CRC_LENGTH_14BIT                          (0x000D0000UL)
    3 R; `% V4 ^/ I( @8 k! y
13. #define SPI_CRC_LENGTH_15BIT                          (0x000E0000UL)
    
14. #define SPI_CRC_LENGTH_16BIT                          (0x000F0000UL)
    
15. #define SPI_CRC_LENGTH_17BIT                          (0x00100000UL)
    
16. #define SPI_CRC_LENGTH_18BIT                          (0x00110000UL)
    
17. #define SPI_CRC_LENGTH_19BIT                          (0x00120000UL)
    " Q* e, x. Z! `  m
18. #define SPI_CRC_LENGTH_20BIT                          (0x00130000UL)
    
19. #define SPI_CRC_LENGTH_21BIT                          (0x00140000UL)
    % d$ B! |7 ~% G5 h9 d6 J; j4 u
20. #define SPI_CRC_LENGTH_22BIT                          (0x00150000UL)
    / F1 r6 C: B) E* g5 v1 T$ D8 x
21. #define SPI_CRC_LENGTH_23BIT                          (0x00160000UL)
    . v& w" N0 r" v$ Y
22. #define SPI_CRC_LENGTH_24BIT                          (0x00170000UL)
    
23. #define SPI_CRC_LENGTH_25BIT                          (0x00180000UL)
    
24. #define SPI_CRC_LENGTH_26BIT                          (0x00190000UL)
    ; O) ^$ f" n% ?' y: i8 O: n; k
25. #define SPI_CRC_LENGTH_27BIT                          (0x001A0000UL)
    + J; p1 x* i" H" w, Z
26. #define SPI_CRC_LENGTH_28BIT                          (0x001B0000UL)
    
27. #define SPI_CRC_LENGTH_29BIT                          (0x001C0000UL)
    / L0 i! Q* Z# G
28. #define SPI_CRC_LENGTH_30BIT                          (0x001D0000UL)
    
29. #define SPI_CRC_LENGTH_31BIT                          (0x001E0000UL)
    
30. #define SPI_CRC_LENGTH_32BIT                          (0x001F0000UL)
    

复制代码

6 Q, h/ e& B- k/ e  NSSPMode
用于设置是否使能NSSP信号，可以通过SPIx_CR2寄存器的SSOM位使能。注意，只有配置为摩托罗拉SPI主控模式时设置此成员才有用。
- z1 b$ _+ x1 s9 f- ?

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

复制代码

  NSSPolarity
用于设置NSS引脚上的高电平或者低电平作为激活电平。
* B4 f. H6 p( x7 V" c$ w
" x: y- i4 [' K  S' S6 Z4 V

1. #define SPI_NSS_POLARITY_LOW                          (0x00000000UL)
   0 Q) o! d0 s$ q. J! @; o
2. #define SPI_NSS_POLARITY_HIGH                          SPI_CFG2_SSIOP

复制代码

# [$ h8 {8 C4 p  FifoThreshold
用于设置SPI的FIFO阀值。
2 B& C; ^5 D9 x# f4 t6 g! O
' f) k0 O# B$ r8 Q) A  W

1. #define SPI_FIFO_THRESHOLD_01DATA                     (0x00000000UL)
   ) w/ V. W* P& v+ y
2. #define SPI_FIFO_THRESHOLD_02DATA                     (0x00000020UL)
   
3. #define SPI_FIFO_THRESHOLD_03DATA                     (0x00000040UL)
   
4. #define SPI_FIFO_THRESHOLD_04DATA                     (0x00000060UL)
   # ]: x8 u9 f+ a) C  T5 G. p
5. #define SPI_FIFO_THRESHOLD_05DATA                     (0x00000080UL)
   
6. #define SPI_FIFO_THRESHOLD_06DATA                     (0x000000A0UL)
   
7. #define SPI_FIFO_THRESHOLD_07DATA                     (0x000000C0UL)
   
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)
    
12. #define SPI_FIFO_THRESHOLD_12DATA                     (0x00000160UL)
    / m; u" k- {6 D& d" v: o# W
13. #define SPI_FIFO_THRESHOLD_13DATA                     (0x00000180UL)
    
14. #define SPI_FIFO_THRESHOLD_14DATA                     (0x000001A0UL)
    - l" u1 ?, [1 P* U
15. #define SPI_FIFO_THRESHOLD_15DATA                     (0x000001C0UL)
    
16. #define SPI_FIFO_THRESHOLD_16DATA                     (0x000001E0UL)

复制代码

( D' r1 L5 l$ k2 R* s  TxCRCInitializationPattern
发送CRC初始化模式。
( b/ z$ @! ]( E0 ]- B9 ^& h2 d1 d+ l
" |0 G) ]4 o5 s4 L; m4 ]7 {8 T

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   . A( {/ M) ~" j8 C
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

  RxCRCInitializationPattern
接收CRC初始化模式
) A. H, r& U: t4 e- V

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   3 E! W& L2 ~) e$ V" x% [1 k1 a: Y
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

+ t" y. H7 k8 m4 V. \6 B7 w6 P$ H MasterSSIdleness
在主模式下插入到SS有效边沿和第一个数据开始之间的额外延迟，单位SPI时钟周期个数。

1. #define SPI_MASTER_SS_IDLENESS_00CYCLE                (0x00000000UL)
   * [% a6 d; m+ j7 v7 K; A$ T
2. #define SPI_MASTER_SS_IDLENESS_01CYCLE                (0x00000001UL)
   
3. #define SPI_MASTER_SS_IDLENESS_02CYCLE                (0x00000002UL)
   7 y6 }3 C2 y6 ?! T% a$ P# Y
4. #define SPI_MASTER_SS_IDLENESS_03CYCLE                (0x00000003UL)
   : V0 m; `1 v% A0 _% s- d
5. #define SPI_MASTER_SS_IDLENESS_04CYCLE                (0x00000004UL)
   
6. #define SPI_MASTER_SS_IDLENESS_05CYCLE                (0x00000005UL)
   . S2 s& K$ _9 x$ Z) n) y
7. #define SPI_MASTER_SS_IDLENESS_06CYCLE                (0x00000006UL)
   
8. #define SPI_MASTER_SS_IDLENESS_07CYCLE                (0x00000007UL)
     h( u5 @0 E) A0 D3 b  C' S
9. #define SPI_MASTER_SS_IDLENESS_08CYCLE                (0x00000008UL)
   
10. #define SPI_MASTER_SS_IDLENESS_09CYCLE                (0x00000009UL)
    
11. #define SPI_MASTER_SS_IDLENESS_10CYCLE                (0x0000000AUL)
    ' p% ^: g* ?8 u7 u& R
12. #define SPI_MASTER_SS_IDLENESS_11CYCLE                (0x0000000BUL)
    
13. #define SPI_MASTER_SS_IDLENESS_12CYCLE                (0x0000000CUL)
    + |3 ^5 ~/ C: d+ d" H3 d( Y
14. #define SPI_MASTER_SS_IDLENESS_13CYCLE                (0x0000000DUL)
    
15. #define SPI_MASTER_SS_IDLENESS_14CYCLE                (0x0000000EUL)
      q1 V0 _$ R; Z* \* e
16. #define SPI_MASTER_SS_IDLENESS_15CYCLE                (0x0000000FUL)
    

复制代码

  MasterInterDataIdleness
主模式下在两个连续数据帧之间插入的最小时间延迟，单位SPI时钟周期个数。

5 M9 E# F7 m. i3 S

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   7 Y/ ?# O" |7 z, `) x  ?! ?5 v2 Y4 T
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX

复制代码

0 t% O. c% S4 f& H8 E  MasterReceiverAutoSusp
用于控制主器件接收器模式下的连续 SPI 传输以及自动管理，以避免出现上溢情况。

. A& I* F( ?! `6 I

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX
   1 [! u6 V$ p( ~

复制代码

  MasterKeepIOState
7 T" s0 r8 G3 F7 p0 e  [禁止SPI后，SPI相关引脚保持当前状态，以防止出现毛刺。在从模式下，该位不应该使用。
5 @6 ~) m5 z! F

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

复制代码

- E2 s: j( u. F: V* k: c, \, Q  m  IOSwap
. s+ N1 x. y/ B0 x" ^( q4 W用于交换MISO和MOSI引脚。
3 P! V! F3 B& q- Q2 R' |
! x& `! u) G8 O. O

1. #define SPI_IO_SWAP_DISABLE                           (0x00000000UL)
   % a+ Z5 z6 J) w& a- O6 |
2. #define SPI_IO_SWAP_ENABLE                            SPI_CFG2_IOSWP

复制代码

7 K' o# T/ m* q72.3.3 SPI总线句柄结构体SPI_HandleTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：
0 A' \0 o( w, r7 i

1. typedef struct __SPI_HandleTypeDef
   
2. {
   " l$ _8 y: F8 T" s9 [
3.   SPI_TypeDef                *Instance;                 
   
4.   SPI_InitTypeDef            Init;                        
   
5.   uint8_t                    *pTxBuffPtr;                 
   6 Z4 c* V9 Z  [+ |4 w) W# T
6.   uint16_t                   TxXferSize;                  
   ) o. a, u3 H# @6 C+ G5 e) T  @3 f) A  \
7.   __IO uint16_t              TxXferCount;                  
   6 g: r6 y3 d2 |+ b1 y' D' H
8.   uint8_t                    *pRxBuffPtr;               
   
9.   uint16_t                   RxXferSize;                  
   5 x* |" }3 L' B3 C* g1 T
10.   __IO uint16_t              RxXferCount;                 
    
11.   uint32_t                   CRCSize;                     
    
12.   void (*RxISR)(struct __SPI_HandleTypeDef *hspi);      
    % |2 w. I9 B( w
13.   void (*TxISR)(struct __SPI_HandleTypeDef *hspi);        
    2 l0 |) @9 M1 z7 a5 S& ^
14.   DMA_HandleTypeDef          *hdmatx;                     
    
15.   DMA_HandleTypeDef          *hdmarx;                     
    5 @1 w" P5 W9 d. y5 Q8 d6 K4 Z
16.   HAL_LockTypeDef            Lock;                        
    
17.   __IO HAL_SPI_StateTypeDef  State;                        
    : F- U8 K6 X0 `
18.   __IO uint32_t              ErrorCode;                  
    2 q) F# x- ?) L4 z6 P
19. #if defined(USE_SPI_RELOAD_TRANSFER)
    , R1 h- h4 L0 `
20.   SPI_ReloadTypeDef          Reload;                     
    * b+ g/ j* Z- k( b
21. #endif
    
22. 
    
23. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    7 s* t. r* _4 R1 j& j
24.   void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
25.   void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
26.   void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    7 n* a" l0 F- @! w. P& S' X
27.   void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    " E9 A! Z1 C- _1 I- {3 W
28.   void (* RxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    
29.   void (* TxRxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);
    
30.   void (* ErrorCallback)(struct __SPI_HandleTypeDef *hspi);      
    - e$ x* j1 Q! b+ K9 w, s
31.   void (* AbortCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    2 _. E; k) s4 X% [, [9 I
32.   void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);   
    
33.   void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);
    
34. #endif  
    
35. } SPI_HandleTypeDef;
    

复制代码

注意事项：

条件编译USE_HAL_SPI_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

  #define   USE_HAL_SPI_REGISTER_CALLBACKS   1
7 y$ l$ t" H5 |# J
, q# @# q' G- k& M/ w通过函数HAL_SPI_RegisterCallback注册回调，取消注册使用函数HAL_SPI_UnRegisterCallback。
+ f7 Z" G, q( n+ w4 I3 f
9 T% {/ N2 Z1 A8 u- s; S" R这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。
; {  R0 p- ^: p2 Y: h3 V* h
) G8 W. L: m7 {0 ]$ p" R3 Z8 w9 a5 q  SPI_TypeDef   *Instance
这个参数是寄存器的例化，方便操作寄存器，比如使能SPI1。

SET_BIT(SPI1 ->CR1,  SPI_CR1_SPE)。
; T8 E1 B' b0 y7 N! x7 [1 N
  SPI_InitTypeDef  Init
这个参数是用户接触最多的，在本章节3.2小节已经进行了详细说明。

9 ^- R# N& B! A2 U& B7 i& P# x  DMA_HandleTypeDef          *hdmatx               
  DMA_HandleTypeDef          *hdmarx
用于SPI句柄关联DMA句柄，方便操作调用。
& K( `! x( ~5 l+ T: D( A) W6 a* z
72.4 SPI总线源文件stm32h7xx_hal_spi.c
% {1 d/ L& _4 Z+ M' T0 y此文件涉及到的函数较多，这里把几个常用的函数做个说明：
' e& E! f- l! s
  HAL_SPI_Init
  HAL_SPI_DeInit
  HAL_SPI_TransmitReceive
% v, }# _/ l/ A2 w& Y  HAL_SPI_TransmitReceive_IT
" W1 d" C5 U. d% E) P  @* c' K  HAL_SPI_TransmitReceive_DMA

0 c7 k; g5 ?8 S72.4.1 函数HAL_SPI_Init
函数原型：

0 W- M2 I5 W8 u/ m+ g! x

1. HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
   7 n2 j* e; S$ W- Z2 [8 c1 R7 A% s, w
2. {
   
3.   uint32_t crc_length = 0UL;
   
4.   uint32_t packet_length;
   
5. 
   
6.   /* 省略未写 */
   $ n2 O  n$ n' ^0 e! k* h
7. 
   # L$ G* q) ~% b8 x# y
8.   /* 如果数据位宽大于16bit，必须是SPI1，SPI2或者SPI3，而SPI4，SPI5和SPI6不支持大于16bit */
   % ]+ J9 s9 j- k$ D+ s
9.   if ((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (hspi->Init.DataSize > SPI_DATASIZE_16BIT))
   
10.   {
    
11.     return HAL_ERROR;
    
12.   }
    
13. 
    
14.   /* SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit
    
15.      这里是查看设置的缓冲大小是否超出了FIFO支持的大小。
    4 `9 |# J  ^, L% X5 y; R
16. */
    0 X9 I0 k# b/ E& }' L& |$ U' v$ b
17.   packet_length = SPI_GetPacketSize(hspi);
    
18.   if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_LOWEND_FIFO_SIZE)) ||
    ( M" S6 Y3 ^8 L4 T3 V
19.       ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_HIGHEND_FIFO_SIZE)))
    1 ]6 V6 Q* d% d! |: C
20.   {
    
21.     return HAL_ERROR;
    6 ]1 a7 J& S$ I8 }- ]8 y* _7 I
22.   }
    
23. 
    
24. #if (USE_SPI_CRC != 0UL)
    ) n7 W9 ^% ^, ]4 ~
25.     /* 省略未写 */
    9 n. V3 r+ b: g, q
26. #endif
    
27. 
    
28.   if (hspi->State == HAL_SPI_STATE_RESET)
    
29.   {
    + R9 P4 v$ t! O# U8 A, w
30.     /* 解锁 */
    * M- B; w# J8 t
31.     hspi->Lock = HAL_UNLOCKED;
    
32. 
    . |* s* x: a" s; I. K& ]
33.     /* 使用自定义回调 */
    
34. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
35.     /* 设置默认回调函数 */
    
36.     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */
    2 g2 v( `+ E9 D. ]
37.     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */
    
38.     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */
    ! g+ D% q' O: A( E
39.     hspi->TxHalfCpltCallback   = HAL_SPI_TxHalfCpltCallback;   /* Legacy weak TxHalfCpltCallback   */
    
40.     hspi->RxHalfCpltCallback   = HAL_SPI_RxHalfCpltCallback;   /* Legacy weak RxHalfCpltCallback   */
    
41.     hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */
    
42.     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */
    
43.     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */
    
44. 
    & L1 n$ C* Q4 x8 ]
45.     if (hspi->MspInitCallback == NULL)
      r4 c2 ~" z% r) j  ?  y
46.     {
    / E6 h, `  d8 H; k7 t) @
47.       hspi->MspInitCallback = HAL_SPI_MspInit;
    - Z- P  j  @, ]) V4 ~
48.     }
    
49. 
    % h0 ?* I! R9 k; e8 ~/ q4 K/ e
50.     /* 初始化地址硬件: GPIO, CLOCK, NVIC... */
    
51.     hspi->MspInitCallback(hspi);
    
52. #else
      Y0 X8 w9 A& ~- Y
53.     /* 初始化底层硬件: GPIO, CLOCK, NVIC... */
    
54.     HAL_SPI_MspInit(hspi);
    
55. #endif
    
56.   }
    # ]% E, f$ g% z7 i; A* c
57. 
    
58.   hspi->State = HAL_SPI_STATE_BUSY;
    ! }5 U7 u; E* O+ g7 f
59. 
    7 i, X( D1 E4 r" g) B9 X8 K
60.   /* 禁止SPI外设 */
    
61.   __HAL_SPI_DISABLE(hspi);
    4 g2 v: y1 w# E
62. 
    ( \0 v+ ^% D) {- W& |
63.   /*----------------------- SPIx CR1 & CR2 配置---------------------*/
    . d% q: H& Z* Y7 {
64.   if ((hspi->Init.NSS == SPI_NSS_SOFT) && (hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.NSSPolarity ==
    / O1 ~; y  {) V' e) i/ Y1 w
65. SPI_NSS_POLARITY_LOW))
    
66.   {
    
67.       SET_BIT(hspi->Instance->CR1, SPI_CR1_SSI);
    8 I3 U* P8 P' z+ S3 A; g* w
68.   }
    
69. 
    
70.   /* SPIx CFG1配置 */
    
71.   WRITE_REG(hspi->Instance->CFG1, (hspi->Init.BaudRatePrescaler | hspi->Init.CRCCalculation | crc_length |
    + O3 h( |" q( q# d( O( a
72.                                    hspi->Init.FifoThreshold     | hspi->Init.DataSize));
    
73. 
    
74.   /* SPIx CFG2配置 */
    , h9 n8 H8 L* b! {. v- w' F9 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     |
    $ f0 X0 \$ p# L3 ~, {8 i% c) X
77.                                    hspi->Init.FirstBit     | hspi->Init.Mode             | hspi->Init.MasterInterDataIdleness |
    
78.                                    hspi->Init.Direction    | hspi->Init.MasterSSIdleness | hspi->Init.IOSwap));
    3 s5 u; l5 h4 i3 i  u" q  t  w
79. 
    0 E# J7 ?( X' o" T
80. #if (USE_SPI_CRC != 0UL)
    5 V+ P2 g" n1 [7 N5 N5 A1 b
81.   /*---------------------------- SPIx CRC配置 ------------------*/
    
82.   /* 配置SPI CRC */
    , e) q( |" v/ J
83.   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    % ^  c# A5 e' k1 G/ R
84.   {
    * |* t: e0 s" n/ n* }9 B& n
85.     /* 初始化TX CRC初始值 */
    ' ?, W) C8 g" s# j
86.     if (hspi->Init.TxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    + Q% d* o1 D; u$ C
87.     {
    8 {, ^, q9 }" G/ u
88.       SET_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    
89.     }
      N9 i2 g0 X7 c/ T/ y  R1 h
90.     else
    ! j" y, H1 N- r# H( _6 g
91.     {
    1 i# J7 n6 g7 i/ K# i1 ^+ z9 b# T" \9 H
92.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    
93.     }
    
94. 
    ( o7 o0 |( e$ _+ G) c$ w1 B
95.     /* 初始化RXCRC初始值 */
    6 S3 \# F4 A" I! x+ f' V, F
96.     if (hspi->Init.RxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    6 i& z$ w* G' [4 b
97.     {
    
98.       SET_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
    , ]; W- d: G* h* `
99.     }
    ( F  n4 j" `; Y  j6 s4 G7 L
100.     else
     " u# N: Q# Y9 ^0 o
101.     {
     
102.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
     
103.     }
     
104. 
     / q. w+ L+ k5 m
105.     /* 使能 33/17 bit CRC计算 */
     
106.     if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (crc_length == SPI_CRC_LENGTH_16BIT)) ||
     " o( P, K" H  A0 F4 Y1 x
107.         ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance))  && (crc_length == SPI_CRC_LENGTH_32BIT)))
     + X- P* ~$ t8 u" ^& Y
108.     {
     7 U5 Z5 C+ p: m) `% y) F
109.       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     * @( I1 Z4 ~, n4 i" k
110.     }
     ) U0 @  V) M* H1 h# C  F9 g
111.     else
     " c5 d7 d( j2 E5 J5 s
112.     {
     1 M4 x4 R- B& G0 e* ~1 D6 ]6 a
113.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     ' k4 Y" S/ H) ~$ o, Q7 N$ X
114.     }
     
115. 
       d6 B/ ~. K3 Z% W7 z4 I7 w5 b. n
116.     /* 写CRC多项式到SPI寄存器 */
     8 q4 E) U0 J) u$ G  `' s' }! g
117.     WRITE_REG(hspi->Instance->CRCPOLY, hspi->Init.CRCPolynomial);
     
118.   }
     
119. #endif
     
120. 
     , B. n% Z5 r. _% q( p( Y
121.   /* SPI从模式，下溢配置 */
     9 `# s3 A7 h) u
122.   if (hspi->Init.Mode == SPI_MODE_SLAVE)
     8 D% m: I: T/ I; L9 Z7 Y2 S( L1 L
123.   {
     : ^# F" `- Z9 ]0 @# X
124.     /* 设置默认下溢配置 */
     ( @3 W+ l6 j, q7 A! k, G: a" k
125. #if (USE_SPI_CRC != 0UL)
     
126.     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_DISABLE)
     & I( R5 K* A- k) |. W1 N. b
127. #endif
     $ y3 g" E9 c- z$ l
128.     {
     
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);
     - t& g& z* b! }% V
132.   }
     
133. 
     ( B" b# w, @$ B* {( e
134. #if defined(SPI_I2SCFGR_I2SMOD)
     
135.   CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);
     
136. #endif
     $ w7 }! }9 o. t/ x' A
137. 
     
138.   /* 确保AFCNTR bit由SPI主机模式管理 */
     7 w% j  Y4 T/ V: r
139.   if ((hspi->Init.Mode & SPI_MODE_MASTER) == SPI_MODE_MASTER)
     3 i" `/ F6 h2 m- ?; {+ \+ l
140.   {
     7 V) ~! Y8 f& P( R# @
141.     /* Alternate function GPIOs control */
     
142.     MODIFY_REG(hspi->Instance->CFG2, SPI_CFG2_AFCNTR, (hspi->Init.MasterKeepIOState));
     1 w& O+ R) U) v8 z  @
143.   }
     
144. 
     , B' m  F; W( {  I" R
145.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
     
146.   hspi->State     = HAL_SPI_STATE_READY;
     
147. 
     6 U  n! i1 v/ [$ O0 R
148.   return HAL_OK;
     " Z( \; O/ I! ^; ]! Z1 ]9 Y0 j% h
149. }
     7 e* B) \. F3 [4 C: E

复制代码

1 n# ^$ n& E" t函数描述：

此函数用于初始化SPI。
* R6 e7 Q, \6 A8 \& P- S" u
函数参数：

7 H4 f6 G4 K. o  `5 [. {  第1个参数是SPI_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
2 y8 a/ J( \* n& `" C
4 N6 Y% M3 u, o/ @
7 M# }7 P7 J/ L5 o9 e注意事项：
函数HAL_SPI_MspInit用于初始化SPI的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hspi的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SPI_HandleTypeDef SpiHandle。
  H0 e" ^1 W8 {: P: V9 U对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SPI_STATE_RESET  = 0x00U。

! \: c8 S3 O4 e; ?( K3 l解决办法有三

1 e- _" C' d% T( |- H: E方法1：用户自己初始化SPI和涉及到的GPIO等。

方法2：定义SPI_HandleTypeDef SpiHandle为全局变量。

方法3：下面的方法
3 ^- [, H* q) X6 P8 ?1 T
& G& N7 N/ [4 z' O8 U) X

1. if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK)
   " C4 J. \# ]  r) k( m/ }$ P
2. {
   
3.     Error_Handler();
   " c& ~, C: ~; [! o
4. }  
   ' R0 f) U7 q  J
5. if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
   - K6 s: I1 a+ s* f3 g" @0 g. g
6. {
   
7.     Error_Handler();
   
8. }

复制代码

使用举例：

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   7 u4 Q) {6 }! N( B$ E" W
3. /* 设置SPI参数 */
   
4. hspi.Instance               = SPIx;                   /* 例化SPI */
   
5. hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
   
6. hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
   : m3 D5 D" s2 f
7. hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
   6 Q3 d$ s2 J4 Q* h" H! z& w
8. hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
   " i0 w& E6 D6 Z8 r
9. hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
   1 }+ G" e: O  C/ l7 V
10. hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    % J$ \6 l, c, K( ]' @, ~0 f
11. hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    ' I5 E! ?5 |, r  i( W' }% ^
12. hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;      /* 禁止CRC */
    " t2 m. D- g) g7 N& Q1 L) L
13. hspi.Init.CRCPolynomial     = 7;                               /* 禁止CRC后，此位无效 */
    
14. hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;             /* 禁止CRC后，此位无效 */
    
15. hspi.Init.NSS               = SPI_NSS_SOFT;                    /* 使用软件方式管理片选引脚 */
    8 J: k9 q5 S! W: C( g. r
16. hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;       /* 设置FIFO大小是一个数据项 */
    
17. hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;           /* 禁止脉冲输出 */
    + X  ^" Z6 ]8 F9 `5 m$ J- e
18. hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    8 W* `" l8 ^+ J% q: j# x" V1 D
19. hspi.Init.Mode                  = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    
20. 
    
21. if (HAL_SPI_Init(&hspi) != HAL_OK)
    
22. {
    
23.     Error_Handler(__FILE__, __LINE__);
    1 `/ \6 e: T# ?4 G4 c
24. }

复制代码

' _. J1 P- d4 {5 X; O1 ?- b72.4.2 函数HAL_SPI_DeInit
9 L  o# g7 S4 |  S函数原型：

1. HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
   
2. {
   
3. /* 检测SPI句柄是否有效 */
   , h: _2 x' g5 Y
4.   if (hspi == NULL)
   ; m& |+ r$ K, _; |3 E) j, V( m
5.   {
   
6.     return HAL_ERROR;
   
7.   }
   
8. 
   4 a. b5 [6 z) z- x: V
9. /* 检查SPI例化参数 */
   - \+ v# i$ @' S" D( v* m+ a( ]" j9 l
10.   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
    
11. 
    ! p! N5 K% s) D$ d6 S1 T6 a4 j
12.   hspi->State = HAL_SPI_STATE_BUSY;
    
13. 
    
14.   /* 禁止SPI外设时钟 */
    5 I. d5 I8 E- N0 w1 g
15.   __HAL_SPI_DISABLE(hspi);
    
16. 
    
17. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
18.   if (hspi->MspDeInitCallback == NULL)
    % O6 y) |& i5 L% v
19.   {
    
20.     hspi->MspDeInitCallback = HAL_SPI_MspDeInit;
    7 I0 U6 a) e3 d- n: [4 n' Y9 Y" J
21.   }
    9 ]7 V: t$ g* S, Q
22. 
    5 b4 r; w) h. B! G- I
23.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    / g2 N7 a6 l0 D/ C" v& o
24.   hspi->MspDeInitCallback(hspi);
    ) ]; Q. J9 W, G6 m7 G) w4 @
25. #else
    : H( ?3 ~5 m- c$ i3 ?# O4 M- n
26.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    3 m  J2 S7 w$ T2 S- ~
27.   HAL_SPI_MspDeInit(hspi);
    
28. #endif
    ! V. y- S& Y. B  |8 \0 \
29. 
    ! c& f- O+ X8 c
30.   /* 设置无错误，复位状态标记 */
    
31.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
    ( [' X  R% K, D
32.   hspi->State = HAL_SPI_STATE_RESET;
    
33. 
    
34.   /* 解锁SPI */
    
35.   __HAL_UNLOCK(hspi);
    
36. 
    1 V1 p$ e$ |2 s. N/ j4 S  N
37.   return HAL_OK;
    : q, |: S( Z) F7 C6 I1 _# ~& _
38. }

复制代码

函数描述：
5 o4 |9 |2 J( J: ]  ~: W
用于复位SPI总线初始化。
) R( F. T+ h, M8 [# T5 a
' d6 z9 _% v: e  k) H6 B2 K函数参数：

7 Z9 c4 ]0 Y- F: i% W8 c  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中
* X: `  p( o" \9 S0 h
' B4 d3 C+ C. N9 g1 [
# k! c1 `+ t) x& |5 {72.4.3 函数HAL_SPI_TransmitReceive
6 i  S! y7 A: T6 e! @7 g: ^4 k函数原型：

5 b' T- l9 J# D+ y! d

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
   
2. {
   
3. 
   5 S- }1 [4 Q4 S% n9 |5 B
4.    /* 省略未写 */
   
5. 
   " ]' ^. }. }, D0 M) o
6.   /* 大于16bit的数据收发 */
   
7.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
   
8.   {
   3 U2 e% r' g8 V2 d
9.        /* 省略未写 */
   
10.   }
    ) u% a2 k; m1 B8 ~+ G7 T+ n
11.   /* 大于8bit，小于16bi的数据收发 */
    8 Q# ]% |1 z' P  M9 d
12.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    7 H( q* P1 y7 X5 Q# ^8 u4 ]4 Q
13.   {
    / {9 V) b1 Z! f8 v( T5 t: S
14.       /* 省略未写 */
    
15.   }
    
16.   /* 小于等于8bit的数据收发 */
    
17.   else
    
18.   {
    
19.        /* 省略未写 */
    9 X: [$ F- c, K4 T" D" p$ L
20.   }
    2 o: {4 o+ o4 r" b* v- ]  _% x
21. 
    
22. }

复制代码

函数描述：

此函数主要用于SPI数据收发，全双工查询方式。
" f/ `1 O$ P- O7 X4 _
函数参数：
; f7 Y; L: }& o- C0 p8 ]4 B% G2 u; z0 N
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
/ A! Z' L3 c9 |' s/ i" ]9 p  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
  第5个参数是传输过程的溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

$ [5 e" q8 C3 m# _! B+ r
使用举例：
' S8 ~' r$ G+ {& D

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)
   ' S) s  o1 U. r7 b
4. {
   4 l8 y9 W" |5 E0 E' H
5.     Error_Handler(__FILE__, __LINE__);
   
6. }

复制代码

3 C2 p; \( `" e. P- c3 J/ E+ p, `  W/ Q72.4.4 函数HAL_SPI_TransmitReceive_IT
. ~8 m. E- c4 V- y3 Y  k. s函数原型：
6 e3 G) _: k0 l

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
   
2. {
   ) L2 V8 y5 ?4 v- g. [8 P
3.    /* 省略未写 */
   1 J5 y* j: z1 u7 K  _2 ?* h
4. 
   
5.   /* 设置传输参数 */
   5 ^0 Y6 g# t/ h0 C) e$ a
6.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   
7.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
   
8.   hspi->TxXferSize  = Size;
   ; c" b8 X1 e$ \( [% C
9.   hspi->TxXferCount = Size;
   
10.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
    
11.   hspi->RxXferSize  = Size;
    
12.   hspi->RxXferCount = Size;
    % _4 S/ o4 q; \5 l" q
13. 
    0 I8 b- q$ }) ?: l6 V
14.   /* 设置中断处理 */
    
15.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    * m% E2 e. |/ |/ D
16.   {
    
17.     hspi->TxISR     = SPI_TxISR_32BIT;
    2 ?4 L- M! G, x6 y1 o: r# h
18.     hspi->RxISR     = SPI_RxISR_32BIT;
    
19.   }
    * E! q; C0 e  i& l' V* M
20.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    
21.   {
    
22.     hspi->RxISR     = SPI_RxISR_16BIT;
    / h4 Y% n5 p) g! P% B. @( h7 j
23.     hspi->TxISR     = SPI_TxISR_16BIT;
    2 d; D  E# [3 t! g. |. a
24.   }
    . B: `  X9 z' U( u
25.   else
    , ^* `; c& q( d4 J" P
26.   {
    
27.     hspi->RxISR     = SPI_RxISR_8BIT;
    
28.     hspi->TxISR     = SPI_TxISR_8BIT;
    ) l2 V7 a+ I" ^) Q3 k
29.   }
    
30. 
    - h# R( h% T; @7 ?% L. T/ Y
31.   /* 设置当前传输数据大小 */
    : O( |: t" T* v/ f
32.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    ' V! R; w4 t4 }$ M( r% r8 f
33. 
    # h8 z, Z$ K  \7 d8 s9 h
34.   /* 使能SPI外设 */
    
35.   __HAL_SPI_ENABLE(hspi);
    9 r9 p) A* `8 E; p% d6 ]4 ~
36. 
    # {4 d. k( L* G9 N4 T$ R
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));
    4 J$ S3 x5 V2 a) Y& h3 P
40. 
    % F  `# X  C; R1 u; a7 T" r" L
41.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    
42.   {
    6 P0 b$ z! G# \4 d, Q4 L
43.     /* 启动传输 */
    
44.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
    
45.   }
    & n1 O9 e+ v; |, u5 c
46. 
    
47.   /* 解锁 */
    
48.   __HAL_UNLOCK(hspi);
    
49.   return errorcode;
    + {* V* [2 N! H
50. }
    

复制代码

. W* v! k$ b& y# \* l5 l函数描述：
4 Q' _) H9 y$ x2 v. S, Q
5 K( n8 X6 n- l此函数主要用于SPI数据收发，全双工中断方式。

函数参数：

  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  b# C" N  f$ I1 i. Y5 ]/ @  第2个参数是发送数据缓冲地址。
4 v+ A( \& w: v8 E  l/ T  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
/ S6 R0 c# Y! J- ?5 x  y  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

) Z* f( q* D! d1 W* `
' v: a. R" c, s. d& {' m( G6 E0 m) W使用举例：

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   & \% s- g1 Q7 F" v( Y
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__);
   : Z. W) j" X& a2 b" j! L' A4 A
6. }

复制代码

9 @5 `" ]$ T/ y72.4.5 函数HAL_SPI_TransmitReceive_DMA
4 v1 Q+ N9 X) g/ h# T函数原型：

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,
   ! w' F# c" L3 S) U+ {
2.                                               uint16_t Size)
   
3. {
   4 J+ G9 s% v1 w
4.    /* 省略未写 */
   + j! Z2 C, Z6 J* p
5. 
   * c3 S5 I8 H& Q, j1 b
6. /* 注意DMA的位宽和对齐设置 */
   
7.   if (((hspi->Init.DataSize > SPI_DATASIZE_16BIT) && (hspi->hdmarx->Init.MemDataAlignment !=
   
8. DMA_MDATAALIGN_WORD))  ||
   
9.       ((hspi->Init.DataSize > SPI_DATASIZE_8BIT) && ((hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_HALFWORD) && (hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_WORD))))
   
10.   {
    
11.   }
    
12. 
    + H8 B0 I. U* l1 C  l
13. /* 调整DMA对齐和数据大小 */
    ' P' {2 y1 A5 Y' c
14.   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)
    
15.   {
    
16.      /* 省略未写 */
    
17.   }
    
18.   else if (hspi->Init.DataSize <= SPI_DATASIZE_16BIT)
    4 w4 T* ?. \6 G3 q
19.   {
    6 ?" W6 E; R1 F( T
20.      /* 省略未写 */
    
21.   }
    . ?4 d' O& K8 \
22.   else
    
23.   {
    + H0 {4 V6 z$ [/ V
24.       /* 省略未写 */
    
25.   }
    5 Z1 `  W. T5 {
26. 
    " J9 z. N- v: Y1 ~: k! _' g
27. /*  DMA接收配置 */
    $ W1 ]; B) B  L6 A0 H. ^& [
28.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->RXDR, (uint32_t)hspi->pRxBuffPtr,
    
29. hspi->RxXferCount))
    
30.   {
    
31. 
    
32.   }
    # g( A% Q. y0 [8 v' Q
33. 
    ) ~( E4 Q( X7 t% O/ H0 Q
34. /* DMA发送配置 */
    - d0 F* W' [) Y6 L" Y
35.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->TXDR,
    ( Z+ l( B6 S/ C
36. hspi->TxXferCount))
    0 l  T% J) J/ W/ M- z% S
37.   {
    
38.   }
    . l& D. {. \3 Q
39. 
    
40.   /* 省略未写 */
    
41. }
    

复制代码

2 a( C, @; |( }5 D. l5 Q函数描述：

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

8 L4 e2 h  ^; g函数参数：

5 y: E4 |* F: Y: x% T  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
; {$ v) e3 `. ~/ T. L7 b  第2个参数是发送数据缓冲地址。
  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
3 ~$ a9 [8 {3 g+ x, u  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
( W8 @8 [  w* l1 J! `  m* [

使用举例：

; W& `' {/ }" ~9 J7 \

1. SPI_HandleTypeDef hspi = {0};
   - V# l4 L# n- {" ]; `
2. 
   
3. if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   & ~+ C; `  ^7 z( `1 ?9 i
4. {
   
5.     Error_Handler(__FILE__, __LINE__);
   
6. }
   0 r0 ?4 j# c4 X0 E8 s

复制代码

2 f1 |" C+ ]7 a, T- h8 Q% [3 C3 @72.5 总结
( M* y7 I$ ^4 v本章节就为大家讲解这么多，要熟练掌握SPI总线的查询，中断和DMA方式的实现，因为基于SPI接口的外设芯片很多，熟练后，可以方便的驱动各种SPI接口芯片，以便选择合适的驱动方式。
# Q$ j( f. R2 b/ y

1 v" e% T$ b% w$ A0 K! F


# c# a/ t4 G# x  m