在使用1.2版本的HAL库开发STM32H743的串口7设备的时候，遇到了如下问题：
数据发送使用HAL_UART_Transmit进行发送，单独测试发送的时候，发送正常。
接收则是HAL_UART_Receive_IT，逐字节进行接收并存放至数组，配合定时器进行不定长数据接收，单独测试接收的时候，接收也正常。
5 g" ]2 k! Z4 q) E* h; C: O然后博主这里就把TX和RX短接，按理说在发送完成后的50ms以内就会打印接收到的数据（定时器设置的50ms溢出，即不定长数据间隔为50ms），但是这里并没有看到输出。
9 B) A2 X- L' e! i$ E4 F
研究了下源码，可以发现，发送的时候，会把串口状态huart->gState标记为发送忙HAL_UART_STATE_BUSY_TX并上锁。
5 s# [& A" d. D

1. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   
2. {
   9 r6 {2 i6 P& H# e( L  B! A
3.   uint16_t* tmp;
   % n! h( h% L+ h$ C% R( z6 @
4.   uint32_t tickstart = 0U;
   ; `. X& ]3 a8 ?+ Q/ |! q8 ~5 C
5. 
   
6.   /* Check that a Tx process is not already ongoing */
   : x4 ^& D. {; H1 ^
7.   if(huart->gState == HAL_UART_STATE_READY)
   * ^4 h. h$ Y' \- f& q
8.   {
   
9.     if((pData == NULL ) || (Size == 0U))
   # o, d; R* `) r0 d; k
10.     {
    $ L( r7 [/ ^0 w! e
11.       return  HAL_ERROR;
    
12.     }
    
13. 
    ! y( v( P: N( ?
14.     /* Process Locked */
    
15.     __HAL_LOCK(huart);
    
16. 
    
17.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    
18.     huart->gState = HAL_UART_STATE_BUSY_TX;
    7 U0 a2 d/ S& H1 i
19. 
    ) |: L4 D9 g3 p, B' B+ F% \
20.     /* Init tickstart for timeout managment*/
    ) _. x' k( |& I8 T' g9 o* A. K
21.     tickstart = HAL_GetTick();
    % |% G" h3 ?6 C. h' d: l4 X
22. 
    . }+ r0 t3 q; A; b- j
23.     huart->TxXferSize = Size;
    6 T- G4 c- l" _1 A8 x
24.     huart->TxXferCount = Size;
    
25.     while(huart->TxXferCount > 0U)
    
26.     {
    1 C5 d$ @0 t, Z: C
27.       huart->TxXferCount--;
    ! ^& m" P$ N6 P" S$ X- i3 N
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))
    + t' @7 l1 E& S+ ?: y
33.       {
    / T3 ^4 b5 X; |/ |& Y
34.         tmp = (uint16_t*) pData;
    
35.         huart->Instance->TDR = (*tmp & (uint16_t)0x01FFU);
    . J% a2 C7 s# {/ j
36.         pData += 2U;
    ( R5 n' ~* r0 N. ?- L9 _  r; O
37.       }
    
38.       else
    
39.       {
    
40.         huart->Instance->TDR = (*pData++ & (uint8_t)0xFFU);
    0 w* Y2 i- i( e$ ~4 D: u# P
41.       }
    
42.     }
    
43.     if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    3 I7 K1 C# P9 j( d
44.     {
    
45.       return HAL_TIMEOUT;
    3 S5 s' T  E6 g. _
46.     }
    
47. 
    - X* n! w# D0 Y
48.     /* At end of Tx process, restore huart->gState to Ready */
    
49.     huart->gState = HAL_UART_STATE_READY;
    
50. 
    3 S6 P9 o" e4 \( m2 V
51.     /* Process Unlocked */
    5 G2 Z+ W6 m  x; U' o
52.     __HAL_UNLOCK(huart);
    
53. 
    
54.     return HAL_OK;
    
55.   }
    8 A: V6 K  {6 T* F4 l, w3 P; c# x
56.   else
    
57.   {
    3 J" Z- D, |+ I2 N4 v. x2 ?
58.     return HAL_BUSY;
    7 S+ f  t# @4 w$ i8 \# j
59.   }
    
60. }
    

复制代码

" q$ s: w; F. E* U) C5 U而接收中断触发后，中断向量入口UART7_IRQHandler会直接调用HAL_UART_IRQHandler(&huart7)分析中断请求，根据接收数据完成请求函数调用UART_Receive_IT(huart)，注意这里会把huart->RxState设置为准备接收HAL_UART_STATE_READY并上锁。

1. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   $ G5 T1 ]! |+ F8 Z$ Z3 A
2. {
   , N7 @. R' w5 b4 c+ q/ c: ^% a" q
3.   /* Check that a Rx process is not already ongoing */
   
4.   if(huart->RxState == HAL_UART_STATE_READY)
   5 w7 h% L6 h( q" S$ N. ^) r/ G" M
5.   {
   ' o; `9 N# P" y6 K/ L7 J
6.     if((pData == NULL ) || (Size == 0U))
   
7.     {
   
8.       return HAL_ERROR;
   
9.     }
   4 n- Z3 v5 n/ b8 p% u: z1 Q  Q
10. 
    + C  k5 j- r1 m  L% E/ i/ b9 {
11.     /* Process Locked */
    
12.     __HAL_LOCK(huart);
    
13. 
    2 S( @: C' x( _! P3 a- P/ R
14.     huart->pRxBuffPtr = pData;
    
15.     huart->RxXferSize = Size;
    
16.     huart->RxXferCount = Size;
    ' r  v2 _" p# _$ V
17. 
    , G, V; i# s& R' |; n, R$ P+ T1 |# I
18.     /* Computation of UART mask to apply to RDR register */
    * e+ ^5 y) @$ P6 @: ~7 a
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 */
    
25.     __HAL_UNLOCK(huart);
    
26. 
    / I! x7 V# I" W4 M0 G
27.     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    : B9 ]. E7 t& z. Z2 l
28.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    
29. 
    
30.     /* Enable the UART Parity Error interupt and RX FIFO Threshold interrupt
    ) z; d2 ^6 x" P3 S
31.        (if FIFO mode is enabled) or Data Register Not Empty interrupt
    , V; p# j7 Y8 C! z4 G
32.        (if FIFO mode is disabled).
    
33.     */
    % B0 Y3 h. {# \0 m8 o  w
34.     if (READ_BIT(huart->Instance->CR1, USART_CR1_FIFOEN) != RESET)
    
35.     {
    
36.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    2 X" g6 s7 X; ~. i6 q+ i5 o6 V
37.       SET_BIT(huart->Instance->CR3, USART_CR3_RXFTIE);
    - L# {2 `9 d4 H
38.     }
    6 `) ?* Z1 @% B) {# P2 Y
39.     else
    
40.     {
    
41.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    1 M2 a/ `8 q9 y' T" w9 o$ O
42.     }
    
43. 
    
44.     return HAL_OK;
    * w7 W) {; t! e" |# @- g
45.   }
    
46.   else
    
47.   {
    
48.     return HAL_BUSY;
    
49.   }
    . c" }5 _2 z' g( h8 o
50. }
    

复制代码

0 |: B7 E4 [+ `4 h' c) |* M; I$ K7 t查看一下定义，可以发现这里的一个设计缺陷，gState代表发送状态，RxState代表接收状态，通过这个状态机来保证接收和发送过程的完整性，但是，只设计了一把锁Lock，而锁是用来保护发送或者接收单个字节的完整性的，这样就导致了在连续发送的过程中，处理接收来的数据发现串口设备被上锁了，返回busy，从而丢失了发送的数据。

1. typedef struct
   
2. {
   : g* h" f9 r. Y) t3 B" e0 ^6 H
3.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   # d: q* K- Y: h( V) E9 d
4. 
   
5.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
6. 
   : C0 ~* U/ H5 [5 q- `5 X1 _
7.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   ) y9 s" m+ @2 ~& p) w7 c  t5 ?  C" f, d
8. 
   
9.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
   / Q1 N2 Y1 A$ n/ |- k
10. 
    
11.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
    , c' C5 D" C: K' H
12. 
    
13.   __IO uint16_t            TxXferCount;      /*!< UART Tx Transfer Counter           */
    ) B* T: x* w+ U, t. R
14. 
    
15.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
    : Z% R: X7 L  ?/ K4 f
16. 
    9 P* R1 I+ j7 I" s; e% \9 j7 o
17.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
18. 
    * u6 B. Q# T# G( e
19.   __IO uint16_t            RxXferCount;      /*!< UART Rx Transfer Counter           */
    * c4 g- y7 b% K4 z8 ?
20. 
    
21.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    0 }0 l, \* v$ w1 Q! Y8 ]( {
22. 
    
23.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
24. 
    
25.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
      W) w4 `- w. U* ~% q2 j2 i( d
26. 
    : q4 ~$ f. @- E' Z/ P1 K5 }% v# N
27.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    5 G5 e6 F- q9 n
28. 
    
29.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    
30.                                                   and also related to Tx operations.
    8 O! U+ |2 d7 B  a. b1 p& W, {
31.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
32. 
    
33.   __IO HAL_UART_StateTypeDef    RxState;     /*!< UART state information related to Rx operations.
    % Q# |, R' n* T9 s& u+ @& k
34.                                                   This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
35. 
    $ \  `5 F- a0 n# Y6 l8 L3 m. P
36.   __IO uint32_t             ErrorCode;       /*!< UART Error code                    */
    
37. 
    ) ], P5 N" {' @
38. }UART_HandleTypeDef;
    

复制代码

0 e2 Y( L; m- P* d& d  m# I因为串口本身是全双工，一个比较合理的设计方法就是再设计一把锁进行保护，而网上的大部分解决方案是注释掉调用锁这个过程，个人是不想改动HAL库的，于是自己写发送函数和接收函数。


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

1. void MX_UART7_Init(void)
   
2. {
   
3. 
   
4.     huart7.Instance = UART7;
   
5.     huart7.Init.BaudRate = 115200;
   
6.     huart7.Init.WordLength = UART_WORDLENGTH_8B;
   % c2 {) R1 {2 U& S) o+ ]( D7 b
7.     huart7.Init.StopBits = UART_STOPBITS_1;
   
8.     huart7.Init.Parity = UART_PARITY_NONE;
   7 U8 u% d7 ?6 S& F: z
9.     huart7.Init.Mode = UART_MODE_TX_RX;
   
10.     huart7.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    ; @# w+ i' m; Y. j2 v6 L
11.     huart7.Init.OverSampling = UART_OVERSAMPLING_16;
    
12.     huart7.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    / b( @. [7 y# o. D3 I. q+ H6 x5 [
13.     huart7.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    6 X7 r7 ]/ _2 I* P
14.     if (HAL_UART_Init(&huart7) != HAL_OK)
    
15.     {
    - a3 b0 A/ t: U. b# N: L5 j
16.         Error_Handler();
    
17.     }
    9 x- b5 _# N, c2 g& U2 g3 L
18.     __HAL_UART_ENABLE_IT(&huart7, UART_IT_RXNE);        //使能接收中断
    

复制代码

; o( ~% `5 t* ~1 q0 f3 W4 R中断服务函数这里，因为我只使能了接收中断，所以只对接收中断进行处理，其他中断源直接清除。
$ l  A7 ~7 |9 E/ g

1. void UART7_IRQHandler(void)
   
2. {
   9 r/ L$ H3 x7 {
3.     char ch;
   , z- m8 o2 D) D: `* G
4.     if ((__HAL_UART_GET_FLAG(&huart7, UART_FLAG_RXNE) != RESET) &&
   
5.             (__HAL_UART_GET_IT_SOURCE(&huart7, UART_IT_RXNE) != RESET))
   
6.     {
   3 r% d' f$ V; H8 `. i4 k
7.         ch = huart7.Instance->RDR;
   
8.                 __HAL_TIM_SET_COUNTER(&htim6, 0);
   5 g4 T8 o# `" ]1 Q
9.         if (USART7_RX_STA & 0x8000) return;         //上次接收完成的未处理，直接退出
   ( c, Z$ p* a! t2 n  x
10.         if (USART7_RX_STA == 0)                         //长度为0，接收到的是第一个字节，启动定时器
    7 b5 p. ~- l8 D2 C
11.         {
    
12.             __HAL_TIM_CLEAR_FLAG(&htim6, TIM_FLAG_UPDATE);
    * f! e$ O; D$ D
13.             HAL_TIM_Base_Start_IT(&htim6);
    3 X0 b- p8 T7 J( r0 e8 |5 E* Q
14.         }
    
15.         USART7_RX_BUF[USART7_RX_STA & 0x3FFF] = ch;
    1 e1 z5 B/ s% n8 t# W- H
16.         USART7_RX_STA++;
    
17.         if (USART7_RX_STA > (USART_REC_LEN - 1))USART7_RX_STA = 0;
    / N/ {$ V! J* B* `4 X
18.     }
    " ~  Y  k0 R/ L. U% ~' {
19.     else
    
20.     {
    
21.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_ORE) != RESET)
    
22.         {
    
23.             __HAL_UART_CLEAR_OREFLAG(&huart7);
    0 a/ ^- x8 d( V: R
24.         }
    
25.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_NE) != RESET)
    
26.         {
    8 l  p# m- y" \! o  I$ B2 L
27.             __HAL_UART_CLEAR_NEFLAG(&huart7);
    ' i  ?/ G* O  c- I* F
28.         }
    
29.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_FE) != RESET)
    ) E7 Z% J1 c+ b
30.         {
    + S, j  N1 ]6 R7 \- r+ @# z5 ^
31.             __HAL_UART_CLEAR_FEFLAG(&huart7);
    6 D) S% T9 J. K' ?, m( j, E* c1 J
32.         }
    
33.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_PE) != RESET)
    
34.         {
    
35.             __HAL_UART_CLEAR_PEFLAG(&huart7);
    
36.         }
    
37.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_CTS) != RESET)
    - W3 a: F. U- Y/ H  O5 f
38.         {
    
39.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_CTS);
    . m, t' ?/ e7 T1 s
40.         }
    3 k  e; E; I$ {; G" K1 ~
41.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TXE) != RESET)
    9 S+ ?6 e& A; c' U. ^1 o9 p- A
42.         {
    / ?, ^5 z/ s1 F3 ?! H7 G
43.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_TXE);
    : ^! ^7 j$ {$ Y( Y
44.         }
    # \0 g# [) \) \" r# N# R
45.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TC) != RESET)
    5 b4 @% \. l5 q! g9 y+ T4 d3 ~
46.         {
    
47.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_TC);
    
48.         }
      j0 M  `7 ^, m- m0 E: O2 a, L
49.         if (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_RXNE) != RESET)
    
50.         {
    * x3 p- i+ f' S( W9 O' x: A
51.             __HAL_UART_CLEAR_IT(&huart7, UART_FLAG_RXNE);
    
52.         }
    ! v- w; q+ d3 X; u
53.     }
    
54. }
    

复制代码

发送过程就比较简单了，等待发送完成继续发送就行了。
! Z9 K. j$ z: ?  Z: |# V% L/ I

1. void u7_printf(char* s)
   
2. {
     |  _5 S# D3 M; _& k. X0 E% X
3.         int i=0;
   
4.         while(s[i])
   
5.         {
   ( |' C8 g9 Q* P+ [: ^
6.                 huart7.Instance->TDR = s[i];
   
7.                 while (__HAL_UART_GET_FLAG(&huart7, UART_FLAG_TC) == RESET);
   
8.                 i++;
   0 l# s8 I$ S# M/ c8 p
9.         }
   
10. }

复制代码

————————————————
版权声明：小盼你最萌哒如有侵权请联系删除
! D: B% i' j+ S
0 ~5 t: d4 g" l! e
9 q& f" q/ F& h; m& e
, y9 B* [3 m' c" b