虽然在平常的使用中，spi使用轮询等待发送完成或者接收完成就行了。
* d9 c' t' u3 x& }但是在对时间有严格要求的设计中，假设我们需要发送完成后立马做xx事情，此时如果有低优先级的信号需要处理，我们的轮询方式就得不到及时的响应；
或者说比如需要定时从spi设备中采集数据，定时器中断来了我们就要马上调用接收函数，接收完成马上进行其他计算，同样此时应该保证数据的优先级。
此时就需要用到发送完成和接收中断了。
% v' ^) O' V5 v8 C4 ]& j
前面我们已经实现了SPI轮询的发送和接收，在前面的基础上进行修改。

接缓冲区满中断
新增发送和接收的回调函数，并在初始化的时候配置，使能SPI接收中断：

# w7 P/ d/ ^! {# Y1 y

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   / R! u$ ]" ]- U
2. 
   2 s  J& N9 w6 K3 w  J5 t4 o, k9 S, Y
3. void rx_isr(SPI_HandleTypeDef *hspi)
   * H$ U5 H, ?7 N( [/ n1 _; [1 D2 e
4. {
   ! r0 u/ O) z9 c. s
5.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
   
6.     {
   
7.         u8 data = SPI3->DR;
   
8.                 printf("0x%X  ",data);
   1 E4 U4 }! T& c# s
9.     }
   5 |- S* I0 J) E7 n7 N& D
10. }
    $ s% a/ w5 c0 a; i
11. void tx_isr(SPI_HandleTypeDef *hspi)
    
12. {
    
13.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
    " G9 F5 l, t6 g/ u* x. W4 [+ J; ]/ ?
14.     {
    ' n( p7 Q6 N( E6 X
15. 
    8 b% d( p9 m3 F9 h2 J
16.     }
    
17. }
    ' _1 Y. P3 E( v0 C/ ?% u/ ~
18. void SPI3_Init(void)
    2 E% L+ o+ W; ?9 e
19. {
    
20.     HAL_NVIC_SetPriority(SPI3_IRQn, 0, 0);
    
21.     HAL_NVIC_EnableIRQ(SPI3_IRQn);
    4 N' E: n  d$ Y0 Q, }' l" T
22. 
    
23.     SPI3_Handler.Instance = SPI3;
    3 [" k' c0 B: Q
24.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
    
25.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
    , |# Y; z0 ]+ W, V
26.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
    
27.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
    % _* @$ `" R' ]. k2 A
28.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    * N% f8 R4 n' B
29.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    
30.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    ( d0 n: i4 S: n+ G
31.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    0 m6 n/ \- |+ m
32.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    
33.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    
34.     SPI3_Handler.Init.CRCPolynomial = 7;
    ( K2 ~3 n. Q( L1 ]. o
35.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    
36.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    / E/ ]. a/ |* a# n, k, {4 D
37. 
    ! u) U5 M/ K/ H! b" W6 J3 }8 J8 X* ^
38.     SPI3_Handler.RxISR = rx_isr;
    2 F3 [7 y5 ]1 D* O$ q  h
39.     SPI3_Handler.TxISR = tx_isr;
    6 J% T8 [; h. C  \* b- f' r
40.                
    1 O4 o. q+ P+ d" f7 V) U
41.     HAL_SPI_Init(&SPI3_Handler);
    
42. 
    5 J3 H6 {  u: u! H/ E
43.     //__HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);
    
44.     __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_RXNE);
    
45. 
    9 T( W( H* X% e+ R' ~
46. }
    
47. void SPI3_IRQHandler(void)
    5 |* V5 r4 v+ p& a9 }
48. {
    . I5 ~# d# u% @" E/ J  w" H' V4 B
49.     HAL_SPI_IRQHandler(&SPI3_Handler);
    
50. }

复制代码

对应的读写操作如下：
6 s  S, K9 @6 b: b$ y

1. u16 W25QXX_ReadID(void)
   ) p6 ~3 A9 _# t" Q0 C: u
2. {
   
3.     u16 Temp = 0;
   
4. 
   
5.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
   
6.     SPI3_ReadWriteByte(0x90);//发送读取ID命令
   
7.     SPI3_ReadWriteByte(0x00);
   
8.     SPI3_ReadWriteByte(0x00);
   3 c5 {7 @. \: S
9.     SPI3_ReadWriteByte(0x00);
   - Y6 q. U5 {8 a* k7 y7 K+ D- [8 o
10.     Temp |= SPI3_ReadWriteByte(0xFF) << 8;
    7 P# j# U! T1 n$ q& P" J$ P0 m9 F
11.     Temp |= SPI3_ReadWriteByte(0xFF);
    
12.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
    
13.     return Temp;
    7 e7 Y" Y8 Y2 S7 l4 i) F
14. }

复制代码

$ ]) s/ A& b% |% {显示结果如下：

4 U  K/ l8 R* Z) _6 ?( p' N
其中前面4个0xFF是因为在写，写完4个byte同样会进入4次中断，但由于我们在接收中断就把数据接受了，所以SPI3_ReadWriteByte因为超时才退出的，可以明显看到几个数不是同时打印的，至于后面的ID没有显示也是同样的道理。

& t( ?0 R/ ?1 y: ?: l# x/ |' ^/ Q3 o3 X发送缓冲区空中断
+ v4 T# `6 ]" K2 R# W同样在前面使能发送完成中断就可以了：
7 ^1 J' [9 V$ c
1 g8 d$ [. h$ d1 O' j4 u

1. __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);

复制代码

但是由于发送完成了之后，发送缓冲区一直为空，所以会一直进入中断，所以我们使用发送完成中断的话，发送完成后除非再次填值或者关闭中断，否则会一直不停进入中断。

  b8 A3 @0 j5 D. @5 F0 ?3 N而实际上HAL库是提供了一个HAL_SPI_TransmitReceive_IT用于中断使用的发送接收函数，其中很重要的一部分内容：
7 Z  R+ {& S4 r2 z: u
; b3 a3 E0 N( f

1.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   & @  g3 m, ]+ t" s8 w! q
2.   hspi->pTxBuffPtr  = pTxData;
   
3.   hspi->TxXferSize  = Size;
   
4.   hspi->TxXferCount = Size;
   
5.   hspi->pRxBuffPtr  = pRxData;
   % P9 t4 p6 I; l- e1 k
6.   hspi->RxXferSize  = Size;
   
7.   hspi->RxXferCount = Size;
   # H: z; y% W  }8 T9 R1 N& ^
8. 
   
9.   /* Set the function for IT treatment */
   * a) I6 m0 `5 J( u& a8 R1 {! m; N
10.   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )
    
11.   {
    
12.     hspi->RxISR = SPI_2linesRxISR_16BIT;
    " I/ s* r3 x) \& a' j- V$ t, Z
13.     hspi->TxISR = SPI_2linesTxISR_16BIT;
    
14.   }
    
15.   else
    
16.   {
    1 @, W( d3 y5 J. @# ?0 k
17.     hspi->RxISR = SPI_2linesRxISR_8BIT;
    
18.     hspi->TxISR = SPI_2linesTxISR_8BIT;
    
19.   }
    
20.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));

复制代码

重新配置了中断函数，配置了发送和接收缓冲区为传入的数组，所以这里的数组要设置为全局变量，而前面设置的中断函数也失效了，而且使能了中断，所以我们前面所作的工作都是白费了。
1 B5 a( c& B5 }5 ^) b- C/ e- y


. o* l7 U  J" X: F. f$ ^/ [  z! w" c