& I! v+ F/ Z" l0 W
, q2 e- h* |+ d- |8 x8 A: b, x之前做一个项目，串口收发频繁就老卡死，后来用了保守法度过去，近来有空详细分析，发现了问题，并解决，这里分享一下。

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

1. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   , x. ?  E6 h9 G% |, Y% U/ u
2. {
   ! o& X; K  L6 Y' N
3.   uint16_t* tmp;
   0 s* |, U, L5 M  F9 v
4.   uint32_t tickstart = 0U;
   1 P+ P3 O' w$ |% k& L! J
5. 
   ( B3 {9 D5 \- k! \/ ?2 s
6.   /* Check that a Tx process is not already ongoing */
   : m6 \- s8 R1 m: c- e& o: A, u
7. //  if(huart->gState == HAL_UART_STATE_READY)
   
8.   {
   8 a4 E- {8 `& y; H8 R5 \) m" I
9.     if((pData == NULL ) || (Size == 0U))
   
10.     {
    
11.       return  HAL_ERROR;
    
12.     }
    
13. 
    
14.     /* Process Locked */
    
15.    // __HAL_LOCK(huart);
    
16. 
    
17.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    + u+ {; s" n, v4 d8 T- P0 y
18.     huart->gState = HAL_UART_STATE_BUSY_TX;
    % z, V4 A/ e: ~
19. 
    
20.     /* Init tickstart for timeout managment*/
    
21.     tickstart = HAL_GetTick();
      _) g' i* R' C
22. 
    
23.     huart->TxXferSize = Size;
    
24.     huart->TxXferCount = Size;
    . B* F+ D; O$ a) K+ h# v
25.     while(huart->TxXferCount > 0U)
    
26.     {
    3 `; N5 d. G# S5 p
27.       huart->TxXferCount--;
    & J  k9 k* |  z' M$ |, o$ G! i
28.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
    , t4 u# l+ [/ w* Y4 n  }
29.       {
    " l- y# m: r: {) k) K% L) D; R3 |4 s3 c
30.         return HAL_TIMEOUT;
    $ [3 h( ~; v4 G2 {- @% n! I3 W
31.       }
    
32.       if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    ; K$ m/ g9 U% Q$ p5 H% l) P* g7 _
33.       {
    / P1 [1 a5 U& n! K
34.         tmp = (uint16_t*) pData;
    - t0 \$ F. p. P* y4 F
35.         huart->Instance->TDR = (*tmp & (uint16_t)0x01FFU);
    0 c* U4 R- P7 r2 k* |1 a
36.         pData += 2;
    $ F3 {% z/ T: z" a0 @: p2 `* D4 i
37.       }
    4 j' ]& A  I" @/ H6 d
38.       else
    
39.       {
    
40.         huart->Instance->TDR = (*pData++ & (uint8_t)0xFFU);
    
41.       }
    
42.     }
    
43.     if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    1 R) r9 m$ J: x* s9 D0 y
44.     {
    
45.       return HAL_TIMEOUT;
    & m: R, X; r/ c7 `- J( p! Q
46.     }
    
47. 
    
48.     /* At end of Tx process, restore huart->gState to Ready */
    8 S! S" A) r, f; y! b( v. s5 r& C
49.     huart->gState = HAL_UART_STATE_READY;
    & \: j1 J' d: B+ }/ r3 c
50. 
    7 X  B" Z6 c! K
51.     /* Process Unlocked */
    8 |, l" }8 v7 ~7 C5 c9 C
52.    // __HAL_UNLOCK(huart);
    0 Q# q: K- q# J% T" H
53. 
    
54.     return HAL_OK;
    
55.   }
    
56. //  else
    
57. //  {
    ! U  ]% p/ @) p
58. //    return HAL_BUSY;
    
59. //  }
    
60. }

复制代码

& X% Z( i+ C* a1 Y+ S3 M! KHAL_UART_Transmit_IT修改如下，除了祛除限制，还屏蔽了中断使能，这个后面再说原因
7 M5 D5 e( _  p1 A2 Q

1. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   4 W. o- Y# z3 _4 s! @* J) J! ^2 S
2. {
   / v6 i! }! A& v2 T
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;
   $ ?# O1 l% ]- V$ D; M& Q0 t8 L
9.     }
   
10. 
    
11.     /* Process Locked */
    
12.    // __HAL_LOCK(huart);
    
13. 
    + v6 _) x5 ~( F2 T, }7 E
14.     huart->pRxBuffPtr = pData;
    
15.     huart->RxXferSize = Size;
    . j) `$ M2 s/ G
16.     huart->RxXferCount = Size;
    
17. 
    3 H9 \* M/ z2 }
18.     /* Computation of UART mask to apply to RDR register */
    ; R5 {6 f1 q3 F8 R4 h
19.     UART_MASK_COMPUTATION(huart);
    
20. 
    2 ?  q, A2 x- Y* W; L: F
21.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    " O. E# D3 V& l  i( y: `& v( ?
22.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    
23. 
    
24.     /* Process Unlocked */
    
25.   //  __HAL_UNLOCK(huart);
    
26. 
    
27.     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    
28.    // SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    : L2 M* a4 \+ r4 _; P% G
29. 
    : N7 M4 q2 q/ Q, Y7 |! Y* ^9 w
30.     /* Enable the UART Parity Error and Data Register not empty Interrupts */
    % I8 G) j) o: s2 f/ m6 u
31.   //  SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    
32. 
    , D3 ]* A' d- v; S# y9 K1 C
33.     return HAL_OK;
    ) S9 g6 `- @7 M9 B; v9 b+ p
34.   }
    
35. //  else
    + \7 G, y2 F/ }7 B
36. //  {
    
37. //    return HAL_BUSY;
    " |" p. n8 @- K9 U) H- ?) G! u
38. //  }
    
39. }

复制代码

接收中断，屏蔽了清除中断的两行，中断开启后就不再停止了
- o) u/ H$ B& ~- _9 ~8 b& m

1. static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
   
2. {
   
3.   uint16_t* tmp;
   
4.   uint16_t uhMask = huart->Mask;
   ' ~- M  V7 v5 G
5. 
   - P, S- W0 u( s* c# V% b
6.   /* Check that a Rx process is ongoing */
   
7.   if(huart->RxState == HAL_UART_STATE_BUSY_RX)
   
8.   {
   
9. 
   
10.     if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    / v6 U- }3 c0 o% E
11.     {
    + h3 m+ s. t8 \7 D& F1 R1 o1 k
12.       tmp = (uint16_t*) huart->pRxBuffPtr ;
    : C- h. @. X( u/ s) y6 P8 j
13.       *tmp = (uint16_t)(huart->Instance->RDR & uhMask);
    0 U. n5 z# F6 X( i/ y
14.       huart->pRxBuffPtr +=2;
    # Q: B9 J$ h; D8 Q9 |
15.     }
    
16.     else
    
17.     {
    # b! z9 _# i6 }0 F" z+ F0 G0 z
18.       *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
    
19.     }
    8 ~! q, q. I, G+ ~9 _
20. 
    
21.     if(--huart->RxXferCount == 0)
    6 Y  c$ y' g* T% P
22.     {
    ; ?' {! [" N' Y2 w0 Y7 O3 {
23.       /* Disable the UART Parity Error Interrupt and RXNE interrupt*/
    % F  y1 ?9 l) |' i
24.    //   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
    
25. 
    
26.       /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    4 K1 D4 p# c0 ^: ]
27.    //   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
    : E5 K6 r6 e. U" E( o  m1 z# M
28. 
    
29.       /* Rx process is completed, restore huart->RxState to Ready */
    
30.       huart->RxState = HAL_UART_STATE_READY;
    
31. 
    + l6 \" \" ~( G
32.       HAL_UART_RxCpltCallback(huart);
    
33. 
    
34.       return HAL_OK;
    
35.     }
    
36. 
    ( y) I0 k' b$ ^. @: G$ W) c
37.     return HAL_OK;
    . ^/ h" l" O5 R; Q* u( m( s
38.   }
    ' z. L% y& p! h7 S' V
39.   else
    
40.   {
    
41.     /* Clear RXNE interrupt flag */
    
42.     __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
    
43. 
    ' L* w3 \$ u6 Q5 ~* m
44.     return HAL_BUSY;
    
45.   }
    
46. }

复制代码

在usart.c添加如下代码，
# i. E$ ?9 C+ l2 p3 N( A. I3 X( w1 ^StartUART_Rx：开启中断，同时开启HAL数据流。本来调用HAL_UART_Receive_IT会重新开启中断，不过前面我把它屏蔽了，这样，这里初始化开一次就行了，上面代码中关中断部分已经屏蔽了
HAL_UART_RxCpltCallback:接收中断回调函数
HAL_UART_ErrorCallback:错误中断回调函数

1. /* USER CODE BEGIN 1 */
   
2. uint8_t a=0;
   
3. void (*UART3_Callback)(uint8_t)=NULL;
   ; P9 T/ X) k  A( _
4. void StartUART_Rx(UART_HandleTypeDef *uartHandle)
   
5. {
   6 N! q7 i8 A) y% t
6.         if(uartHandle->Instance==USART3)
   
7.         {
   
8.                 if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
   + b  t! M! {4 N& E
9.                 {
   3 \6 r) U6 z$ R, w2 J5 C
10.                         assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
    
11.                 }        
    ( `! t* M) b; o6 W, V
12.                 SET_BIT(uartHandle->Instance->CR3, USART_CR3_EIE);        
    
13.                 SET_BIT(uartHandle->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);               
    
14.         }
    ! N! b& z7 W* j( a4 r
15. }
    4 L" t8 |5 F( v% q2 M0 Q
16. 
    2 q/ B4 h* ~9 c8 u
17. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *uartHandle)
    . e; J% b# @3 k% B. u
18. {
    0 N: a5 N, _0 c- g
19.         if(uartHandle->Instance==USART3)
    , f6 A' v" Q5 V) ?/ l' K
20.         {
    - ^4 c; q9 D6 C* z6 t
21.                 if(UART3_Callback!=NULL)
    6 m/ o6 z7 K7 G$ c8 \. x  o+ v
22.                 {
    
23.                         UART3_Callback(a);
    / O5 P3 u# P- O3 h( k
24.                 }
    6 Y; O6 y  o- ~+ g
25.                 if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
    4 d1 b  y7 X% S0 m6 X2 A
26.                 {
    
27.                         assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
    
28.                 }                        
    
29.         }
    
30. }
    ( N/ g; Z  G$ ]. a' @4 n
31. void HAL_UART_ErrorCallback(UART_HandleTypeDef *uartHandle)
    ; ?$ B/ T! ~- [3 q) A- x
32. {
    3 a2 F: K# i. v$ C- D% @2 T
33.         uartHandle->RxState = HAL_UART_STATE_READY;
    4 [' Q) x2 S, H; f
34.         if(uartHandle->Instance==USART3)
    $ G  ?6 [+ ~2 }$ Q( B
35.         {
    
36.                 if(HAL_OK!=HAL_UART_Receive_IT(uartHandle,&a,1))
    1 F# w' {) E2 Z6 ^
37.                 {
    # B" \  d' c# [. T
38.                         assert("HAL_UART_Receive_IT",__FILE__,__LINE__);
    
39.                 }
    9 U1 h8 M$ ^/ X; g+ A0 _. a
40.         }
    9 w5 m) M* l6 _* d
41. }
    # \5 Q  t0 N4 _
42. 
    * o* y) {& g1 R* |; o2 M. k
43. 
    2 g, N) l4 ~6 `" }& L! Q
44. 
    
45. /* USER CODE END 1 */

复制代码

/ N. ?8 {# n& q/ ^: F/ }
7 P3 h) b7 ^7 e# A# i

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

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

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

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

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

$ H. ^' u' ]. c- k% |& p+ K

/ T1 ^; X/ x2 b- |0 k% D! x

感谢分享        

感谢分享

完美解决，必须要赞