在使用1.2版本的HAL库开发STM32H743的串口7设备的时候，遇到了如下问题：
数据发送使用HAL_UART_Transmit进行发送，单独测试发送的时候，发送正常。
. G' B% o: S! }  A8 ^1 E9 _4 `接收则是HAL_UART_Receive_IT，逐字节进行接收并存放至数组，配合定时器进行不定长数据接收，单独测试接收的时候，接收也正常。
然后博主这里就把TX和RX短接，按理说在发送完成后的50ms以内就会打印接收到的数据（定时器设置的50ms溢出，即不定长数据间隔为50ms），但是这里并没有看到输出。
5 `% m9 k' v' X: d. }
研究了下源码，可以发现，发送的时候，会把串口状态huart->gState标记为发送忙HAL_UART_STATE_BUSY_TX并上锁。
+ w8 j1 k5 b0 q7 r% z3 A

1. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   
2. {
   
3.   uint16_t* tmp;
   
4.   uint32_t tickstart = 0U;
   ; W- I3 |9 |& h2 g3 q! r4 H
5. 
   
6.   /* Check that a Tx process is not already ongoing */
   
7.   if(huart->gState == HAL_UART_STATE_READY)
   
8.   {
   9 x; G7 g4 [/ X: s, ]% b
9.     if((pData == NULL ) || (Size == 0U))
   
10.     {
    " ]/ q3 Y! o6 ]/ p0 `- z
11.       return  HAL_ERROR;
    
12.     }
    
13. 
    - a4 q1 r* y6 w, }7 W4 J
14.     /* Process Locked */
    ' a% n, B+ c1 L) }# ]0 q# f0 R
15.     __HAL_LOCK(huart);
    
16. 
    & J' [! b, T3 F, u2 v
17.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    ) Z5 ^' x: d# c- v" P4 D3 `
18.     huart->gState = HAL_UART_STATE_BUSY_TX;
    
19. 
    
20.     /* Init tickstart for timeout managment*/
    
21.     tickstart = HAL_GetTick();
    
22. 
    
23.     huart->TxXferSize = Size;
    
24.     huart->TxXferCount = Size;
    
25.     while(huart->TxXferCount > 0U)
    ! F3 [: I: ^# [" V" k5 B
26.     {
    
27.       huart->TxXferCount--;
    ) X  @5 U8 R% R4 x7 r6 y
28.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
    
29.       {
    
30.         return HAL_TIMEOUT;
    
31.       }
    
32.       if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    
33.       {
    
34.         tmp = (uint16_t*) pData;
    * f# F' Q3 j/ {' n
35.         huart->Instance->TDR = (*tmp & (uint16_t)0x01FFU);
    % L# V, `) o' s# Q* ^
36.         pData += 2U;
    ! k" r* C( C' m0 n$ |  T7 V# _
37.       }
    ) v- o3 j% b5 u9 \
38.       else
    5 q# G* A$ |& D. ^4 o( G% N" A
39.       {
    1 B' g% N* E: u0 F
40.         huart->Instance->TDR = (*pData++ & (uint8_t)0xFFU);
    
41.       }
    
42.     }
    
43.     if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    6 _+ M, ]3 \) `# H# b
44.     {
    
45.       return HAL_TIMEOUT;
    % c9 c2 `8 Y2 Y5 U" x/ E. d( x
46.     }
    ( p4 [1 v, @" f, C. e1 X& |
47. 
    , v- g* S2 v5 |0 k
48.     /* At end of Tx process, restore huart->gState to Ready */
    7 I3 Z7 R/ V8 I3 l* C& m  [  T. Z
49.     huart->gState = HAL_UART_STATE_READY;
    ( T) T& N( P$ P! U# ?
50. 
    
51.     /* Process Unlocked */
    . q" Q4 b. l; k
52.     __HAL_UNLOCK(huart);
    
53. 
    
54.     return HAL_OK;
    
55.   }
    : e$ ^# a7 v% X( B" I
56.   else
    
57.   {
    8 H- o& M1 B5 ^# D4 K
58.     return HAL_BUSY;
    
59.   }
    : @4 O, G  A0 k( k5 ?( x& v4 c
60. }
    

复制代码

7 s( D  ^) S7 m; v而接收中断触发后，中断向量入口UART7_IRQHandler会直接调用HAL_UART_IRQHandler(&huart7)分析中断请求，根据接收数据完成请求函数调用UART_Receive_IT(huart)，注意这里会把huart->RxState设置为准备接收HAL_UART_STATE_READY并上锁。
; f& A2 h  z/ N2 C6 D2 t

1. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   , ~0 k3 O& m' i1 I) O' m9 C
2. {
   9 R  ^# H3 a% I7 F, u
3.   /* Check that a Rx process is not already ongoing */
   , S& }- o/ S3 D% B$ Z
4.   if(huart->RxState == HAL_UART_STATE_READY)
   
5.   {
   
6.     if((pData == NULL ) || (Size == 0U))
   ( S5 O5 z* B( b. h. d, {+ [
7.     {
   
8.       return HAL_ERROR;
   
9.     }
   
10. 
    
11.     /* Process Locked */
    
12.     __HAL_LOCK(huart);
    * G( ?3 v9 u; F( `0 E
13. 
    
14.     huart->pRxBuffPtr = pData;
    
15.     huart->RxXferSize = Size;
    
16.     huart->RxXferCount = Size;
    - S  Q& k7 l' \2 N- B0 k
17. 
    9 }9 A/ e7 W3 i- y  F) @
18.     /* Computation of UART mask to apply to RDR register */
    
19.     UART_MASK_COMPUTATION(huart);
    0 G3 O: F8 H5 R% K3 N
20. 
    # A& D+ o5 J/ T) X
21.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    , ^* B; P. Y+ q" j1 X9 j8 }* Q( r
22.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    . t( H) C6 _! p: k
23. 
    9 U! J# S, l- e) C( l
24.     /* Process Unlocked */
    
25.     __HAL_UNLOCK(huart);
    ( Z$ ^" Z% U8 P+ A& l) h2 R
26. 
    " `! c, l8 h, k8 F. _' e, P; q- O. Z
27.     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    6 D" e, I4 Z% N* z( s4 }
28.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
      D9 _$ e* p1 t+ H
29. 
    
30.     /* Enable the UART Parity Error interupt and RX FIFO Threshold interrupt
    
31.        (if FIFO mode is enabled) or Data Register Not Empty interrupt
    
32.        (if FIFO mode is disabled).
    ) q  X! h) K) R: b, t& u
33.     */
    9 [2 x0 e4 ?) ~
34.     if (READ_BIT(huart->Instance->CR1, USART_CR1_FIFOEN) != RESET)
    
35.     {
    ! T: F7 M5 m- g. `! b
36.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    
37.       SET_BIT(huart->Instance->CR3, USART_CR3_RXFTIE);
    6 j1 J% X, M" N( j7 M" E5 D
38.     }
    9 `# f( d4 c& W2 z: ]2 h' u& n  R, j
39.     else
    
40.     {
    : h: [1 {# c9 r6 |# c! C/ x
41.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    
42.     }
    7 N# ^3 k! Z0 `+ k
43. 
    
44.     return HAL_OK;
    
45.   }
    ! B0 C; E* a; _. u8 ~9 P# C2 |
46.   else
    * g+ Z$ j' O! K! i
47.   {
    / I9 F; N% L# i
48.     return HAL_BUSY;
    " @2 u! |# {/ ]0 r# K8 I2 u7 ~
49.   }
    9 z( u0 \$ ^  e# F1 C, e
50. }
    

复制代码

9 L/ E/ f# l0 L- \查看一下定义，可以发现这里的一个设计缺陷，gState代表发送状态，RxState代表接收状态，通过这个状态机来保证接收和发送过程的完整性，但是，只设计了一把锁Lock，而锁是用来保护发送或者接收单个字节的完整性的，这样就导致了在连续发送的过程中，处理接收来的数据发现串口设备被上锁了，返回busy，从而丢失了发送的数据。

1. typedef struct
   
2. {
   , o5 G! P/ ~7 K8 b+ @
3.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   
4. 
   # A* b1 ^  ?! ~% ?7 |
5.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
     m, i2 a' y/ u# U+ j
6. 
   
7.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   
8. 
   
9.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
   
10. 
    
11.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    " J$ Y& [! n# Y2 _; S) C- o$ n
12. 
    
13.   __IO uint16_t            TxXferCount;      /*!< UART Tx Transfer Counter           */
    
14. 
    . n7 D3 m, i, ~3 }$ u9 N
15.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    
16. 
    ; v5 }1 J+ T" h) q9 n, F. V
17.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
18. 
    # \' g3 N* b9 r" S2 s! |/ N
19.   __IO uint16_t            RxXferCount;      /*!< UART Rx Transfer Counter           */
    4 E% c* n6 X5 G
20. 
    - `) H! g7 R$ W/ F) E$ b* |
21.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    ( |! G, n$ [5 W: M" ?: D1 W4 {$ K
22. 
    4 n, q7 p* J# h" V2 R- G4 p7 d
23.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
24. 
    ) ^  U) }: ^" p5 |
25.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    ! }; }9 a# h. M% g/ o0 O. d
26. 
    
27.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    
28. 
    5 a; p5 @$ ]6 b; T8 |
29.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    
30.                                                   and also related to Tx operations.
      p! v0 Q, ]% p* G& ^5 @0 \
31.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    2 M- T& c* o. a* R
32. 
    
33.   __IO HAL_UART_StateTypeDef    RxState;     /*!< UART state information related to Rx operations.
    
34.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    4 j5 Q/ }. [( \0 _% l. o
35. 
    
36.   __IO uint32_t             ErrorCode;       /*!< UART Error code                    */
    
37. 
    
38. }UART_HandleTypeDef;
    : q1 e: H6 {. v6 F

复制代码

因为串口本身是全双工，一个比较合理的设计方法就是再设计一把锁进行保护，而网上的大部分解决方案是注释掉调用锁这个过程，个人是不想改动HAL库的，于是自己写发送函数和接收函数。
! o& ]  }/ G: W' p  ]
, q" \0 E- l  ~! a
首先是串口初始化，没有使用HAL_UART_Receive_IT设置接收buffer，而是直接使能接收中断。

1. void MX_UART7_Init(void)
   & j& L" W% x! W" n6 m' z0 I4 u
2. {
   
3. 
   
4.     huart7.Instance = UART7;
   6 d8 v0 b# v' v  W: `" ]/ A2 c' a
5.     huart7.Init.BaudRate = 115200;
   
6.     huart7.Init.WordLength = UART_WORDLENGTH_8B;
   . C8 q9 i* n/ J- r- T
7.     huart7.Init.StopBits = UART_STOPBITS_1;
   4 i0 [+ y5 w# ~3 p& d7 p
8.     huart7.Init.Parity = UART_PARITY_NONE;
   " x( Q2 Y% x# q: r# h
9.     huart7.Init.Mode = UART_MODE_TX_RX;
     G5 @8 U" F, {+ q) q
10.     huart7.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
11.     huart7.Init.OverSampling = UART_OVERSAMPLING_16;
    ! e2 q* ?0 f* L- ]+ x4 _# b8 @
12.     huart7.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
13.     huart7.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    ! }/ ]1 X( h  p. {: ~# _& x  K
14.     if (HAL_UART_Init(&huart7) != HAL_OK)
    
15.     {
    
16.         Error_Handler();
    
17.     }
    ( g5 |3 Q9 N, r' H
18.     __HAL_UART_ENABLE_IT(&huart7, UART_IT_RXNE);        //使能接收中断
    7 u7 G3 X0 A8 Q5 k5 |2 K+ J

复制代码

中断服务函数这里，因为我只使能了接收中断，所以只对接收中断进行处理，其他中断源直接清除。
+ ?8 j5 s. g7 N. g! Z2 F% i8 r

1. void UART7_IRQHandler(void)
   
2. {
   
3.     char ch;
   2 H' r& o  d; T; R6 o2 U8 u- c
4.     if ((__HAL_UART_GET_FLAG(&huart7, UART_FLAG_RXNE) != RESET) &&
   
5.             (__HAL_UART_GET_IT_SOURCE(&huart7, UART_IT_RXNE) != RESET))
   & y0 E+ `8 m! q4 _' n6 A5 x8 P% U
6.     {
   0 h9 w6 [; H4 _" n. a$ p" H! Q8 A
7.         ch = huart7.Instance->RDR;
   9 g0 j2 M" x- H4 B9 H  H  e
8.                 __HAL_TIM_SET_COUNTER(&htim6, 0);
   
9.         if (USART7_RX_STA & 0x8000) return;         //上次接收完成的未处理，直接退出
   
10.         if (USART7_RX_STA == 0)                         //长度为0，接收到的是第一个字节，启动定时器
    
11.         {
    
12.             __HAL_TIM_CLEAR_FLAG(&htim6, TIM_FLAG_UPDATE);
    
13.             HAL_TIM_Base_Start_IT(&htim6);
    % i/ }% ]# J( \, c; c* j+ t; N
14.         }
    
15.         USART7_RX_BUF[USART7_RX_STA & 0x3FFF] = ch;
    
16.         USART7_RX_STA++;
    
17.         if (USART7_RX_STA > (USART_REC_LEN - 1))USART7_RX_STA = 0;
    8 ~9 G' t7 d. o" z- U
18.     }
    1 R( R, z1 J% o8 ?  T- _, a" c
19.     else
    
20.     {
    
21.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE) != RESET)
    / h1 T! n' H7 |. G. d
22.         {
    
23.             __HAL_UART_CLEAR_OREFLAG(&huart7);
    
24.         }
    
25.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE) != RESET)
    . Q! X3 k& R8 ~( M
26.         {
    
27.             __HAL_UART_CLEAR_NEFLAG(&huart7);
    
28.         }
    # n1 D* T/ P0 J9 B5 t! c1 C* ?
29.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE) != RESET)
    
30.         {
    7 C9 Y  D1 t7 U
31.             __HAL_UART_CLEAR_FEFLAG(&huart7);
    - N0 @5 M/ S& e2 C, _% |; [0 _
32.         }
    + J, i  G( y1 t" C, S
33.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE) != RESET)
    
34.         {
    7 p5 Y' }) C  J) `! T
35.             __HAL_UART_CLEAR_PEFLAG(&huart7);
    
36.         }
    ; w- D8 Q" G  Z& |" o$ @& X
37.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_CTS) != RESET)
    . N# H& T, H! \0 O+ H- J
38.         {
    & E# m* K' [& z$ \& i& e$ c
39.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_CTS);
    
40.         }
    . C" d: N" ?5 E; p, C
41.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TXE) != RESET)
    * G+ R7 s% l- f( Z0 u- w
42.         {
    . n; L& }! o/ o$ \
43.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_TXE);
    - z$ l! B8 \, X! a" J: `
44.         }
    
45.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TC) != RESET)
    
46.         {
    1 X' M7 M5 T- J+ r1 u
47.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_TC);
    ) {  Q9 }( Y% M$ a: N0 D
48.         }
    * r, c* e( A% ]! R8 P
49.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_RXNE) != RESET)
    3 `$ J, {  V" V$ R
50.         {
    
51.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_RXNE);
    ( {+ O1 a( g( c" {% e
52.         }
    
53.     }
    
54. }
    - n5 N! K( K, E/ g) E0 V+ f

复制代码

; `6 |3 B0 h) V+ ]! ~# ~3 V发送过程就比较简单了，等待发送完成继续发送就行了。
/ N+ m3 {0 x5 r# j: Q1 B6 g( W

1. void u7_printf(char* s)
   & x( Y5 e% l- X
2. {
   9 q: r4 e4 H. p) r9 Q, @9 \( o
3.         int i=0;
   5 O4 D" M  L2 D# Y5 }9 d
4.         while(s[i])
   
5.         {
   1 o; r1 @$ c( X1 _' }$ |/ A
6.                 huart7.Instance->TDR = s[i];
   
7.                 while (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TC) == RESET);
   ) n; @6 Q1 Z. @* H# j, w
8.                 i++;
   
9.         }
     @+ h; [' T& q6 T. h
10. }

复制代码

————————————————
! r* O, M2 N" G  y: v版权声明：小盼你最萌哒如有侵权请联系删除
& m8 Y' |0 n% f5 p8 H