看输出名，以为这个函数是比较参数2和参数3是否一致。
结果仔细看代码，好像是参数2和参数3不一致的话，才返回hal_ok，否则返回hal_timeout.

1. /**
   
2. * @brief  This function handles SPI Communication Timeout.
   
3. * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains
   
4. *                the configuration information for SPI module.
   
5. * @param  Flag: SPI flag to check
   
6. * @param  Status: Flag status to check: RESET or set
   
7. * @param  Timeout: Timeout duration
   
8. * @retval HAL status
   
9. */
   
10. static HAL_StatusTypeDef SPI_WaitOnFlagUntilTimeout(SPI_HandleTypeDef *hspi,
    
11.         uint32_t Flag, FlagStatus Status, uint32_t Timeout)
    
12. {
    
13.     uint32_t tickstart = 0;
    
14. 
    
15.     /* Get tick */
    
16.     tickstart = HAL_GetTick();
    
17. 
    
18.     /* Wait until flag is set */
    
19.     if (Status == RESET)
    
20.     {
    
21.         while (__HAL_SPI_GET_FLAG(hspi, Flag) == RESET)
    
22.         {
    
23.             if (Timeout != HAL_MAX_DELAY)
    
24.             {
    
25.                 if ((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
    
26.                 {
    
27.                     /* Disable the SPI and reset the CRC: the CRC value should be cleared
    
28.                      on both master and slave sides in order to resynchronize the master
    
29.                      and slave for their respective CRC calculation */
    
30. 
    
31.                     /* Disable TXE, RXNE and ERR interrupts for the interrupt process */
    
32.                     __HAL_SPI_DISABLE_IT(hspi,
    
33.                             (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));
    
34. 
    
35.                     /* Disable SPI peripheral */
    
36.                     __HAL_SPI_DISABLE(hspi);
    
37. 
    
38.                     /* Reset CRC Calculation */
    
39.                     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    
40.                     {
    
41.                         SPI_RESET_CRC(hspi);
    
42.                     }
    
43. 
    
44.                     hspi->State = HAL_SPI_STATE_READY;
    
45. 
    
46.                     /* Process Unlocked */
    
47.                     __HAL_UNLOCK(hspi);
    
48. 
    
49.                     return HAL_TIMEOUT;
    
50.                 }
    
51.             }
    
52.         }
    
53.     }
    
54.     else
    
55.     {
    
56.         while (__HAL_SPI_GET_FLAG(hspi, Flag) != RESET)
    
57.         {
    
58.             if (Timeout != HAL_MAX_DELAY)
    
59.             {
    
60.                 if ((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
    
61.                 {
    
62.                     /* Disable the SPI and reset the CRC: the CRC value should be cleared
    
63.                      on both master and slave sides in order to resynchronize the master
    
64.                      and slave for their respective CRC calculation */
    
65. 
    
66.                     /* Disable TXE, RXNE and ERR interrupts for the interrupt process */
    
67.                     __HAL_SPI_DISABLE_IT(hspi,
    
68.                             (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));
    
69. 
    
70.                     /* Disable SPI peripheral */
    
71.                     __HAL_SPI_DISABLE(hspi);
    
72. 
    
73.                     /* Reset CRC Calculation */
    
74.                     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    
75.                     {
    
76.                         SPI_RESET_CRC(hspi);
    
77.                     }
    
78. 
    
79.                     hspi->State = HAL_SPI_STATE_READY;
    
80. 
    
81.                     /* Process Unlocked */
    
82.                     __HAL_UNLOCK(hspi);
    
83. 
    
84.                     return HAL_TIMEOUT;
    
85.                 }
    
86.             }
    
87.         }
    
88.     }
    
89.     return HAL_OK;
    
90. }
    

复制代码

就是一个等待超时的判断 如果等待的状态在指定的时间内到了就ok