虽然在平常的使用中，spi使用轮询等待发送完成或者接收完成就行了。
4 s" u9 n3 k2 u# h8 a* v/ N/ z/ `* @但是在对时间有严格要求的设计中，假设我们需要发送完成后立马做xx事情，此时如果有低优先级的信号需要处理，我们的轮询方式就得不到及时的响应；
/ [* I5 h" t7 l5 Q# w* ]  i或者说比如需要定时从spi设备中采集数据，定时器中断来了我们就要马上调用接收函数，接收完成马上进行其他计算，同样此时应该保证数据的优先级。
此时就需要用到发送完成和接收中断了。
3 G9 Q2 Z2 q  L
3 I# ^! B$ j$ S: N- O前面我们已经实现了SPI轮询的发送和接收，在前面的基础上进行修改。

. }) r" y3 X$ z4 Z5 b" d) C
接缓冲区满中断
- ]  E" O' \  i1 p& t3 S. O新增发送和接收的回调函数，并在初始化的时候配置，使能SPI接收中断：

1. SPI_HandleTypeDef SPI3_Handler;  //SPI2句柄
   
2. 
   9 G- t" R$ t! Z) r* ?2 E+ B7 Q$ Q
3. void rx_isr(SPI_HandleTypeDef *hspi)
   % n! [0 H/ |7 O( V7 w7 q
4. {
     m! \+ n$ u/ i8 x: T0 l* J
5.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
   * i  d! `+ j1 e# Y& J6 i+ a+ [
6.     {
   
7.         u8 data = SPI3->DR;
   
8.                 printf("0x%X  ",data);
   
9.     }
   ; Y' b, Q+ f3 [5 l3 r: b) l
10. }
    
11. void tx_isr(SPI_HandleTypeDef *hspi)
    0 _. x9 j) s1 x0 j5 K+ [
12. {
    5 ]7 i; M6 Z9 A/ i
13.     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) == 1)
    5 T) s& E$ K7 S; Z: ~  B  I
14.     {
    
15. 
    ' z4 m3 q, n1 t
16.     }
    $ K; ]3 |* R( m1 d# }& ^0 T6 d% o
17. }
    
18. void SPI3_Init(void)
    
19. {
    
20.     HAL_NVIC_SetPriority(SPI3_IRQn, 0, 0);
    
21.     HAL_NVIC_EnableIRQ(SPI3_IRQn);
    
22. 
    3 x/ X) D4 d: o- F; c& K/ _- n; F7 Z
23.     SPI3_Handler.Instance = SPI3;
    ; q4 i' V# w* {0 W
24.     SPI3_Handler.Init.Mode = SPI_MODE_MASTER;
    0 k/ R+ K& n3 m" ?1 v
25.     SPI3_Handler.Init.Direction = SPI_DIRECTION_2LINES;
    " a8 I( M* T0 o* N2 s
26.     SPI3_Handler.Init.DataSize = SPI_DATASIZE_8BIT;
    
27.     SPI3_Handler.Init.CLKPolarity = SPI_POLARITY_LOW;
    2 K* K) o! F6 P( ]9 }0 N. `
28.     SPI3_Handler.Init.CLKPhase = SPI_PHASE_1EDGE;
    
29.     SPI3_Handler.Init.NSS = SPI_NSS_SOFT;
    - [" {( Q$ f7 a# _- d1 F
30.     SPI3_Handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
    
31.     SPI3_Handler.Init.FirstBit = SPI_FIRSTBIT_MSB;
    - }! U/ |+ w5 O7 E6 S) [+ u
32.     SPI3_Handler.Init.TIMode = SPI_TIMODE_DISABLE;
    
33.     SPI3_Handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    " A4 D$ Y! J" b5 q3 d
34.     SPI3_Handler.Init.CRCPolynomial = 7;
    - T6 W8 m9 _: |) [2 b1 F
35.     SPI3_Handler.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
    
36.     SPI3_Handler.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
    
37. 
    & U, m$ U: a# g& u" D1 j( o
38.     SPI3_Handler.RxISR = rx_isr;
    ; ~3 I, \& u7 M' m) e8 H7 [
39.     SPI3_Handler.TxISR = tx_isr;
    & v# s9 g& ~5 H: U& W8 J
40.                
    ) u! e) h# h: t( a* q
41.     HAL_SPI_Init(&SPI3_Handler);
    - _" [7 e) {' O' U( I  C; ?( ?
42. 
    
43.     //__HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);
    
44.     __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_RXNE);
    ' K; M/ K) C4 I" {5 _! E
45. 
    
46. }
    
47. void SPI3_IRQHandler(void)
    
48. {
    
49.     HAL_SPI_IRQHandler(&SPI3_Handler);
    
50. }
    
51. 
    - v/ @) S8 D* ^) g

复制代码

对应的读写操作如下：
' p+ }  w: Y) X+ c* F

1. u16 W25QXX_ReadID(void)
   6 ^/ M+ E; L' K$ X4 _4 Z& v* k
2. {
   
3.     u16 Temp = 0;
   
4. 
   9 k+ q2 b8 |9 N  m; H3 p1 p
5.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
   $ A* i/ t* a5 d7 q$ y9 r$ ]
6.     SPI3_ReadWriteByte(0x90);//发送读取ID命令
   * M3 `3 @  r+ J2 j  U
7.     SPI3_ReadWriteByte(0x00);
   , I4 {, D' D3 J7 h  c, A
8.     SPI3_ReadWriteByte(0x00);
   9 e* n$ b, v$ }" c
9.     SPI3_ReadWriteByte(0x00);
   2 f, W, z3 r& x* K0 T8 _
10.     Temp |= SPI3_ReadWriteByte(0xFF) << 8;
      s3 A" Q1 B5 H
11.     Temp |= SPI3_ReadWriteByte(0xFF);
    . R* k) h+ w, i( T4 X$ [7 P( p! j
12.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
    - F/ N( i* i% f" L8 ^! |( I* ~
13.     return Temp;
    2 R/ @" d# ~7 R- a4 l$ {
14. }
    + E: I$ [6 q2 ~4 G4 w

复制代码

显示结果如下：



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

发送缓冲区空中断
同样在前面使能发送完成中断就可以了：

1. __HAL_SPI_ENABLE_IT(&SPI3_Handler, SPI_IT_TXE);

复制代码

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

- o: ]0 W. L' D而实际上HAL库是提供了一个HAL_SPI_TransmitReceive_IT用于中断使用的发送接收函数，其中很重要的一部分内容：
7 m8 W9 ]! V4 }, p

1.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
   - d( G* V; I9 I& W7 z; ]9 t
2.   hspi->pTxBuffPtr  = pTxData;
   
3.   hspi->TxXferSize  = Size;
   
4.   hspi->TxXferCount = Size;
   
5.   hspi->pRxBuffPtr  = pRxData;
   
6.   hspi->RxXferSize  = Size;
   7 J/ y* E! E! v  x' I
7.   hspi->RxXferCount = Size;
   + A1 e- E/ l, J$ t* t8 x
8. 
   
9.   /* Set the function for IT treatment */
   ) |0 p7 e; x" E
10.   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )
    0 E% F" z5 s- j- j
11.   {
    
12.     hspi->RxISR = SPI_2linesRxISR_16BIT;
    
13.     hspi->TxISR = SPI_2linesTxISR_16BIT;
    
14.   }
    
15.   else
    
16.   {
    5 p+ s+ |0 d8 D0 ]. E9 Q9 ~
17.     hspi->RxISR = SPI_2linesRxISR_8BIT;
    / _: a: s8 {5 @) d: J
18.     hspi->TxISR = SPI_2linesTxISR_8BIT;
    
19.   }
    8 L- b3 b. }9 H5 h5 ?4 K* R
20.   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));
    

复制代码

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

+ ]$ e) y* h6 c0 j9 u! u+ Y至于HAL_SPI_TransmitReceive_IT的具体过程，先埋个坑……（项目现在没这需求了）
————————————————
版权声明：小盼你最萌哒
) A; o; z8 p1 P3 _7 x2 N