72.1 初学者重要提示
  STM32H7的SPI支持4到32bit数据传输，而STM32F1和F4系列仅支持8bit或者16bit。
  STM32H7的主频400MHz时，SPI1, 2, 3最高通信时钟是100MHz，而SPI4, 5, 6是50MHz。
" u0 }/ N+ _/ g* J$ E) C* u# o. T1 j  STM32H7的MISO和MOSI引脚功能可以互换，使用比较灵活。
  SPI总线的片选引脚SS在单一的主从器件配置下是可选的，一般情况下可以不使用。

72.2 SPI总线基础知识
72.2.1 SPI总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SPI的基本功能，然后再看手册了解细节。
' F8 l$ V  B# O0 }1 @# \
/ @/ c) K" [* {1 [$ A

% i0 k( W. x3 q+ z
通过这个框图，我们可以得到如下信息：

  spi_wkup输出
5 }0 B  @3 m; O4 ^低功耗唤醒信号。

" O8 p! R8 e! H  spi_it输出
0 D, `2 E/ n- v6 V0 q7 H8 Wspi的中断请求信号。

  spi_tx_dma
spi_rx_dma
1 l% M% ?' r) xspi的DMA发送和接收请求信号。
$ V1 b& J7 Z. b7 `6 l- C- n$ ^
  t8 N* E- `) S& a6 d" X) _  spi_pclk
& Q) @6 ?0 A# f9 g7 C& V% v为寄存器提供时钟。
4 F/ }6 d0 L5 @$ j9 \
  spi_ker_ck
为spi内核时钟。

- d# T" v' ]7 h7 I  SCK（CK），Serial Clock
# c! z2 w! H3 ~* `此引脚在主机模式下用于时钟输出，从机模式下用于时钟输入。
# Z' s3 i6 O( s' n/ h( E
" _7 ~. p9 g7 F' F) E3 x  MISO（SDI），Master In / Slave Out data
此引脚在从机模式下用于发送数据，主机模式下接收数据。
( A4 N4 ?/ L- M5 d/ r9 t
7 j- p# U- P1 U/ C9 k7 E0 I% B  MOSI（SDO）, Master Out / Slave In data
* L/ m1 _& ^# S; Y' w6 o$ X此引脚在从机模式下用于数据接收，主机模式下发送数据。

- ]! E1 Z3 A2 ~* q( d  SS（WS）, Slave select pin
2 e  T' V- r" q+ m3 D7 a/ a% P根据SPI和SS设置，此引脚可用于：
! A) U+ m* S$ r
a. 选择三个从器件进行通信。

" {& M6 m$ L; f/ ob. 同步数据帧。

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

通过这个框图还要认识到一点，SPI有三个时钟域，分别是寄存器所在的ABP总线时钟域，内核时钟发生器时钟域以及内核时钟发生器分频后的串行时钟域。
+ N5 D$ P9 A- m1 B3 n' a
72.2.2 SPI接口的区别和时钟源（SPI1到SPI6）
这个知识点在初学的时候容易忽视，所以我们这里整理下。
, }& {1 i7 V; p: W  I( S* g: c% H
  SPI1到SPI6的区别
: ~/ f4 M7 N! }* S! `1 a  SPI1，SPI2和SPI3支持4到32bit数据传输，SPI4，SPI5和SPI6是4到16bit数据传输。
  SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit。
6 T0 [: j3 K$ Y. n# v

/ n5 n7 `# B( a- [# M: P& h" \; x  SPI1到SPI6的所在的总线（对应SPI框图的SPI_CLK时钟域）
SPI1，SPI4和SPI5在APB2总线，SPI2，SPI3在APB1总线，SPI6在APB4总线。注意，SPI的最高时钟不是由这些总线决定的。

; M/ N- ^& X1 Q1 c. T  {  SPI1到SPI6的支持的最高时钟（对应SPI框图的SPI_KER_CK）
- s4 L6 J- S1 E1 ], Q2 QSTM32H7主频在400MHz下，SPI1，SPI2和SPI3的最高时钟是200MHz，而SPI4,5,6是100MHz, 以SPI1为了，可以选择的时钟源如下：
! t& M* s2 V8 ]7 o4 ?5 m" `- z
2 S2 d" n$ z5 k

) g5 O3 I6 a* ?. g7 d+ y% J6 V8 e这里特别注意一点，SPI工作时最少选择二分频，也就是说SPI1,2,3实际通信时钟是100MHz，而SPI4,5,6是50MHz。
5 g6 K' s6 d& @
72.2.3 SPI总线全双工，单工和半双工通信
片选信号SS在单一的主从器件配置下是可选的，一般情况下可以不使用。但需要同步数据流，或者用于TI模式时需要此信号。
4 y; l# M- x) F8 `3 \
  全双工通信
2 m7 N  g- ^8 J  l! s全双工就是主从器件之间同时互传数据，SPI总线的全双工模式接线方式如下：

( I/ {2 H  j+ g  e5 S8 `, W

5 t: B) s9 `1 e6 |: G* D关于这个接线图要认识到以下几点：
: _) G2 h6 G7 m6 R5 l
: b5 m/ f/ n, n& R  注意接线方式，对于主器件来说MISO引脚就是输入端，从器件的MISO是输出端，即Master In / Slave Out data。MOSI也是同样道理。
  每个时钟信号SCK的作用了，主器件的MISO引脚接收1个bit数据，MOSI引脚输出1个bit数据。
$ J2 Y2 O8 y  Y/ r; c; {$ U  这种单一的主从接线模式下，SS引脚可以不使用。
  半双工通信
+ ^- t0 j) N, d; i) d) T半双工就是同一个时刻只能为一个方向传输数据，SPI总线的半工模式接线方式如下：

  z, G3 V* H9 Y" V4 r  `+ D: o
% x. l* A; _8 \3 r关于这个接线图要认识到以下几点：
4 b1 ^3 \' t! v  f, @
" Q5 a; ^: a" z/ K  更改通信方式时，要先禁止SPI。
, X9 w; E* r; z2 o0 n- o  主器件的MISO和从器件的MISO不使用，可以继续用作标准GPIO。
  1KΩ的接线电阻很有必要，因为当主器件和从器件的通信方向不是同步变化时，容易出现其中一个输出低电平，另一个输出高电平，造成短路。
5 q& g! i* T1 t  i5 E  F  这种单一的主从接线模式下，SS引脚可以不使用。
  单工模式
) W' `* P+ P" i" s+ w单工就是只有一种通信方向，即发送或者接收，SPI总线的全双工模式接线方式如下：
5 i# w) Y" J! g# }0 j3 U" x
4 J3 M% U  ^* [

7 Y; p* L3 s7 ^
- Y$ ^! i6 j* W5 X* t0 }$ [* h关于这个接线图要认识到以下几点：

& O  ^* q( ?4 w( |7 N8 h  未用到的MOSI或者MISO可以用作标准GPIO。
) k8 \! i5 @) }. n- {! ~  这种单一的主从接线模式下，SS引脚可以不使用。
72.2.4 SPI总线星型拓扑
SPI总线星型拓扑用到的地方比较多，V7开发板就是用的星型拓扑外接多种SPI器件：

关于这个接线图，有以下几点需要大家了解：

7 ?+ J- x+ O  Z' d4 c- U  主器件的SS引脚不使用，使用通用GPIO控制。为每个器件配一个SS引脚，方便单独片选控制。
  从器件的MISO引脚要配置为复用开漏输出（很多外部芯片在未片选时，数据引脚是呈现高阻态）。
72.2.5 SPI总线通信格式
SPI总线主要有四种通信格式，由CPOL时钟极性和CPHA时钟相位控制：
, [( P* t' @" W3 _  J& b

" t- r- H; F. i( \4 O1 Q" i4 p
四种通信格式如下：

  当CPOL = 1， CPHA = 1时
4 C& d" U' y  i1 X( E2 ^SCK引脚在空闲状态处于低电平，SCK引脚的第2个边沿捕获传输的第1个数据。
. X0 |# ~8 D+ p; E
! Z5 _1 Y/ V- d8 c# E  当CPOL = 0， CPHA = 1时
3 ^' T8 }9 N# P" H5 \; XSCK引脚在空闲状态处于高电平，SCK引脚的第2个边沿捕获传输的第1个数据。

) }! p# L4 g1 p' @# z  当CPOL = 1， CPHA = 0时
SCK引脚在空闲状态处于低电平，SCK引脚的第1个边沿捕获传输的第1个数据。

  当CPOL = 1， CPHA = 0时
, [9 ^* x0 R0 j- H, ~/ R& gSCK引脚在空闲状态处于高电平，SCK引脚的第1个边沿捕获传输的第1个数据。
0 L- M: h1 i' R* A6 g. Y4 Y% o
72.3 SPI总线的HAL库用法
% o% A! k' I# A& M72.3.1 SPI总线结构体SPI_TypeDef
SPI总线相关的寄存器是通过HAL库中的结构体SPI_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

- z2 v9 |2 A, ~; x/ y" b& e

1. typedef struct
   * V1 a. X; s( W) n+ L. K
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 */
   6 N  h8 O% v% f2 S' r
5.   __IO uint32_t CFG1;          /*!< SPI Configuration register 1,                    Address offset: 0x08 */
   
6.   __IO uint32_t CFG2;          /*!< SPI Configuration register 2,                    Address offset: 0x0C */
   & K' h/ [+ g, v# U- l
7.   __IO uint32_t IER;           /*!< SPI/I2S Interrupt Enable register,               Address offset: 0x10 */
   5 _7 X  e% m" ?, v9 k
8.   __IO uint32_t SR;            /*!< SPI/I2S Status register,                         Address offset: 0x14 */
   ) E' a3 @& I7 h4 \% R
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 */
    / ]% y7 {' y6 K( P# |9 \$ h
12.   uint32_t      RESERVED1[3];  /*!< Reserved, 0x24-0x2C                                                   */
    " ~/ ~' E* J% v# z
13.   __IO uint32_t RXDR;          /*!< SPI/I2S Receive data register,                   Address offset: 0x30 */
    1 M- u) ]. Z2 U+ t
14.   uint32_t      RESERVED2[3];  /*!< Reserved, 0x34-0x3C                                                   */
    / M  @+ T& E( h, ^" f5 N' t$ {
15.   __IO uint32_t CRCPOLY;       /*!< SPI CRC Polynomial register,                     Address offset: 0x40 */
    
16.   __IO uint32_t TXCRC;         /*!< SPI Transmitter CRC register,                    Address offset: 0x44 */
    ) q/ x( p5 _& N
17.   __IO uint32_t RXCRC;         /*!< SPI Receiver CRC register,                       Address offset: 0x48 */
    3 O! i6 `2 s4 w( _  z
18.   __IO uint32_t UDRDR;         /*!< SPI Underrun data register,                      Address offset: 0x4C */
    
19.   __IO uint32_t I2SCFGR;       /*!< I2S Configuration register,                      Address offset: 0x50 */
    ) z. B7 W3 W: H8 e+ F3 Q4 k
20. 
    
21. } SPI_TypeDef;

复制代码

% h5 A8 T! V) B, l$ I这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。

& L$ i) V# s4 P% l! `- Q6 j7 P; b__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
* v! H! h+ p) ]8 B9 M- ^

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
     R  j+ D7 D2 R/ M5 u: X
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

5 X7 j; o) |$ M1 k下面我们看下SPI的定义，在stm32h743xx.h文件。
' D; ?& p: }& V! [2 }# L6 R
; ~, e5 }2 }0 l1 |

1. #define PERIPH_BASE           (0x40000000UL)
     P- x' \: k" ~6 o
2. #define D2_APB1PERIPH_BASE     PERIPH_BASE
   # n0 e- B- U; U/ r: O
3. #define D2_APB2PERIPH_BASE    (PERIPH_BASE + 0x00010000UL)
   
4. #define D3_APB1PERIPH_BASE    (PERIPH_BASE + 0x18000000UL)
   
5. 
   
6. #define SPI2_BASE             (D2_APB1PERIPH_BASE + 0x3800UL)
   8 l6 p0 u& n) z# }; A
7. #define SPI3_BASE             (D2_APB1PERIPH_BASE + 0x3C00UL)
   4 ~  n$ @0 P8 g6 J% z  E
8. #define SPI1_BASE             (D2_APB2PERIPH_BASE + 0x3000UL)
   ; Y" m, B! d/ s1 ~
9. #define SPI4_BASE             (D2_APB2PERIPH_BASE + 0x3400UL)
   
10. #define SPI5_BASE             (D2_APB2PERIPH_BASE + 0x5000UL)
    
11. #define SPI6_BASE             (D3_APB1PERIPH_BASE + 0x1400UL)
    
12. 
    5 N1 D3 @; D1 c* ]* L# w% W+ b
13. #define SPI1                ((SPI_TypeDef *) SPI1_BASE)
    5 g' w6 r' {% w& i/ D/ G
14. #define SPI2                ((SPI_TypeDef *) SPI2_BASE)
    / f9 _) K  f8 r
15. #define SPI3                ((SPI_TypeDef *) SPI3_BASE)
    
16. #define SPI4                ((SPI_TypeDef *) SPI4_BASE)
    
17. #define SPI5                ((SPI_TypeDef *) SPI5_BASE)
    4 _! p' P3 C$ n; L
18. #define SPI6                ((SPI_TypeDef *) SPI6_BASE) <----- 展开这个宏，(FLASH_TypeDef *)0x58001400

复制代码

9 K' G# W$ n1 B8 K6 S8 a4 f我们访问SPI的CR1寄存器可以采用这种形式：SPI->CR1 = 0。
% F3 O4 Z! @5 l5 }! t# @
72.3.2 SPI总线初始化结构体SPI_InitTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：

1. typedef struct
   6 W3 j9 `2 T" ^0 Y: B6 w7 F
2. {
   
3.   uint32_t Mode;                           
   4 Y' u/ v. x& P9 w
4.   uint32_t Direction;                     
   * y/ c- v& _' L4 y" S
5.   uint32_t DataSize;                          
   
6.   uint32_t CLKPolarity;                       
   
7.   uint32_t CLKPhase;                        
   
8.   uint32_t NSS;                             
   * a% a- l+ M. D- d) ^
9.   uint32_t BaudRatePrescaler;               
   
10.   uint32_t FirstBit;                        
    + B: j* e5 A* t5 Z$ V
11.   uint32_t TIMode;                          
    
12.   uint32_t CRCCalculation;                  
    * y. A6 q  s) d) ]& |3 [
13.   uint32_t CRCPolynomial;                     
    
14.   uint32_t CRCLength;                        
    7 k9 |7 {2 a3 B5 E' Y  L8 R. _
15.   uint32_t NSSPMode;                        
    % {0 f: I, I& F) A7 b
16.   uint32_t NSSPolarity;                    
    2 @4 i+ m) m8 q4 J: S5 u
17.   uint32_t TxCRCInitializationPattern;      
    
18.   uint32_t RxCRCInitializationPattern;      
    4 j# A* e/ K+ V2 T7 Z4 W6 e
19.   uint32_t MasterSSIdleness;                 
    1 {+ r- y6 v7 c0 W* G
20.   uint32_t MasterInterDataIdleness;           
    2 k; n& b9 E( T7 C+ L$ ]
21.   uint32_t MasterReceiverAutoSusp;         
    6 e' ^4 P9 y9 Z$ b  Z
22.   uint32_t MasterKeepIOState;               
    2 z& v9 l! a; J) s5 i4 {2 a/ i
23.   uint32_t IOSwap;                          
    
24. } SPI_InitTypeDef;

复制代码

+ x/ c4 ^: G, Z: m' B& P下面将结构体成员逐一做个说明：
% m! G! h( M1 P/ C+ ^# p. [) M
) m5 n5 v7 u. A6 n# F  Mode
* b3 S3 [! F1 T& m* J用于设置工作在主机模式还是从机模式。

' R4 U- F& I& g# O6 ?: a. p

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

复制代码

& t- \! T& I5 B- H* W6 o8 @+ g; R  Direction
% m  K" ~# q) t0 c3 q用于设置SPI工作在全双工，单工，还是半双工模式。

1. #define SPI_DIRECTION_2LINES           (0x00000000UL)     /* 全双工 */
   2 z- D0 j4 X1 V, J2 e& }, S" x$ ]
2. #define SPI_DIRECTION_2LINES_TXONLY     SPI_CFG2_COMM_0   /* 单工，仅发送 */
   
3. #define SPI_DIRECTION_2LINES_RXONLY     SPI_CFG2_COMM_1   /* 单工，仅接收 */
   0 X. ^5 `7 F- F6 }( o% R+ x
4. #define SPI_DIRECTION_1LINE             SPI_CFG2_COMM     /* 半双工 */

复制代码

7 S& v7 G1 S. {& `  DataSize
用于设置SPI总线数据收发的位宽，支持4-32bit。

1. #define SPI_DATASIZE_4BIT                             (0x00000003UL)
   
2. #define SPI_DATASIZE_5BIT                             (0x00000004UL)
   8 L" Z1 A% ?* G% u. |
3. #define SPI_DATASIZE_6BIT                             (0x00000005UL)
   
4. #define SPI_DATASIZE_7BIT                             (0x00000006UL)
   
5. #define SPI_DATASIZE_8BIT                             (0x00000007UL)
   
6. #define SPI_DATASIZE_9BIT                             (0x00000008UL)
   * H' Y# r6 Q9 j6 T4 d
7. #define SPI_DATASIZE_10BIT                            (0x00000009UL)
   
8. #define SPI_DATASIZE_11BIT                            (0x0000000AUL)
   
9. #define SPI_DATASIZE_12BIT                            (0x0000000BUL)
   3 g, z" s4 Y3 l1 }; N6 g% q) p
10. #define SPI_DATASIZE_13BIT                            (0x0000000CUL)
    " S9 F2 y% G& Q9 m; X0 G, @
11. #define SPI_DATASIZE_14BIT                            (0x0000000DUL)
    5 ~( _' ~# ^8 U$ u) u
12. #define SPI_DATASIZE_15BIT                            (0x0000000EUL)
      |; @- ]' P: |6 }6 H
13. #define SPI_DATASIZE_16BIT                            (0x0000000FUL)
    3 R0 R+ E% ]7 x8 y3 V: m' l
14. #define SPI_DATASIZE_17BIT                            (0x00000010UL)
    # c% Z2 @" B2 c0 m' m/ c4 K) ?
15. #define SPI_DATASIZE_18BIT                            (0x00000011UL)
    
16. #define SPI_DATASIZE_19BIT                            (0x00000012UL)
    
17. #define SPI_DATASIZE_20BIT                            (0x00000013UL)
    
18. #define SPI_DATASIZE_21BIT                            (0x00000014UL)
    
19. #define SPI_DATASIZE_22BIT                            (0x00000015UL)
    
20. #define SPI_DATASIZE_23BIT                            (0x00000016UL)
    % ^, B+ v! h, P1 X4 z* d& s# |2 i
21. #define SPI_DATASIZE_24BIT                            (0x00000017UL)
    
22. #define SPI_DATASIZE_25BIT                            (0x00000018UL)
    ; M# r! ~3 S3 t! [2 g, e: d; B4 ?" \% \
23. #define SPI_DATASIZE_26BIT                            (0x00000019UL)
    
24. #define SPI_DATASIZE_27BIT                            (0x0000001AUL)
    - S8 l1 q/ n7 J9 H* ?+ W
25. #define SPI_DATASIZE_28BIT                            (0x0000001BUL)
    
26. #define SPI_DATASIZE_29BIT                            (0x0000001CUL)
    
27. #define SPI_DATASIZE_30BIT                            (0x0000001DUL)
    
28. #define SPI_DATASIZE_31BIT                            (0x0000001EUL)
    
29. #define SPI_DATASIZE_32BIT                            (0x0000001FUL)

复制代码

8 B$ J( w& L' k. Q  CLKPolarity
用于设置空闲状态时，CLK是高电平还是低电平。

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

复制代码

  NSS
1 S9 }: k7 ~" b2 i8 @' c. f用于设置NSS信号由硬件NSS引脚管理或者软件SSI位管理。
+ f7 N7 \$ D# B9 e4 m, y1 \# R
6 z4 @. i1 h1 W$ {( d% h& E

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

复制代码

1 j; f, v4 u1 d  J1 e  BaudRatePrescaler
用于设置SPI时钟分频，仅SPI工作在主控模式下起作用，对SPI从机模式不起作用。
: b; I* N4 o6 \) Y7 x/ Y# H
+ _. N% e# ~- q3 r$ I8 E' q6 q

1. #define SPI_BAUDRATEPRESCALER_2                       (0x00000000UL)
   7 k/ o, J3 t; w  D& Q9 `
2. #define SPI_BAUDRATEPRESCALER_4                       (0x10000000UL)
   1 l- c0 L9 o! `- w
3. #define SPI_BAUDRATEPRESCALER_8                       (0x20000000UL)
   
4. #define SPI_BAUDRATEPRESCALER_16                      (0x30000000UL)
   
5. #define SPI_BAUDRATEPRESCALER_32                      (0x40000000UL)
   
6. #define SPI_BAUDRATEPRESCALER_64                      (0x50000000UL)
   + r7 A$ t0 \, _" H9 M" B
7. #define SPI_BAUDRATEPRESCALER_128                     (0x60000000UL)
   : S+ s% c/ l  l* |$ t
8. #define SPI_BAUDRATEPRESCALER_256                     (0x70000000UL)

复制代码

& e  {- I, g$ ]  FirstBit
用于设置数据传输从最高bit开始还是从最低bit开始。
  M; t: V; T* r* S

1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
   3 F9 L$ K. P0 J
2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST
   3 c; C" @& _* V

复制代码

  TIMode
用于设置是否使能SPI总线的TI模式。
0 P, i! y& y- {3 [3 E

1. #define SPI_TIMODE_DISABLE               (0x00000000UL)
   9 P% u/ ?$ J; G& I: W) I2 w
2. #define SPI_TIMODE_ENABLE                SPI_CFG2_SP_0

复制代码

* Y. O, S4 s; i# B  CRCCalculation
用于设置是否使能CRC计算。
* a$ v- W* i4 O

1. #define SPI_CRCCALCULATION_DISABLE                    (0x00000000UL)
   : v- b2 K1 a' o1 h
2. #define SPI_CRCCALCULATION_ENABLE                     SPI_CFG1_CRCEN

复制代码

  CRCPolynomial
1 w; B! x& o" k5 t* Q用于设置CRC计算使用的多项式，必须是奇数，范围0到65535。

: w, Y* N( A- |* w0 W: r  p$ }  CRCLength
, a' b7 n1 t1 Y$ w2 Y用于设置CRC计算时的CRC长度。大小要与同属此结构体的DataSize一致。或是DataSize的整数倍。
) ^3 }8 w0 d- Z% k
6 i- r: U( }' e/ f

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)
   
5. #define SPI_CRC_LENGTH_7BIT                           (0x00060000UL)
   
6. #define SPI_CRC_LENGTH_8BIT                           (0x00070000UL)
   
7. #define SPI_CRC_LENGTH_9BIT                           (0x00080000UL)
   6 [* I4 g* x$ u. q
8. #define SPI_CRC_LENGTH_10BIT                          (0x00090000UL)
   
9. #define SPI_CRC_LENGTH_11BIT                          (0x000A0000UL)
   : a3 w; [1 n. ^2 \: D
10. #define SPI_CRC_LENGTH_12BIT                          (0x000B0000UL)
    ' [9 A! G( ^# v0 F8 F  C
11. #define SPI_CRC_LENGTH_13BIT                          (0x000C0000UL)
    ! m5 t  O' Q! E' z4 |4 S: v
12. #define SPI_CRC_LENGTH_14BIT                          (0x000D0000UL)
    3 K1 b* o9 e4 c1 U4 O, J2 M8 q
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)
    . _) w" I- H& Q: W3 L
17. #define SPI_CRC_LENGTH_19BIT                          (0x00120000UL)
    & w( M9 Y2 H9 z2 U9 Y2 C( n
18. #define SPI_CRC_LENGTH_20BIT                          (0x00130000UL)
    9 N. |$ W) k2 y$ R4 L5 w8 C/ _6 P
19. #define SPI_CRC_LENGTH_21BIT                          (0x00140000UL)
    ! ~/ v/ s: P; g' j% M7 k
20. #define SPI_CRC_LENGTH_22BIT                          (0x00150000UL)
    / x( |+ U! ]; Y9 z+ k* u- c
21. #define SPI_CRC_LENGTH_23BIT                          (0x00160000UL)
    % ~, z. Z9 g( S. P/ f
22. #define SPI_CRC_LENGTH_24BIT                          (0x00170000UL)
    9 Q: R, e7 y& E9 _* M
23. #define SPI_CRC_LENGTH_25BIT                          (0x00180000UL)
    
24. #define SPI_CRC_LENGTH_26BIT                          (0x00190000UL)
    # p. R; y3 S* Y' |9 ^0 T
25. #define SPI_CRC_LENGTH_27BIT                          (0x001A0000UL)
    . z' h( m/ |, T& s# r, w! B
26. #define SPI_CRC_LENGTH_28BIT                          (0x001B0000UL)
    * g5 Q% D7 j4 e) A" _
27. #define SPI_CRC_LENGTH_29BIT                          (0x001C0000UL)
    - p( ^0 ?  L! |9 p# E/ b
28. #define SPI_CRC_LENGTH_30BIT                          (0x001D0000UL)
    
29. #define SPI_CRC_LENGTH_31BIT                          (0x001E0000UL)
    
30. #define SPI_CRC_LENGTH_32BIT                          (0x001F0000UL)

复制代码

; v+ y; B! Z9 [

& u2 G/ a* |" L$ J8 o, W& l  NSSPMode
用于设置是否使能NSSP信号，可以通过SPIx_CR2寄存器的SSOM位使能。注意，只有配置为摩托罗拉SPI主控模式时设置此成员才有用。

1. #define SPI_NSS_PULSE_DISABLE                         (0x00000000UL)
   8 B/ I8 l  t) d/ r  B6 S
2. #define SPI_NSS_PULSE_ENABLE                          SPI_CFG2_SSOM

复制代码

0 c- D6 }" w0 d! I( v  NSSPolarity
用于设置NSS引脚上的高电平或者低电平作为激活电平。
1 s+ `" H/ h) b, y4 \8 X

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

复制代码

; R0 J) O0 C3 m1 _3 e4 r2 g) X  FifoThreshold
+ y8 m9 u4 p* Y9 A$ ~用于设置SPI的FIFO阀值。
' U( `6 {# v. d

1. #define SPI_FIFO_THRESHOLD_01DATA                     (0x00000000UL)
   
2. #define SPI_FIFO_THRESHOLD_02DATA                     (0x00000020UL)
   9 G1 s2 {$ R/ D8 W# d2 B5 l' z
3. #define SPI_FIFO_THRESHOLD_03DATA                     (0x00000040UL)
   
4. #define SPI_FIFO_THRESHOLD_04DATA                     (0x00000060UL)
   
5. #define SPI_FIFO_THRESHOLD_05DATA                     (0x00000080UL)
   
6. #define SPI_FIFO_THRESHOLD_06DATA                     (0x000000A0UL)
   
7. #define SPI_FIFO_THRESHOLD_07DATA                     (0x000000C0UL)
   ) I% o# J8 D) n7 u2 b
8. #define SPI_FIFO_THRESHOLD_08DATA                     (0x000000E0UL)
   9 z9 \: e& B- r: G- i8 I
9. #define SPI_FIFO_THRESHOLD_09DATA                     (0x00000100UL)
   
10. #define SPI_FIFO_THRESHOLD_10DATA                     (0x00000120UL)
    
11. #define SPI_FIFO_THRESHOLD_11DATA                     (0x00000140UL)
    * V5 @7 A3 ^- G
12. #define SPI_FIFO_THRESHOLD_12DATA                     (0x00000160UL)
    ( U! }" R* ]1 F1 j( V( ^2 a8 a0 @
13. #define SPI_FIFO_THRESHOLD_13DATA                     (0x00000180UL)
    5 _" q& Q0 _' o' P/ H
14. #define SPI_FIFO_THRESHOLD_14DATA                     (0x000001A0UL)
    
15. #define SPI_FIFO_THRESHOLD_15DATA                     (0x000001C0UL)
    
16. #define SPI_FIFO_THRESHOLD_16DATA                     (0x000001E0UL)
    & f3 n8 ]( f- x# d' B3 U

复制代码

5 t( i7 x- `9 K8 s0 Y" Q  TxCRCInitializationPattern
; S/ H, ~1 B- L  c; a  @5 \发送CRC初始化模式。

5 i: M7 O/ ?. K3 C. z

1. #define SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN       (0x00000000UL)
   7 s- f" [$ i% X* p6 V
2. #define SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN        (0x00000001UL)
   

复制代码

  RxCRCInitializationPattern
: N7 d- M$ Z* W% c接收CRC初始化模式
9 f: b& G. U6 L+ U5 ~( D" t
5 H- K; y  f6 D3 b

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

复制代码

5 A$ [1 ]8 o+ e$ ` MasterSSIdleness
在主模式下插入到SS有效边沿和第一个数据开始之间的额外延迟，单位SPI时钟周期个数。
& \' ~, {  ^( A, r" D! J

1. #define SPI_MASTER_SS_IDLENESS_00CYCLE                (0x00000000UL)
   
2. #define SPI_MASTER_SS_IDLENESS_01CYCLE                (0x00000001UL)
   - R3 g$ _4 m7 V
3. #define SPI_MASTER_SS_IDLENESS_02CYCLE                (0x00000002UL)
   " M. m+ `( Z* j9 Y
4. #define SPI_MASTER_SS_IDLENESS_03CYCLE                (0x00000003UL)
   ; p4 ~' {' [6 C' d0 `+ `
5. #define SPI_MASTER_SS_IDLENESS_04CYCLE                (0x00000004UL)
   " |" Z, n7 q! }1 y4 K- v; O
6. #define SPI_MASTER_SS_IDLENESS_05CYCLE                (0x00000005UL)
   % T# x& Y% v3 K/ W
7. #define SPI_MASTER_SS_IDLENESS_06CYCLE                (0x00000006UL)
   " p# f4 k+ U8 e; E1 ?
8. #define SPI_MASTER_SS_IDLENESS_07CYCLE                (0x00000007UL)
   , U) P1 f  h* 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)
    3 `" R' n7 `+ b2 X9 e7 A( n$ D
12. #define SPI_MASTER_SS_IDLENESS_11CYCLE                (0x0000000BUL)
    0 G/ X# h. ?+ W9 r8 V1 U; z" ]
13. #define SPI_MASTER_SS_IDLENESS_12CYCLE                (0x0000000CUL)
    
14. #define SPI_MASTER_SS_IDLENESS_13CYCLE                (0x0000000DUL)
    ) Y5 r+ Q! k  a7 `6 o% [7 }
15. #define SPI_MASTER_SS_IDLENESS_14CYCLE                (0x0000000EUL)
    
16. #define SPI_MASTER_SS_IDLENESS_15CYCLE                (0x0000000FUL)
    . q% L% x) r) f! J) s) _- I

复制代码

  MasterInterDataIdleness
主模式下在两个连续数据帧之间插入的最小时间延迟，单位SPI时钟周期个数。
& _  z! k; @' ]- H

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   : q7 g6 q/ b% P5 B
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX

复制代码

3 P8 ?6 r" M- J! D* J  \  ~) t$ `) t: e  MasterReceiverAutoSusp
用于控制主器件接收器模式下的连续 SPI 传输以及自动管理，以避免出现上溢情况。
' Z+ Z4 ~; K7 l4 k2 j

1. #define SPI_MASTER_RX_AUTOSUSP_DISABLE                (0x00000000UL)
   % u9 F$ l+ t% h$ l1 l7 U
2. #define SPI_MASTER_RX_AUTOSUSP_ENABLE                 SPI_CR1_MASRX
   

复制代码

- @. A( c* c$ ^0 B+ ~/ x. l  MasterKeepIOState
' B6 g: @# ?+ Q) O. R禁止SPI后，SPI相关引脚保持当前状态，以防止出现毛刺。在从模式下，该位不应该使用。

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

复制代码

' a+ c& e% l7 c# g7 |4 M) j  IOSwap
用于交换MISO和MOSI引脚。

4 s; _. ~, Q2 R; ^0 ]

1. #define SPI_IO_SWAP_DISABLE                           (0x00000000UL)
   2 l+ b* v0 Q. V
2. #define SPI_IO_SWAP_ENABLE                            SPI_CFG2_IOSWP

复制代码

72.3.3 SPI总线句柄结构体SPI_HandleTypeDef
下面是SPI总线的初始化结构体，用到的地方比较多：
* K9 T5 B  s: q; o
3 e$ \2 v/ o' {% M, Z1 m

1. typedef struct __SPI_HandleTypeDef
   ) r  A5 \  c! y
2. {
   ( s! @# j4 E  y; O( w" n: C$ \
3.   SPI_TypeDef                *Instance;                 
   
4.   SPI_InitTypeDef            Init;                        
   6 p+ N6 t& E+ q( q, T7 H7 n& W
5.   uint8_t                    *pTxBuffPtr;                 
   / Q* w/ E" M& q$ N' C# O( v* `' L
6.   uint16_t                   TxXferSize;                  
   2 o! @- B9 N/ b# e' E" S8 F9 k$ p
7.   __IO uint16_t              TxXferCount;                  
   
8.   uint8_t                    *pRxBuffPtr;               
   & T  ]  ]4 L  G
9.   uint16_t                   RxXferSize;                  
   
10.   __IO uint16_t              RxXferCount;                 
    
11.   uint32_t                   CRCSize;                     
    ) I. N& I% E  ]  i: H
12.   void (*RxISR)(struct __SPI_HandleTypeDef *hspi);      
    6 q8 |. F5 u/ L: ?: H1 i' V
13.   void (*TxISR)(struct __SPI_HandleTypeDef *hspi);        
    & s$ s! n( ^/ \
14.   DMA_HandleTypeDef          *hdmatx;                     
    ; L: v# C1 j% M( j* ?6 n! t2 e
15.   DMA_HandleTypeDef          *hdmarx;                     
    
16.   HAL_LockTypeDef            Lock;                        
    
17.   __IO HAL_SPI_StateTypeDef  State;                        
    
18.   __IO uint32_t              ErrorCode;                  
    
19. #if defined(USE_SPI_RELOAD_TRANSFER)
    
20.   SPI_ReloadTypeDef          Reload;                     
    # v" l% l$ `8 \1 _) n+ r
21. #endif
    
22. 
    
23. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    & v+ h8 T# S# o! a, l
24.   void (* TxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
25.   void (* RxCpltCallback)(struct __SPI_HandleTypeDef *hspi);      
    
26.   void (* TxRxCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    " Q% ~2 J: ~7 O' E( ~! t( ?
27.   void (* TxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    
28.   void (* RxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);  
    , g, s! q+ f$ `. Q3 Q9 o
29.   void (* TxRxHalfCpltCallback)(struct __SPI_HandleTypeDef *hspi);
    1 P! S3 o* s; X! d- y
30.   void (* ErrorCallback)(struct __SPI_HandleTypeDef *hspi);      
    5 @  t* ~1 J- ^7 \7 j8 i
31.   void (* AbortCpltCallback)(struct __SPI_HandleTypeDef *hspi);   
    
32.   void (* MspInitCallback)(struct __SPI_HandleTypeDef *hspi);   
    ; e" A3 s0 w/ _* D5 K
33.   void (* MspDeInitCallback)(struct __SPI_HandleTypeDef *hspi);
    
34. #endif  
    
35. } SPI_HandleTypeDef;
    

复制代码

  `! d8 ~, B9 v1 N
# Q2 o% Z, m9 N7 X注意事项：
3 f* _% P+ w7 ~. e/ ^) M' d7 }
条件编译USE_HAL_SPI_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

) L) T: k( Q. t; U; H" z8 c  #define   USE_HAL_SPI_REGISTER_CALLBACKS   1

5 c. ~( D6 U$ u% z) Y通过函数HAL_SPI_RegisterCallback注册回调，取消注册使用函数HAL_SPI_UnRegisterCallback。
; l, P1 K- X% }
: I+ T9 a3 V1 d! T: ]- v这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。
( v) J8 b9 W* ]* K% I) O, M
: b+ ]& `& \- X; v3 i  SPI_TypeDef   *Instance
这个参数是寄存器的例化，方便操作寄存器，比如使能SPI1。

4 W/ V! j: a6 WSET_BIT(SPI1 ->CR1,  SPI_CR1_SPE)。
3 A$ e/ C& X$ \: l
  SPI_InitTypeDef  Init
这个参数是用户接触最多的，在本章节3.2小节已经进行了详细说明。

  DMA_HandleTypeDef          *hdmatx               
  DMA_HandleTypeDef          *hdmarx
$ u3 M& m; b, q1 h用于SPI句柄关联DMA句柄，方便操作调用。
/ F( @( A: ]. {
72.4 SPI总线源文件stm32h7xx_hal_spi.c
此文件涉及到的函数较多，这里把几个常用的函数做个说明：

1 \( F) Z  C6 V( p/ e  HAL_SPI_Init
: u; L* M3 |( W- u% W- m  HAL_SPI_DeInit
  HAL_SPI_TransmitReceive
  HAL_SPI_TransmitReceive_IT
  HAL_SPI_TransmitReceive_DMA
  t3 ]% ]1 o& C72.4.1 函数HAL_SPI_Init
函数原型：
4 r9 x0 W7 \8 ^8 S

1. HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
   % _. a- l$ H. V3 w3 e0 m2 j6 K! O
2. {
   ( g3 T3 V3 V3 }8 ^1 j+ a0 s
3.   uint32_t crc_length = 0UL;
   : V' o. n4 u% \0 A1 l
4.   uint32_t packet_length;
   2 c4 L/ r6 h" C3 F; _7 D' t7 h
5. 
   
6.   /* 省略未写 */
   + ]9 q1 F3 X/ k, [& [" J
7. 
   6 P* |+ N. Y- V! s- w$ e
8.   /* 如果数据位宽大于16bit，必须是SPI1，SPI2或者SPI3，而SPI4，SPI5和SPI6不支持大于16bit */
   . S/ d* H4 @' S" Q- W. h7 B# E
9.   if ((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (hspi->Init.DataSize > SPI_DATASIZE_16BIT))
   
10.   {
    0 j& K* ~6 e, M& r# x
11.     return HAL_ERROR;
    $ Y2 _6 o( l' N
12.   }
    
13. 
    
14.   /* SPI1，SPI2和SPI3的FIFO大小是16*8bit，而SPI4，SPI5和SPI6的FIFO大小是8*8bit
    8 i8 l( b# h; M& j4 `
15.      这里是查看设置的缓冲大小是否超出了FIFO支持的大小。
    ! G) z* T- o- Q1 _
16. */
    4 Y4 m7 c6 `4 A
17.   packet_length = SPI_GetPacketSize(hspi);
    
18.   if (((!IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_LOWEND_FIFO_SIZE)) ||
    * [4 r  F: m$ P
19.       ((IS_SPI_HIGHEND_INSTANCE(hspi->Instance)) && (packet_length > SPI_HIGHEND_FIFO_SIZE)))
    ( ]% d: [2 c% C: K
20.   {
    
21.     return HAL_ERROR;
    
22.   }
    
23. 
    : G0 ]' b! e! f5 y
24. #if (USE_SPI_CRC != 0UL)
    2 J3 z& N/ J6 Z4 m  a) A
25.     /* 省略未写 */
    6 s7 T  W2 D/ A9 D
26. #endif
    
27. 
    
28.   if (hspi->State == HAL_SPI_STATE_RESET)
    : G! I! ^+ o9 R+ p
29.   {
    
30.     /* 解锁 */
    
31.     hspi->Lock = HAL_UNLOCKED;
    
32. 
    
33.     /* 使用自定义回调 */
      J5 s! }, o  B: ]* H5 e9 R4 [4 W
34. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
35.     /* 设置默认回调函数 */
      L' G' m. _) t
36.     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */
    
37.     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */
    # T+ `/ v/ T$ U3 B; D
38.     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */
    - d3 V: H7 K2 @( {
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 */
    7 F$ Z  w+ F. Z
42.     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */
    1 n% m  m3 }% c8 I4 u7 q
43.     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */
    
44. 
    ' B/ v& o7 t8 a! y$ g0 M) t5 v# G# d
45.     if (hspi->MspInitCallback == NULL)
    1 B* h7 X5 X# v8 ~8 c
46.     {
    : C! L/ m" j3 ?; h
47.       hspi->MspInitCallback = HAL_SPI_MspInit;
    - K; ?8 B" j2 g- f0 i2 u
48.     }
    
49. 
    
50.     /* 初始化地址硬件: GPIO, CLOCK, NVIC... */
    
51.     hspi->MspInitCallback(hspi);
    
52. #else
    * {- y% n$ V. ^9 L7 C* L
53.     /* 初始化底层硬件: GPIO, CLOCK, NVIC... */
    + t& u  [, u! C. Y$ Z7 p* g& G1 P
54.     HAL_SPI_MspInit(hspi);
    
55. #endif
    
56.   }
    9 Y0 I! E2 {0 U" S1 @
57. 
    # M& V1 X+ q1 p
58.   hspi->State = HAL_SPI_STATE_BUSY;
    
59. 
    
60.   /* 禁止SPI外设 */
    3 J+ G! i( h8 W& i8 a
61.   __HAL_SPI_DISABLE(hspi);
    7 x6 W7 M6 ]. g) d: H! r
62. 
    
63.   /*----------------------- SPIx CR1 & CR2 配置---------------------*/
    
64.   if ((hspi->Init.NSS == SPI_NSS_SOFT) && (hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.NSSPolarity ==
    $ \6 ~  J3 N, s( L! @3 X. x" t
65. SPI_NSS_POLARITY_LOW))
    " h' b. e7 {, k) v% [& g
66.   {
    
67.       SET_BIT(hspi->Instance->CR1, SPI_CR1_SSI);
    
68.   }
    
69. 
    
70.   /* SPIx CFG1配置 */
    
71.   WRITE_REG(hspi->Instance->CFG1, (hspi->Init.BaudRatePrescaler | hspi->Init.CRCCalculation | crc_length |
    ( f+ `5 U( K8 V! V
72.                                    hspi->Init.FifoThreshold     | hspi->Init.DataSize));
    
73. 
    
74.   /* SPIx CFG2配置 */
    
75.   WRITE_REG(hspi->Instance->CFG2, (hspi->Init.NSSPMode     | hspi->Init.TIMode           | hspi->Init.NSSPolarity  |
    ; q" m9 F$ ], c" ~& l
76.                                    hspi->Init.NSS          | hspi->Init.CLKPolarity      | hspi->Init.CLKPhase     |
    8 p/ J- e7 [* Z! S# @" ]% G
77.                                    hspi->Init.FirstBit     | hspi->Init.Mode             | hspi->Init.MasterInterDataIdleness |
    1 G. o) p9 M+ L$ c
78.                                    hspi->Init.Direction    | hspi->Init.MasterSSIdleness | hspi->Init.IOSwap));
    . Y/ U0 O) w- ?# e
79. 
    , Y2 H5 x- r! I
80. #if (USE_SPI_CRC != 0UL)
    
81.   /*---------------------------- SPIx CRC配置 ------------------*/
    6 V  H  I  v( u. {& M. h" k; l
82.   /* 配置SPI CRC */
    1 F* L& t& E* Z7 l3 W- u1 m- f& u8 D
83.   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    9 i7 G: a) D5 F3 q( y: Z3 F
84.   {
    ) ]! s  M2 ?/ x/ D; L% J
85.     /* 初始化TX CRC初始值 */
    
86.     if (hspi->Init.TxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    
87.     {
    
88.       SET_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    
89.     }
    1 ?% V4 U. W0 w' [% U- D$ f+ S# [4 y' g
90.     else
    3 }0 @4 J* G2 x0 r; O3 L/ }
91.     {
    
92.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_TCRCINI);
    * n0 g' B& E/ y8 h
93.     }
    
94. 
    
95.     /* 初始化RXCRC初始值 */
    
96.     if (hspi->Init.RxCRCInitializationPattern == SPI_CRC_INITIALIZATION_ALL_ONE_PATTERN)
    
97.     {
    
98.       SET_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
    6 b0 W1 A$ l, m, q
99.     }
    2 [& M$ e, U4 z; L6 t3 P
100.     else
     / j- w$ ]6 ^, x1 Z
101.     {
     % F5 |: @5 }( y
102.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_RCRCINI);
     % h& I6 o' X- `) ?  N
103.     }
     
104. 
     7 U+ H7 h* Q8 _. Z. ]! D
105.     /* 使能 33/17 bit CRC计算 */
     9 |; }8 O9 |% a8 K% m9 ^$ P
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)))
     6 t# a' I! G6 R. [
108.     {
     8 K- e7 C. f: g$ T( X2 O1 S% E
109.       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     
110.     }
     : b2 b, H, \* h
111.     else
     
112.     {
     0 [  B: U& b0 O5 q! r
113.       CLEAR_BIT(hspi->Instance->CR1, SPI_CR1_CRC33_17);
     9 l: z9 ]  m, _4 X% B' R( C0 P
114.     }
     
115. 
     ( k0 J4 C3 }( H9 E( E
116.     /* 写CRC多项式到SPI寄存器 */
     5 O7 o* g( p3 d! ^
117.     WRITE_REG(hspi->Instance->CRCPOLY, hspi->Init.CRCPolynomial);
     9 y, z  z+ F$ B) S3 G
118.   }
     & Q* q0 E  @. R" Q
119. #endif
     . P6 V! r+ o( y; x7 p
120. 
     & p% l" E: o' P/ }
121.   /* SPI从模式，下溢配置 */
     
122.   if (hspi->Init.Mode == SPI_MODE_SLAVE)
     . e" M8 H4 C/ A9 b+ X
123.   {
     
124.     /* 设置默认下溢配置 */
     # z* V2 C/ l0 O! V
125. #if (USE_SPI_CRC != 0UL)
     
126.     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_DISABLE)
     
127. #endif
     
128.     {
     + z# G7 r% Y2 B) Z' e2 G
129.       MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, SPI_CFG1_UDRDET_0);
     % t  s+ N0 m! ~/ b
130.     }
     - L* p+ Z+ I+ |) m
131.     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRCFG, SPI_CFG1_UDRCFG_1);
       Y" A  W3 u7 A4 u# ]4 K0 K! ^
132.   }
     ( T. n  P  o/ U1 d, h7 t# `
133. 
     # X$ p) y2 w9 y* F. p
134. #if defined(SPI_I2SCFGR_I2SMOD)
     
135.   CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);
     9 j9 Q( o# q. Q1 ~; J
136. #endif
     
137. 
     
138.   /* 确保AFCNTR bit由SPI主机模式管理 */
     
139.   if ((hspi->Init.Mode & SPI_MODE_MASTER) == SPI_MODE_MASTER)
     
140.   {
     
141.     /* Alternate function GPIOs control */
     % W2 x0 _, L. {7 L* m
142.     MODIFY_REG(hspi->Instance->CFG2, SPI_CFG2_AFCNTR, (hspi->Init.MasterKeepIOState));
     # K* s2 C  x& ?+ F1 X9 y
143.   }
     
144. 
     # E+ k. y- m" {$ c% N1 |
145.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
     8 F3 P2 ], o  n7 L8 T$ c
146.   hspi->State     = HAL_SPI_STATE_READY;
     ; J; `$ \( `& M' |
147. 
     2 d( o, L( E  T
148.   return HAL_OK;
     
149. }
     # x" d9 K- b; e' P

复制代码

, e: d! r2 S' U1 ^' a9 ^函数描述：
' M2 c% J  v6 x& `- O* m% r
此函数用于初始化SPI。

: \+ H2 C# W$ L8 }( I( P& t函数参数：
1 m& C  V" J+ P* P; y7 a
  第1个参数是SPI_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
: O& J. ]- {6 {4 x" U  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
注意事项：
, H' k3 m& o4 e6 a2 u
函数HAL_SPI_MspInit用于初始化SPI的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
& z$ N$ S( y" p如果形参hspi的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SPI_HandleTypeDef SpiHandle。
( d) r: C, H" H: n) @4 p* l对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SPI_STATE_RESET  = 0x00U。
# P* I# }2 \% p  h
! Y; P# l2 Z6 z/ B9 @解决办法有三

5 o7 M/ A4 [1 D方法1：用户自己初始化SPI和涉及到的GPIO等。
4 E7 u2 \# K$ d. g' ~# o
方法2：定义SPI_HandleTypeDef SpiHandle为全局变量。

方法3：下面的方法
9 q4 I( Q4 f' h0 v$ w

1. if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK)
   0 S% S" o0 w+ T! L: p2 `! d2 D
2. {
   ! W; h3 \1 u5 s- y+ v
3.     Error_Handler();
   * Q, M) T. m1 Y4 x
4. }  
   
5. if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
   & _: v3 [3 ~; r" M) G& `% I5 ?
6. {
   
7.     Error_Handler();
   
8. }

复制代码

7 t* Y0 a7 a# A& H# D9 {使用举例：
" r9 ^7 B; O  w9 H
7 ]5 |4 G( J$ |# {  Q& g

1. SPI_HandleTypeDef hspi = {0};
   * }. l+ ]) B0 h2 A
2. 
   
3. /* 设置SPI参数 */
   
4. hspi.Instance               = SPIx;                   /* 例化SPI */
   
5. hspi.Init.BaudRatePrescaler = _BaudRatePrescaler;     /* 设置波特率 */
   
6. hspi.Init.Direction         = SPI_DIRECTION_2LINES;   /* 全双工 */
   - Q# ]5 t% G" Z, X8 }7 z% F9 w$ @
7. hspi.Init.CLKPhase          = _CLKPhase;              /* 配置时钟相位 */
   , m: M% c. |$ g; W
8. hspi.Init.CLKPolarity       = _CLKPolarity;           /* 配置时钟极性 */
   
9. hspi.Init.DataSize          = SPI_DATASIZE_8BIT;      /* 设置数据宽度 */
   ; |% ]7 u+ O, @& A! f. e% B5 v$ C# m
10. hspi.Init.FirstBit          = SPI_FIRSTBIT_MSB;       /* 数据传输先传高位 */
    ( l! Z- ?$ C( q  f  X1 F+ Q" \7 O. R
11. hspi.Init.TIMode            = SPI_TIMODE_DISABLE;     /* 禁止TI模式  */
      F% ?! _5 U$ r+ c# @
12. hspi.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;      /* 禁止CRC */
    
13. hspi.Init.CRCPolynomial     = 7;                               /* 禁止CRC后，此位无效 */
    
14. hspi.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;             /* 禁止CRC后，此位无效 */
    7 Z" _; b' b, s8 d  C+ n2 l5 \% ]
15. hspi.Init.NSS               = SPI_NSS_SOFT;                    /* 使用软件方式管理片选引脚 */
    6 N0 J2 z% K2 L2 d7 K
16. hspi.Init.FifoThreshold     = SPI_FIFO_THRESHOLD_01DATA;       /* 设置FIFO大小是一个数据项 */
    ; j+ @) T' J* Y3 A$ \) _/ D& U" Y
17. hspi.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;           /* 禁止脉冲输出 */
    % o. F; j8 K# _- O& g* Q: x2 A
18. hspi.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE; /* 禁止SPI后，SPI相关引脚保持当前状态 */  
    + L9 f& c% b+ Z8 _6 ^  r
19. hspi.Init.Mode                  = SPI_MODE_MASTER;            /* SPI工作在主控模式 */
    
20. 
    
21. if (HAL_SPI_Init(&hspi) != HAL_OK)
    $ Q  d& x9 N* I% a0 e5 m* w
22. {
    3 ]7 S1 {- u  n: V  r3 u3 L
23.     Error_Handler(__FILE__, __LINE__);
    * |7 h. {, ^( w) q5 O
24. }

复制代码

72.4.2 函数HAL_SPI_DeInit
2 s4 V# x+ L4 R7 Z# q0 E函数原型：
! J  F8 x! P! O' t8 S

1. HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)
   
2. {
   
3. /* 检测SPI句柄是否有效 */
   
4.   if (hspi == NULL)
   
5.   {
   ) C) V& h9 o& R3 m: `$ U, t( x& G5 H
6.     return HAL_ERROR;
   
7.   }
   
8. 
   
9. /* 检查SPI例化参数 */
   2 o1 x! _* N$ t
10.   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));
    / x/ J' R, F( p% r- Z' g7 E* ?
11. 
    
12.   hspi->State = HAL_SPI_STATE_BUSY;
    
13. 
    
14.   /* 禁止SPI外设时钟 */
    
15.   __HAL_SPI_DISABLE(hspi);
    & D' C3 V% u0 K, q0 I; z
16. 
    
17. #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1UL)
    
18.   if (hspi->MspDeInitCallback == NULL)
    : i. P+ j) K- p7 F: r& t! Y2 k  x
19.   {
    , y) K* V$ i3 I
20.     hspi->MspDeInitCallback = HAL_SPI_MspDeInit;
    
21.   }
    ' l6 Z  V# i2 r2 s, \+ k0 J' i* h
22. 
    
23.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    / V' b9 e" }2 m& ]: D
24.   hspi->MspDeInitCallback(hspi);
    
25. #else
    
26.   /* 复位底层硬件: GPIO, CLOCK, NVIC... */
    
27.   HAL_SPI_MspDeInit(hspi);
    0 X; r& y4 n% M; \
28. #endif
    6 N& Q5 t; t& v5 Z, M
29. 
    
30.   /* 设置无错误，复位状态标记 */
    $ T  T3 H6 N3 m& J/ E9 N6 r
31.   hspi->ErrorCode = HAL_SPI_ERROR_NONE;
    * e5 y' a& A9 Z1 {* l: V
32.   hspi->State = HAL_SPI_STATE_RESET;
    
33. 
    # [4 u+ ?/ O6 H
34.   /* 解锁SPI */
    
35.   __HAL_UNLOCK(hspi);
    
36. 
    " _, o1 T' u! e; \! L
37.   return HAL_OK;
    ( \% g8 ?* r/ O, M" d
38. }

复制代码

函数描述：

/ o. _! ]7 h: ~- J2 C4 ?, U用于复位SPI总线初始化。
* b9 |* w& _: j: h8 ]0 S. ]: ~) V
函数参数：
: v! O1 |3 K/ J0 M6 Y0 S' ?
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
) @( \3 r9 V! ~) J' U2 w  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中
72.4.3 函数HAL_SPI_TransmitReceive
函数原型：

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
   
2. {
   
3. 
   1 [7 p0 @& J$ E  `, r
4.    /* 省略未写 */
   8 p( h  n- k7 L$ `7 o7 s1 N
5. 
   
6.   /* 大于16bit的数据收发 */
   ! L! G" @' e. ]# a. Z( e$ q
7.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
   
8.   {
   - D' O2 z1 Z  T; i% N0 e2 I
9.        /* 省略未写 */
   # P7 M! U8 ]- J+ z7 D& s9 [6 g
10.   }
    
11.   /* 大于8bit，小于16bi的数据收发 */
    
12.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    / a4 b, d6 `' G/ B5 Q6 j8 q1 \  V" e6 @
13.   {
    ' d% ~5 I$ o6 O) K8 X
14.       /* 省略未写 */
    
15.   }
    0 U6 Y- u& b3 B7 u
16.   /* 小于等于8bit的数据收发 */
    : {1 w8 y  l' Y# o& e8 j6 m+ L
17.   else
    
18.   {
    
19.        /* 省略未写 */
    3 m0 t! v4 t5 U: Q) ?
20.   }
    9 ]# A5 v% p1 Y/ w2 Y/ e
21. 
    . h, w. @+ R1 ?0 \0 b
22. }
    

复制代码

函数描述：

/ n% w4 r2 e# d  Y$ p+ w1 {此函数主要用于SPI数据收发，全双工查询方式。

函数参数：
. h" i+ D0 b+ ^7 M
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
5 f/ \+ q$ R. f, c6 O- I  A  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
, h3 }6 n4 M, X' u! |2 Q  第5个参数是传输过程的溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
2 ?5 z4 b/ f* j# F1 D! i% @使用举例：
+ z# K! m( M; ?" i& [0 t' y

1. SPI_HandleTypeDef hspi = {0};
   
2. 
   1 T9 N! {# @0 W3 L: m2 _
3. if(HAL_SPI_TransmitReceive(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen, 1000000) != HAL_OK)
   8 h3 K* Q% h  W" P. W
4. {
   $ p; P. v! \! I9 Z
5.     Error_Handler(__FILE__, __LINE__);
   
6. }

复制代码

72.4.4 函数HAL_SPI_TransmitReceive_IT
函数原型：
/ M& Q* [2 n$ @: {, Y( M1 k
& ]9 S7 F& d" X1 S/ p

1. HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
   
2. {
   
3.    /* 省略未写 */
   4 Y$ |4 X5 _" o* G
4. 
   
5.   /* 设置传输参数 */
   
6.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
     q1 O; t5 T" l5 g! q5 ~' {& M
7.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
   
8.   hspi->TxXferSize  = Size;
   
9.   hspi->TxXferCount = Size;
   
10.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
    
11.   hspi->RxXferSize  = Size;
    0 }$ L* U, }) g& e) R8 t# l
12.   hspi->RxXferCount = Size;
    4 z8 T0 t: c5 H( s  u/ c8 N
13. 
    
14.   /* 设置中断处理 */
    ! v' D: q2 B; M( m. i0 F
15.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    ( P4 \0 X& z* c; A; B  D" h' Q
16.   {
    
17.     hspi->TxISR     = SPI_TxISR_32BIT;
    ' m- v: L" {' ^7 |5 |1 q
18.     hspi->RxISR     = SPI_RxISR_32BIT;
    # v; D' V. V4 K- O/ B3 G; w
19.   }
    8 }6 c: W* O4 s1 ?* W
20.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    
21.   {
    $ Y# {- D, [' i( n; E9 {1 Y
22.     hspi->RxISR     = SPI_RxISR_16BIT;
    , ?9 t* o! G+ [
23.     hspi->TxISR     = SPI_TxISR_16BIT;
    
24.   }
    9 \/ P9 e; _( W/ T
25.   else
    
26.   {
    ' X4 Z0 }/ @2 C5 w. ^% C9 S& P/ r* J
27.     hspi->RxISR     = SPI_RxISR_8BIT;
    + S& Z% h+ i2 G- C( N6 d8 \
28.     hspi->TxISR     = SPI_TxISR_8BIT;
    * q5 ~& z/ A7 q, X3 I) B
29.   }
    % R2 X" n% R  w) r$ v( D/ u
30. 
    " o7 ?2 p+ o$ o- F3 i7 ?; w
31.   /* 设置当前传输数据大小 */
    
32.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    
33. 
    5 o- w* j5 P! m
34.   /* 使能SPI外设 */
    
35.   __HAL_SPI_ENABLE(hspi);
    2 s# t  F+ M1 ^4 \, N3 ^
36. 
    
37.   /* 使能各种中断标志 */
    + D" U9 }8 U, `9 v# f! @& G# T
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));
    , v( A7 y2 C  `+ f
40. 
    
41.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    
42.   {
    
43.     /* 启动传输 */
    . o' X) [: h$ B5 ^7 D; J
44.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
      Y$ @' Z5 {$ Z9 J+ `
45.   }
    # {) F1 y4 V  u+ D! T) a+ Q
46. 
    
47.   /* 解锁 */
    
48.   __HAL_UNLOCK(hspi);
    & W, ]6 `* v  e
49.   return errorcode;
    
50. }

复制代码

函数描述：
  z& b  b5 ~+ D0 W& p
此函数主要用于SPI数据收发，全双工中断方式。

函数参数：
% r0 R& k* p$ v% F: `; o  J
9 w) W. f$ M" i  |# s" \7 _  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
  第2个参数是发送数据缓冲地址。
. a# f8 D& t6 t  `  第3个参数是接收数据缓冲地址。
. A, x" H3 N9 c$ u: l' Q  第4个参数是传输的数据大小，单位字节个数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

1. SPI_HandleTypeDef hspi = {0};
   $ K$ C1 N7 `0 v! z, i7 U/ d
2. 
   ! k& Z- S! U/ m# b
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__);
   ( L0 A, a3 G7 B5 ~' c0 X6 t) r
6. }
   : X' _7 M7 B) i4 `
7. 
   
8. 
   
9. 72.4.5 函数HAL_SPI_TransmitReceive_DMA
   
10. 函数原型：
    
11. 
    
12. HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,
    
13.                                               uint16_t Size)
    " a; {- D$ P" B
14. {
    ( c! I: `/ k% v+ n  B
15.    /* 省略未写 */
    0 T0 C6 H& w" A6 K3 G) C! l5 O, ]
16. 
    , f4 k- s. h& m+ L4 @
17. /* 注意DMA的位宽和对齐设置 */
    # {5 F+ r7 Z3 r; I! z1 J( S1 m" g( r
18.   if (((hspi->Init.DataSize > SPI_DATASIZE_16BIT) && (hspi->hdmarx->Init.MemDataAlignment !=
    6 U  \  }# b0 {/ t/ E9 b, y5 @
19. DMA_MDATAALIGN_WORD))  ||
    
20.       ((hspi->Init.DataSize > SPI_DATASIZE_8BIT) && ((hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_HALFWORD) && (hspi->hdmarx->Init.MemDataAlignment != DMA_MDATAALIGN_WORD))))
    ' s; p$ I* J3 D2 ^7 R2 e
21.   {
    
22.   }
    
23. 
    
24. /* 调整DMA对齐和数据大小 */
    
25.   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)
    2 V* n1 W2 w, O* m. g
26.   {
    
27.      /* 省略未写 */
    4 V" {2 a4 t7 D, A3 o
28.   }
    3 q( B! D" p7 m( L4 H8 g9 F" o7 M
29.   else if (hspi->Init.DataSize <= SPI_DATASIZE_16BIT)
    
30.   {
    
31.      /* 省略未写 */
    
32.   }
    / P% O2 X4 C% g& ]% D
33.   else
    
34.   {
    # @) a; R# d  d  m  r- @  C
35.       /* 省略未写 */
    " e& ]2 V: y- A9 p
36.   }
    . }9 ]! ]6 c: v! W6 k8 T
37. 
    
38. /*  DMA接收配置 */
    ! {3 p; Y, @- V- {% r$ C- [, {
39.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->RXDR, (uint32_t)hspi->pRxBuffPtr,
    
40. hspi->RxXferCount))
    
41.   {
    
42. 
    
43.   }
    2 Q, [4 n, ^: f4 C. S. z
44. 
    
45. /* DMA发送配置 */
    4 D. W0 [9 ]- U  z4 v" Q
46.   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->TXDR,
    ( j: }( K7 m6 a6 F# s: M
47. hspi->TxXferCount))
    
48.   {
    ' {( U- J; J$ [- x
49.   }
    9 l6 }4 }1 e( x1 [7 J% f( e  e: b. P
50. 
    9 O# j$ Q  _. b+ n2 |) n/ f
51.   /* 省略未写 */
    
52. }
    

复制代码

函数描述：
- n: W& A3 [5 Q  V9 D+ t2 u
. K6 l. F: `4 {  N- x# L3 S$ _此函数主要用于SPI数据收发，全双工DMA方式。

$ c, ?8 |+ b: E/ r  }函数参数：
- F5 c+ S3 T# m6 P3 a8 s
  第1个参数是SPI_HandleTypeDef类型结构体指针变量。
' R' i6 t( f# K7 I( F  第2个参数是发送数据缓冲地址。
  第3个参数是接收数据缓冲地址。
  第4个参数是传输的数据大小，单位字节个数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
- D% T. h8 ]3 N: K! i9 z使用举例：

! {5 {1 G# \, N0 H7 f# @9 j& C

1. SPI_HandleTypeDef hspi = {0};
   ) Q* H, d' p9 e% ]" H. m
2. 
   
3. if(HAL_SPI_TransmitReceive_DMA(&hspi, (uint8_t*)g_spiTxBuf, (uint8_t *)g_spiRxBuf, g_spiLen) != HAL_OK)   
   # h9 \' Q+ X# @, \
4. {
   4 o) P* K7 a4 Z+ r, e  p$ V5 |1 Z
5.     Error_Handler(__FILE__, __LINE__);
   ( N( C& h" _/ n" j
6. }

复制代码

72.5 总结
本章节就为大家讲解这么多，要熟练掌握SPI总线的查询，中断和DMA方式的实现，因为基于SPI接口的外设芯片很多，熟练后，可以方便的驱动各种SPI接口芯片，以便选择合适的驱动方式。

9 v" |/ @+ @. \