在使用1.2版本的HAL库开发STM32H743的串口7设备的时候，遇到了如下问题：
  ~5 Z; b) G+ d: l+ \数据发送使用HAL_UART_Transmit进行发送，单独测试发送的时候，发送正常。
% Y; w: [, t. [2 K9 ?5 f0 Q  T接收则是HAL_UART_Receive_IT，逐字节进行接收并存放至数组，配合定时器进行不定长数据接收，单独测试接收的时候，接收也正常。
然后博主这里就把TX和RX短接，按理说在发送完成后的50ms以内就会打印接收到的数据（定时器设置的50ms溢出，即不定长数据间隔为50ms），但是这里并没有看到输出。
& k. d7 |' v* t
研究了下源码，可以发现，发送的时候，会把串口状态huart->gState标记为发送忙HAL_UART_STATE_BUSY_TX并上锁。

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;
   # E8 T3 H5 m7 T  O
5. 
   
6.   /* Check that a Tx process is not already ongoing */
   + a  f9 v. {* N/ t$ }
7.   if(huart->gState == HAL_UART_STATE_READY)
   
8.   {
   . q% \2 {, |# b8 [
9.     if((pData == NULL ) || (Size == 0U))
   
10.     {
    
11.       return  HAL_ERROR;
    ( I5 {" t  G$ {3 q& n* z0 I0 L
12.     }
    
13. 
    ) h5 V) y' e- @! y, s0 C) b& Q
14.     /* Process Locked */
    : w! W2 v) O1 p- C
15.     __HAL_LOCK(huart);
    * W+ R" O* w4 I* @# D* W9 ]
16. 
    ; b9 ]( Z' \4 o* h% b% ^3 K
17.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    ' c. Q4 \, P& ~% Q5 ]! X
18.     huart->gState = HAL_UART_STATE_BUSY_TX;
    ) K4 x, N2 i" [5 C
19. 
    : t# Z+ I# d1 a! R1 Z& Z
20.     /* Init tickstart for timeout managment*/
    
21.     tickstart = HAL_GetTick();
    ; Z1 q" Y6 ?- l! c& ~$ U. }9 v
22. 
    
23.     huart->TxXferSize = Size;
    $ l2 c/ v: R( G5 v1 Y; y; e& I- e9 [
24.     huart->TxXferCount = Size;
    
25.     while(huart->TxXferCount > 0U)
    
26.     {
    
27.       huart->TxXferCount--;
    ! @. P! c9 q, T1 }
28.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
    
29.       {
    
30.         return HAL_TIMEOUT;
    * k  O9 M" p6 V  X. A
31.       }
    
32.       if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    
33.       {
    & B5 [$ @* y( n$ o% n4 G. o
34.         tmp = (uint16_t*) pData;
    
35.         huart->Instance->TDR = (*tmp & (uint16_t)0x01FFU);
    " ]3 i  H' N0 a
36.         pData += 2U;
    
37.       }
    
38.       else
    
39.       {
    
40.         huart->Instance->TDR = (*pData++ & (uint8_t)0xFFU);
    $ W1 S- |, D, S
41.       }
    + @* f+ h  a# n8 c
42.     }
    
43.     if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    - x3 Z$ b- X  O: u5 I, i/ y
44.     {
    7 b/ ~9 e+ F) P, r0 Q# N
45.       return HAL_TIMEOUT;
    7 K; Y! B' X& C- ~" \4 Y+ y
46.     }
    6 J) b  b4 e6 N  m( K( R+ y0 B
47. 
    
48.     /* At end of Tx process, restore huart->gState to Ready */
    # U" d- a# i. n7 U( {. j
49.     huart->gState = HAL_UART_STATE_READY;
    # s& x- ?0 T1 T8 A# K5 V7 r
50. 
    
51.     /* Process Unlocked */
    % q$ p7 z# f& ?7 o0 ~6 A0 [
52.     __HAL_UNLOCK(huart);
    9 L9 m0 P6 N' o! v& R
53. 
    
54.     return HAL_OK;
    % O  M0 [% Y0 e6 W  j1 |
55.   }
    5 v( r7 k2 F" S' m: ?( Q9 U" u
56.   else
    " F( T% ~- o( _9 T& h( o6 M7 b
57.   {
    
58.     return HAL_BUSY;
    
59.   }
    
60. }
    ' z' q( L( _2 J( m2 J

复制代码

0 H( d0 l0 Z0 f; t: x: L而接收中断触发后，中断向量入口UART7_IRQHandler会直接调用HAL_UART_IRQHandler(&huart7)分析中断请求，根据接收数据完成请求函数调用UART_Receive_IT(huart)，注意这里会把huart->RxState设置为准备接收HAL_UART_STATE_READY并上锁。
+ g) P+ ?! r6 E6 I4 o

1. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   
2. {
   0 |: _0 F" X9 r7 v6 v; {( b
3.   /* Check that a Rx process is not already ongoing */
   
4.   if(huart->RxState == HAL_UART_STATE_READY)
   ' P% }! J& [8 W( A0 k* d
5.   {
   $ [) G# K; e2 a
6.     if((pData == NULL ) || (Size == 0U))
   0 V* q: d. K' |& e# W/ N
7.     {
   
8.       return HAL_ERROR;
   - _- x9 l! p9 f
9.     }
   
10. 
    ' f7 l" L& ^4 c- h# M* S
11.     /* Process Locked */
    
12.     __HAL_LOCK(huart);
    7 ~% s  n0 F- R9 o5 n# J" g
13. 
    ) k2 B- o" f" \" C9 j+ \9 P
14.     huart->pRxBuffPtr = pData;
    
15.     huart->RxXferSize = Size;
    
16.     huart->RxXferCount = Size;
    : o% _+ u4 z( R8 E( y
17. 
    & B! U6 W9 r4 S! c9 R3 N$ l/ |
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;
    
23. 
    
24.     /* Process Unlocked */
    6 j, E4 @9 X. `6 v6 w
25.     __HAL_UNLOCK(huart);
    
26. 
    
27.     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    4 ?' Z. l/ E2 z# {5 |- U, h& M
28.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    + s3 Z1 @; C( ^
29. 
    1 M$ O' K" }. r6 r  l5 Z6 N# v, L
30.     /* Enable the UART Parity Error interupt and RX FIFO Threshold interrupt
    , ^  h( p- b4 m3 s6 \0 U# C
31.        (if FIFO mode is enabled) or Data Register Not Empty interrupt
    + U0 z7 t8 V  u7 |  S
32.        (if FIFO mode is disabled).
    & z5 o) b5 n) V4 [; o7 \
33.     */
    ( _2 ?' ?0 v5 {# u7 `/ m% H
34.     if (READ_BIT(huart->Instance->CR1, USART_CR1_FIFOEN) != RESET)
    5 b. U  k2 s6 _# R
35.     {
    6 l6 f: ~# N! c( l6 v* d) N
36.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    
37.       SET_BIT(huart->Instance->CR3, USART_CR3_RXFTIE);
    
38.     }
    
39.     else
    $ u' k! C8 S$ h2 W
40.     {
    5 O! f4 a- m( Y  S9 P  A
41.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    
42.     }
    
43. 
    1 d9 c) I' p) h' o
44.     return HAL_OK;
    
45.   }
    
46.   else
    
47.   {
    / E0 Y- @* w* H: B
48.     return HAL_BUSY;
    
49.   }
    # v" F  V; ?1 p. C) l0 y1 n
50. }
    

复制代码

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

1. typedef struct
   
2. {
   * ]( q1 z' u+ E% R! V
3.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   $ N- m+ s7 N- w% T3 _2 E
4. 
   ' z4 @3 w1 R+ B% Q" `" k! D
5.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   " H4 @* b* \& T9 X
6. 
   
7.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   & a$ `7 l, F9 c3 p& I
8. 
   
9.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
   6 p9 q+ F( [( X+ K
10. 
    ! x% I$ j7 k9 j& N5 E$ n4 _% o9 x: [
11.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    
12. 
    3 ]) j- t+ p* _
13.   __IO uint16_t            TxXferCount;      /*!< UART Tx Transfer Counter           */
    
14. 
    
15.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    + o! i, N5 ]1 [: c; r# D
16. 
    
17.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
      V  b' |+ h9 v: y: ^4 U
18. 
    
19.   __IO uint16_t            RxXferCount;      /*!< UART Rx Transfer Counter           */
    $ _% R& ]) f- R
20. 
    
21.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    
22. 
    
23.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
24. 
    % g+ v* I2 Y% s% k( ?
25.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
26. 
    
27.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    - V! a/ Q6 s1 n: V0 p5 c' O
28. 
    
29.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    : L4 J- r/ `9 _1 s  I. u# R
30.                                                   and also related to Tx operations.
    
31.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
32. 
    / T1 {- }5 O' Y
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 */
    
35. 
    1 @7 L9 L4 s8 v) O& C- M" `* L
36.   __IO uint32_t             ErrorCode;       /*!< UART Error code                    */
    " U/ O0 h# n7 W! X1 e
37. 
    : r$ t" X/ ]; F) y( c
38. }UART_HandleTypeDef;
    

复制代码

7 B/ O0 |7 _: E4 `+ y6 ?因为串口本身是全双工，一个比较合理的设计方法就是再设计一把锁进行保护，而网上的大部分解决方案是注释掉调用锁这个过程，个人是不想改动HAL库的，于是自己写发送函数和接收函数。
+ v8 C- t: P# v6 E3 O4 B

首先是串口初始化，没有使用HAL_UART_Receive_IT设置接收buffer，而是直接使能接收中断。

1. void MX_UART7_Init(void)
   + G' e! X+ C# t/ Z* N
2. {
   
3. 
   
4.     huart7.Instance = UART7;
   0 c* y7 T; S1 R( t. q6 N0 D6 {2 e
5.     huart7.Init.BaudRate = 115200;
   
6.     huart7.Init.WordLength = UART_WORDLENGTH_8B;
   
7.     huart7.Init.StopBits = UART_STOPBITS_1;
   
8.     huart7.Init.Parity = UART_PARITY_NONE;
   - W# q) r) n$ B% W# O
9.     huart7.Init.Mode = UART_MODE_TX_RX;
   
10.     huart7.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
11.     huart7.Init.OverSampling = UART_OVERSAMPLING_16;
    0 H# L$ Q9 b2 a4 j* M
12.     huart7.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
13.     huart7.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    , H9 L! m! @9 x6 f
14.     if (HAL_UART_Init(&huart7) != HAL_OK)
    + z, X# J) r( T( x7 V( h
15.     {
    
16.         Error_Handler();
    8 o% C! [$ k! ?4 i& i- F. r
17.     }
    + C$ y8 ^$ G4 E) L! {, b
18.     __HAL_UART_ENABLE_IT(&huart7, UART_IT_RXNE);        //使能接收中断
    

复制代码

中断服务函数这里，因为我只使能了接收中断，所以只对接收中断进行处理，其他中断源直接清除。
3 W" w$ K' p' E7 v  G

1. void UART7_IRQHandler(void)
   6 G0 w- E7 u( ]4 y% }
2. {
   5 R! V: l3 C4 D* ^4 J; R! W$ ]1 f+ r
3.     char ch;
   
4.     if ((__HAL_UART_GET_FLAG(&huart7, UART_FLAG_RXNE) != RESET) &&
   1 D6 R6 ^, ?  ^
5.             (__HAL_UART_GET_IT_SOURCE(&huart7, UART_IT_RXNE) != RESET))
   2 U; b! m: W* M9 k
6.     {
   
7.         ch = huart7.Instance->RDR;
     W) B  A$ @- Q2 |) n+ @* g
8.                 __HAL_TIM_SET_COUNTER(&htim6, 0);
   
9.         if (USART7_RX_STA & 0x8000) return;         //上次接收完成的未处理，直接退出
   ' g8 a; ^/ E7 V) |: i4 g2 _# z& f+ M
10.         if (USART7_RX_STA == 0)                         //长度为0，接收到的是第一个字节，启动定时器
    9 t3 K* S0 B$ M. ^$ x7 I
11.         {
    + m7 e! J2 a; d
12.             __HAL_TIM_CLEAR_FLAG(&htim6, TIM_FLAG_UPDATE);
    
13.             HAL_TIM_Base_Start_IT(&htim6);
    
14.         }
    , \5 Y  p9 d9 N! |) W: h7 z
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;
    
18.     }
    % k: K* a, {0 j" j
19.     else
    # v3 m' V+ y5 ?6 w- U* b" n
20.     {
    : a8 W$ C' [4 w8 F- D$ V5 z# K
21.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE) != RESET)
    
22.         {
      v, o6 T! t9 T4 ?# U+ q. |
23.             __HAL_UART_CLEAR_OREFLAG(&huart7);
    
24.         }
    ; _$ f" I) |- W3 I/ q1 U
25.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE) != RESET)
    $ b9 t9 e9 Z% h/ {* w/ p
26.         {
    
27.             __HAL_UART_CLEAR_NEFLAG(&huart7);
    
28.         }
    
29.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE) != RESET)
    " S4 N, q, i/ ~$ |3 n$ u
30.         {
    
31.             __HAL_UART_CLEAR_FEFLAG(&huart7);
    # o0 d0 I, p5 V! R4 c
32.         }
    
33.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE) != RESET)
    
34.         {
    4 V' {# ^% q! q" ~
35.             __HAL_UART_CLEAR_PEFLAG(&huart7);
    
36.         }
    
37.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_CTS) != RESET)
    
38.         {
    
39.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_CTS);
      C" }" Q3 u1 J+ ~) f) P/ ^4 j
40.         }
    , g  m5 ~; X; ~
41.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TXE) != RESET)
    
42.         {
    9 f6 i2 J  J; c; I( D! X
43.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_TXE);
    
44.         }
    & `3 s2 B: T/ K4 N
45.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TC) != RESET)
    8 @3 J9 |0 D3 D, O
46.         {
    1 e; N7 D" w+ x: f8 w; w) x3 p
47.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_TC);
    / ^$ p, [- n, e0 X
48.         }
    
49.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_RXNE) != RESET)
    + D1 H$ v/ g& Q* N2 j" l
50.         {
    / y& H( ?' i& Q# U1 }; S
51.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_RXNE);
    ' [5 \, {% H+ H0 O1 P' ^+ y# A
52.         }
    
53.     }
    
54. }
    

复制代码

发送过程就比较简单了，等待发送完成继续发送就行了。
3 a. A+ H" M4 I; x# Z; i0 u4 ]$ u

1. void u7_printf(char* s)
   
2. {
   
3.         int i=0;
   : Z$ D; Y! |9 l
4.         while(s[i])
   6 K- Q- V/ N3 h/ @
5.         {
   
6.                 huart7.Instance->TDR = s[i];
   
7.                 while (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TC) == RESET);
   % f) y2 o4 n$ ?# `1 W2 u4 y
8.                 i++;
   5 U9 Q! ]" G8 {( Z: H( x- `
9.         }
   6 }2 K. o' E8 V$ Q( g8 x& j
10. }

复制代码

————————————————
版权声明：小盼你最萌哒如有侵权请联系删除
% X# T) J, |3 U7 k9 N
! M( m% s6 k1 L$ k3 Q' }
4 V0 k9 L' y% b$ Y