今天主要记录一下STM32H7系列串口的使用，正点原子、野火等各大家都有教程，当然用起来也没有问题。
6 T1 o* P) T$ G  w% q; N$ V
解决方法后边有红色大字提醒，直接看后边就可以，如果你没有时间想去了解HAL库的接收思想。
! C9 S: Z# Z! U$ @
ST推的HAL库，在整个接收过程中，是没有用到串口的接收空闲中断，它的处理有三种，分别是轮询，接收完成中断（每一个字节一次），DMA接收。
/ v- s: U& {  r: E
  V8 g& j, F" n( y2 h整个Hal库把接收和发送过程都封装好了，就用最简单的轮询方式看，先看库函数代码：

, w: b0 M& Z6 R: M  q6 R" q

1. /**
   
2.   * @brief Receive an amount of data in blocking mode.
   ( S! @8 v) _( U; y" q2 F
3.   * @note When FIFO mode is enabled, the RXFNE flag is set as long as the RXFIFO
   2 j1 G0 Z5 j9 q: V4 O# n8 f- r
4.   *       is not empty. Read operations from the RDR register are performed when
   
5.   *       RXFNE flag is set. From hardware perspective, RXFNE flag and
   1 s" S7 ^5 V5 T$ `! X; G
6.   *       RXNE are mapped on the same bit-field.
   ; t) O( @$ B1 @8 S% [
7.   * @param huart   UART handle.
   
8.   * @param pData   Pointer to data buffer.
   ) V4 `' q. D* o, E
9.   * @param Size    Amount of data to be received.
   7 s8 G5 [: r" ]  E9 ]$ x4 C1 ?1 U8 y
10.   * @param Timeout Timeout duration.
    ' ~4 T5 B0 {  \" E1 O& f
11.   * @retval HAL status
    
12.   */
    2 J" R& Q( ^8 E) a( s1 R  \
13. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
    7 I9 A# S; B. h) C  m& z
14. {
    ) ~  h3 o: b7 q' t3 a
15.   uint8_t  *pdata8bits;
    
16.   uint16_t *pdata16bits;
    " J: \0 f/ O9 G, m* X7 t
17.   uint16_t uhMask;
    0 i5 @8 A4 T6 z. \# p
18.   uint32_t tickstart;
    ) y9 R4 [! k5 `) C, x
19. 
    
20.   /* Check that a Rx process is not already ongoing */
    
21.   if (huart->RxState == HAL_UART_STATE_READY)
    ' }$ `8 r, G; o2 L# o5 i
22.   {
    
23.     if ((pData == NULL) || (Size == 0U))
    
24.     {
    
25.       return  HAL_ERROR;
    
26.     }
    
27. 
    . D  f1 B$ O( l+ x3 s
28.     /* Process Locked */
    
29.     __HAL_LOCK(huart);
    9 s& V- i# a, Y0 g1 ]% W
30. 
    
31.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    
32.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    ( j" X" `/ U" ~  Q2 N4 ~6 L
33. 
    
34.     /* Init tickstart for timeout managment*/
    
35.     tickstart = HAL_GetTick();
    
36. 
    . a3 |+ K2 ^( @& ~) p: A! A4 M
37.     huart->RxXferSize  = Size;
      W1 P( I' o4 ]+ z' R
38.     huart->RxXferCount = Size;
    
39. 
    
40.     /* Computation of UART mask to apply to RDR register */
    ! v4 s$ s# |% a7 c4 Z! j/ ?3 Q
41.     UART_MASK_COMPUTATION(huart);
    
42.     uhMask = huart->Mask;
    + O% v5 Q2 O  V
43. 
    
44.     /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */
    3 m* d! U/ c' ]0 u# \" F8 o
45.     if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    
46.     {
    4 Z  w! ]- l( U
47.       pdata8bits  = NULL;
    
48.       pdata16bits = (uint16_t *) pData;
    / B% `6 p. T9 _0 H
49.     }
    " i( `8 p; F" `
50.     else
    
51.     {
    
52.       pdata8bits  = pData;
    0 R  ~; |$ X; w% ^# b- n/ z
53.       pdata16bits = NULL;
    ! {: V5 K' O: C1 Q
54.     }
    
55. 
    0 Z$ g/ l+ n3 {6 h7 h
56.     /* as long as data have to be received */
    
57.     while (huart->RxXferCount > 0U)
    
58.     {
    ) d2 [' V3 U$ B) M& R# N' b
59.       if (UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
    
60.       {
    
61.         return HAL_TIMEOUT;
    + H/ y7 h) |8 g  o, Q6 b
62.       }
    ' N4 S7 e* V, J# T2 k. S  [
63.       if (pdata8bits == NULL)
    . B) ]2 C' [& |% W' p
64.       {
    
65.         *pdata16bits = (uint16_t)(huart->Instance->RDR & uhMask);
    * [2 _  ^* L; K+ Y* @
66.         pdata16bits++;
    
67.       }
    6 r) I0 z) V6 Z- G4 f
68.       else
    / |& L. y0 J1 @4 B
69.       {
    
70.         *pdata8bits = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
    8 d! \8 l/ X0 B# A
71.         pdata8bits++;
      {# X$ }0 y2 A0 h
72.       }
    
73.       huart->RxXferCount--;
    
74.     }
    / J; L- W1 \3 q+ b, m$ ^2 b5 G( I
75. 
    1 V$ @! z2 b/ }# y1 \: U1 M  k8 D
76.     /* At end of Rx process, restore huart->RxState to Ready */
    - H# ]9 _2 d0 x) N/ O* h
77.     huart->RxState = HAL_UART_STATE_READY;
    4 U: L! H4 N( J' W0 h  ]
78. 
    
79.     /* Process Unlocked */
    
80.     __HAL_UNLOCK(huart);
    / {, `' N+ j* Z1 c* J$ t" B7 c
81. 
    1 Q6 ]; x, T, l, M
82.     return HAL_OK;
    
83.   }
    5 I" H/ G2 ?) L  ~
84.   else
    - G: Z6 o) w( R& U! ?, C' S
85.   {
    
86.     return HAL_BUSY;
    3 P2 [# Q. Z4 s
87.   }
    
88. }

复制代码

: o4 ~$ b. J; P  y9 G0 S% O简单的看，里边有个while循环，在规定的时间内接收固定字节数的数据，在裸机中，接收过程真就是接收过程，主循环就什么都干不了了，想想，480M的主频，你让我在这个地方等待接收直至完成，本来串口传输就慢（常用115200传输），简直浪费，如果是这样，我为何不用一个51 去玩，所以实际项目中这个方法，只能说拜拜。

8 |$ ]- I4 b) @7 G但是这个方法作为一个串口接收原理说明是一个很好的例子。
& S0 Z6 F( r1 j1 K/ f6 Y2 j3 x
5 j$ D: f. i" i接下来看中断接收方式，继续看库函数代码：
6 \, L$ @% H9 G9 G  h, q& t* [0 x
- W8 x' k( X$ k. P% ~

1. /**
   
2.   * @brief Receive an amount of data in interrupt mode.
   
3.   * @param huart UART handle.
   
4.   * @param pData Pointer to data buffer.
   
5.   * @param Size  Amount of data to be received.
   8 `3 W1 W2 n$ s+ I7 N# h- |
6.   * @retval HAL status
   
7.   */
   
8. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   1 L4 T& B3 |  y/ y0 V' i% P
9. {
   , @& h3 [& S  D1 M* P! C! C
10.   /* Check that a Rx process is not already ongoing */
    
11.   if (huart->RxState == HAL_UART_STATE_READY)
    
12.   {
    
13.     if ((pData == NULL) || (Size == 0U))
    2 m/ k" {) B; P2 j: G, g& i
14.     {
    
15.       return HAL_ERROR;
    
16.     }
    ( L! H$ Z' F- Q
17. 
      D8 O8 j1 H4 |1 ^4 o" K
18.     /* Process Locked */
    ' _- e* R4 D; y& ?$ b% W
19.     __HAL_LOCK(huart);
    - p4 c, g  H8 }" b+ T$ \
20. 
      d; z" L& _+ G5 I- k- k
21.     huart->pRxBuffPtr  = pData;
    % M$ G# J3 R2 H
22.     huart->RxXferSize  = Size;
    
23.     huart->RxXferCount = Size;
    . ^& O& t% E( c. }
24.     huart->RxISR       = NULL;
    8 [2 E9 u0 G8 R; c* ?% o3 W
25. 
    
26.     /* Computation of UART mask to apply to RDR register */
    
27.     UART_MASK_COMPUTATION(huart);
    
28. 
    
29.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    0 T2 r4 t( W: [1 L( x2 m+ J/ a
30.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    * a1 x6 F% I, M; A4 [1 d* `3 _9 y
31. 
    % q/ p( m3 |+ d! D0 @6 g3 r
32.     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    / M& {, {! f  _
33.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    
34. 
    
35.     /* Configure Rx interrupt processing*/
    ; m% j  _& Y2 D9 h5 D# q7 x' A% ~
36.     if ((huart->FifoMode == UART_FIFOMODE_ENABLE) && (Size >= huart->NbRxDataToProcess))
    + @' \  J9 p9 {( N; n
37.     {
    4 t5 Q0 x$ |4 C# s: i
38.       /* Set the Rx ISR function pointer according to the data word length */
    
39.       if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    
40.       {
    % `  {0 Y/ G  B6 o5 Z" t, x* n
41.         huart->RxISR = UART_RxISR_16BIT_FIFOEN;
    
42.       }
    5 L0 Z0 c- Z3 @( v
43.       else
    
44.       {
    4 X6 v1 ^3 _0 B' o
45.         huart->RxISR = UART_RxISR_8BIT_FIFOEN;
    ; \( {1 |& j4 ?$ q( W. n: }
46.       }
    : ?( Q8 R! w- B, t1 g; h( K
47. 
    4 K# {* A0 k; ~, w* ]$ @; S
48.       /* Process Unlocked */
    
49.       __HAL_UNLOCK(huart);
    & y  c/ V) E8 `3 L
50. 
    ) d3 r0 q2 G1 I9 a
51.       /* Enable the UART Parity Error interrupt and RX FIFO Threshold interrupt */
    5 u1 R4 w( k! l3 ^0 o( `8 Z
52.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    3 B- `& ^% q- L& F5 H3 v
53.       SET_BIT(huart->Instance->CR3, USART_CR3_RXFTIE);
    
54.     }
    
55.     else
    3 ?2 x; E# V! Y5 d5 Y, ]
56.     {
    
57.       /* Set the Rx ISR function pointer according to the data word length */
    
58.       if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
    1 D" y' I. t; h# v  S, ^, W
59.       {
    : F' N9 r. Z. \% h( O5 D
60.         huart->RxISR = UART_RxISR_16BIT;
    
61.       }
    % A" I2 Z, `; a) u
62.       else
    
63.       {
    
64.         huart->RxISR = UART_RxISR_8BIT;
    ' |. q& m6 L& q- ]
65.       }
    ! \  ]+ x* ^9 e4 h8 I* f
66. 
    
67.       /* Process Unlocked */
    
68.       __HAL_UNLOCK(huart);
    , x; E* C  c1 y) K+ l$ q+ Z
69. 
    
70.       /* Enable the UART Parity Error interrupt and Data Register Not Empty interrupt */
    
71.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE_RXFNEIE);
    + t3 E6 q, g2 r0 m/ i( g# ~! G
72.     }
    
73. 
    7 h: \. L2 ^0 }8 a" i
74.     return HAL_OK;
    - p0 N, g0 v9 O
75.   }
    . @- S+ Y  X* {8 w$ Q0 m! P
76.   else
    - x4 A9 {2 R- x/ k7 y& H
77.   {
    
78.     return HAL_BUSY;
      [" b2 U/ \) c- `# h) D
79.   }
    
80. }

复制代码

乍一眼没有看出什么问题吧，它仅仅做了一个，启动接收状态，并打开接收完成中断，看函数名就知道接收过程是在中断中进行的，中断函数比较长，咱就不贴完整的代码了，只贴接收部分相关的：
; {( t* i. n, \9 v9 s5 j; o

1. /**
   
2.   * @brief Handle UART interrupt request.
   . O' [5 h1 f' B. ?% Y2 Y* {
3.   * @param huart UART handle.
   
4.   * @retval None
   
5.   */
   ' w5 ]+ F% {0 s3 Z( q6 ?; h- b6 N
6. void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
   
7. {
   
8.   uint32_t isrflags   = READ_REG(huart->Instance->ISR);
   
9.   uint32_t cr1its     = READ_REG(huart->Instance->CR1);
   : Z$ V. _0 L( O* m* n' u4 Y. y
10.   uint32_t cr3its     = READ_REG(huart->Instance->CR3);
    9 J# J$ Q+ c9 T; _+ Q8 P
11. 
    
12.   uint32_t errorflags;
    / f2 L, F3 K# T. X) V- d) T
13.   uint32_t errorcode;
    
14. 
    : O0 w$ s& A6 P
15.   /* If no error occurs */
    9 m+ D. |: y1 V+ z* w; M
16.   errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE));
    . C8 f) i2 s; y# \% A# W4 l
17.   if (errorflags == 0U)
    
18.   {
    
19.     /* UART in mode Receiver ---------------------------------------------------*/
    - ?; J! ^/ _) t" m7 @
20.     if (((isrflags & USART_ISR_RXNE_RXFNE) != 0U)
    ' u( p$ e. n" ]' i: Q# H" S
21.         && (((cr1its & USART_CR1_RXNEIE_RXFNEIE) != 0U)
    ! d2 e5 u) G! R$ B
22.             || ((cr3its & USART_CR3_RXFTIE) != 0U)))
      a5 @9 I* k; {6 x! V% r2 h/ J  W! j
23.     {
    
24.       if (huart->RxISR != NULL)
    
25.       {
    
26.         huart->RxISR(huart);
    $ ]. S1 h: L9 f% W  G! K; H
27.       }
    + r+ }2 C6 l4 {$ C8 M. v
28.       return;
    
29.     }
    
30.   }
    
31. /* 这里省略了其他关系不大的代码 */
    / P8 s1 ~" z" B! R: g# N" q: g0 q1 D
32. }
    
33. 从这能看出的是接收过程在huart->RxISR()中，因此我们还要看这个代码，上一段代码的倒数16行处对它有赋值，我们也需要去看，函数名是UART_RxISR_8BIT()，又要贴代码了   ^v^    ^v^：
    " h( L0 g) d' o+ W* @! s
34. 
    
35. /**
    9 p# T3 v; v  @) L
36.   * @brief RX interrrupt handler for 7 or 8 bits data word length .
    0 s5 j7 b, j) \; y0 Q3 v& H
37.   * @param huart UART handle.
    1 D& G% O) U/ h
38.   * @retval None
    % s  n& b8 f/ q3 n0 u6 f5 N9 Q
39.   */
    
40. static void UART_RxISR_8BIT(UART_HandleTypeDef *huart)
    
41. {
    $ ^9 E0 u+ V# v% ^4 K6 _
42.   uint16_t uhMask = huart->Mask;
    
43.   uint16_t  uhdata;
    
44. 
    
45.   /* Check that a Rx process is ongoing */
    
46.   if (huart->RxState == HAL_UART_STATE_BUSY_RX)
    + e8 ^0 X3 N' ]  z" m( {
47.   {
    % N* o, C# r5 N+ U2 I5 N; Z5 b, c
48.     uhdata = (uint16_t) READ_REG(huart->Instance->RDR);
    
49.     *huart->pRxBuffPtr = (uint8_t)(uhdata & (uint8_t)uhMask);
    $ i: g; Z: L9 |) M  R
50.     huart->pRxBuffPtr++;
    
51.     huart->RxXferCount--;
    
52. 
    
53.     if (huart->RxXferCount == 0U)
    4 {% B3 v& r: B$ V
54.     {
    % y$ s7 ?( n2 Q1 X9 X) h# x3 l6 r
55.       /* Disable the UART Parity Error Interrupt and RXNE interrupts */
    / K0 I9 \7 ?# |( v/ O
56.       CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE));
    
57. 
    
58.       /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    
59.       CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
    
60. 
    
61.       /* Rx process is completed, restore huart->RxState to Ready */
    : o: L* R$ j3 l& z3 m' H
62.       huart->RxState = HAL_UART_STATE_READY;
    
63. 
    4 C. N* W' ~6 y5 v: L
64.       /* Clear RxISR function pointer */
    / z1 ~- d2 y, k; Q0 k4 Q1 d# x
65.       huart->RxISR = NULL;
    
66. 
    
67. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    % F! g% g: T9 D+ q3 ~
68.       /*Call registered Rx complete callback*/
    - F# g* u5 D+ k/ d) {
69.       huart->RxCpltCallback(huart);
    ; Q! U4 R: o; h+ _' h5 i
70. #else
    
71.       /*Call legacy weak Rx complete callback*/
    + Y! w- o8 ^% Z5 J' ~4 S) ]
72.       HAL_UART_RxCpltCallback(huart);
    
73. #endif /* USE_HAL_UART_REGISTER_CALLBACKS */
    
74.     }
    6 k. r9 C$ z3 J
75.   }
    
76.   else
    1 H6 b9 x( J9 }6 b: d* Q
77.   {
    
78.     /* Clear RXNE interrupt flag */
    ; X+ b" P$ O: D4 H
79.     __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
    3 }. A0 b3 O( g& }. Z- S" k
80.   }
    * z. s: m5 R$ C" h9 O
81. }

复制代码

4 f0 u+ r0 ?- P( r# I这样差不多一个接收过程就完整了，也仅仅是个差不多。这个函数里边做了一下工作：1.从外设里边读接收到的字节，并存储到缓存数组中。2.更新接收控制部分，就是那三行自增自减的代码。3.如果接收数据达到指定的数量，就调用HAL_UART_RxCpltCallback函数，并释放接收串口接收状态，关闭接收完成中断。用户需要实现HAL_UART_RxCpltCallback函数，需要注意的是，这个函数是在中断中执行的，单片机这类东西，我们都希望中断里边尽可能精简，显然HAL库那是不可能了。

% g1 Z, h  l3 y* O2 ]6 t, fDMA接收方式，H7暂时还没有仔细看，我在F1、F4中一律用DMA接收发送的，这里暂时不发表意见。
! j2 g4 U9 w: Q0 \6 ~! D. ^
轮询和终端接收方式，都需要用户提供一个数据缓存区，并制定接收数据的量，否则返回值就是错误或者超时，实际上，比如你用串口和串口转WiFi模块通信的时候，每次传输的数据量都是不固定也是未知的，这就比较麻烦了。
$ t  Z# B# ?7 Y& M" X
, P, [" ], N9 b4 b" [7 {& i& p当然解决方法有很多，如果你有心，完全可以直接寄存器操作，抛弃这个HAL库，并且效率你说了算。

! V9 S& L+ _( a" ?正点原子的解决方式是，函数入口HAL_UART_Receive_IT填参数的时候，数量设为1个字节，相当于HAL库没有什么作用，反而占用了大量的执行空间和时间，效率更低。

精华来了，重点来了，然后再加个粗，把字号也放大一些。
5 Q) s7 S& ^- a# k/ {) b先贴上我的代码，后边简要说明实现方法，代码如下：
3 Q! B3 J. c5 T3 W  E: ?& H5 }( W% m

1. #include "Uart.h"
   
2. #include "stm32h7xx_hal.h"
   . n# N; D; h3 B: P
3. 
   2 R* Y1 J! Q& R& P, T
4. #define RxBufSize                        1024
   ) Z: z* \% E) ~  @, ?8 U$ h
5. 
   
6. UART_HandleTypeDef huart1 = {0};
   
7. uint8_t RxBuf[2][RxBufSize] __attribute__((section (".RAM_D1")));
   
8. void (*Uart1RxCompleteCallback)(uint8_t *pData,uint16_t *Count);
   5 B) ?" E" w" q/ Z5 O
9. 
   ' s, y- a3 t, ^- F6 [! R
10. void Uart1Init(uint32_t BaudRate,void (*RxCompleteCallback)(uint8_t *pData,uint16_t *Count))
    
11. {
    
12.         huart1.Instance = USART1;
    1 t# c, x+ w5 K+ t/ R
13.         huart1.Init.BaudRate = BaudRate;
    
14.         huart1.Init.ClockPrescaler = UART_PRESCALER_DIV2;
    7 m. c3 y9 l  ~# X! a
15.         huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    ( w3 q5 M, p# h* A' t- U
16.         huart1.Init.Mode = UART_MODE_TX_RX;
    
17.         huart1.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED;
    2 H1 _" B% |  K
18.         huart1.Init.OverSampling = UART_OVERSAMPLING_8;
    2 x- n' \1 r# u1 t
19.         huart1.Init.Parity = UART_PARITY_NONE;
    
20.         huart1.Init.StopBits = UART_STOPBITS_1;
    * ]" e* |* b; ]& b; C
21.         huart1.Init.WordLength = UART_WORDLENGTH_8B;
    
22.         huart1.FifoMode = UART_FIFOMODE_DISABLE;
    
23.         
    
24.         HAL_UART_Init(&huart1);
    9 T+ {/ K% a' q9 Z8 b$ L. L. x# I
25.         HAL_UART_Receive_IT(&huart1,RxBuf[0],RxBufSize);
    1 i, z" Q! |# M  ]" i
26.         __HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);
    
27.         HAL_NVIC_EnableIRQ(USART1_IRQn);
    2 e$ ^" d/ A! M! @* O0 \4 `
28.         HAL_NVIC_SetPriority(USART1_IRQn,11,0);
    : n/ w4 A1 I  ^) C
29.         
    6 I& ]: k- i% \/ X
30.         Uart1RxCompleteCallback = RxCompleteCallback;
    + H" \  |" x8 y% {
31. }
    # _+ x# H0 x$ {
32. 
    
33. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    
34. {
    
35.         if(huart == &huart1)//串口1
    2 d8 ?% L9 G! h3 I
36.         {
    
37.                 GPIO_InitTypeDef GPIO_InitStruct;
    ( x0 _9 w3 q' Q* D- [" A; |" U) U
38.                
    
39.                 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
40.                 GPIO_InitStruct.Pull = GPIO_NOPULL;
    $ L  U! Z# u/ G2 E8 _, K" X+ b
41.                 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
    
42.                 GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    
43.                 GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_9;
    
44.                
    ; q9 s( Z% {  u& E4 L
45.                 __HAL_RCC_GPIOA_CLK_ENABLE();
    
46.                 __HAL_RCC_USART1_CLK_ENABLE();
    
47.                
    7 J" V" @+ Q2 q; ~. j$ z% @
48.                 HAL_GPIO_Init(GPIOA,&GPIO_InitStruct);
    % X8 {) n9 ]7 F* P. E7 V& r5 E8 `$ g( y
49.         }
    
50. }
    5 W( `! f0 u; H8 M/ I
51. 
    
52. void Uart1TxData(uint8_t *pData,uint16_t Count)
    ; E: P- }* Z8 q* g5 }) J/ C
53. {
    6 |* c9 p9 f  C% i
54.         HAL_UART_Transmit_IT(&huart1,pData,Count);
    ; F" k; |/ y' s, I% _! m0 P! T% |6 ~
55. }
    
56. 
    
57. void USART1_IRQHandler(void)
    
58. {
    " g/ O4 [/ x$ ~8 x' }2 m) y: k
59.         HAL_UART_IRQHandler(&huart1);
    
60.         if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))
    
61.         {
    7 o$ v# `6 Q! o! f, T
62.                 static uint16_t count;
    + d* i0 Y7 ?* n
63.                 __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    1 k, m+ f( D8 V( w
64.                 if(Uart1RxCompleteCallback)
    
65.                 {
    
66.                         count = RxBufSize - huart1.RxXferCount;
    
67.                         huart1.RxState = HAL_UART_STATE_READY;
    ( T, W6 S$ G( U
68.                         if(huart1.pRxBuffPtr <= RxBuf[1])
    0 k/ V, r8 m9 }( j" \% p! m. T
69.                                 Uart1RxCompleteCallback(RxBuf[0],&count);
    
70.                         else
    ) l" _+ X+ Z) g! c; ~+ }
71.                                 Uart1RxCompleteCallback(RxBuf[1],&count);
    
72.                         HAL_UART_RxCpltCallback(&huart1);
    % o6 h$ K& _2 X+ ?. |
73.                 }
    
74.         }
    ! V  {1 w' K# Q6 ?5 g  r% t
75. }
    ( a* m) N+ A' M; z2 J* c: |8 e4 F
76. 
    
77. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    
78. {
    / {( `0 t9 E" l: D
79.         if(huart == &huart1)
    
80.         {
    4 H& T* j- j1 O/ D
81.                 if(huart->pRxBuffPtr <= RxBuf[1])
    ; H6 O! Q: B" u2 w
82.                         HAL_UART_Receive_IT(&huart1,RxBuf[1],RxBufSize);
    
83.                 else
    : _! G( |3 k* i9 _3 G6 n* R
84.                         HAL_UART_Receive_IT(&huart1,RxBuf[0],RxBufSize);
    8 U% e3 u/ D- X" M1 c2 W
85.         }
    
86. }

复制代码

这是C文件，共计84行，也不多，连带着初始化也有了，下边是H文件，代码如下:

1. #ifndef __Uart_H_
   
2. #define __Uart_H_
   . k, b7 m. W: ]! l7 a8 U7 R7 [: c
3. 
   
4. #include "stdint.h"
   6 _, v$ m, x, M7 k
5. 
   * S7 r' A; }- r1 P
6. void Uart1Init(uint32_t BaudRate,void (*RxCompleteCallback)(uint8_t *pData,uint16_t *Count));
   1 ~' Q, h- y% |; F
7. void Uart1TxData(uint8_t *pData,uint16_t Count);
   # y  z9 Z! |9 ^" ]
8. 
   . A+ k) N" m: L8 e
9. #endif /* End __Uart_H_ */
   
10. 就是这么简单明了，咦，是不是发现接口函数只有发送没有接收，没关系，咱继续，贴一个简单应用，代码如下：
    3 {0 e, @7 _9 |
11. 
    
12. #include "Uart1Task.h"
    : @! o* O# _- D! n5 T" V! ~( S6 `
13. #include "limits.h"//ULONG_MAX
    9 L6 F8 ^. y0 ], C" R/ V2 |
14. #include "Uart.h"
    & M* X% Y6 P' t' b* p0 V* I5 y& s! {
15. 
    
16. #define Uart1RxCompleteFlag                0x01
    
17. 
    3 d) ]% y' g0 L# t$ l3 b9 P: O
18. static uint8_t *Uart1RxData;
    
19. static uint16_t Uart1RxCount;
    8 R3 I5 h7 o; D* e/ p, R
20. TaskHandle_t Uart1TaskHandle;
    
21. 
    : I3 }7 Z4 w: l' P& l0 u/ G4 D
22. void Uart1RxIRQ(uint8_t *pData,uint16_t *Count);
    
23. 
    & w" i# |& F* g/ B# V
24. TaskHandle_t *GetTaskHandle_t(void)
    
25. {
    
26.         return &Uart1TaskHandle;
    $ a4 M8 ?2 z/ A+ R/ ?* a8 ~
27. }
    4 ^2 Q( z6 u7 S  w
28. 
    
29. void Uart1Task(void *pvParameter)
    
30. {
    
31.         Uart1Init(115200,Uart1RxIRQ);
    6 C8 R& c# H9 K( L
32.         while(1)
    + `' J( V4 k! Y2 J0 e
33.         {
    ) O  y& n/ k; u- Q
34.                 uint32_t NotifyValue = 0;
    
35.                 xTaskNotifyWait(pdFALSE,ULONG_MAX,&NotifyValue,portMAX_DELAY);
    8 T5 h% V0 ^6 a
36.                 Uart1TxData(Uart1RxData,Uart1RxCount);
    7 l: n0 g. |: Z/ J( e
37.         }
    ; N. t# ^+ y! k; \4 B
38. }
    
39. 
    % H3 U* \# F- w0 |; w
40. void Uart1RxIRQ(uint8_t *pData,uint16_t *Count)
    4 J" G! [: s+ F
41. {
    / B6 P% i6 c9 s$ `5 q  L' T: G) A
42.         Uart1RxData = pData;
    
43.         Uart1RxCount = *Count;
    / t5 T9 m  j' K" g
44.         BaseType_t pxHigherPriorityTaskWoken;
    * h8 Y8 W# O1 L' `8 I9 [5 l6 Q, }
45.         xTaskNotifyFromISR(*GetTaskHandle_t(),Uart1RxCompleteFlag,eSetBits,&pxHigherPriorityTaskWoken);
    
46.         portYIELD_FROM_ISR(pxHigherPriorityTaskWoken);
    
47. }

复制代码

以上应用，仅仅是做一个，把接收到数据再发回去，这个Uart1Task函数是在FreeRTOS里边的一个任务，裸机中你就可以当main函数理解，用到了任务通知，这个不是重点，重点是初始化有两个参数，一个是波特率没啥好说的，另一个是注册了一个回调函数，在空闲中断发送的时候调用，这个函数也有连个参数，这个不需要你关心，你只需要知道，你接收到的数据在哪里，接收了多少，pData就是接收到数据起始位置的一个指针，Count就是接收到的数据量，目前单帧最大可接收1024字节，缓存为2K，暂时不支持连续超过1K数据的接收行为，当你仔细看一遍我的方法，你就知道该怎么解决这个问题了，以后有空再适配到DMA接收方式，那才是真正的完美。

简单说一下，实现思路，在HAL库的基础上，把固定死的大小设为缓存，接收过程由HAL库完成。每当空闲中断来，意味着，一帧不定长数据接收完毕了，此时只需要把接收到的数据起始地址和接收到的数据量发给用户代码即可，然后把缓存切换到另一个缓存区，防止覆盖，且留给用户足够多的时间处理串口数据。
9 ]+ h0 B1 H1 \$ y( t

8 |! D2 ~, h/ |: w3 ?5 u- f% S