72.1 初学者重要提示
  STM32H7的SPI支持4到32bit数据传输，而STM32F1和F4系列仅支持8bit或者16bit。
+ L" ]  S( m( Y; a  STM32H7的主频400MHz时，SPI1, 2, 3最高通信时钟是100MHz，而SPI4, 5, 6是50MHz。
# {! P- w9 I# w  J' l  STM32H7的MISO和MOSI引脚功能可以互换，使用比较灵活。
% p8 O. S3 k9 X) N! i  SPI总线的片选引脚SS在单一的主从器件配置下是可选的，一般情况下可以不使用。
% }7 v6 x2 [5 P3 ~# k% k  v
8 w2 d' ~( Z) ^* K  G: P72.2 SPI总线基础知识
. J. N' m3 G4 l: a9 h! j72.2.1 SPI总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SPI的基本功能，然后再看手册了解细节。
: a# L0 T( m# T8 K  z
3 r. d' [- I0 v+ s6 i

' h7 ]+ A! S2 w# N: X2 T0 M6 W& \通过这个框图，我们可以得到如下信息：
  spi_wkup输出
0 s& z; P+ U3 e$ W3 M7 H) n) W
) e* h) x, g% w- e5 ]  `  B9 D4 A低功耗唤醒信号。
  spi_it输出
2 F; G  B! ^: Q
, z* j0 x9 M: {. y/ H( s* @! A3 i# [! w
spi的中断请求信号。
  spi_tx_dma
$ [4 L" Q/ D' q. i* H& S  spi_rx_dma
' N/ p0 M0 t$ \
& U. I' s3 \/ x  ]
spi的DMA发送和接收请求信号。
  spi_pclk
# q, F: H" F6 B0 H' C2 @4 c$ g
0 Y0 Z6 K3 V4 a0 [5 c: ~
" `4 n- j% o; E为寄存器提供时钟。
  spi_ker_ck
$ {/ [1 Y/ k: O( M# M+ L  |
/ |. _4 d* H5 a
3 w5 I2 e* q3 u为spi内核时钟。
. N2 L2 s' j3 R$ G( k4 ?3 E7 a& p  SCK（CK），Serial Clock


* S- y& l0 h' M+ l" j. D& x此引脚在主机模式下用于时钟输出，从机模式下用于时钟输入。
/ l2 G# Z3 T+ B% t: v2 ^* R, _) v  MISO（SDI），Master In / Slave Out data

  t9 g" ^. c+ g( ]) G
此引脚在从机模式下用于发送数据，主机模式下接收数据。
& a6 ]) X8 r9 o2 _$ a  MOSI（SDO）, Master Out / Slave In data
. [% h: a: m0 Q9 w0 V

* H4 C# i5 j0 f此引脚在从机模式下用于数据接收，主机模式下发送数据。
2 [% D: P3 @% V  a+ @, ^7 j  SS（WS）, Slave select pin


根据SPI和SS设置，此引脚可用于：
a. 选择三个从器件进行通信。

b. 同步数据帧。
# r+ D5 I6 x" r9 Q& ]
3 W0 f# `6 K. `0 Y0 G% G) x+ g! gc. 检测多个主器件之间是否存在冲突。

$ M+ M! ^* ?; B( L. y+ a通过这个框图还要认识到一点，SPI有三个时钟域，分别是寄存器所在的ABP总线时钟域，内核时钟发生器时钟域以及内核时钟发生器分频后的串行时钟域。
: Q1 U# c  g; X0 U5 L
72.2.2 SPI接口的区别和时钟源（SPI1到SPI6）
8 s) J( [: S6 {0 b- Q- U这个知识点在初学的时候容易忽视，所以我们这里整理下。
2 E) t/ C0 B; Q1 R  {SPI1到SPI6的区别
2 a5 N. {4 q) y  SPI1，SPI2和SPI3支持4到32bit数据传输，SPI4，SPI5和SPI6是4到16bit数据传输。
  SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit。

, u, W4 m/ W% g( `6 C  SPI1到SPI6的所在的总线（对应SPI框图的SPI_CLK时钟域）


SPI1，SPI4和SPI5在APB2总线，SPI2，SPI3在APB1总线，SPI6在APB4总线。注意，SPI的最高时钟不是由这些总线决定的。
' r3 V* I) g8 n. y9 }+ W# m
  SPI1到SPI6的支持的最高时钟（对应SPI框图的SPI_KER_CK）
. e7 h! a0 v; }4 z/ M

STM32H7主频在400MHz下，SPI1，SPI2和SPI3的最高时钟是200MHz，而SPI4,5,6是100MHz, 以SPI1为了，可以选择的时钟源如下：
& ~* H5 L$ h2 l1 [

这里特别注意一点，SPI工作时最少选择二分频，也就是说SPI1,2,3实际通信时钟是100MHz，而SPI4,5,6是50MHz。
* }: y9 v3 d/ r
# }: k5 d( Y3 A. o: ~72.2.3 SPI总线全双工，单工和半双工通信
0 \9 V' K' ^7 s" Z2 l9 Y! w9 w片选信号SS在单一的主从器件配置下是可选的，一般情况下可以不使用。但需要同步数据流，或者用于TI模式时需要此信号。
. _5 A1 T9 \. G$ h' |' T
; N  W) _' a  Y' J, _6 j2 a+ w  全双工通信
' u7 ~8 ~; t, q7 G全双工就是主从器件之间同时互传数据，SPI总线的全双工模式接线方式如下：

8 E( t/ o. k# h% p) }

0 i7 |" t9 N* H- w  ^
关于这个接线图要认识到以下几点：
  注意接线方式，对于主器件来说MISO引脚就是输入端，从器件的MISO是输出端，即Master In / Slave Out data。MOSI也是同样道理。
  每个时钟信号SCK的作用了，主器件的MISO引脚接收1个bit数据，MOSI引脚输出1个bit数据。
9 o4 T! h9 h- V5 x  这种单一的主从接线模式下，SS引脚可以不使用。

半双工通信
半双工就是同一个时刻只能为一个方向传输数据，SPI总线的半工模式接线方式如下：

! G! o* M2 T8 M9 h% n

% `% ]: V5 ]9 h* k
8 u1 A* B. V% D8 `) k8 b关于这个接线图要认识到以下几点：

) [2 J" H! ^9 L! H% h- V  更改通信方式时，要先禁止SPI。
! Q/ l( {* p+ ~, D  主器件的MISO和从器件的MISO不使用，可以继续用作标准GPIO。
% P# s/ u7 ~, @' B1 q! H. j" A  1KΩ的接线电阻很有必要，因为当主器件和从器件的通信方向不是同步变化时，容易出现其中一个输出低电平，另一个输出高电平，造成短路。
7 c; f" S9 z4 p# V7 x  这种单一的主从接线模式下，SS引脚可以不使用。
  
单工模式
单工就是只有一种通信方向，即发送或者接收，SPI总线的全双工模式接线方式如下：
) w! P. v: C/ m
! ]( y4 V. g% i1 O

* x9 n" H( A0 X% _8 l$ u关于这个接线图要认识到以下几点：
: H# m- L( h! M8 j1 @4 }& d# F
& ]: W5 M/ R1 L) ]' ]9 G9 I5 j1 |  未用到的MOSI或者MISO可以用作标准GPIO。
; l: g, `9 T& _) \7 F( f+ F! E4 y  这种单一的主从接线模式下，SS引脚可以不使用。

# n: Q8 q6 j) s( C1 L3 ^% L72.2.4 SPI总线星型拓扑
  z, }4 V3 U1 `  ]# CSPI总线星型拓扑用到的地方比较多，V7开发板就是用的星型拓扑外接多种SPI器件：
% n/ F. [0 q# z

: g4 L- U2 q- d
% k! }  ^* E5 O' ?$ Z$ z关于这个接线图，有以下几点需要大家了解：
! G1 ^& S$ A$ w+ ^
0 e1 t% h$ v7 e8 ]" J5 ?  主器件的SS引脚不使用，使用通用GPIO控制。为每个器件配一个SS引脚，方便单独片选控制。
  从器件的MISO引脚要配置为复用开漏输出（很多外部芯片在未片选时，数据引脚是呈现高阻态）。
# c( Y+ J$ \! o- n6 ~: G

72.2.5 SPI总线通信格式
; M- e- l: M- N+ x' rSPI总线主要有四种通信格式，由CPOL时钟极性和CPHA时钟相位控制：
# ~/ P1 }5 z# n

四种通信格式如下：
! D. ^. Y: L, V$ d. Z9 \  当CPOL = 1， CPHA = 1时
$ ~* B* z  F2 m4 Y& z% Z

& n2 L' }6 @3 s% USCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
/ L; o% B6 x) z: \% v% D3 ]  当CPOL = 0， CPHA = 1时

( U) s% }3 p6 J1 q( ?
SCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。
  当CPOL = 1， CPHA = 0时


SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。
3 p1 d8 {& E9 K) S. s$ S1 S! R6 s: [  当CPOL = 1， CPHA = 0时
" s9 t' e" `8 ~  j" f* g+ f8 l) m1 d
$ }! ^" X* b) N8 |7 `+ ~* z) P4 g
5 b& s2 {$ J3 d6 wSCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
( V# ?+ O9 K' K& Y' q2 Z
72.3 SPI总线的HAL库用法
72.3.1 SPI总线结构体SPI_TypeDef
. X4 G8 X  g, u/ z: LSPI总线相关的寄存器是通过HAL库中的结构体SPI_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
0 X2 |& `7 [, V, {
1 l! s0 G- N. _: n- B

1. typedef struct
   
2. {
   
3.   __IO uint32_t CR1;           /*!< SPI/I2S Control register 1,                      Address offset: 0x00 */
   
4.   __IO uint32_t CR2;           /*!< SPI Control register 2,                          Address offset: 0x04 */
   
5.   __IO uint32_t CFG1;          /*!< SPI Configuration register 1,                    Address offset: 0x08 */
   
6.   __IO uint32_t CFG2;          /*!< SPI Configuration register 2,                    Address offset: 0x0C */
     `1 R, k. A6 j  b) {
7.   __IO uint32_t IER;           /*!< SPI/I2S Interrupt Enable register,               Address offset: 0x10 */
   ' n4 @( p+ M* v7 t# C4 @6 @% E
8.   __IO uint32_t SR;            /*!< SPI/I2S Status register,                         Address offset: 0x14 */
   . K2 m6 _& I; O
9.   __IO uint32_t IFCR;          /*!< SPI/I2S Interrupt/Status flags clear register,   Address offset: 0x18 */
   : d5 b1 G* \+ X+ z
10.   uint32_t      RESERVED0;     /*!< Reserved, 0x1C                                                        */
    / V/ k) e6 Y# g$ e  e% L) u# ^
11.   __IO uint32_t TXDR;          /*!< SPI/I2S Transmit data register,                  Address offset: 0x20 */
    5 {# B2 h. E) _- M0 K% n6 R
12.   uint32_t      RESERVED1[3];  /*!< Reserved, 0x24-0x2C                                                   */
    % B! T* X% A; O) {
13.   __IO uint32_t RXDR;          /*!< SPI/I2S Receive data register,                   Address offset: 0x30 */
    
14.   uint32_t      RESERVED2[3];  /*!< Reserved, 0x34-0x3C                                                   */
    8 A+ S( k6 p3 `! f9 Z# j. E
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 */
    : i2 k. Z+ ?: {( D5 I
18.   __IO uint32_t UDRDR;         /*!< SPI Underrun data register,                      Address offset: 0x4C */
    
19.   __IO uint32_t I2SCFGR;       /*!< I2S Configuration register,                      Address offset: 0x50 */
    
20. 
    . |- m) m$ }- P
21. } SPI_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。
# D! E/ ~) {" L* d
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

1 P  {, K+ O/ q) X

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

复制代码

下面我们看下SPI的定义，在stm32h743xx.h文件。
0 B( q( p: u% ?6 Y, T: S! w! ^
5 S- t$ S, `" I+ G: e* q8 _/ b

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)
   " }2 Q* S. a: E7 {' _
5. 
   0 u! O3 n9 S9 i6 G) B
6. #define SPI2_BASE             (D2_APB1PERIPH_BASE + 0x3800UL)
   1 P4 t( b* A7 }( a
7. #define SPI3_BASE             (D2_APB1PERIPH_BASE + 0x3C00UL)
   
8. #define SPI1_BASE             (D2_APB2PERIPH_BASE + 0x3000UL)
   
9. #define SPI4_BASE             (D2_APB2PERIPH_BASE + 0x3400UL)
   : R0 P: a: I" a1 ^* {! \
10. #define SPI5_BASE             (D2_APB2PERIPH_BASE + 0x5000UL)
    
11. #define SPI6_BASE             (D3_APB1PERIPH_BASE + 0x1400UL)
    , x9 v* V0 B' ]
12. 
    " O2 D% Q, f7 ?8 A' d( h6 @1 |9 S( }
13. #define SPI1                ((SPI_TypeDef *) SPI1_BASE)
    
14. #define SPI2                ((SPI_TypeDef *) SPI2_BASE)
    
15. #define SPI3                ((SPI_TypeDef *) SPI3_BASE)
    
16. #define SPI4                ((SPI_TypeDef *) SPI4_BASE)
    
17. #define SPI5                ((SPI_TypeDef *) SPI5_BASE)
    , F4 m3 C" K/ `( v1 s
18. #define SPI6                ((SPI_TypeDef *) SPI6_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x58001400

复制代码

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

7 E) |" L2 S% U/ P1 B2 n& d6 n72.3.2 SPI总线初始化结构体SPI_InitTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：
4 T- z& V/ o( b) @0 V1 c& t
2 |* B7 j5 ]3 y; f  e

1. typedef struct
   0 N" Z7 W' z4 l$ Z% s
2. {
   
3.   uint32_t Mode;                           
   
4.   uint32_t Direction;                     
   
5.   uint32_t DataSize;                          
   
6.   uint32_t CLKPolarity;                       
   
7.   uint32_t CLKPhase;                        
   % K3 a. z+ z3 M- {9 ~$ `
8.   uint32_t NSS;                             
   ; ]2 K, q' d  S. I% {/ s  h
9.   uint32_t BaudRatePrescaler;               
   ! C3 M* B5 W. L  e" A& i
10.   uint32_t FirstBit;                        
    
11.   uint32_t TIMode;                          
    9 w, c% S3 L$ b0 j  F
12.   uint32_t CRCCalculation;                  
    7 h% ]( x  u" b+ ]; o
13.   uint32_t CRCPolynomial;                     
    
14.   uint32_t CRCLength;                        
    
15.   uint32_t NSSPMode;                        
    7 ^2 s3 c0 _; ]4 x# K
16.   uint32_t NSSPolarity;                    
    
17.   uint32_t TxCRCInitializationPattern;      
    
18.   uint32_t RxCRCInitializationPattern;      
    4 b5 _7 A! ~2 ~: \: Z
19.   uint32_t MasterSSIdleness;                 
    
20.   uint32_t MasterInterDataIdleness;           
    
21.   uint32_t MasterReceiverAutoSusp;         
    $ i- c2 B* U/ x
22.   uint32_t MasterKeepIOState;               
    + N- l- B4 J' h9 i7 F/ D2 x' ~
23.   uint32_t IOSwap;                          
    
24. } SPI_InitTypeDef;

复制代码

2 C' d8 a6 A: v9 |( E- z下面将结构体成员逐一做个说明：
6 R/ o# y* z% N! @- }- a+ O; y  Mode
) ?* V. w6 F" ?* G: }
7 f1 k* w4 [/ M' Q$ V用于设置工作在主机模式还是从机模式。

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

复制代码

& r2 a* ]1 w: N, ~  Direction
用于设置SPI工作在全双工，单工，还是半双工模式。
- q, W0 u5 J: P1 f+ @3 T
8 ^( Y' P% b4 G# r0 L5 [

1. #define SPI_DIRECTION_2LINES           (0x00000000UL)     /* 全双工 */
   & e# O* P7 U5 Z; H5 ~- }
2. #define SPI_DIRECTION_2LINES_TXONLY     SPI_CFG2_COMM_0   /* 单工，仅发送 */
   5 O/ Q% Z  O! N5 i, z' a- R
3. #define SPI_DIRECTION_2LINES_RXONLY     SPI_CFG2_COMM_1   /* 单工，仅接收 */
   . N( ^9 j1 ^6 Q! p4 _
4. #define SPI_DIRECTION_1LINE             SPI_CFG2_COMM     /* 半双工 */

复制代码

  DataSize
6 ~! Z) K: m9 N& x用于设置SPI总线数据收发的位宽，支持4-32bit。

1. #define SPI_DATASIZE_4BIT                             (0x00000003UL)
   - T0 _, ^+ Q4 y
2. #define SPI_DATASIZE_5BIT                             (0x00000004UL)
   % @) i& R- H$ M% U9 M" C9 i% ?. F
3. #define SPI_DATASIZE_6BIT                             (0x00000005UL)
   
4. #define SPI_DATASIZE_7BIT                             (0x00000006UL)
   
5. #define SPI_DATASIZE_8BIT                             (0x00000007UL)
   4 X/ U) D! j2 U$ E! j8 a# p
6. #define SPI_DATASIZE_9BIT                             (0x00000008UL)
   
7. #define SPI_DATASIZE_10BIT                            (0x00000009UL)
   
8. #define SPI_DATASIZE_11BIT                            (0x0000000AUL)
   
9. #define SPI_DATASIZE_12BIT                            (0x0000000BUL)
   
10. #define SPI_DATASIZE_13BIT                            (0x0000000CUL)
    # I" o1 {2 F  a: Z+ x
11. #define SPI_DATASIZE_14BIT                            (0x0000000DUL)
    
12. #define SPI_DATASIZE_15BIT                            (0x0000000EUL)
    
13. #define SPI_DATASIZE_16BIT                            (0x0000000FUL)
    - k/ z! |$ N: N9 a1 q
14. #define SPI_DATASIZE_17BIT                            (0x00000010UL)
      ?! V7 J1 k( A) O% s
15. #define SPI_DATASIZE_18BIT                            (0x00000011UL)
      t7 Q3 z( B' d$ I# j8 K; |. G% l
16. #define SPI_DATASIZE_19BIT                            (0x00000012UL)
    
17. #define SPI_DATASIZE_20BIT                            (0x00000013UL)
    9 y- g5 v  j' [5 I) p; F# S  ^
18. #define SPI_DATASIZE_21BIT                            (0x00000014UL)
    
19. #define SPI_DATASIZE_22BIT                            (0x00000015UL)
    
20. #define SPI_DATASIZE_23BIT                            (0x00000016UL)
      ^. n. q7 _. R5 q6 x9 V# ]
21. #define SPI_DATASIZE_24BIT                            (0x00000017UL)
    
22. #define SPI_DATASIZE_25BIT                            (0x00000018UL)
    1 D+ w2 N8 I, e( @+ z. f1 ]% R
23. #define SPI_DATASIZE_26BIT                            (0x00000019UL)
    : l8 Q' M" P% q# Q/ _" H3 ^
24. #define SPI_DATASIZE_27BIT                            (0x0000001AUL)
    
25. #define SPI_DATASIZE_28BIT                            (0x0000001BUL)
    # U/ p% K% {" w4 @* B* M/ c
26. #define SPI_DATASIZE_29BIT                            (0x0000001CUL)
    % w/ `! a. _! d  M
27. #define SPI_DATASIZE_30BIT                            (0x0000001DUL)
    
28. #define SPI_DATASIZE_31BIT                            (0x0000001EUL)
    
29. #define SPI_DATASIZE_32BIT                            (0x0000001FUL)
    

复制代码

: r& o1 w+ M7 t1 u& p% K
  CLKPolarity
. {9 @; h" ?1 X, L& R& T用于设置空闲状态时，CLK是高电平还是低电平。

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

复制代码

  NSS
3 X7 k0 E2 N% N" z: B5 ]用于设置NSS信号由硬件NSS引脚管理或者软件SSI位管理。
4 m7 b4 |+ O. H6 H  P
( T, w4 y* D* @* l: g

1. #define SPI_NSS_SOFT                                  SPI_CFG2_SSM
   ) W' Z1 P+ R" M! _9 n3 ]) t9 z
2. #define SPI_NSS_HARD_INPUT                            (0x00000000UL)
   
3. #define SPI_NSS_HARD_OUTPUT                           SPI_CFG2_SSOE

复制代码

: U" r) g% r% T2 w# |  BaudRatePrescaler
用于设置SPI时钟分频，仅SPI工作在主控模式下起作用，对SPI从机模式不起作用。
8 s: B$ C. g8 a# a
( l% y  f& x: [' Z1 E' H  y

1. #define SPI_BAUDRATEPRESCALER_2                       (0x00000000UL)
   
2. #define SPI_BAUDRATEPRESCALER_4                       (0x10000000UL)
   * {& c: Q! ^5 T% d
3. #define SPI_BAUDRATEPRESCALER_8                       (0x20000000UL)
   : E6 w$ ]/ ~6 [& M7 I7 z9 ~
4. #define SPI_BAUDRATEPRESCALER_16                      (0x30000000UL)
   # U  T1 s: V; ?; u
5. #define SPI_BAUDRATEPRESCALER_32                      (0x40000000UL)
   7 j# a7 W: n- p7 K0 B8 ~8 h
6. #define SPI_BAUDRATEPRESCALER_64                      (0x50000000UL)
   + i3 `7 N0 U0 v# o
7. #define SPI_BAUDRATEPRESCALER_128                     (0x60000000UL)
   : b8 |' H  d9 d* x0 q0 n7 `# W
8. #define SPI_BAUDRATEPRESCALER_256                     (0x70000000UL)

复制代码

7 L+ }5 Q! ]- M  FirstBit
用于设置数据传输从最高bit开始还是从最低bit开始。
6 {, [' N1 j* K  }( }; q; l1 v

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

复制代码

  TIMode
9 R( f3 Y9 h1 u* m% B- K  {用于设置是否使能SPI总线的TI模式。

1. #define SPI_TIMODE_DISABLE               (0x00000000UL)
   ) |, L5 z* p" R7 r
2. #define SPI_TIMODE_ENABLE                SPI_CFG2_SP_0

复制代码

# N9 e/ _% d- F9 ^) _- x  CRCCalculation
) O( A2 e2 u1 X& K/ L4 }; K用于设置是否使能CRC计算。

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

复制代码

  CRCPolynomial
# M# U/ D1 P8 a3 {& @6 {用于设置CRC计算使用的多项式，必须是奇数，范围0到65535。
* Z: u6 x4 q, ^+ ~. o5 n, x
: D$ T8 a: O" \* B: ]; A3 P! L; w( e  CRCLength
( p/ r& Z5 p  P8 U/ x& Z  H用于设置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)
   
4. #define SPI_CRC_LENGTH_6BIT                           (0x00050000UL)
     L2 B/ W) o. {1 I! G7 O0 L4 {
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)
   2 ]6 d/ a6 U' x$ o; f
9. #define SPI_CRC_LENGTH_11BIT                          (0x000A0000UL)
   
10. #define SPI_CRC_LENGTH_12BIT                          (0x000B0000UL)
    
11. #define SPI_CRC_LENGTH_13BIT                          (0x000C0000UL)
      m  Z+ V; |$ U0 b& A8 k
12. #define SPI_CRC_LENGTH_14BIT                          (0x000D0000UL)
    
13. #define SPI_CRC_LENGTH_15BIT                          (0x000E0000UL)
    8 {. V' i' A* c% a1 Y
14. #define SPI_CRC_LENGTH_16BIT                          (0x000F0000UL)
    
15. #define SPI_CRC_LENGTH_17BIT                          (0x00100000UL)
    " r" W% {9 Q6 s9 X0 ~2 u4 w
16. #define SPI_CRC_LENGTH_18BIT                          (0x00110000UL)
    
17. #define SPI_CRC_LENGTH_19BIT                          (0x00120000UL)
    # A% |8 y( u& @  K" l  S
18. #define SPI_CRC_LENGTH_20BIT                          (0x00130000UL)
    0 K' D4 x4 I7 c
19. #define SPI_CRC_LENGTH_21BIT                          (0x00140000UL)
    
20. #define SPI_CRC_LENGTH_22BIT                          (0x00150000UL)
    
21. #define SPI_CRC_LENGTH_23BIT                          (0x00160000UL)
    
22. #define SPI_CRC_LENGTH_24BIT                          (0x00170000UL)
    
23. #define SPI_CRC_LENGTH_25BIT                          (0x00180000UL)
    
24. #define SPI_CRC_LENGTH_26BIT                          (0x00190000UL)
    : e- k4 y. [* n/ e
25. #define SPI_CRC_LENGTH_27BIT                          (0x001A0000UL)
    
26. #define SPI_CRC_LENGTH_28BIT                          (0x001B0000UL)
    
27. #define SPI_CRC_LENGTH_29BIT                          (0x001C0000UL)
    
28. #define SPI_CRC_LENGTH_30BIT                          (0x001D0000UL)
    
29. #define SPI_CRC_LENGTH_31BIT                          (0x001E0000UL)
    1 o7 @& {3 r7 s. n7 E  f
30. #define SPI_CRC_LENGTH_32BIT                          (0x001F0000UL)
    

复制代码

* X4 U* }- H5 ]6 N/ {/ ?6 h  NSSPMode
用于设置是否使能NSSP信号，可以通过SPIx_CR2寄存器的SSOM位使能。注意，只有配置为摩托罗拉SPI主控模式时设置此成员才有用。

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

复制代码

( [2 Z3 E$ Q" j. i1 @7 S) c/ h2 k; p! g$ k  NSSPolarity
用于设置NSS引脚上的高电平或者低电平作为激活电平。

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

复制代码

  FifoThreshold
用于设置SPI的FIFO阀值。
3 ]/ s4 `, C. }+ \2 T: Z

1. #define SPI_FIFO_THRESHOLD_01DATA                     (0x00000000UL)
   
2. #define SPI_FIFO_THRESHOLD_02DATA                     (0x00000020UL)
   2 t# o8 e# j- U2 m6 ?
3. #define SPI_FIFO_THRESHOLD_03DATA                     (0x00000040UL)
   5 E$ E6 W( ^" y) H3 i4 F# p
4. #define SPI_FIFO_THRESHOLD_04DATA                     (0x00000060UL)
   
5. #define SPI_FIFO_THRESHOLD_05DATA                     (0x00000080UL)
   " }5 `- F* q3 s+ f6 m& N
6. #define SPI_FIFO_THRESHOLD_06DATA                     (0x000000A0UL)
   5 _# Y" z% M# t3 a
7. #define SPI_FIFO_THRESHOLD_07DATA                     (0x000000C0UL)
   * D6 }$ M/ R# [0 B3 R
8. #define SPI_FIFO_THRESHOLD_08DATA                     (0x000000E0UL)
   
9. #define SPI_FIFO_THRESHOLD_09DATA                     (0x00000100UL)
   * S' T! A- t2 k& u' R" u
10. #define SPI_FIFO_THRESHOLD_10DATA                     (0x00000120UL)
    * ^/ l8 I5 h- d- i& h# K' I  ]% O
11. #define SPI_FIFO_THRESHOLD_11DATA                     (0x00000140UL)
    
12. #define SPI_FIFO_THRESHOLD_12DATA                     (0x00000160UL)
    2 Y: }8 ~+ b+ k& O- j
13. #define SPI_FIFO_THRESHOLD_13DATA                     (0x00000180UL)
    
14. #define SPI_FIFO_THRESHOLD_14DATA                     (0x000001A0UL)
    
15. #define SPI_FIFO_THRESHOLD_15DATA                     (0x000001C0UL)
    0 q$ O/ r* s7 f: `
16. #define SPI_FIFO_THRESHOLD_16DATA                     (0x000001E0UL)

复制代码

( v5 G9 b! l4 _, A2 s& t& \3 ^7 u  TxCRCInitializationPattern
发送CRC初始化模式。

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   $ o$ z/ d& T8 W2 A. A
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

  RxCRCInitializationPattern
/ `4 x% X) |5 ]$ y* l接收CRC初始化模式

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   9 i0 r3 v, D+ A% i$ S4 _
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)

复制代码

, Z: q4 J; I& T* o  i: v% q$ G MasterSSIdleness
4 b- o. M9 \) H在主模式下插入到SS有效边沿和第一个数据开始之间的额外延迟，单位SPI时钟周期个数。
$ B8 b4 B: F2 X2 u2 U4 G

1. #define SPI_MASTER_SS_IDLENESS_00CYCLE                (0x00000000UL)
   
2. #define SPI_MASTER_SS_IDLENESS_01CYCLE                (0x00000001UL)
   
3. #define SPI_MASTER_SS_IDLENESS_02CYCLE                (0x00000002UL)
   
4. #define SPI_MASTER_SS_IDLENESS_03CYCLE                (0x00000003UL)
   # f: O) U# W* m. v4 J% L
5. #define SPI_MASTER_SS_IDLENESS_04CYCLE                (0x00000004UL)
   
6. #define SPI_MASTER_SS_IDLENESS_05CYCLE                (0x00000005UL)
   * P, X- c) l3 ?$ \2 `1 }# ?
7. #define SPI_MASTER_SS_IDLENESS_06CYCLE                (0x00000006UL)
   
8. #define SPI_MASTER_SS_IDLENESS_07CYCLE                (0x00000007UL)
   
9. #define SPI_MASTER_SS_IDLENESS_08CYCLE                (0x00000008UL)
   
10. #define SPI_MASTER_SS_IDLENESS_09CYCLE                (0x00000009UL)
    
11. #define SPI_MASTER_SS_IDLENESS_10CYCLE                (0x0000000AUL)
    : t- Z- f: x5 {, r+ y6 l. h( q' u
12. #define SPI_MASTER_SS_IDLENESS_11CYCLE                (0x0000000BUL)
    * C# h% y5 ~7 F8 \, t6 Q
13. #define SPI_MASTER_SS_IDLENESS_12CYCLE                (0x0000000CUL)
    $ r+ s. E4 ]$ e, ?& H& t
14. #define SPI_MASTER_SS_IDLENESS_13CYCLE                (0x0000000DUL)
    
15. #define SPI_MASTER_SS_IDLENESS_14CYCLE                (0x0000000EUL)
    3 j' w# n) A7 C5 {: {4 d( S
16. #define SPI_MASTER_SS_IDLENESS_15CYCLE                (0x0000000FUL)
    6 I% m, Q* b  A0 \: |

复制代码

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

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

复制代码

  MasterReceiverAutoSusp
2 ~5 o/ l; z5 k3 p4 \用于控制主器件接收器模式下的连续 SPI 传输以及自动管理，以避免出现上溢情况。
% G# l8 q9 d& D# r, G

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

复制代码

  MasterKeepIOState
% ~( A/ @% f/ K7 {% l! g2 y禁止SPI后，SPI相关引脚保持当前状态，以防止出现毛刺。在从模式下，该位不应该使用。

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

复制代码

  IOSwap
" l" d" @0 S: C4 y( V/ N- P% T用于交换MISO和MOSI引脚。
6 O+ H4 L; o9 v

1. #define SPI_IO_SWAP_DISABLE                           (0x00000000UL)
   + a9 [& i6 P# A! [  z" F) |
2. #define SPI_IO_SWAP_ENABLE                            SPI_CFG2_IOSWP

复制代码

72.3.3 SPI总线句柄结构体SPI_HandleTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：
' x6 s: O3 o$ [# F9 `" r

1. typedef struct __SPI_HandleTypeDef
   % j! v8 j3 v+ `
2. {
   8 v3 s6 [/ w( h1 I. Y4 v1 }
3.   SPI_TypeDef                *Instance;                 
   
4.   SPI_InitTypeDef            Init;                        
     E! Z$ T  I! r/ S
5.   uint8_t                    *pTxBuffPtr;                 
   
6.   uint16_t                   TxXferSize;                  
   
7.   __IO uint16_t              TxXferCount;                  
   ! }/ C, ?6 Q# W' X% R1 k) g
8.   uint8_t                    *pRxBuffPtr;               
   , Y' |$ W% q& H
9.   uint16_t                   RxXferSize;                  
   * i& i# Y, ?( u" x$ [& e  O
10.   __IO uint16_t              RxXferCount;                 
    
11.   uint32_t                   CRCSize;                     
    
12.   void (*RxISR)(struct __SPI_HandleTypeDef *hspi);      
    : d1 }0 i6 L5 M  L* o  U/ F! Y* }% u
13.   void (*TxISR)(struct __SPI_HandleTypeDef *hspi);        
    + V3 n4 V. Z' g
14.   DMA_HandleTypeDef          *hdmatx;                     
    
15.   DMA_HandleTypeDef          *hdmarx;                     
    4 z- R0 ^; Y) e9 \/ O( {
16.   HAL_LockTypeDef            Lock;                        
    : k* f& o6 y3 A! I5 D8 d
17.   __IO HAL_SPI_StateTypeDef  State;                        
    7 x" e) O- F4 X8 e% L
18.   __IO uint32_t              ErrorCode;                  
    
19. #if defined(USE_SPI_RELOAD_TRANSFER)
    
20.   SPI_ReloadTypeDef          Reload;                     
    
21. #endif
    
22. 
    
23. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
24.   void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    % Y9 J' E; K" l' T; f$ F9 v& q
25.   void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
26.   void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    
27.   void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    ! [, A# G$ W+ N  D4 h6 G1 N4 P
28.   void (* RxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    & ~/ @- ]* v1 V6 M, ?
29.   void (* TxRxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);
    ' @& M( E5 j, G9 Q- H0 ?
30.   void (* ErrorCallback)(struct __SPI_HandleTypeDef *hspi);      
    2 m6 [# [, |; o: s# Q
31.   void (* AbortCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    ( y! n0 m' `0 B$ o7 H! C% L
32.   void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);   
    
33.   void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);
    ' g: y( e7 H$ [, Y/ |3 j
34. #endif  
    , P; y1 `8 F$ y# @6 {
35. } SPI_HandleTypeDef;
    

复制代码

注意事项：
& K- g1 Z! r6 m2 a& Y
1 T' j* o5 A3 K( F9 A条件编译USE_HAL_SPI_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

2 J0 d! }3 J/ ^" _4 w  #define   USE_HAL_SPI_REGISTER_CALLBACKS   1

通过函数HAL_SPI_RegisterCallback注册回调，取消注册使用函数HAL_SPI_UnRegisterCallback。

这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。
% Y) r9 b5 N" E1 B: A" g! L; k' O
  SPI_TypeDef   *Instance
7 p5 c2 k4 u6 |$ F+ L- o) g这个参数是寄存器的例化，方便操作寄存器，比如使能SPI1。

SET_BIT(SPI1 ->CR1,  SPI_CR1_SPE)。
+ T* }( n6 g+ ?: G/ @
  SPI_InitTypeDef  Init
+ ]" J8 r5 V: S- y" @; D这个参数是用户接触最多的，在本章节3.2小节已经进行了详细说明。

  DMA_HandleTypeDef          *hdmatx               
  DMA_HandleTypeDef          *hdmarx
% O! ^# ?' S& L9 [; y- ~用于SPI句柄关联DMA句柄，方便操作调用。
/ j; i$ v  [. ]# M# g) [8 [  G
72.4 SPI总线源文件stm32h7xx_hal_spi.c
' l0 Y2 N$ G5 p0 j此文件涉及到的函数较多，这里把几个常用的函数做个说明：
; @  [& @6 N" t' F4 Y$ a* |
" ~! H1 J0 B/ j+ w: E  HAL_SPI_Init
  HAL_SPI_DeInit
  HAL_SPI_TransmitReceive
  HAL_SPI_TransmitReceive_IT
' r/ L+ b* y- x6 |  r: }: [7 V/ ~8 Y  HAL_SPI_TransmitReceive_DMA
/ q/ U5 e0 v4 C' Y
72.4.1 函数HAL_SPI_Init
函数原型：
/ F5 `7 ^1 f6 p5 H- Q. ]. v5 V2 J
6 J) V* c* N, x$ j3 ?

1. HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
     o5 T6 {5 ?+ s1 q) o/ E+ B. K
2. {
   
3.   uint32_t crc_length = 0UL;
   8 J8 H  t4 s) n0 X! q
4.   uint32_t packet_length;
   
5. 
   
6.   /* 省略未写 */
   
7. 
   5 d6 ~2 c, h& u  R: K# W" Y* T
8.   /* 如果数据位宽大于16bit，必须是SPI1，SPI2或者SPI3，而SPI4，SPI5和SPI6不支持大于16bit */
   9 I% E/ z$ r% }8 k
9.   if ((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (hspi->Init.DataSize > SPI_DATASIZE_16BIT))
   . T8 ^) y2 A6 m( h
10.   {
    
11.     return HAL_ERROR;
    / I9 S0 C; P% K
12.   }
    
13. 
    
14.   /* SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit
    
15.      这里是查看设置的缓冲大小是否超出了FIFO支持的大小。
    ; K, y& v0 z" f# c  t6 v1 e
16. */
    3 V& l5 V" U% c) G+ B7 h
17.   packet_length = SPI_GetPacketSize(hspi);
    & O# B+ ]$ |; x
18.   if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_LOWEND_FIFO_SIZE)) ||
    5 {6 b" b! e, T6 o
19.       ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_HIGHEND_FIFO_SIZE)))
    ( J  ]& p7 P/ f# x
20.   {
    
21.     return HAL_ERROR;
    . _. q3 j, _+ i7 ^; t
22.   }
    3 q+ ~, @6 W* _5 s  s5 Q
23. 
    3 S: W; w3 F: `  ^
24. #if (USE_SPI_CRC != 0UL)
    
25.     /* 省略未写 */
    
26. #endif
    ! D/ `. x- i! y" I6 S
27. 
    
28.   if (hspi->State == HAL_SPI_STATE_RESET)
    
29.   {
    
30.     /* 解锁 */
    
31.     hspi->Lock = HAL_UNLOCKED;
    
32. 
    
33.     /* 使用自定义回调 */
    7 U2 T, L; k# B; `
34. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
35.     /* 设置默认回调函数 */
    
36.     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */
    ; \5 e+ i2 r/ E6 D  n& u% g
37.     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */
    1 c2 ?) M6 X& @2 [. U: B& T
38.     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */
    ) |, b. v! H9 J7 Y  t
39.     hspi->TxHalfCpltCallback   = HAL_SPI_TxHalfCpltCallback;   /* Legacy weak TxHalfCpltCallback   */
    ; M. K6 M* v. l  H, x1 I3 K: J' c/ ]
40.     hspi->RxHalfCpltCallback   = HAL_SPI_RxHalfCpltCallback;   /* Legacy weak RxHalfCpltCallback   */
    : A0 T0 g8 V- `8 m0 F- n0 z
41.     hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */
    # M6 {" l6 C# M& O) P: _5 }; [! r
42.     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */
    " g1 a9 m/ a7 r/ @8 s
43.     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */
    
44. 
    
45.     if (hspi->MspInitCallback == NULL)
    : S) U! M2 a+ e, r! V
46.     {
    8 X  S: j) h/ A1 N$ s6 L, O
47.       hspi->MspInitCallback = HAL_SPI_MspInit;
    
48.     }
    
49. 
    
50.     /* 初始化地址硬件: GPIO, CLOCK, NVIC... */
    
51.     hspi->MspInitCallback(hspi);
    - t: d' @) H; K$ S8 F, [
52. #else
    * `- e5 `  G* N
53.     /* 初始化底层硬件: GPIO, CLOCK, NVIC... */
    
54.     HAL_SPI_MspInit(hspi);
    
55. #endif
    % e: c( O: E" e# g/ E
56.   }
    3 i# S$ D- \* j9 z# V
57. 
    
58.   hspi->State = HAL_SPI_STATE_BUSY;
    
59. 
    & ]* m7 B2 x! Z# G' N
60.   /* 禁止SPI外设 */
    
61.   __HAL_SPI_DISABLE(hspi);
    
62. 
    # c9 X5 f* g# ^6 E
63.   /*----------------------- SPIx CR1 & CR2 配置---------------------*/
    
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);
    
68.   }
    5 H( J( t, F0 K' m1 p( h
69. 
    " i; h7 D# d; }7 h  c  O# B
70.   /* SPIx CFG1配置 */
    
71.   WRITE_REG(hspi->Instance->CFG1, (hspi->Init.BaudRatePrescaler | hspi->Init.CRCCalculation | crc_length |
    
72.                                    hspi->Init.FifoThreshold     | hspi->Init.DataSize));
    
73. 
    # P; Q% R+ r0 a
74.   /* SPIx CFG2配置 */
    
75.   WRITE_REG(hspi->Instance->CFG2, (hspi->Init.NSSPMode     | hspi->Init.TIMode           | hspi->Init.NSSPolarity  |
    ) ?# [, ^) l" a1 E1 @8 S; X9 \5 \
76.                                    hspi->Init.NSS          | hspi->Init.CLKPolarity      | hspi->Init.CLKPhase     |
    * M9 ?' J7 z5 Y: C  p( y
77.                                    hspi->Init.FirstBit     | hspi->Init.Mode             | hspi->Init.MasterInterDataIdleness |
    
78.                                    hspi->Init.Direction    | hspi->Init.MasterSSIdleness | hspi->Init.IOSwap));
    
79. 
    ; B; d! o: N7 e) V" G3 k+ r. I
80. #if (USE_SPI_CRC != 0UL)
    
81.   /*---------------------------- SPIx CRC配置 ------------------*/
    ) r% o: {9 y" J/ U  G6 I' A$ O7 |
82.   /* 配置SPI CRC */
    
83.   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    / m" p7 \9 k( U3 ]' F
84.   {
    
85.     /* 初始化TX CRC初始值 */
    
86.     if (hspi->Init.TxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    
87.     {
    $ C" M# T7 B3 t- g
88.       SET_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    
89.     }
    
90.     else
    ' {9 P% Z% L+ |5 C
91.     {
      |+ m& j& T6 Z7 b% E% M7 @& r4 M5 S/ J
92.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    $ i: I' ^8 r  D" P
93.     }
    
94. 
    7 w. t* @& {( L, `8 u
95.     /* 初始化RXCRC初始值 */
    
96.     if (hspi->Init.RxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    
97.     {
    
98.       SET_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
    
99.     }
    6 T4 Z8 r( E$ H' R8 X3 A
100.     else
     
101.     {
     : r: F: `  d% |& ^) D  L
102.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
     , C  @$ p0 J) d, O
103.     }
     3 L2 @" ?2 N- e: |, @
104. 
     
105.     /* 使能 33/17 bit CRC计算 */
     ( f7 F0 x9 H8 v
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)))
     + G, F- M, w: _9 d
108.     {
     
109.       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     
110.     }
     
111.     else
     - c; S8 J% D! d# K, S/ p1 L
112.     {
     
113.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     9 Z2 [8 K+ S& r3 m7 E
114.     }
     ! P1 D) m8 @+ w$ Z2 Z' G
115. 
     $ h6 u# g2 C8 l) E. V- ^0 F5 m
116.     /* 写CRC多项式到SPI寄存器 */
     ' M6 k% y4 a9 N/ b9 ]* A
117.     WRITE_REG(hspi->Instance->CRCPOLY, hspi->Init.CRCPolynomial);
     ) U2 K. r7 Y' v# @
118.   }
     3 I- k  S3 D  B+ T8 y: E
119. #endif
     
120. 
     
121.   /* SPI从模式，下溢配置 */
     
122.   if (hspi->Init.Mode == SPI_MODE_SLAVE)
     
123.   {
     
124.     /* 设置默认下溢配置 */
     0 _7 l* W3 t# `0 F, ~- ~
125. #if (USE_SPI_CRC != 0UL)
     
126.     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_DISABLE)
     
127. #endif
     
128.     {
     , ?8 a1 i+ N7 P. l, F
129.       MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, SPI_CFG1_UDRDET_0);
     / c* C0 q* I9 l* M# R: X
130.     }
     
131.     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRCFG, SPI_CFG1_UDRCFG_1);
     
132.   }
     ' Y% f$ `% l* I5 I7 K
133. 
     
134. #if defined(SPI_I2SCFGR_I2SMOD)
     
135.   CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);
     
136. #endif
     
137. 
     
138.   /* 确保AFCNTR bit由SPI主机模式管理 */
     8 y1 s1 w* B& b! p1 Z
139.   if ((hspi->Init.Mode & SPI_MODE_MASTER) == SPI_MODE_MASTER)
     
140.   {
     - p4 n# M3 r! ]9 d/ Y
141.     /* Alternate function GPIOs control */
     
142.     MODIFY_REG(hspi->Instance->CFG2, SPI_CFG2_AFCNTR, (hspi->Init.MasterKeepIOState));
     
143.   }
     $ L8 W% C/ |/ ?8 f
144. 
     
145.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
     
146.   hspi->State     = HAL_SPI_STATE_READY;
     " d/ u. A: n! o) D6 Q# ^
147. 
     - J6 Y$ L3 X6 x
148.   return HAL_OK;
     
149. }
     ( `" K' |, u& ?0 [# i. w; F

复制代码

. }% D" |( y: Y5 o3 R7 p$ h8 {9 ]函数描述：
/ ~  w* E; A# i1 Z" J
' h; ]; q6 {- M! R. Q9 X0 I此函数用于初始化SPI。
+ }& ^, I- ?+ C0 F4 m( |; m
函数参数：
. J! h7 ^0 H- I6 d7 C! }
) V5 b. t& ]( o) p  j  第1个参数是SPI_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。


注意事项：
函数HAL_SPI_MspInit用于初始化SPI的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hspi的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SPI_HandleTypeDef SpiHandle。
$ h' F6 `4 f% v$ `( G5 }对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SPI_STATE_RESET  = 0x00U。
' m9 y( p: \$ f0 ~: j# @( n
解决办法有三

方法1：用户自己初始化SPI和涉及到的GPIO等。

' p0 \- }+ H* I方法2：定义SPI_HandleTypeDef SpiHandle为全局变量。
6 _& h' b+ ~$ _
方法3：下面的方法
0 F3 r, J/ e( y" y. Y. {! s

1. if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK)
   7 \1 K) E. A$ W9 h5 |: \
2. {
   
3.     Error_Handler();
   ) I( A3 K. m% I. E+ g
4. }  
   $ E% K  _1 M8 V8 u: J- t* }1 t
5. if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
   
6. {
   / ^) V" [- T& i5 f2 B* f% z
7.     Error_Handler();
   
8. }

复制代码

使用举例：

1. SPI_HandleTypeDef hspi = {0};
   1 [+ r' b" |5 X" |1 \" a
2. 
   + t) _; H9 o0 i, p0 X
3. /* 设置SPI参数 */
   ( v# A. Q7 a* y: ?/ \
4. hspi.Instance               = SPIx;                   /* 例化SPI */
   
5. hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
   
6. hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
   % D+ [! C3 E7 X6 s$ M7 b
7. hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
   
8. hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
   
9. hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
   # V0 x& F; |) A
10. hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    
11. hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
    
12. hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;      /* 禁止CRC */
    
13. hspi.Init.CRCPolynomial     = 7;                               /* 禁止CRC后，此位无效 */
    ! p* P0 l6 \8 ]. Y
14. hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;             /* 禁止CRC后，此位无效 */
    
15. hspi.Init.NSS               = SPI_NSS_SOFT;                    /* 使用软件方式管理片选引脚 */
    9 l( N8 m2 t6 y0 x1 U- q0 |  W  m1 [
16. hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;       /* 设置FIFO大小是一个数据项 */
      l( h" L5 {# Z* t4 N3 z  Y' D" o( n
17. hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;           /* 禁止脉冲输出 */
    4 R* G0 M, ^5 C- J# v
18. hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    
19. hspi.Init.Mode                  = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    
20. 
    
21. if (HAL_SPI_Init(&hspi) != HAL_OK)
    
22. {
    
23.     Error_Handler(__FILE__, __LINE__);
    5 ]: {& s8 B1 h+ g7 S) U
24. }

复制代码

72.4.2 函数HAL_SPI_DeInit
# f& y  D4 m! n- q$ [函数原型：

1. HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
   7 C! M8 J& e* j3 f" a7 ~' k
2. {
   4 W/ K" F! M- f8 r4 Y
3. /* 检测SPI句柄是否有效 */
   2 _1 N- S5 q" l
4.   if (hspi == NULL)
   
5.   {
   0 R5 v0 D: R8 z6 C: d) X, b
6.     return HAL_ERROR;
   / T; X1 `. z  ~5 ]! e! Z# {
7.   }
   
8. 
   
9. /* 检查SPI例化参数 */
   
10.   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
    
11. 
    
12.   hspi->State = HAL_SPI_STATE_BUSY;
    
13. 
    
14.   /* 禁止SPI外设时钟 */
    - G$ `' k* q; D8 S% P  `
15.   __HAL_SPI_DISABLE(hspi);
    ) p/ y$ @) ^7 e2 S3 M
16. 
    
17. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    " y3 o8 G( y" ?7 P, D. N" P2 g
18.   if (hspi->MspDeInitCallback == NULL)
    
19.   {
    # e* @9 N( S; Z) [8 i( k
20.     hspi->MspDeInitCallback = HAL_SPI_MspDeInit;
    ' ]- n9 X3 d2 Z2 f) p3 b$ K5 y
21.   }
    8 H" `) U" y6 h+ u7 Y! e+ b$ b
22. 
    
23.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    $ a7 O, M2 i" \9 T" D( @5 J' L+ Q
24.   hspi->MspDeInitCallback(hspi);
    
25. #else
    - A% n* ~2 p7 r
26.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    
27.   HAL_SPI_MspDeInit(hspi);
    
28. #endif
    ! A6 z$ b$ r1 {  S+ |/ i
29. 
    
30.   /* 设置无错误，复位状态标记 */
    6 \1 W1 X7 s8 F
31.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
    5 \1 P$ S& ^8 d7 b2 S* B
32.   hspi->State = HAL_SPI_STATE_RESET;
    
33. 
    ; r5 T6 \7 K1 f' F6 Y) c4 Q6 |
34.   /* 解锁SPI */
    ' `7 v5 ]$ r+ a- e
35.   __HAL_UNLOCK(hspi);
    3 O1 K3 X& f) {
36. 
    $ Q! n7 f0 E' `- C9 Q
37.   return HAL_OK;
    " h/ A- Z; M+ [! A
38. }

复制代码

6 {' N: ]  n* `5 @& L函数描述：
2 ]* @) I$ B) e% \# t
用于复位SPI总线初始化。
, U9 Y9 a0 L: O8 l% B
函数参数：

  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中

* y+ b, _+ j3 V# m0 N0 Q
  \  X1 K7 ^- R" Q3 H72.4.3 函数HAL_SPI_TransmitReceive
3 m* V7 e( e0 P, N: |' F" H5 J函数原型：

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
   + t( ^% |* S6 g# R4 k7 C
2. {
     M- a, @6 }6 ?/ K8 p
3. 
   8 J. d3 x; h) [8 C) C! y
4.    /* 省略未写 */
   0 l+ J( X+ \' r# ^
5. 
   + C; H& k- W$ K$ V" S- W; |: q# ]
6.   /* 大于16bit的数据收发 */
   
7.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
   
8.   {
   " e0 |' L7 ]8 H0 p$ p! s- n
9.        /* 省略未写 */
   * Q: P( ]4 _2 u$ F: f) `1 H
10.   }
    
11.   /* 大于8bit，小于16bi的数据收发 */
    
12.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    ; d+ N6 w/ v- g
13.   {
    2 l! u4 \# C3 q, t& {% l9 M
14.       /* 省略未写 */
    
15.   }
    4 G  g& N* h7 b5 ~+ S8 H
16.   /* 小于等于8bit的数据收发 */
    
17.   else
    , s! T) U9 j7 _1 L- T0 F: X
18.   {
    8 L- F: l& O) L# @; _5 f
19.        /* 省略未写 */
    ) ]5 Y* N- r% i3 V# f4 Z& x
20.   }
    
21. 
    
22. }

复制代码

函数描述：
' U4 d! F5 {/ Z! r
, X% ]" d, ~- i  t此函数主要用于SPI数据收发，全双工查询方式。

函数参数：
/ _( W! L; ?$ g$ l: R4 D, O
+ }: H( h3 |( m: O) q7 A  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
  第5个参数是传输过程的溢出时间，单位ms。
2 ?! M1 p& _0 r+ X8 T# M  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
. S- @, D7 F1 M* O7 x

使用举例：

1. SPI_HandleTypeDef hspi = {0};
   9 h( J4 k- Z- T6 V
2. 
   5 u  K' w. S7 g% T  m. ]* ]8 @; h! C
3. if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)
   
4. {
   ' }1 P% Y: a. ?8 X2 P& o+ S: l
5.     Error_Handler(__FILE__, __LINE__);
   
6. }

复制代码

72.4.4 函数HAL_SPI_TransmitReceive_IT
3 T9 O7 j* v8 A( e函数原型：

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
   - E" a0 K( P# {" W+ l0 ]
2. {
   2 f" u' G7 `2 i& s& B5 j
3.    /* 省略未写 */
   0 R9 s" M/ ~' D2 P0 f7 {5 ~2 S
4. 
   5 B) t6 l: l1 `
5.   /* 设置传输参数 */
   
6.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
     K3 Q7 l) B& Y* L& b8 }
7.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
   2 h. M3 ?! f+ N) C* }# D4 ?
8.   hspi->TxXferSize  = Size;
   
9.   hspi->TxXferCount = Size;
   
10.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
    
11.   hspi->RxXferSize  = Size;
    & D4 K4 _7 `& l( p2 B: \
12.   hspi->RxXferCount = Size;
    % l5 X' n' H7 l% o0 M
13. 
    0 O( x" i1 L0 f7 L( Y) U1 S  [
14.   /* 设置中断处理 */
    1 s, d) t- b) \$ ~1 @* n
15.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    & `9 }2 x' f2 e
16.   {
    8 P$ o! V% m+ O5 e" u4 e7 x: m
17.     hspi->TxISR     = SPI_TxISR_32BIT;
    % _5 o0 p* r& R: E) H
18.     hspi->RxISR     = SPI_RxISR_32BIT;
    + E$ y: v9 [+ \( j3 Y! ^" B* {8 V
19.   }
    
20.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    
21.   {
    " G: c0 x" @- v( k* v- @, @
22.     hspi->RxISR     = SPI_RxISR_16BIT;
    ; G: T' y0 ^) s6 Y% d  c$ V. r
23.     hspi->TxISR     = SPI_TxISR_16BIT;
    ! h7 m% g; `  N( F+ c4 o
24.   }
    ( [7 O8 I/ h8 U) {! q+ A
25.   else
    
26.   {
    
27.     hspi->RxISR     = SPI_RxISR_8BIT;
    5 z% p3 }2 Q6 P6 |/ j
28.     hspi->TxISR     = SPI_TxISR_8BIT;
    
29.   }
    ' h$ N# G5 v+ i$ j! t8 }
30. 
    % q+ q3 x$ w6 j8 S& ]1 I
31.   /* 设置当前传输数据大小 */
    ; j( ?" G+ j$ \: g
32.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    & ^7 V5 |# o/ e9 V2 b& C5 ~6 m
33. 
    
34.   /* 使能SPI外设 */
    
35.   __HAL_SPI_ENABLE(hspi);
    % ^. C7 \6 A8 u0 [" Q( c
36. 
    
37.   /* 使能各种中断标志 */
    
38.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_EOT | SPI_IT_RXP | SPI_IT_TXP | SPI_IT_DXP | SPI_IT_UDR | SPI_IT_OVR |
    
39. SPI_IT_FRE | SPI_IT_MODF | SPI_IT_TSERF));
    
40. 
    - K- D; }  O% @& P% l
41.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    
42.   {
    
43.     /* 启动传输 */
    8 Z% S9 b% W) R3 a4 z1 k
44.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
    
45.   }
    + D9 \5 p1 U4 n1 C, r" x
46. 
    5 p4 v( {# {9 A1 k1 W1 h" h% W
47.   /* 解锁 */
    
48.   __HAL_UNLOCK(hspi);
    . S: H$ g4 P, _) _6 X
49.   return errorcode;
    
50. }
    

复制代码

函数描述：
7 D1 x9 ]$ c) a- h0 F- R* e# Z! B
此函数主要用于SPI数据收发，全双工中断方式。

; v4 h& a/ i# q$ o$ z, H" h函数参数：

# u; m% j9 n: g3 j  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
, D  g% j1 _8 [2 m  第2个参数是发送数据缓冲地址。
  第3个参数是接收数据缓冲地址。
% X" X0 `0 w) o8 R- g( r  第4个参数是传输的数据大小，单位字节个数。
1 a# B0 J' l9 y" A, _* Z4 C  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
4 N! S, `$ v7 @1 X+ s. `& V

6 _% ]1 A( X0 H" v0 e: l# G1 a使用举例：
& |  t! C' z! h, s

1. SPI_HandleTypeDef hspi = {0};
   : s; a& j) U/ [$ ]
2. 
   
3. if(HAL_SPI_TransmitReceive_IT(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   0 L& g5 M' S* R4 `7 L3 T/ v
4. {
   + x8 S  V2 ]5 G1 @* B; X4 V
5.     Error_Handler(__FILE__, __LINE__);
   / _- b' h& c- u1 m$ R! }7 F. \
6. }

复制代码

5 f6 z" i4 y/ f1 Q. @$ h0 T5 m72.4.5 函数HAL_SPI_TransmitReceive_DMA
$ J/ f7 `3 b7 l函数原型：
, @3 U' N. I- D; d0 E5 \% t

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,
   0 C6 t! |( H0 M2 H
2.                                               uint16_t Size)
   
3. {
   3 n, R/ R  w6 p$ T; J
4.    /* 省略未写 */
   - ~4 J# d' P: @+ v/ _% ]3 n7 H
5. 
   ) X3 s# d# S9 G
6. /* 注意DMA的位宽和对齐设置 */
   
7.   if (((hspi->Init.DataSize > SPI_DATASIZE_16BIT) && (hspi->hdmarx->Init.MemDataAlignment !=
   $ @7 f2 F# U: t, H% m
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))))
   ! u( g) g- D4 z! E0 B, _" X5 X1 d  K
10.   {
    6 k5 Y& p3 h' f# \
11.   }
    
12. 
    
13. /* 调整DMA对齐和数据大小 */
    6 V1 |& T1 X# ^5 u+ K2 T
14.   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)
    . K+ L) X4 W1 w2 ]; }1 @
15.   {
    
16.      /* 省略未写 */
    * g8 p2 U  W! v0 f. H
17.   }
      m" P" Q4 i( E8 v4 F2 h
18.   else if (hspi->Init.DataSize <= SPI_DATASIZE_16BIT)
    . |3 `: n1 ?1 M4 c
19.   {
    0 ~  M9 [$ k' ?& H- J: d# ^
20.      /* 省略未写 */
    
21.   }
    
22.   else
    1 ^2 t4 M0 m( y- `/ u
23.   {
    ; ~' K2 ^! E$ z
24.       /* 省略未写 */
    
25.   }
    : e) c) t( N. f( I/ U5 g: D
26. 
    6 L1 y* M9 K! R" B, G
27. /*  DMA接收配置 */
    
28.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->RXDR, (uint32_t)hspi->pRxBuffPtr,
    
29. hspi->RxXferCount))
    ) ?! f! B6 m3 p4 L
30.   {
    $ M7 V( E/ \/ m2 r
31. 
    2 f$ p2 ]2 p& q/ G6 i0 }
32.   }
    
33. 
    
34. /* DMA发送配置 */
    + _5 B' F: P% K7 ^' n( ~5 P/ w6 @. o3 q
35.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->TXDR,
    ! R" l) s8 q4 r& A
36. hspi->TxXferCount))
    
37.   {
    
38.   }
    + f" C* b/ i: ~7 f, I. |6 ~
39. 
    
40.   /* 省略未写 */
    : n0 d! V, n# }! ~. L
41. }
      v) m& k1 ^( I8 g

复制代码

函数描述：
# v0 `7 Z: U8 W* ~! d& l% B
此函数主要用于SPI数据收发，全双工DMA方式。
" d& n' m0 _- ?1 E
函数参数：

. O. L6 ]% Z$ z( X- h  k1 D  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
" }+ P3 O" \; c; q: ?: p, ^8 v' g) z  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。

* E  v/ K0 \" e1 Z
使用举例：
& I) R! c8 J; \2 P' K
. ?4 e' F* d! v) L4 {

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   , R( x& c' M6 O; o# b
3. if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   
4. {
   
5.     Error_Handler(__FILE__, __LINE__);
   
6. }
   . h  q) l: L2 _: Q; f8 ?; ~1 P/ [# k. T

复制代码

72.5 总结
$ I5 _& ~& F( |/ S+ w本章节就为大家讲解这么多，要熟练掌握SPI总线的查询，中断和DMA方式的实现，因为基于SPI接口的外设芯片很多，熟练后，可以方便的驱动各种SPI接口芯片，以便选择合适的驱动方式。
. f4 c! a+ H( N! o4 G# z7 S
: G& l4 n- w8 ]4 S% C- l
0 C1 \# D: ^& w! L+ s

- ^- E6 [6 j0 R: ^6 A, M
. @3 X* i6 m3 t0 Y4 E