虽然在平常的使用中，spi使用轮询等待发送完成或者接收完成就行了。
但是在对时间有严格要求的设计中，假设我们需要发送完成后立马做xx事情，此时如果有低优先级的信号需要处理，我们的轮询方式就得不到及时的响应；
" i2 U) k! ]- l: q或者说比如需要定时从spi设备中采集数据，定时器中断来了我们就要马上调用接收函数，接收完成马上进行其他计算，同样此时应该保证数据的优先级。
此时就需要用到发送完成和接收中断了。

前面我们已经实现了SPI轮询的发送和接收，在前面的基础上进行修改。
8 m% v- k$ }( m1 x
! F9 m5 k' Y6 l( @4 T% z9 I, m接缓冲区满中断
( @6 s. E; i4 |9 T# Y新增发送和接收的回调函数，并在初始化的时候配置，使能SPI接收中断：
5 W. Y0 o! G2 e6 x. g9 z

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   
2. 
   7 x( G# Y# H4 K7 b0 ^6 V' T: g2 ?
3. void rx_isr(SPI_HandleTypeDef *hspi)
   & `$ a$ p( B/ c# x- C/ Q3 M
4. {
   
5.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
   2 l* l; I, {4 A8 ^- F0 C  p
6.     {
   
7.         u8 data = SPI3->DR;
   ; k% f) t' m% q8 j; m$ O- O
8.                 printf("0x%X  ",data);
   1 Z4 _% M  H3 {
9.     }
   8 J4 U% j, P+ V5 z
10. }
    * j% N, s+ D$ [3 v2 ^( H* Q9 E
11. void tx_isr(SPI_HandleTypeDef *hspi)
    
12. {
    
13.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
    
14.     {
    6 W! \7 R( B, y$ f" T
15. 
    
16.     }
    4 r, M/ ^. s4 b" E  b  b" M, g- s
17. }
    
18. void SPI3_Init(void)
    " O# y( e8 t# ]: t0 _* q
19. {
    
20.     HAL_NVIC_SetPriority(SPI3_IRQn, 0, 0);
    5 a5 ?$ ~+ \9 n. O4 |0 k
21.     HAL_NVIC_EnableIRQ(SPI3_IRQn);
    . G* R) O  H# U
22. 
    1 X2 J. L& J. `7 K2 o  i  j" M0 m
23.     SPI3_Handler.Instance = SPI3;
    : A9 Z( o) \/ W7 \6 n, R
24.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
    0 H/ ?) L2 A0 M2 A% D1 q
25.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
    
26.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
    - Y- y, Z. R, m) _, r( ?1 v4 @6 X0 Y
27.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
    
28.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    
29.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    
30.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    ' L& j$ a% z3 e' P* E' K* [
31.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    
32.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    
33.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    
34.     SPI3_Handler.Init.CRCPolynomial = 7;
    ' b7 g4 K  ^  l- y; v0 P6 m: V
35.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    
36.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    
37. 
    , D3 E* d2 P1 b: E8 F, C
38.     SPI3_Handler.RxISR = rx_isr;
    3 }3 c+ o& I3 ]- }
39.     SPI3_Handler.TxISR = tx_isr;
    
40.                
    
41.     HAL_SPI_Init(&SPI3_Handler);
    
42. 
    
43.     //__HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);
    
44.     __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_RXNE);
    
45. 
    4 D# y) x3 @8 \/ |* E- i8 ~
46. }
    6 N0 n9 D4 {4 F; {: f
47. void SPI3_IRQHandler(void)
    5 `% T7 v# u2 m# y
48. {
    5 o; u; X: D) d9 S3 o' I4 K
49.     HAL_SPI_IRQHandler(&SPI3_Handler);
    
50. }

复制代码

. Z0 y- N0 H4 L% e3 f) v. {" H对应的读写操作如下：

1. u16 W25QXX_ReadID(void)
   : z& S3 O! S3 K: b$ s
2. {
   * p7 C2 H2 u* O3 B
3.     u16 Temp = 0;
   
4. 
   % @1 S* x' _6 |+ j0 _
5.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
   
6.     SPI3_ReadWriteByte(0x90);//发送读取ID命令
   
7.     SPI3_ReadWriteByte(0x00);
   7 D5 _0 Z& k) z! ]
8.     SPI3_ReadWriteByte(0x00);
   3 k% l! o" j! O1 {& [; [
9.     SPI3_ReadWriteByte(0x00);
   
10.     Temp |= SPI3_ReadWriteByte(0xFF) << 8;
    
11.     Temp |= SPI3_ReadWriteByte(0xFF);
    
12.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
    
13.     return Temp;
    
14. }

复制代码

' E* E* H: n; o显示结果如下：

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

- I. u: _, E9 D3 M, w: m发送缓冲区空中断
: y" U/ Q- W6 u( j/ s同样在前面使能发送完成中断就可以了：

  R5 c2 C3 o" ]% @4 |8 @

1. __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);

复制代码

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

而实际上HAL库是提供了一个HAL_SPI_TransmitReceive_IT用于中断使用的发送接收函数，其中很重要的一部分内容：
6 g# v" G3 L- K+ U5 u; G' i

1.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   
2.   hspi->pTxBuffPtr  = pTxData;
   3 f7 @. V, L( P; c, G
3.   hspi->TxXferSize  = Size;
   ' |! Y, f  q6 i% q
4.   hspi->TxXferCount = Size;
   
5.   hspi->pRxBuffPtr  = pRxData;
   
6.   hspi->RxXferSize  = Size;
   , j3 P6 `1 M. x3 T
7.   hspi->RxXferCount = Size;
   
8. 
   
9.   /* Set the function for IT treatment */
   * L% H6 l8 H' M7 p' R1 j* o
10.   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )
    ; b" m. `8 h+ {& `
11.   {
    0 G' M6 J* j$ c8 [9 U
12.     hspi->RxISR = SPI_2linesRxISR_16BIT;
    
13.     hspi->TxISR = SPI_2linesTxISR_16BIT;
    
14.   }
    9 L0 |1 J1 b3 E7 R' X
15.   else
    
16.   {
    
17.     hspi->RxISR = SPI_2linesRxISR_8BIT;
    ; Z* W$ d2 w9 \+ z" q2 g: X
18.     hspi->TxISR = SPI_2linesTxISR_8BIT;
    
19.   }
    
20.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));

复制代码

& A) @9 ?$ n& |6 q% L重新配置了中断函数，配置了发送和接收缓冲区为传入的数组，所以这里的数组要设置为全局变量，而前面设置的中断函数也失效了，而且使能了中断，所以我们前面所作的工作都是白费了。

" }4 Z: n: i$ e* G4 l: I9 a
0 t: a" }, C! Y: C/ i