# g. V/ ?* _# X# U
之前做一个项目，串口收发频繁就老卡死，后来用了保守法度过去，近来有空详细分析，发现了问题，并解决，这里分享一下。

这里不对基本操作分析，仅仅讨论一种方式，能让我们稳定的用串口，本文会对HAL库进行些微的修改。
HAL库的串口大致可以分解为2个部分，一个是寄存器控制部分，一个是数据传输部分。我接下来的只修改寄存器控制部分一点点内容，数据传输部分不变，任然采用其回调函数形式，下面具体说明。
" `; z$ }1 M' o( k7 g一般来说最常用的是发送数据HAL_UART_Transmit，中断接收数据HAL_UART_Transmit_IT。串口其余，如DMA什么的不做分析。
研究一下会发现，HAL库中强制对串口进行了半双工限制，其实STM32的串口是全双工的，很多时候卡死，是因为我们做了全双工操作导致的卡死(不是HAL_UART_STATE_READY状态)。
HAL_UART_Transmit修改后如下

1. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   ' z: s5 M% D- Q6 J' y
2. {
   , I: n8 G* b' D, |
3.   uint16_t* tmp;
   
4.   uint32_t tickstart = 0U;
   
5. 
   + }1 R  U, A, R# l: d# X" c
6.   /* Check that a Tx process is not already ongoing */
   1 X$ D/ ?$ C1 E) M
7. //  if(huart->gState == HAL_UART_STATE_READY)
   + @9 s* Y3 k. q* h( ~  N6 V5 d
8.   {
   
9.     if((pData == NULL ) || (Size == 0U))
   ( c. e5 o5 P, l# x: G% k! p
10.     {
    5 M$ S* q* u) `8 p8 }  u
11.       return  HAL_ERROR;
    
12.     }
    
13. 
    " \; [5 A- @- t# p& j/ t
14.     /* Process Locked */
    # h5 O  w& j: ^/ q6 S! P/ W) H; x
15.    // __HAL_LOCK(huart);
    
16. 
    
17.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    0 C2 E* G& P( N) }2 ]
18.     huart->gState = HAL_UART_STATE_BUSY_TX;
    
19. 
    " Y2 j/ v/ ~& j5 v* k6 G6 U
20.     /* Init tickstart for timeout managment*/
    
21.     tickstart = HAL_GetTick();
    ; a! d$ l. N1 b8 V
22. 
    * m8 c) |8 \% I( _% `& A7 g: \
23.     huart->TxXferSize = Size;
    9 v: i) a5 G* h9 k* K) ]' x( ^; G
24.     huart->TxXferCount = Size;
    % s7 Q) H  E+ j
25.     while(huart->TxXferCount > 0U)
    + y+ u; s/ D8 ~: |. X2 s
26.     {
    
27.       huart->TxXferCount--;
    
28.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
    
29.       {
    
30.         return HAL_TIMEOUT;
    * X% q3 n, w( g6 a7 x7 Q
31.       }
    ( W$ O$ d* k) p4 N! U
32.       if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    
33.       {
    . Y6 z; K# n! G
34.         tmp = (uint16_t*) pData;
    
35.         huart->Instance->TDR = (*tmp & (uint16_t)0x01FFU);
    
36.         pData += 2;
    
37.       }
    ( [, T" b) L! l) S" n: p- E
38.       else
    
39.       {
    
40.         huart->Instance->TDR = (*pData++ & (uint8_t)0xFFU);
    * o0 _: e' p/ T) d2 P% S& k
41.       }
    
42.     }
    
43.     if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    
44.     {
    
45.       return HAL_TIMEOUT;
    
46.     }
    
47. 
    
48.     /* At end of Tx process, restore huart->gState to Ready */
    9 U3 \8 Z3 z( t
49.     huart->gState = HAL_UART_STATE_READY;
    ( O, n/ g4 B: E& `# Z3 w: b
50. 
    & o9 C- u& i! |) D  X
51.     /* Process Unlocked */
    * \% o6 O" W9 E. x" o. |0 c+ d, `
52.    // __HAL_UNLOCK(huart);
    
53. 
    + C4 R% y7 k6 P+ |* V
54.     return HAL_OK;
    
55.   }
    - w7 `* g2 @- }& H' t% b- }) P
56. //  else
    8 F0 T) {& X+ J+ n% Q3 U% }
57. //  {
    7 C0 g; p. y, U
58. //    return HAL_BUSY;
    
59. //  }
    8 e% }, K2 M! t4 G+ _- h7 q4 ~
60. }

复制代码

HAL_UART_Transmit_IT修改如下，除了祛除限制，还屏蔽了中断使能，这个后面再说原因
- m  u& V! G- ?; o# t7 F5 x$ [0 a

1. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   
2. {
   
3.   /* Check that a Rx process is not already ongoing */
   
4. // if(huart->RxState == HAL_UART_STATE_READY)
   
5.   {
   
6.     if((pData == NULL ) || (Size == 0U))
   
7.     {
   
8.       return HAL_ERROR;
   
9.     }
   # p# n3 Q9 q) a- T& n4 k
10. 
    - \, `6 p) X9 s% `
11.     /* Process Locked */
      i  I! V! H- B" ~! c& i
12.    // __HAL_LOCK(huart);
    
13. 
    ( T8 @& f0 v$ ~" ]% @# [
14.     huart->pRxBuffPtr = pData;
    
15.     huart->RxXferSize = Size;
    8 S1 _% b) Y- C+ n# n
16.     huart->RxXferCount = Size;
    
17. 
    
18.     /* Computation of UART mask to apply to RDR register */
    
19.     UART_MASK_COMPUTATION(huart);
    
20. 
    
21.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    
22.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    2 z2 b( d2 _8 m  v4 H
23. 
    , c( M7 `9 |8 d; L$ ]+ [
24.     /* Process Unlocked */
    
25.   //  __HAL_UNLOCK(huart);
    
26. 
    4 X2 m/ F* y. R  G# g' c; Y( b
27.     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    
28.    // SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    
29. 
    
30.     /* Enable the UART Parity Error and Data Register not empty Interrupts */
    : ~7 m) Z% J8 u2 I
31.   //  SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    . ?5 ~+ k' w; X1 H1 i
32. 
    
33.     return HAL_OK;
    
34.   }
    ' g- U' D: C, {4 y- ]/ g$ J) m
35. //  else
    - w7 r5 N0 J0 w
36. //  {
    ; y7 Z4 k' |  C, e7 y+ j* W! j: O
37. //    return HAL_BUSY;
    & Z& g5 A& M" Z2 D: j- Z, o2 |, z
38. //  }
    6 r. h. r/ c# P+ d5 `* {
39. }

复制代码

接收中断，屏蔽了清除中断的两行，中断开启后就不再停止了

1. static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
   
2. {
   
3.   uint16_t* tmp;
   
4.   uint16_t uhMask = huart->Mask;
   3 [% P* }* r3 A  O
5. 
   + {( w! m# D1 x  i0 W0 L! B! j$ l
6.   /* Check that a Rx process is ongoing */
   + M: B, Z& M* c
7.   if(huart->RxState == HAL_UART_STATE_BUSY_RX)
   
8.   {
   * F/ e- }: h* Z6 G
9. 
   4 K2 J1 c  [$ t( P' n; H2 I: K' [
10.     if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    
11.     {
    
12.       tmp = (uint16_t*) huart->pRxBuffPtr ;
    / v* w; J: T  k7 y  t) b6 V
13.       *tmp = (uint16_t)(huart->Instance->RDR & uhMask);
    
14.       huart->pRxBuffPtr +=2;
    
15.     }
    
16.     else
    
17.     {
    . [( s# V7 V  Q) I9 }' |: B
18.       *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
    
19.     }
    
20. 
    
21.     if(--huart->RxXferCount == 0)
    8 e% C: m: C  \, L1 B/ h
22.     {
    5 \6 J. J. _  @& K. O
23.       /* Disable the UART Parity Error Interrupt and RXNE interrupt*/
    
24.    //   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
      m- t7 p  a, h0 i/ b3 ?2 b
25. 
    6 @6 D9 M; Z. Z" j7 v9 r
26.       /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    
27.    //   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
    5 O- U+ @" g& q8 |) {# k
28. 
    
29.       /* Rx process is completed, restore huart->RxState to Ready */
    1 `3 W4 J  X  H% T; r" S
30.       huart->RxState = HAL_UART_STATE_READY;
    3 t: q6 q( r7 X2 X: C
31. 
    
32.       HAL_UART_RxCpltCallback(huart);
    ! h4 A5 W1 W/ c6 u- N9 v; n
33. 
    
34.       return HAL_OK;
    - |2 E. z+ d3 E2 k! \
35.     }
    
36. 
    
37.     return HAL_OK;
    
38.   }
    
39.   else
    - Q6 p$ ^2 `5 k, I4 j* V
40.   {
    ! C& s& P* l7 b4 o
41.     /* Clear RXNE interrupt flag */
    
42.     __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
    
43. 
    ; Q' q+ t$ \6 g
44.     return HAL_BUSY;
    6 u! B- Q# Y4 f+ o0 v
45.   }
    
46. }

复制代码

在usart.c添加如下代码，
4 l+ V7 _% A, ^4 FStartUART_Rx：开启中断，同时开启HAL数据流。本来调用HAL_UART_Receive_IT会重新开启中断，不过前面我把它屏蔽了，这样，这里初始化开一次就行了，上面代码中关中断部分已经屏蔽了
HAL_UART_RxCpltCallback:接收中断回调函数
, u8 x8 O% s, C) C$ M( `/ L# w, D3 pHAL_UART_ErrorCallback:错误中断回调函数

) V* C# N# k* N

1. /* USER CODE BEGIN 1 */
   : D* l" j& U; M5 W. N& ?! Y+ q5 O
2. uint8_t a=0;
   
3. void (*UART3_Callback)(uint8_t)=NULL;
   
4. void StartUART_Rx(UART_HandleTypeDef *uartHandle)
   * q  N( N) w* S( [: A
5. {
   
6.         if(uartHandle->Instance==USART3)
   
7.         {
   ! |$ O, e* X6 d. ~
8.                 if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
   6 o8 a- [/ Z# n- E+ u$ Z* P+ `! t# H7 W
9.                 {
   ! j% N7 w- e" X  L4 {0 I/ b- g1 ^
10.                         assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
    # w1 u. p4 A+ J3 K" u: z; J
11.                 }        
    
12.                 SET_BIT(uartHandle->Instance->CR3, USART_CR3_EIE);        
    
13.                 SET_BIT(uartHandle->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);               
    
14.         }
    2 J* a* z3 R& v
15. }
    6 T3 L- c: G) q& ?& w. e
16. 
    
17. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *uartHandle)
    
18. {
    9 C# C, o& w1 i, g- I
19.         if(uartHandle->Instance==USART3)
    
20.         {
    
21.                 if(UART3_Callback!=NULL)
    
22.                 {
    , B; G+ u2 j# F# o1 Y1 a6 |
23.                         UART3_Callback(a);
    / ~$ ^8 l1 \5 I1 @
24.                 }
    ! N( w* W3 ~" i. x
25.                 if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
      |* a/ A: a& i; i+ }* W3 D
26.                 {
    2 e) N) O( s+ N9 j" ^1 O' L
27.                         assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
    ' c7 \5 ^( c6 P- F' a7 D
28.                 }                        
    
29.         }
    " W3 |( u& [; `9 _2 E
30. }
    8 C, Y) s; q, t- t( X$ y8 R8 B
31. void HAL_UART_ErrorCallback(UART_HandleTypeDef *uartHandle)
    
32. {
    8 V7 M+ v( e! j& s, n+ r, W6 f
33.         uartHandle->RxState = HAL_UART_STATE_READY;
    
34.         if(uartHandle->Instance==USART3)
    
35.         {
    
36.                 if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
    0 R4 }6 K" i7 ~. ?
37.                 {
    ; G+ E$ l% k$ u" Z5 X" Z
38.                         assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
    8 ~9 W# \  V% `/ p
39.                 }
    % }( \7 K/ w, x& A. O! \
40.         }
    + m( c# N! ]! w& k8 A9 r/ I8 u
41. }
    
42. 
    ; @3 w. R) o1 ~% J& j" J& B7 \
43. 
    
44. 
    
45. /* USER CODE END 1 */

复制代码

# \; i" Z! r3 F0 W' m4 d
% y2 F8 ~  [$ R, |

基本这样改就能应付大部分应用了，

2 N% g7 A  G4 z* o, V, A/ g

当然有另外一种方式，就是开一个检测任务，定期检测串口状态，如果发现串口卡死，则重新初始化即可。

亦有人用了DMA+空闲中断的方法，不过感觉是不太稳定的。

估计HAL库其他驱动亦有类似的情况，自己把自己卡死。

改库有风险，跟风需谨慎！

- h" B9 q+ `2 x2 y, G
, V; S5 J( }" k

感谢分享        

感谢分享

完美解决，必须要赞