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

前面我们已经实现了SPI轮询的发送和接收，在前面的基础上进行修改。

# L% [8 ~* ^  e4 N* s
( G: X* s5 D$ f; \( [接缓冲区满中断
6 N; _- y  i( j% o/ F新增发送和接收的回调函数，并在初始化的时候配置，使能SPI接收中断：

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   
2. 
   
3. void rx_isr(SPI_HandleTypeDef *hspi)
   
4. {
   ! c# T* t  U' S& {1 n8 A
5.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
   
6.     {
   6 _7 Z: F* R0 }: k4 z1 P# u
7.         u8 data = SPI3->DR;
   9 D2 Y5 h, H; }: ^- B
8.                 printf("0x%X  ",data);
   3 |; I% v  o* [, O1 P$ y
9.     }
   
10. }
    7 o+ U* V; A4 c+ L. F- G) q
11. void tx_isr(SPI_HandleTypeDef *hspi)
    9 w6 a- P1 g: e8 p6 I# Z
12. {
    
13.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
    2 I- \- v/ M3 n
14.     {
    # o& v' i+ y- @
15. 
    & M, @+ ^. T" x2 r
16.     }
    
17. }
    
18. void SPI3_Init(void)
    5 C2 N5 i# h! h, y1 ?9 F, Z' q
19. {
    
20.     HAL_NVIC_SetPriority(SPI3_IRQn, 0, 0);
    3 e6 J  t6 r! Y4 z- k& Q
21.     HAL_NVIC_EnableIRQ(SPI3_IRQn);
    
22. 
    + Z# F+ y8 p) d3 H5 r: f# K
23.     SPI3_Handler.Instance = SPI3;
    1 ]; q. O) ?2 ^0 z0 Q% Z
24.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
    , R+ N+ [/ U4 m7 }' U! {
25.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
    " k. k. i* N: V$ ?# g+ M1 }* t
26.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
    + d* K' c8 V5 i$ I3 V
27.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
    ' Q! A3 j  G- |) p* P6 Y
28.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    ; @+ t0 {  ^( R* V4 i1 m: z- C
29.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    / j* M3 w* w/ C# {$ l
30.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    ( Y& z- m3 b. L* `! Z
31.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    9 i5 _4 j1 P# v. G
32.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    4 @, K* c8 l5 ]3 C# K6 Z  f
33.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    
34.     SPI3_Handler.Init.CRCPolynomial = 7;
      {" U$ a2 ]& c' a
35.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    
36.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    : M- B1 |; O( M) u, L) Z& y7 ]& U
37. 
    
38.     SPI3_Handler.RxISR = rx_isr;
    
39.     SPI3_Handler.TxISR = tx_isr;
    
40.                
    
41.     HAL_SPI_Init(&SPI3_Handler);
    8 R! {5 n3 d1 y8 W8 T
42. 
    
43.     //__HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);
    - M1 R4 P4 P6 j' ^; S2 p
44.     __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_RXNE);
    + E/ c! A+ o  ~+ k7 j: K
45. 
    
46. }
    * P+ G0 V3 y# p- `
47. void SPI3_IRQHandler(void)
    
48. {
    9 }4 q4 f4 B3 g  i/ m0 X' x
49.     HAL_SPI_IRQHandler(&SPI3_Handler);
    
50. }
    
51. 
    5 G. \% D8 T7 t

复制代码

) ]! I& r% @7 V! H" b对应的读写操作如下：

1. u16 W25QXX_ReadID(void)
   
2. {
   , {, h1 x& f% @6 f$ k. f
3.     u16 Temp = 0;
   
4. 
   1 t' v/ L* G) W$ c4 e- K
5.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
   9 u* l) \- v1 T
6.     SPI3_ReadWriteByte(0x90);//发送读取ID命令
   
7.     SPI3_ReadWriteByte(0x00);
   
8.     SPI3_ReadWriteByte(0x00);
   
9.     SPI3_ReadWriteByte(0x00);
   
10.     Temp |= SPI3_ReadWriteByte(0xFF) << 8;
    
11.     Temp |= SPI3_ReadWriteByte(0xFF);
    9 I% l8 V3 d4 G/ @
12.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
    
13.     return Temp;
    
14. }
    

复制代码

显示结果如下：


# |2 T% L! O6 K5 _: h) n' e
& \4 N! n9 p/ m/ y其中前面4个0xFF是因为在写，写完4个byte同样会进入4次中断，但由于我们在接收中断就把数据接受了，所以SPI3_ReadWriteByte因为超时才退出的，可以明显看到几个数不是同时打印的，至于后面的ID没有显示也是同样的道理。

发送缓冲区空中断
6 {% H6 x) [3 V同样在前面使能发送完成中断就可以了：
  g5 D( z! D. ]. h9 D5 E6 _7 Q

1. __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);

复制代码

' `. @$ R4 X# J但是由于发送完成了之后，发送缓冲区一直为空，所以会一直进入中断，所以我们使用发送完成中断的话，发送完成后除非再次填值或者关闭中断，否则会一直不停进入中断。
* Z7 p7 c* I' @2 X/ I5 }
而实际上HAL库是提供了一个HAL_SPI_TransmitReceive_IT用于中断使用的发送接收函数，其中很重要的一部分内容：
2 E0 H7 D4 m/ g( b' K+ @

1.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   
2.   hspi->pTxBuffPtr  = pTxData;
   
3.   hspi->TxXferSize  = Size;
   2 }* |! l4 q! @1 B0 h, p/ u
4.   hspi->TxXferCount = Size;
   $ Z- f, T! I2 R: w; L9 k% Q
5.   hspi->pRxBuffPtr  = pRxData;
   
6.   hspi->RxXferSize  = Size;
   4 K3 h$ L' h+ t/ o% [) r5 q, T0 w
7.   hspi->RxXferCount = Size;
   
8. 
   # f4 A4 U& e: l" U% c/ n
9.   /* Set the function for IT treatment */
   1 }1 |2 ]% |3 p( Z) V
10.   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )
    4 ~$ q( i& H4 w. W. P( j5 b+ T, O
11.   {
    
12.     hspi->RxISR = SPI_2linesRxISR_16BIT;
    % S) F5 T- [" ~% G
13.     hspi->TxISR = SPI_2linesTxISR_16BIT;
    
14.   }
    
15.   else
    9 \( W$ i& B/ G5 c1 l) ^* M/ E
16.   {
    
17.     hspi->RxISR = SPI_2linesRxISR_8BIT;
    
18.     hspi->TxISR = SPI_2linesTxISR_8BIT;
    
19.   }
    : t3 d* s! K' [
20.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));
    

复制代码

重新配置了中断函数，配置了发送和接收缓冲区为传入的数组，所以这里的数组要设置为全局变量，而前面设置的中断函数也失效了，而且使能了中断，所以我们前面所作的工作都是白费了。

至于HAL_SPI_TransmitReceive_IT的具体过程，先埋个坑……（项目现在没这需求了）
————————————————
% C& c- i" @% g( b1 a8 c版权声明：小盼你最萌哒

. V7 {+ H. T3 t3 ], t