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

前面我们已经实现了SPI轮询的发送和接收，在前面的基础上进行修改。
; t# F* C0 l% ?- J
: R9 L, |2 T9 B6 E# n' t接缓冲区满中断
新增发送和接收的回调函数，并在初始化的时候配置，使能SPI接收中断：

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   7 Q/ t& w$ }4 M  x# Z8 A# K, I
2. 
   
3. void rx_isr(SPI_HandleTypeDef *hspi)
   % E% v  D4 s& m
4. {
     ~, x( R8 L  U2 I% H
5.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
   : v( m2 i9 V0 Q! u9 A
6.     {
   
7.         u8 data = SPI3->DR;
   
8.                 printf("0x%X  ",data);
   
9.     }
   
10. }
    
11. void tx_isr(SPI_HandleTypeDef *hspi)
    ( {; e7 S+ \0 U/ l2 p7 |+ ?4 c
12. {
    8 y5 Z5 [5 }5 I
13.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
    
14.     {
    / {# A2 ]$ J  a& X5 `( h; e
15. 
    " n" f9 Q7 d) M" o
16.     }
    
17. }
    
18. void SPI3_Init(void)
    
19. {
    . o' ^$ ]6 M3 h5 b% _, y5 E; |
20.     HAL_NVIC_SetPriority(SPI3_IRQn, 0, 0);
    
21.     HAL_NVIC_EnableIRQ(SPI3_IRQn);
    
22. 
    
23.     SPI3_Handler.Instance = SPI3;
    
24.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
    - Z8 D% K7 [, h: u
25.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
    3 W5 v# `1 p' K, i9 _' T- S
26.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
    / k' @4 \! b! c* Q) _
27.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
    
28.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    4 j% M8 r1 S2 h, L& B1 w3 K
29.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    . `9 s, f' z6 o8 d2 X/ S3 C
30.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    
31.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    5 B; L) m( x9 K/ }
32.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    
33.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    % m4 J& M2 Q3 s
34.     SPI3_Handler.Init.CRCPolynomial = 7;
    
35.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    * }! |9 V& U2 F' f2 E6 l1 {
36.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    ! o- {) \! R7 L
37. 
    & b9 N/ Y4 m! m
38.     SPI3_Handler.RxISR = rx_isr;
    + G  Y- e: f# c4 V- `: g: l8 _
39.     SPI3_Handler.TxISR = tx_isr;
    
40.                
    
41.     HAL_SPI_Init(&SPI3_Handler);
      ?1 I9 H& H' K# ]# ~( _  v
42. 
    
43.     //__HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);
    / K# W4 z7 b9 z3 T2 V  Y9 d: K
44.     __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_RXNE);
    5 e4 c- B) K. a
45. 
    ! _# p  |: D& f: k
46. }
    
47. void SPI3_IRQHandler(void)
    
48. {
    ; H9 t7 K9 U" n5 h" Q, n
49.     HAL_SPI_IRQHandler(&SPI3_Handler);
    : [: F: E! A; B1 F
50. }

复制代码

6 a8 f3 D0 |7 i  z( S  W+ u对应的读写操作如下：
/ ^! p% K9 W9 k/ x4 R2 x* E# o
# {  L: M; e, s

1. u16 W25QXX_ReadID(void)
   
2. {
   & J  `; B  ^1 [8 j0 l. g9 c* N
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);
   
9.     SPI3_ReadWriteByte(0x00);
   + i6 O3 A& y5 n  p* T: M/ W
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;
    # X" K/ B3 y' c/ v& g" e
14. }

复制代码

显示结果如下：
9 t. Q; C. E! r$ H

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

7 Y0 [7 _0 Q" k4 F发送缓冲区空中断
同样在前面使能发送完成中断就可以了：

1. __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);

复制代码

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

) O6 u/ @& X6 b9 [- {, k而实际上HAL库是提供了一个HAL_SPI_TransmitReceive_IT用于中断使用的发送接收函数，其中很重要的一部分内容：
/ ^5 R/ v: T+ q5 V7 Q
' T- b, E+ K1 K

1.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   
2.   hspi->pTxBuffPtr  = pTxData;
   
3.   hspi->TxXferSize  = Size;
   
4.   hspi->TxXferCount = Size;
     [" {/ q( }* {6 n8 ?4 F$ a: s/ Y
5.   hspi->pRxBuffPtr  = pRxData;
   : ]- S6 G; V, K5 X9 r, t5 d) x
6.   hspi->RxXferSize  = Size;
   
7.   hspi->RxXferCount = Size;
   
8. 
   ' t+ X; m( G/ J; K- A
9.   /* Set the function for IT treatment */
   5 i$ M3 r# `6 j
10.   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )
    . M0 A5 n9 Y/ t; g9 o5 @
11.   {
    5 F' P* h5 U9 O1 s
12.     hspi->RxISR = SPI_2linesRxISR_16BIT;
    $ E2 r8 b+ a2 }
13.     hspi->TxISR = SPI_2linesTxISR_16BIT;
    
14.   }
    
15.   else
    6 y. d# x! J4 c* {6 a( A
16.   {
    0 h2 U3 J$ ]$ _4 l$ H1 ~
17.     hspi->RxISR = SPI_2linesRxISR_8BIT;
    
18.     hspi->TxISR = SPI_2linesTxISR_8BIT;
    ; `4 V: j( L* j2 n$ f1 k
19.   }
    
20.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));

复制代码

' |  n/ W$ b: M! ^5 J" \重新配置了中断函数，配置了发送和接收缓冲区为传入的数组，所以这里的数组要设置为全局变量，而前面设置的中断函数也失效了，而且使能了中断，所以我们前面所作的工作都是白费了。
: H" U4 Y4 x6 {* S


( J7 w6 p$ i7 H# i+ f