29.1 初学者重要提示
  学习串口外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。而串口的通信学习，推荐看时序图。
  STM32H7的串口比STM32F4和F1的串口支持了更多高级特性。比如超时接收检测、自适应波特率、TX和RX引脚互换等功能。
  部分中断标志是可以通过操作发送数据寄存器TDR或者接收数据寄存器RDR实现清除，这点要特别注意，详情看本章29.3.4小节。
' v7 R* J! |: s2 R. q( o9 d  初次使用USART，还是有不少注意事项的，详情看本章29.3.3小节和29.4.1小节。
29.2 串口基础知识
USART的全称是Universal synchronous asynchronous receiver transmitter，中文意思是通用同步异步收发器。我们经常使用串口是异步串口，简称UART。
' s* O8 [; ?6 V6 |0 N
29.2.1 串口的硬件框图
+ r: R+ u" f& S9 \. _, m/ _" p认识一个外设，最好的方式就是看它的框图，方便我们快速的了解串口的基本功能，然后再看手册了解细节。

. G1 q  {* Y  i, f
: [( D7 O7 ?" E0 e, i通过这个框图，我们可以得到如下信息：
. v0 E$ r) `3 m' c) z: a% e2 {
  IRQ Interface中断接口
& s1 F( L  A$ \* f  Z! Q( V' o用于实现中断方式的串口唤醒usart_wkup和串口的相关中断usart_it。
2 |) P4 ^5 }6 c5 H) S2 V
  DMA Interface DMA接口
( u1 Y: X0 L" M' i  R' a- @& ]4 q实现串口发送usart_tx_dma和接收usart_rx_dma的DMA方式。

  u" {7 I; X/ i% I6 w! `8 ~& V  COM Contronller串口控制器
串口相关的寄存器基本都在这部分。

  TxFIFO和RxFIFO
串口的发送和接收都支持了硬件FIFO功能。

  TX和RX引脚的互换功能
发送偏移寄存器（TX Shift Reg）和接收偏移寄存器（RX Shift Reg）与TX引脚，RX引脚之间弄了个交叉连接，这里的意思是支持了引脚互换功能，这样大家在设计PCB的时候就可以比较随性了，接反了也没有关系。

# e0 M: b0 x( b* y  发送过程经过的寄存器
' i$ m/ }5 Q  E' B. g依次是USART_TDR -> TxFIFO ->Tx Shift Reg偏移寄存器 –> TX或者RX引脚。

7 \3 S! k" Q' w3 C4 t8 `7 ^  接收经过的寄存器
依次是USART_RDR -> RxFIFO ->Rx Shift Reg偏移寄存器 –> TX或者RX引脚。

' S% B/ X3 F1 G' U  两个时钟usart_pclk和usart_ker_ck
  O3 a6 A* B. g& [2 D这两个时钟是独立的，作用如下：
; R- _4 X0 ?' q% ]: M* ]! q
) |& H- t2 I1 s/ S; P, I+ ~  usart_pclk
9 X7 r2 [3 `/ s' ?  i用于为外设总线提供时钟。
( H7 C6 j3 Y. A, }4 s1 m$ v( w: g8 E
  usart_ker_ck
4 ]0 w' S9 G  y$ ^+ _. V7 I串口外设的时钟源。

29.2.2 串口的基本功能
STM32的串口功能很强大，支持太多的模式。我们只需关心我们最常用的特性即可。我们的串口驱动使用的串口中断+FIFO结构，没有使用DMA。因此我们只讨论和串口中断、串口常规参数有关的知识。
; w0 A  H2 A1 T- Q, c$ q
STM32串口的优越特性：（只列了举常用的）

  任意波特率。硬件采用分数波特率发生器系统，可以设置任意的波特率，最高达4.5Mbits/s。这一点很重要。比如ES8266串口WIFI芯片，上电时有个奇怪的波特率74880bps，当然STM32是可以支持的。
  可编程数据字长度，支持7bit，8bit和9bit。
  可配置的停止位。支持1或2个停止位。
  发送器和接收器可以单独使能。比如GPS应用只需要串口接收，那么发送的GPIO就可以节省出来用作其他功能。
  检测标志和中断：
6 d9 n. v  S3 N. Y/ _0 }, h8 X+ `  接收缓冲器满，可产生中断。串口中断服务程序据此判断是否接收到数据。
  发送缓冲器空，可产生中断。串口中断服务程序据此启动发送下一个数据。
  传输结束标志，可产生中断。用于RS485通信，等最后一个字节发送完毕后，需要控制RS485收发器芯片切换为接收模式。

0 A4 [4 F- O$ o, h1 o/ }
: {% M5 b" y3 J, Z& |其它中断不常用，包括：CTS改变、LIN断开符检测、检测到总线为空闲（在DMA不定长接收方式会用到）、溢出错误、帧错误、噪音错误、校验错误。

29.2.3 串口的高级特性
相比F1和F4系列，H7系列的串口支持了一些高级特性，比如：
3 f, A- A5 `: R5 G5 z
7 _! B) n3 P- y  ^( ^1 c  数据逻辑电平翻转。
  RX和TX引脚交换。
9 x2 P$ G0 A7 _' c0 A  ^! `  超时接收特性。
4 T6 J9 j7 d4 R) a) L  MSB位先发送。
  自适应波特率。
7 e& D+ H5 l' R7 H  外接485的PHY芯片时，硬件支持收发切换，无需用户手动控制DE引脚。


通过下面的表格，可以对串口1-8支持的功能有个全面的认识：
' z* `. w& m0 v2 `, N. R: T
, V' Q4 \7 l% Z. r& S+ v

1 Y+ I  `6 U( J; Y5 U
; k8 ?2 C2 F: ?$ J0 n29.2.4 串口的自适应波特率
3 z5 \( ~) L+ s, @) G; D  m$ \7 D( Z这里简单为大家介绍下高级特性里面的自适应波特率：
3 o( Z3 c* d+ ~7 Z
  应用场合：
  系统的通信速度未知。
  系统使用相对低精度的时钟源，并且该机制能够在没有测量时钟偏差的情况下获得正确的波特率。
  测量范围：
注，usart_ker_ck_pres在不做串口分频的情况下，是100MHz。

0 W/ y0 u. u0 H+ R! t* `  8倍过采样的情况下，测量速度范围是usart_ker_ck_pres/65535 到 usart_ker_ck_pres/8。最高串口速度是100MHz / 8 = 12.5Mbps。
! F  e$ X9 p1 d9 t! l) B* c. L: U 16倍过采样的情况下，速度范围是usart_ker_ck_pres/65535 到 usart_ker_ck_pres/16。最高串口速度是100MHz / 16 = 6.25Mbsp。
. ]9 g/ R) C- O2 D. p  测量方法：
根据不同的字符特征，支持四种自适应方法。自适应波特率在同步数据接收期间会测量多次，而且每次测量都会跟前一次做比较。
4 ^; V- j( ^  D5 y1 w. A' O: X
- C; R: g( Z' d当前支持四种字符样式进行识别，识别成功后会将中断状态寄存的ABRF位置1，其中模式2发送几次0x7F基本都可以适应成功，相对好用，模式3跟模式2差不多，而模式0检测起始位的持续时间和模式1检测起始位以及第1个bit的数据位持续时间，这两种模式不好用。
) J) M2 v+ w: v/ E

8 i# e' q* y  J6 _

29.2.5 串口的数据帧格式
( d2 I# H! F" N$ u7 c# @* l串口支持的帧格式如下（M和PCE都是USART_CR1寄存器的位，其中M位用于控制帧长度，PCE用于使能奇偶校验位）：
/ Z$ K: @  e$ A$ j3 f, j; G
, m4 s6 j% M/ H# @) }8 m

这里特别注意奇偶校验位，用户在配置的时候可以选择奇校验和偶校验，校验位是占据的最高位。比如选择M=00，PCE=1，即7bit的数据位。
/ l3 N. [" s0 t$ K4 D
  串口发送数据：
# \1 J' B2 e( q/ ?. L/ V4 J如果发送的7bit数据是111 0011，这个里面有奇数个1，那么选择偶校验的情况下，校验位 = 1，凑够偶数个1，而选择奇校验的情况下，校验位 = 0，因为已经是奇数个1。校验位不需要用户去计算，是硬件自动生成的。

9 f7 o5 C& z% n+ N/ S  J4 C& u  串口接收数据：
& V$ j6 b! N$ ]根据用户设置的奇校验或者偶校验类型，串口硬件会对接收到的数据做校验，如果失败，USART_ISR寄存器的PE位会被置1。如果使能了对应的中断PEIE，那么失败的时候还会产生中断。
了解到帧格式后，再来看一下实际数据发送时，数据位的先后顺序：

9 j% i: x  P. g6 x
! {. l: W5 v( s& V* q
29.2.6 串口发送时序图
4 y, }4 E5 m3 h7 G这个时序图非常具有代表性，可以帮助大家很好的理解TC发送完成中断和TXE空中断。

29.2.7 同步串口和异步串口的区别
异步通信是按字符传输的。每传输一个字符就用起始位来进行收、发双方的同步，不会因收发双方的时钟频率的小的偏差导致错误。这种传输方式利用每一帧的起、止信号来建立发送与接收之间的同步。
( L7 P% |8 y8 R9 d- ^8 p" }0 }
异步的特点是：每帧内部各位均采用固定的时间间隔，而帧与帧之间的间隔是随机的。接收机完全靠每一帧的起始位和停止位来识别字符是正在进行传输还是传输结束。
: N, T/ I2 Y' t' A8 Y
同步通信的发送和接收双方要保持完全的同步，因此要求接收和发送设备必须使用同一时钟。优点是可以实现高速度、大容量的数据传送；缺点是要求发生时钟和接收时钟保持严格同步，同时硬件复杂。
! M- Z' r, s0 i7 }- ]
可以这样说，不管是异步通信还是同步通信都需要进行同步，只是异步通信通过传送字符内的起始位来进行同步，而同步通信采用共用外部时钟来进行同步。所以，可以说前者是自同步，后者是外同步。
" ?- Z/ _$ v6 u
! @! ?+ k' T1 V29.2.8 单工，半双工和全双工通讯
- |; K) N( \+ w: R4 i% Z5 M8 t# x单工：在一个单工的串行通讯系统中，一般至少有两根线（信号线和地线），数据传送只有一个方向，例如可以使用单工数据传送将数据从一个简单的数据监测系统传送到PC上。
" v! J4 G$ q. D- V9 z) W
半双工：在半双工串行通信系统中，一般同样要求至少有两根线。这里的数据传送是双向的。然而，同一个时刻只能为一个方向。在上面的数据监测的例子中做了一些变化，可以使用半双工通讯机制发送信息到嵌入式模块（来设置参数，比如采样率）。此外，在其他时候，可以使用这个种连接将嵌入式装置上的数据下载到PC中。
0 o+ G8 ?: S( K- D6 X8 L+ f
9 G" k  m3 l. R# d* s5 a8 |9 Z0 A全双工：在一个全双工的串行通信系统中，一般要求至少有三根线（信号线A，信号线B和地线）。信号线A将传输一个方向上的数据，同时信号线B传送另一个方向上的数据。
8 Y8 }& d) j8 L  t) ^# w- p$ \
# f" k+ V6 ^. z- k: y( t29.3 串口的HAL库用法
串口的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。
( ?2 w3 i' W/ z7 o! G4 U3 Y5 g" v
) H; {5 ~. y; V8 |7 L5 d29.3.1 串口寄存器结构体USART_TypeDef
USART相关的寄存器是通过HAL库中的结构体USART_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：
! P5 M) P/ l* V  f0 _( s" d* w

1. typedef struct
   9 |8 E) G- g& B1 o
2. {
   
3.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   
4.   __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
   
5.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   + P# Q. E3 v0 F9 n
6.   __IO uint32_t BRR;    /*!< USART Baud rate register,                 Address offset: 0x0C */
   
7.   __IO uint16_t GTPR;   /*!< USART Guard time and prescaler register,  Address offset: 0x10 */
   2 p& @+ C* |( Q! A- Q; M
8.   uint16_t  RESERVED2;  /*!< Reserved, 0x12                                                 */
   ; s+ V9 T; k, `- B) H5 C8 E
9.   __IO uint32_t RTOR;   /*!< USART Receiver Time Out register,         Address offset: 0x14 */
   : {5 O% ~, N- Z4 T2 A( o+ D- \: p8 z
10.   __IO uint16_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
    
11.   uint16_t  RESERVED3;  /*!< Reserved, 0x1A                                                 */
    
12.   __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
    
13.   __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
    
14.   __IO uint16_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
    
15.   uint16_t  RESERVED4;  /*!< Reserved, 0x26                                                 */
    
16.   __IO uint16_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    
17.   uint16_t  RESERVED5;  /*!< Reserved, 0x2A                                                 */
    
18.   __IO uint32_t PRESC;  /*!< USART clock Prescaler register,           Address offset: 0x2C */
    5 i3 l* W) s8 a
19. } USART_TypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的USART寄存器是一 一对应的。
& h8 l: F9 H0 @
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

. Y1 C% L" @' T7 a6 v' S5 m, n

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

, e) m4 `  }6 C$ A下面我们看下USART1、USART2 ... UART8的定义，在stm32h743xx.h文件。
/ h4 [. p" I; Q& ~! B. F$ X
7 h( h# ?/ Q! [) j3 w

1. #define PERIPH_BASE         ((uint32_t)0x40000000)
   5 x% a9 K2 Y( s" y  h8 P
2. #define D2_APB1PERIPH_BASE   PERIPH_BASE
   
3. #define D2_APB2PERIPH_BASE   (PERIPH_BASE + 0x00010000)
   
4. 
   7 m+ p: t  B  ~$ i1 t) y, U
5. #define USART1_BASE           (D2_APB2PERIPH_BASE + 0x1000)
   ; H2 \' W# i0 R0 r' {3 P
6. #define USART2_BASE           (D2_APB1PERIPH_BASE + 0x4400)
   
7. #define USART3_BASE           (D2_APB1PERIPH_BASE + 0x4800)
   2 p! l% q" U  N4 g7 {6 B
8. #define UART4_BASE            (D2_APB1PERIPH_BASE + 0x4C00)
   5 Z" s. p. m1 l) V
9. #define UART5_BASE            (D2_APB1PERIPH_BASE + 0x5000)
   
10. #define USART6_BASE           (D2_APB2PERIPH_BASE + 0x1400)
    7 ^- G( ?6 ^# J) O* `' j
11. #define UART7_BASE            (D2_APB1PERIPH_BASE + 0x7800)
    
12. #define UART8_BASE            (D2_APB1PERIPH_BASE + 0x7C00)
    
13. 
    
14. #define USART1              ((USART_TypeDef *) USART1_BASE) <----- 展开这个宏，(USART_TypeDef *) 0x40011000
    
15. #define USART2              ((USART_TypeDef *) USART2_BASE)
    ) R8 ?, ^6 k# s( g
16. #define USART3              ((USART_TypeDef *) USART3_BASE)
    
17. #define UART4               ((USART_TypeDef *) UART4_BASE)
    
18. #define UART5               ((USART_TypeDef *) UART5_BASE)
    3 W- I6 f: n$ Z8 h0 v; F8 n0 `
19. #define USART6              ((USART_TypeDef *) USART6_BASE)
    1 l: a& g! ~& [
20. #define UART7               ((USART_TypeDef *) UART7_BASE)
    4 ]4 n& i0 ]2 x* J3 w% l: ]
21. #define UART8               ((USART_TypeDef *) UART8_BASE)

复制代码

+ i8 A( E2 \7 `1 L4 X% j我们访问USART1的CR1寄存器可以采用这种形式：USART1->CR1 = 0。
$ m  j) A+ h, Z& O9 T$ ^- ]; d
29.3.2 串口句柄结构体UART_HandleTypeDef
% J. H6 D2 |. G& E0 a* aHAL库在USART_TypeDef的基础上封装了一个结构体UART_HandleTypeDef，定义如下：

. ^: \9 o: ?8 b( a

1. typedef struct
   
2. {
   2 ^& h; }5 f( H; u' R) ?
3.   USART_TypeDef            *Instance;        /*!< UART registers base address        */
   * ~8 G- X! Q/ Y) s* b0 l( Z
4.   UART_InitTypeDef         Init;             /*!< UART communication parameters      */
   
5.   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */
   
6.   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
   : S4 f; j3 b1 s: H9 C) G9 V
7.   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */
   
8.   __IO uint16_t            TxXferCount;      /*!< UART Tx Transfer Counter           */
   2 _6 @7 }/ l+ F
9.   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
   - u8 |  S8 Y$ X  ^0 [6 d
10.   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */
    
11.   __IO uint16_t            RxXferCount;      /*!< UART Rx Transfer Counter           */
    $ z; @  O' C: d- H, a* c
12.   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */
    : D7 t! R1 I3 e* K, p
13.   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */
    
14.   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */
    
15.   HAL_LockTypeDef           Lock;            /*!< Locking object                     */
    2 i) q6 l2 B' u$ ?
16.   __IO HAL_UART_StateTypeDef    gState;      /*!< UART state information related to global Handle management
    
17.                                                 and also related to Tx operations.
    
18.                                                 This parameter can be a value of @ref HAL_UART_StateTypeDef */
    
19.   __IO HAL_UART_StateTypeDef    RxState;     /*!< UART state information related to Rx operations.
    7 D6 e4 U7 {9 D$ x0 Q' s0 i3 K
20.                                                 This parameter can be a value of @ref HAL_UART_StateTypeDef */
    $ R! {( k! Z0 v* L% G: S
21.   __IO uint32_t             ErrorCode;       /*!< UART Error code                  */
    
22. }UART_HandleTypeDef;

复制代码

这里重点介绍前三个参数，其它参数主要是HAL库内部使用的。
$ z% w! `8 V/ D
9 S2 r& x. J. }. W  USART_TypeDef  *Instance
5 N& t" t: w. f6 N" X这个参数是寄存器的例化，方便操作寄存器，比如使能串口的发送空中断。

SET_BIT(huart->Instance->CR1,  USART_CR1_TXEIE)。

7 |6 Q& g2 D4 ?2 Y  UART_InitTypeDef  Init
. |5 V" w" u( M! J# R/ z这个参数是用户接触最多的，用于配置串口的基本参数，像波特率、奇偶校验、停止位等。UART_InitTypeDef结构体的定义如下：

1 p, y, T$ [4 l5 e

1. typedef struct
   & u0 X! @5 E+ a
2. {
   
3.   uint32_t BaudRate;       /* 波特率 */
   + I1 O+ m0 Q' \9 W
4.   uint32_t WordLength;     /* 数据位长度 */
   
5.   uint32_t StopBits;       /* 停止位 */         
   $ t  _: k8 J6 H  L4 |' c
6.   uint32_t Parity;         /* 奇偶校验位 */         
   ( B8 p/ F, O% j( H- E" G& ~4 a+ _3 r
7.   uint32_t Mode;           /* 发送模式和接收模式使能 */         
   8 V" y- W! F! N# I: o  ^5 v* V
8.   uint32_t HwFlowCtl;      /* 硬件流控制 */         
   
9.   uint32_t OverSampling;   /* 过采样，可以选择8倍和16倍过采样 */        
   2 _$ F# L' r' z1 p9 e
10.   uint32_t Prescaler;      /* 串口分频 */            
    
11.   uint32_t FIFOMode;         /* 串口FIFO使能 */         
    $ _3 t3 Z% m/ S" U
12.   uint32_t TXFIFOThreshold;  /* 发送FIFO的阀值 */         
    
13.   uint32_t RXFIFOThreshold;  /* 接收FIFO的阀值 */         
    
14. }UART_InitTypeDef;

复制代码

  UART_AdvFeatureInitTypeDef AdvancedInit
这个参数用于配置串口的高级特性。具体支持的功能参数如下：
& k7 M; {/ ^5 F3 l5 @1 g9 J) m
# w* m9 z8 \0 Z3 H- q) M

1. typedef struct
   
2. {
   
3.   uint32_t AdvFeatureInit;       /* 初始化的高级特性类别 */
   : ^, J& P. q1 v: z0 p) A) W
4.   uint32_t TxPinLevelInvert;     /* Tx引脚电平翻转 */
   
5.   uint32_t RxPinLevelInvert;     /* Rx引脚电平翻转 */
   & W6 c7 V) q. O3 |) t" O
6.   uint32_t DataInvert;           /* 数据逻辑电平翻转 */
   
7.   uint32_t Swap;                 /* Tx和Rx引脚交换 */
   
8.   uint32_t OverrunDisable;       /* 接收超时检测禁止 */
   
9.   uint32_t DMADisableonRxError;  /* 接收出错，禁止DMA */
   , {, x7 o: _" C9 P0 b: l
10.   uint32_t AutoBaudRateEnable;   /* 自适应波特率使能 */
    
11.   uint32_t AutoBaudRateMode;     /* 自适应波特率的四种检测模式选择 */
    
12.   uint32_t MSBFirst;             /* 发送或者接收数据时，高位在前 */
    ' \$ l; Y  \. |
13. } UART_AdvFeatureInitTypeDef;

复制代码

配置串口参数，其实就是配置结构体UART_HandleTypeDef的成员。比如下面配置为波特率115200，8个数据位，无奇偶校验，1个停止位。
2 p3 i5 _. \$ y. W4 Y! ]

1. UART_HandleTypeDef UartHandle;
   9 R& J& u6 E9 Q8 v, S: k
2. 
   
3. /* USART3工作在UART模式 */
   
4. /* 配置如下:
   7 _  e1 N6 B! J. i
5.   - 数据位 = 8 Bits
   1 G: v, M# @" F5 ]
6.   - 停止位 = 1 bit
   4 O8 k. N9 l/ j# I  f! U. Y
7.   - 奇偶校验位 = 无
   - }1 h; T+ d. g# @- W: R$ x+ A
8.   - 波特率 = 115200bsp
   7 t- F. i( G+ ^: T0 D
9.   - 硬件流控制 (RTS 和 CTS 信号) */
   . ]' _, N# P' t& ?
10. UartHandle.Instance        = USART3;
    ' A8 \2 T. i8 `( _& u
11. 
    : C  h7 C7 L' M" Z: x; M
12. UartHandle.Init.BaudRate     = 115200;
    
13. UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
    : k) w0 e& S$ J7 l3 L; u
14. UartHandle.Init.StopBits     = UART_STOPBITS_1;
    
15. UartHandle.Init.Parity       = UART_PARITY_NONE;
    
16. UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
    
17. UartHandle.Init.Mode         = UART_MODE_TX_RX;
    
18. UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    ' }+ l4 N2 K2 W0 M- J
19. UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
20. 
    3 }! q% o! ~3 v+ A0 ]
21. if(HAL_UART_Init(&UartHandle) != HAL_OK)
    & l: L% D8 A% n1 \; l
22. {
    3 R  e  a: @6 A4 Z! W9 [
23.         Error_Handler();
    ! \) @3 z' C& n( y, p) h
24. }

复制代码

29.3.3 串口的底层配置（GPIO、时钟、中断等）
串口外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置串口1，使用引脚PA9和PA10。

1. /* 串口1的GPIO  PA9, PA10 */
   9 V6 ]7 Y/ e- {
2. #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   
3. #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
4. #define USART1_TX_GPIO_PORT              GPIOA
   
5. #define USART1_TX_PIN                    GPIO_PIN_9
   
6. #define USART1_TX_AF                     GPIO_AF7_USART1
   
7. 
   
8. /*
   $ I" \$ I' G1 s; a9 d
9. *********************************************************************************************************
   
10. *        函 数 名: InitHardUart
    ; x2 f3 ]7 g) I
11. *        功能说明: 配置串口的硬件参数和底层
    
12. *        形    参: 无
    
13. *        返 回 值: 无
    9 `; C  w. X1 d2 j# v$ E
14. *********************************************************************************************************
    5 o/ a( p  m- U# m  p' g
15. */
    ; s1 o! o, E" s0 |4 H( Z, S8 ?
16. static void InitHardUart(void)
    
17. {
    , o2 A) M# b: E% Z
18.         GPIO_InitTypeDef  GPIO_InitStruct;
    * f. x" Q) a( R3 D3 S
19.         RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
20. 
    
21. #if UART1_FIFO_EN == 1                /* 串口1 */
    * B& O, R& M& j0 g
22.         /* 使能 GPIO TX/RX 时钟 */
    4 R) S+ p. G. Q2 w: _7 {
23.         USART1_TX_GPIO_CLK_ENABLE();
    
24.         USART1_RX_GPIO_CLK_ENABLE();
    2 T9 Z9 b/ t' W* ?& k$ \- D
25.         
    1 _' M4 {; e/ W
26.         /* 使能 USARTx 时钟 */
    
27.         USART1_CLK_ENABLE();        
    # R2 w; l+ i9 V6 g: Y, y+ w% c3 S
28. 
    8 m% D5 B% ?7 K+ l& N. b
29.         /* 配置TX引脚 */
    
30.         GPIO_InitStruct.Pin       = USART1_TX_PIN;
    
31.         GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    % g, u; T4 u* C( v3 |
32.         GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
33.         GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    * F  k* T0 S6 @/ C; D
34.         GPIO_InitStruct.Alternate = USART1_TX_AF;
    
35.         HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    
36.         
    3 z0 T5 I0 W" N! X7 U2 n
37.         /* 配置RX引脚 */
    
38.         GPIO_InitStruct.Pin = USART1_RX_PIN;
    7 [+ N' I- a9 W: C
39.         GPIO_InitStruct.Alternate = USART1_RX_AF;
    # I; [; u6 K8 D
40.         HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
41. 
    
42.         /* 配置NVIC the NVIC for UART */   
    5 Y, g% }' x: Y4 ]! J( o/ {- u$ F
43.         HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    9 j$ s1 x0 m, l* B. q
44.         HAL_NVIC_EnableIRQ(USART1_IRQn);
    
45. 
    / y; L4 x* m3 E7 [' u8 Z0 B  H6 f
46.         /* 配置波特率、奇偶校验 */
    3 _' x2 q+ H, K# a
47.         bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
48. 
    % i; q- {. {: h; ?7 }- n& p4 |$ n
49.         SET_BIT(USART1->ICR, USART_ICR_TCCF);  /* 清除TC发送完成标志 */
    
50.         SET_BIT(USART1->RQR, USART_RQR_RXFRQ); /* 清除RXNE接收标志 */
    
51.         SET_BIT(USART1->CR1, USART_CR1_RXNEIE);/* 使能PE. RX接受中断 */
    
52. #endif
    7 c8 d( C/ A, A$ k/ j" L
53. }

复制代码

总结下来就是以下几点：
" M9 w+ s) r9 o% c* K0 ~' G
  配置GPIO引脚时钟。
, L( r8 h, ~3 `. H2 @  配置USART时钟。
" ?6 J9 A5 R# a) U  配置USART的发送和接收引脚。
' B7 L" q8 \" l9 v  通过NVIC配置中断。
8 n" f1 `' J" I& v. |+ ~/ I' X  配置波特率，奇偶校验等，在上一小节有讲。
  清除TC和RXNE标志，使能接收中断。

% Q' r+ n% D6 q) z& @
9 T% \, }, M2 {关于这个底层配置有以下几点要着重说明下：

  串口发送和接收引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如串口1有两个复用

1. #define GPIO_AF4_USART1    ((uint8_t)0x04)  /* USART1 Alternate Function mapping */
   
2. #define GPIO_AF7_USART1    ((uint8_t)0x07)  /* USART1 Alternate Function mapping */

复制代码

. v: x& ^0 O) V+ {具体使用那个，要看数据手册，比如我们这里使用引脚PA9和PA10，对应的复用如下：

2 L6 I1 w; j; _/ W* |, l

那么使用GPIO_AF7_USART1即可。
# \; c8 l8 Y! g! z; h' Y; t
  根据情况要清除TC发送完成标志和RXNE接收数据标志，因为这两个标志位在使能了串口后就已经置位，所以当用户使用了TC或者RX中断后，就会进入一次中断服务程序，这点要特别注意。
  HAL库有个自己的底层初始化回调函数HAL_UART_MspInit，是弱定义的，用户可以在其它的C文件里面实现，并将相对的底层初始化在里面实现。当用户调用HAL_UART_Init后，会在此函数里面调用HAL_UART_MspInit，对应的底层复位函数HAL_UART_MspDeInit是在函数HAL_UART_DeInit里面被调用的。
当然，用户也可以自己初始化，不限制必须在两个函数里面实现。
5 g5 F- I. B( s( e) t1 E
  上面举的例子里面没有用到DMA，如果用到了DMA，也是要初始化的。
29.3.4 串口的状态标志清除问题
注，早前使用F1和F4时候，经常会有网友咨询为什么串口中断服务程序里面没有做清除标志。
& j- D/ j% D7 [2 N+ V
8 j: j/ K4 C# f: _8 Q下面我们介绍__HAL_USART_GET_FLAG函数。这个函数用来检查USART标志位是否被设置。
% b) V( `6 C) j& y$ y+ m4 x
' v- n  Y8 R4 t

1. /** @brief  Check whether the specified USART flag is set or not.
   
2.   * @param  __HANDLE__: specifies the USART Handle
   
3.   * @param  __FLAG__: specifies the flag to check.
   
4.   *        This parameter can be one of the following values:
   
5.   *            @arg USART_FLAG_TXFT: TXFIFO threshold flag
   
6.   *            @arg USART_FLAG_RXFT: RXFIFO threshold flag
   
7.   *            @arg USART_FLAG_RXFF:  RXFIFO Full flag
   
8.   *            @arg USART_FLAG_TXFE:  TXFIFO Empty flag
   , A% h, r8 S# p5 i& ^5 P$ [
9.   *            @arg USART_FLAG_REACK: Receive enable ackowledge flag
     g7 `  u: u7 Q
10.   *            @arg USART_FLAG_TEACK: Transmit enable ackowledge flag
    
11.   *            @arg USART_FLAG_BUSY:  Busy flag
    
12.   *            @arg USART_FLAG_TXE:   Transmit data register empty flag
    4 N* u* f4 L/ P! Q8 R! K. e& v
13.   *            @arg USART_FLAG_TC:    Transmission Complete flag
    + ]  d! F/ g5 D6 e( V6 @8 }3 H
14.   *            @arg USART_FLAG_RXNE:  Receive data register not empty flag
    
15.   *            @arg USART_FLAG_IDLE:  Idle Line detection flag
    ) W  L3 V+ |0 D- W, V, Y$ f; d7 k
16.   *            @arg USART_FLAG_ORE:   OverRun Error flag
    
17.   *            @arg USART_FLAG_UDR:   UnderRun Error flag
    
18.   *            @arg USART_FLAG_NE:    Noise Error flag
    
19.   *            @arg USART_FLAG_FE:    Framing Error flag
    2 m# M, E% j! ~" }4 e
20.   *            @arg USART_FLAG_PE:    Parity Error flag
    
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    
22.   */
    ! G8 u% ~. z) M
23. #define __HAL_USART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__))

复制代码

4 o( V6 K( n$ ?USART_FLAG有如下几种取值：
; @2 `* e6 K$ E) V# T4 H# h! Y. {
" W+ j9 `. m: J7 S

2 s& C( E% v( r* L$ L" \( L, T

5 v- Q0 p$ n/ I& }' k. a; P

/ U, Y7 G  f$ u( X  A& e- m7 w. K5 W

请大家重点关注上表中红字部分，USART标志是需要软件主动清零的。清零有两种方式：一种是调用__HAL_USART_CLEAR_FLAG函数，另一种是操作相关寄存器后自动清零。
, ~# j. Y' s% p! p4 j

1. /** @brief  Clear the specified USART pending flag.
   
2.   * @param  __HANDLE__: specifies the USART Handle.
   8 ^& E/ c/ m; |$ n; o. Y# [, o3 G
3.   * @param  __FLAG__: specifies the flag to check.
   
4.   *          This parameter can be any combination of the following values:
   
5.   *            @arg USART_FLAG_TXFT:  TXFIFO threshold flag
   8 o$ U# L7 S: ]
6.   *            @arg USART_FLAG_RXFT:  RXFIFO threshold flag
   ' Y& U% m7 g# L& Z
7.   *            @arg USART_FLAG_RXFF:  RXFIFO Full flag
   
8.   *            @arg USART_FLAG_TXFE:  TXFIFO Empty flag
   
9.   *            @arg USART_FLAG_REACK: Receive enable ackowledge flag
   * N( B1 `# }- U
10.   *            @arg USART_FLAG_TEACK: Transmit enable ackowledge flag
    4 i+ T2 s* M' B3 |6 J2 A2 J7 R
11.   *            @arg USART_FLAG_WUF:   Wake up from stop mode flag
    3 ]4 G- u( p  H. r! `
12.   *            @arg USART_FLAG_RWU:   Receiver wake up flag (is the USART in mute mode)
    
13.   *            @arg USART_FLAG_SBKF:  Send Break flag
    
14.   *            @arg USART_FLAG_CMF:   Character match flag
    1 U, W0 `4 o& ?5 O' C9 V% D# B
15.   *            @arg USART_FLAG_BUSY:  Busy flag
    
16.   *            @arg USART_FLAG_ABRF:  Auto Baud rate detection flag
    . ], K9 B  n- w- w* k4 [7 b
17.   *            @arg USART_FLAG_ABRE:  Auto Baud rate detection error flag
    ! g: T* Y* S( u
18.   *            @arg USART_FLAG_RTOF:  Receiver timeout flag
    
19.   *            @arg USART_FLAG_LBD:   LIN Break detection flag
    
20.   *            @arg USART_FLAG_TXE:   Transmit data register empty flag
    
21.   *            @arg USART_FLAG_TC:    Transmission Complete flag
    + k$ I3 M, D9 j' d$ s9 ^6 M
22.   *            @arg USART_FLAG_RXNE:  Receive data register not empty flag
    
23.   *            @arg USART_FLAG_IDLE:  Idle Line detection flag
    
24.   *            @arg USART_FLAG_ORE:   OverRun Error flag
    6 M4 w8 U; Y5 J2 K# e; E
25.   *            @arg USART_FLAG_NE:    Noise Error flag
    / F; r: `/ Z& c. r1 l
26.   *            @arg USART_FLAG_FE:    Framing Error flag
    0 j2 K. d. P; g) k9 O* T- v
27.   *            @arg USART_FLAG_PE:    Parity Error flag
    
28.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    * b  f7 s) W( R* \
29.   */
    3 f% ?& s% j+ e
30. #define __HAL_USART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__))

复制代码

上面介绍的USART标志大部分能够设置为产生中断，也就是有对应的USART中断标志。我们只介绍几个串口驱动要用到的中断标志：
; K  {+ o( o! U/ J
$ C+ N6 ?; T) ~8 p' F+ hUSART_IT_TXE：TXE:发送数据寄存器空（此时数据可能正在发送）。

+ q) D* y- J: TUSART_IT_TC：发送完成 。

1 p7 k6 T' r1 B5 f7 f5 L$ oUSART_IT_RXNE：接收数据寄存器非空。

# K: {: B  ^9 h* L( U  y# K中断缺省都是关闭的，通过__HAL_USART_ENABLE_IT函数可以使能相应的中断标志。函数定义如下：
2 R( e) q# w3 t* @- E0 s1 r! f

1. /** @brief  Enable the specified USART interrupt.
   ' b: z8 h$ x2 H9 M
2.   * @param  __HANDLE__: specifies the USART Handle.
   
3.   * @param  __INTERRUPT__: specifies the USART interrupt source to enable.
   * N' Q* q! j5 {$ C) g4 R5 @
4.   *          This parameter can be one of the following values:
   
5.   *            @arg USART_IT_RXFF: RXFIFO Full interrupt
   
6.   *            @arg USART_IT_TXFE: TXFIFO Empty interrupt
   
7.   *            @arg USART_IT_RXFT: RXFIFO threshold interrupt
     M: y8 a8 k$ P6 P  ?$ M
8.   *            @arg USART_IT_TXFT: TXFIFO threshold interrupt
   & S- Y1 f: @4 R9 n/ e3 v
9.   *            @arg USART_IT_TXE : Transmit Data Register empty interrupt
   % v+ \: i0 F: \3 Q
10.   *            @arg USART_IT_TC  : Transmission complete interrupt
    & o5 G$ h$ U$ z- |
11.   *            @arg USART_IT_RXNE: Receive Data register not empty interrupt
    $ ~) H; o1 @* F
12.   *            @arg USART_IT_IDLE: Idle line detection interrupt
    2 m) O- v' q5 _; c
13.   *            @arg USART_IT_PE  : Parity Error interrupt
    : `- N- X9 `( T- D5 h
14.   *            @arg USART_IT_ERR : Error interrupt(Frame error, noise error, overrun error)
    / z+ E6 M" d9 \6 j' Y2 ^; d2 f
15.   * @retval None
    " |. [4 n: u2 V* Q; K( z
16.   */
    1 c1 N0 j' {' o' L. H" [
17. #define __HAL_USART_ENABLE_IT(__HANDLE__, __INTERRUPT__)   (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1)? ((__HANDLE__)->Instance->CR1 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
    
18.                                                             ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2)? ((__HANDLE__)->Instance->CR2 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
    
19.                           ((__HANDLE__)->Instance->CR3 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))))

复制代码

STM32一个串口的中断服务程序入口地址只有一个，进入中断服务程序后，我们需要判断是什么原因进入的中断，因此需要调用一个函数来检测中断标志。函数原型如下：
, D- s) J6 F% v9 R& P* `; n

1. #define __HAL_USART_GET_IT(__HANDLE__, __IT__) ((__HANDLE__)->Instance->ISR & ((uint32_t)1 << ((__IT__)>> 0x08)))

复制代码

, z# H, {$ X- o2 l5 |* {9 s中断处理完毕后，必须软件清除中断标志，否则中断返回后，会重入中断。清中断标志位的函数为：

" O9 p! b9 G1 A8 s, a/ p; s/ G; X" F

1. #define __HAL_USART_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR = (uint32_t)(__IT_CLEAR__))

复制代码

正如前面介绍的，不是所有的标志都需要用这个函数清零。
8 h: J/ l$ Z! f

) ^: L, e7 j! p# S7 Q
注意：操作串口的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用USART1->CR1操作即可。
/ b9 {( N3 {: \% n7 U7 b8 c
29.3.5 串口初始化流程总结
使用方法由HAL库提供：
$ |+ u8 T2 p& F4 g) n2 ^+ Z
  第1步：定义UART_HandleTypeDef类型串口结构体变量，比如UART_HandleTypeDef huart。
* @* [+ z, ?- o2 ]/ i  O1 x- Y- q
  第2步：使用函数HAL_UART_MspInit初始化串口底层，不限制一定要用此函数里面初始化，用户也可以自己实现。

. Z( L% @4 R) o6 ?3 c+ i% [  使能串口时钟。
  引脚配置。
        a、使能串口所使用的GPIO时钟。

        b、配置GPIO的复用模式。
( m! A9 k, }# X
  如果使用中断方式函数HAL_UART_Transmit_IT和HAL_UART_Receive_IT需要做如下配置。
        a、配置串口中断优先级。
+ A# R6 t4 {2 W* `6 ?8 d( q6 h
        b、使能串口中断。
2 C  R! k4 x6 D# V7 A4 G
2 Q8 Y3 N9 q, P1 F, g, u  串口中断的开关是通过函数__HAL_UART_ENABLE_IT() 和 __HAL_UART_DISABLE_IT()来实现，这两个函数被嵌套到串口的发送和接收函数中调用。
  如果使用DMA方式函数HAL_UART_Transmit_DMA和HAL_UART_Receive_DMA需要做如下配置。
+ R' o5 L6 h* g/ I# K& `! W        a、声明串口的发送和接收DMA结构体变量，注意发送和接收是独立的，如果都使用，那就都需要配置。
* e2 H) [2 \. J9 ^
* A' x1 n, h$ Y( o+ C1 G4 H. s        b、使能DMA接口时钟。

        c、配置串口的发送和接收DMA结构体变量。
9 u% Q8 l* R- Y" w6 e; t' Q3 }% R
        d、配置DMA发送和接收通道。

* h, D. ^9 S+ b( k2 K" j: O        e、关联DMA和串口的句柄。
' {/ Y' K" E# H* m) s
        f、配置发送DMA和接收DMA的传输完成中断和中断优先级。

. f3 \( r2 _& x6 l5 l$ C" p" G6 V  第3步：配置串口的波特率，位长，停止位，奇偶校验位，流控制和发送接收模式。

  第4步：如果需要，可以编程高级特性，比如TX/RX交换引脚，自动波特率检测。通过第1步串口结构体变量huart的结构体成员AdvancedInit来设置。
6 l, e, m( i- @
  第5步：串口初始化调用的函数HAL_UART_Init初始化。

; w5 P0 ^7 i! h" V' T1 w5 K$ @29.4 源文件stm32h7xx_hal_uart.c
9 S2 B$ z* `7 \" O2 c9 A! r此文件涉及到的函数较多，这里把几个常用的函数做个说明：
9 Y$ q2 [( K* W5 Y  g' j
  HAL_UART_Init
  HAL_UART_Transmit
4 g* n; r5 I& Y, v  HAL_UART_Receive
! X5 W# k0 i; O. `# q  HAL_UART_Transmit_IT
, T; S! O. _5 U; q3 h7 {  HAL_UART_Receive_IT
  HAL_UART_Transmit_DMA
  HAL_UART_Receive_DMA


其实V7开发板设计的8个串口FIFO驱动文件bsp_uart_fifo.c仅用到了函数HAL_UART_Init，其它函数都没有用到，不过这里也为大家做个说明。

29.4.1 函数HAL_UART_Init
: n; [9 U. H$ t# N$ ?+ s函数原型：
; k- a1 ~( P, l1 \$ O

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
     K/ L- _; b) d
2. {
   2 D7 r, M; Y: |: w, K$ o
3. 
   4 H% t( C  U* q- [# b
4.    /* 省略 */
   
5. 
   ( f9 u; q8 E4 @0 f" `- w8 Y
6.   if(huart->gState == HAL_UART_STATE_RESET)
   
7.   {
   / ^/ h4 {' e  \6 ]* x$ a
8.     huart->Lock = HAL_UNLOCKED;
   ( R, c" ~3 {7 f9 g
9. 
   % `3 w( g$ o8 T0 P$ E" _. S
10.     /* 初始化硬件: GPIO, CLOCK */
    
11.     HAL_UART_MspInit(huart);
    % L& j" J( d! w
12.   }
    6 w; I5 I/ C  _# {4 i+ y3 `4 k7 n5 ]
13. 
    
14.   huart->gState = HAL_UART_STATE_BUSY;
    
15. 
    ; {7 ^# `' y" @; I
16.   /* 禁止串口 */
    
17.   __HAL_UART_DISABLE(huart);
    - O; W9 \' L, S1 a/ W9 t8 i0 U# v
18. 
    ( M4 S; M: k( F" c6 X9 t* U+ t
19.   /* 配置串口参数 */
    
20.   if (UART_SetConfig(huart) == HAL_ERROR)
    4 j: z. n+ |8 P# ?+ Y+ V
21.   {
    . U  L* b. h$ Q" s9 ]
22.     return HAL_ERROR;
    , d3 d1 h  L/ R! l) R* x4 g
23.   }
    
24. 
    
25.    /* 配置串口高级特性 */
    
26.   if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
    
27.   {
    
28.     UART_AdvFeatureConfig(huart);
    2 n6 R/ R( y$ A# B- y0 K
29.   }
    
30. 
    6 d" J1 P2 Q: h  H% A$ i: R
31.   /* 清寄存器的一些标志位 */
    
32.   CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
    
33.   CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
    , Z5 d0 U  a$ Y
34. 
    
35.   /* 使能串口 */
    
36.   __HAL_UART_ENABLE(huart);
    % i( L0 l  M1 m0 L8 Z4 Z5 G+ a7 R+ t
37. 
    
38.   return (UART_CheckIdleState(huart));
    2 w, j- i1 P9 p' I
39. }

复制代码

函数描述：
1 u6 c4 i5 y$ \4 T& A
% J) o3 E( g1 [此函数用于初始化串口的基础特性和高级特性。

8 ^5 n& c* C( }7 L函数参数：
8 F4 T6 R3 a- W9 f2 T
* o. c& H" P( r2 m/ U* V  第1个参数是UART_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
注意事项：

函数HAL_UART_MspInit用于初始化USART的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参huart的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量UART_HandleTypeDef UartHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_UART_STATE_RESET  = 0x00U。

解决办法有三
) _  i+ Q6 a+ i5 q( k" R
8 a8 D& U$ z0 r, a5 g方法1：用户自己初始串口和涉及到的GPIO等。
9 H0 @' L. f4 I# j) O7 Z# s
5 O( K: J# X0 l8 G3 F方法2：定义UART_HandleTypeDef UartHandle为全局变量。
! `# z; D4 H0 k! c$ K# H
  _0 r$ a9 w8 o9 p* C方法3：下面的方法
( T1 e2 h# x) ?  G, V8 _
( S% v! p/ a! p, ]! p: `5 J: q

1. if(HAL_UART_DeInit(&UartHandle) != HAL_OK)
   4 G, L: W6 W, H, C1 v* v
2. {
   6 y0 S6 ~* C1 i
3.     Error_Handler();
   
4. }  
   
5. if(HAL_UART_Init(&UartHandle) != HAL_OK)
   : I; W# c2 C, j( \1 Q4 }* O. s
6. {
   6 @* H7 m0 P4 x
7.     Error_Handler();
   5 p" P- R% |9 e# [9 M. X) }' _
8. }
   8 [& B6 C: a1 z" A. Y$ Y

复制代码

注意串口的中断状态寄存器USART_ISR复位后，TC发送完成状态和RXNE接收状态都被置1，如果用户使能这两个中断前，最好优先清除中断标志。
/ P$ b: i; A: ~  b# ~  i) j使用举例：
. G* R. `* t2 l" V# l. m- K- C
: `% m' s& Y3 [3 U3 ~: D( Z

1. UART_HandleTypeDef UartHandle;
   0 ^% S! k9 Y' _
2. 
   
3. /* USART3工作在UART模式 */
   8 S! h8 `* W+ ]5 o  Z3 y/ s$ R  w
4. /* 配置如下:
   - {+ D0 ]8 W' `4 Y5 Q/ F1 m; ]5 O7 a
5.   - 数据位 = 8 Bits
   
6.   - 停止位 = 1 bit
   
7.   - 奇偶校验位 = 无
   ! R4 g8 ~$ O6 Y, e. [
8.   - 波特率 = 115200bsp
   7 c! X, T- F3 C% ^; D' V9 ?
9.   - 硬件流控制 (RTS 和 CTS 信号) */
   9 ~% h' I$ w+ h
10. UartHandle.Instance        = USART3;
    $ E; [# L" H+ R9 L: O4 Z
11. 
    
12. UartHandle.Init.BaudRate     = 115200;
    
13. UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
    ' g( G: w* L. V  x# m$ d  o4 p
14. UartHandle.Init.StopBits     = UART_STOPBITS_1;
    
15. UartHandle.Init.Parity       = UART_PARITY_NONE;
    
16. UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
    
17. UartHandle.Init.Mode         = UART_MODE_TX_RX;
    
18. UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
19. UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
20. 
    
21. if(HAL_UART_Init(&UartHandle) != HAL_OK)
    8 t3 v* I4 a* ~' y& m% M5 X
22. {
    3 v5 K4 u3 U9 I5 k4 j
23.         Error_Handler();
    
24. }

复制代码

5 s' v" P) x" o, q$ [7 s, c2 G29.4.2 函数HAL_UART_Transmit
函数原型：

5 Z0 _7 o7 ?4 i% S% h. X' d* [

1. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   
2. {
   , k4 w' c2 q5 D& q& Z
3.    /* 省略 */
   7 ^, s9 `& T# P1 j  S: j! n
4. 
   3 S; B8 x5 x9 V6 t
5.   if(huart->gState == HAL_UART_STATE_READY)
   : s, \# d- U: u# p
6.   {
   " k( l, O1 `; I+ m6 l$ x- q1 h
7.      /* 省略 */
   ' J& v( Z) z1 m8 U1 }' H. _; N8 i
8. 
   
9.     while(huart->TxXferCount > 0U)
   
10.     {
    
11.       huart->TxXferCount--;
    / k; p3 n% g+ }
12.           /* 等待发送空中断标志 */
    
13.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
    , S% e1 s: N3 |2 X+ P# M
14.       {
    9 r3 W7 p8 e3 }/ N
15.         return HAL_TIMEOUT;
    5 Z! N* U6 u; @! F0 T) z0 ~, m, ]
16.       }
    
17. }
    ! d3 P7 d- Z3 _
18. /* 等待发送完成中断 */
    0 A8 x2 x* Z3 i- n$ Y" \  d, }
19.     if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    - x8 C8 w6 c" _5 i
20.     {
    ) @8 m$ w+ T( [$ t7 Q
21.       return HAL_TIMEOUT;
    2 e& Y0 E: ~! s8 H# r! Z0 c! u
22.     }
    
23. 
    
24.     /* 省略 */
    
25.     return HAL_OK;
    
26.   }
    
27.   else
    
28.   {
    
29.     return HAL_BUSY;
    
30.   }
    
31. }

复制代码

函数描述：
% P0 J& B* b+ u5 V
! E* ~$ D. n8 o6 k  z) Q: U. C此函数以查询的方式发送指定字节。看源码的话，程序里面最重要的就是上面代码中置红的两个标志，发送空标志和发送完成标志。发送空标志表示发送数据寄存器为空，数据还在移位寄存器里面，而发送完成标志表示数据已经从移位寄存器发送出去。

+ T- T! Y2 R7 D2 r函数参数：

9 i8 K  |2 `& W/ I: h' e' g  第1个参数是UART_HandleTypeDef类型结构体指针变量。
. Z* q0 H) F/ a" W6 A& D  第2个参数是要发送的数据地址。
) S9 v  w  @( ?$ l& t2 N3 L; [  第3个参数是要发送的数据大小，单位字节。
  第4个参数是溢出时间，单位ms。
1 p) H' [9 A  `; J* ?" T- U  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
使用举例：

1. /*
   
2. *********************************************************************************************************
   / |, q! S; I4 k9 U; M
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   0 M" b: L, L8 T& n
5. *        形    参: 无
   0 V6 {2 F4 I9 }
6. *        返 回 值: 无
   6 O0 d6 M: A: d% K$ Y
7. *********************************************************************************************************
   + v# I2 r/ }' u  F, S
8. */
   
9. int fputc(int ch, FILE *f)
     b+ l) e: J$ J/ Y. P, w/ G
10. {
    / ^' h8 ]! g! J: c$ E$ l! G$ `" p
11.         HAL_UART_Transmit(&UartHandle, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
    
12. 
    5 B+ _* B' `/ F
13.         return ch;
    
14. }

复制代码

) W1 j& W5 i/ E: J# y- B8 [29.4.3 函数HAL_UART_Receive
& O* N, Y/ c$ Z% i6 r# @函数原型：

1. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   ) a6 m) p1 q, ~# D7 s
2. {
   
3. 
   
4. /* 省略 */
   ; _, s. t" e0 I6 Q/ Q  u
5.   if(huart->RxState == HAL_UART_STATE_READY)
   , R/ U  A( {. x. g6 w
6.   {
   
7. 
   3 }9 A" h- R% K2 K) d
8.     /* 省略 */
   
9.     while(huart->RxXferCount > 0U)
   
10.     {
    
11.       huart->RxXferCount--;
    
12.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
    ' d) b  C, S! L; l( A: J7 R
13.       {
    
14.         return HAL_TIMEOUT;
    
15.       }
    ; i% {4 G# ?" n0 A
16. 
    
17. 
    $ ^! y# m  m5 m/ v7 f% k  Z! U
18.     }
    
19.     /* 省略 */
    
20.     return HAL_OK;
    6 u1 r3 `% s6 B6 T
21.   }
    0 [4 A* y; W, W5 K$ |8 ~! B
22.   else
    * A) l- z" |# G7 a, C
23.   {
    3 P/ ?3 o5 s% N! k  r7 t7 t
24.     /* 省略 */
    
25.     return HAL_BUSY;
    : }8 G6 R% v% V( N2 t; ?
26.   }
    / o# p; q& D# d9 ?% D6 t2 K
27. }

复制代码

函数描述：

0 q* v3 Z1 S% l2 B* E此函数以查询的方式接收指定字节。这个函数相对比较好理解，就是等待上面程序中的RXNE标志，置位了表示接收数据寄存器已经存入数据。
7 E! _( t3 u* B- l$ D
函数参数：

/ b; a/ b( f4 @- _$ A  第1个参数是UART_HandleTypeDef类型结构体指针变量。
* ]' J' k7 s7 X1 c: W  第2个参数是要接收的数据地址。
  第3个参数是要接收的数据大小，单位字节。
# i9 }, p' b) }+ P  第4个参数是溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
+ v2 y; Q5 t9 r) E/ \2 C& Q使用举例：

1. /*
   
2. *********************************************************************************************************
     S9 \( T* N) i! y6 |% [1 a3 @
3. *        函 数 名: fgetc
   6 n3 |1 \$ H3 M) z- {  c" X, h4 ]
4. *        功能说明: 重定义getc函数，这样可以使用scanff函数从串口1输入数据
   4 F$ ?/ {) j6 E* b
5. *        形    参: 无
   
6. *        返 回 值: 无
   2 A, ?& F& z1 `& a* y* y( b4 n# G
7. *********************************************************************************************************
   9 g: m. d; B6 Z1 \! M
8. */
   " e6 N  A0 d5 [
9. int fgetc(FILE *f)
   4 N1 f! ]" g. a
10. {
    . Z0 J! y  M% |6 a
11.     int ret;
    
12.                
    
13.         HAL_UART_Receive(&UartHandle, (uint8_t *)&ret, 1, HAL_MAX_DELAY);
    
14. 
    ! d9 z" ?$ N% L2 {
15.         return ret;
    
16. }

复制代码

! P* c6 }  y4 I( W- w9 ~29.4.4 函数HAL_UART_Transmit_IT
6 Q+ M  r$ t4 X6 w' D2 a7 R% ?函数原型：
. |" S' h" I: P! B. |3 a: R
- a1 y) x5 R/ f- n% n

1. HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   9 l7 s' c. w, r/ u( B
2. {
   
3. 
   
4.   if(huart->gState == HAL_UART_STATE_READY)
   4 A5 U* j: c. P" r+ k0 D
5.   {
   * y1 z8 I- w! ^! N) R
6.     if((pData == NULL ) || (Size == 0U))
   0 V6 \. w- F, i  g  x8 H
7.     {
   5 o. }; _5 s9 @! L: a
8.       return HAL_ERROR;
   & i5 ^6 Y! e' T5 ?0 `; G, K
9.     }
   4 |+ Z3 U$ M) V5 C
10. 
    9 y6 m- x/ W( r- f% Q
11.     __HAL_LOCK(huart);
    0 T: ?' V+ C: S/ @/ J( E- z1 }
12. 
    
13.     huart->pTxBuffPtr = pData;
    , c6 B# A( B+ M$ \6 k
14.     huart->TxXferSize = Size;
    
15.     huart->TxXferCount = Size;
    
16. 
    & M: X: j* F# C+ ~" K! C; ]) J
17.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    ) z. d) |* T1 {1 G) `' ?# F" ^
18.     huart->gState = HAL_UART_STATE_BUSY_TX;
    
19. 
    
20. 
    
21.     __HAL_UNLOCK(huart);
    # s( `  R* p" r5 R1 t0 F
22. 
    
23.     if (READ_BIT(huart->Instance->CR1, USART_CR1_FIFOEN) != RESET)
    
24. {
    
25.   /* 使能FIFO发送中断 */
    
26.       SET_BIT(huart->Instance->CR3, USART_CR3_TXFTIE);
    
27.     }
    0 M& _  b" `- j  R, B* Z: h
28.     else
    
29. {
    
30.   /* 使能发空中断 */
    
31.       SET_BIT(huart->Instance->CR1, USART_CR1_TXEIE);
      H, W) X" K- T. s- B
32.     }
    4 f# `7 ~* S0 D; g) ?4 V, n
33. 
    
34.     return HAL_OK;
    
35.   }
    
36.   else
    
37.   {
    
38.     return HAL_BUSY;
    
39.   }
    - K8 I( T) [& t2 M. ^, L; A" w
40. }

复制代码

$ S% O$ M+ `5 H" a) W/ D; k函数描述：

此函数以中断的方式发送指定字节，可以选择使能FIFO中断方式或者发送空中断方式。具体数据的发送是在中断处理函数HAL_UART_IRQHandler里面实现。
- r9 B) l1 m- L
函数参数：

  第1个参数是UART_HandleTypeDef类型结构体指针变量。
- b! t# u% ~5 O  第2个参数是要发送的数据地址。
# o. Z* r6 t& t, F: r  第3个参数是要发送的数据大小，单位字节。
  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
$ E4 k$ t% B, U6 w8 S) c6 l使用举例：
! V0 G7 i% B& w, y: ]9 T3 P
9 X" c0 k1 a9 ^  h  E

1. UART_HandleTypeDef UartHandle;
   ' u) O( |: y! r: Z& F, q4 A
2. uint8_t s_ucBuf[5];
   9 P6 u& `2 b2 q  {5 ~( K5 P1 W
3. 
   
4. /* 数据发送 */
   ( l% I( Q: w9 ]* P2 W
5. HAL_UART_Transmit_IT(&UartHandle, s_ucBuf, 1);
   ! }# V' k! s+ e
6. HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)"KEY_DOWN_K1\r\n", 13);
   % g; W9 |1 b5 U; L7 T1 \
7. 29.4.5 函数HAL_UART_Receive_IT
   
8. 函数原型：
   
9. 
   . j( y1 [5 m7 Q% X$ M+ w& w" H) B
10. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
    
11. {
    & L9 Q# T/ m1 d. D& |4 S
12. 
    5 u! I7 ?$ @" @- T1 l% ]& Q
13.   if(huart->RxState == HAL_UART_STATE_READY)
    + h6 }& u7 @* D3 q0 o* L
14.   {
    
15.     if((pData == NULL ) || (Size == 0U))
    
16.     {
    
17.       return HAL_ERROR;
    7 I; @# P0 Z& b) [
18.     }
    
19. 
    # Q, O5 b7 A7 K8 V
20.     __HAL_LOCK(huart);
    
21. 
    0 h8 z: _: A; T. l* S( b" x& |
22.     huart->pRxBuffPtr = pData;
    
23.     huart->RxXferSize = Size;
    
24.     huart->RxXferCount = Size;
    
25. 
    
26.     UART_MASK_COMPUTATION(huart);
    
27. 
    
28.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    
29.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    
30. 
    0 Y5 X& `7 m6 U0 a9 Z1 z6 H
31.     __HAL_UNLOCK(huart);
    " S8 F  {, }8 ]6 @8 Y
32. 
    - Z6 a$ Z+ E2 K9 p! I9 y
33.     /* 使能错误中断: (Frame error, noise error, overrun error) */
    
34.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
      r2 W+ Z9 Y5 R0 Q5 `0 e
35. 
    
36.     if (READ_BIT(huart->Instance->CR1, USART_CR1_FIFOEN) != RESET)
    
37. {
    
38.   /* 使能奇偶校验失败中断 */
    * @1 b, h- X$ o: Y& C* ~
39.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    
40.       /* 使能FIFO接收中断 */
    8 A: Z* B3 ?" S: o
41.       SET_BIT(huart->Instance->CR3, USART_CR3_RXFTIE);
    . L; \# {  O3 `! b' _! y0 @$ T
42.     }
    4 G$ s! ~* _9 j* o: y8 r, Y8 z3 Z
43.     else
    0 m% U' l7 v' U4 S* P5 W# n8 ?7 j2 D
44. {
    
45.   /* 使能奇偶校验失败中断和接收中断 */
    
46.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    
47.     }
    
48. 
    
49.     return HAL_OK;
    3 R+ H7 e. S  ?' P% z9 h% K# L- P
50.   }
    
51.   else
    
52.   {
      T$ N9 E! @* l- S" K
53.     return HAL_BUSY;
    4 W7 _2 D( r' v7 k. g
54.   }
    4 Q' V6 g3 h: s
55. }

复制代码

函数描述：

$ P2 }$ @& i/ e. k* D5 @此函数以中断的方式接收指定字节，可以选择使能FIFO中断方式或者普通中断方式，两种方式使能了奇偶校验中断失败和错误中断。具体数据的接收是在中断处理函数HAL_UART_IRQHandler里面实现。

函数参数：
& c& l& A. j0 i& s
! C- S, Z4 v) s2 X7 d3 j  第1个参数是UART_HandleTypeDef类型结构体指针变量。
. b5 \* ^5 L7 h4 [  第2个参数是要接收的数据地址。
  第3个参数是要接收的数据大小，单位字节。
  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
使用举例：
2 l3 ^- G5 G$ @/ v# c
& y* l/ P) k% {

1. UART_HandleTypeDef UartHandle;
   
2. uint8_t s_ucBuf[5];
   
3. 
   * `4 C6 D3 A% Q5 ?$ a- n& `% A8 C
4. /* 数据接收*/
   . k, \: P/ T1 y
5. HAL_UART_Receive_IT(&UartHandle, s_ucBuf, 1);
   0 h% z) x* Y* x+ E/ c( c, [" Z( Z
6. 29.4.6 函数HAL_UART_Transmit_DMA
   
7. 函数原型：
   
8. 
   
9. HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   
10. {
    
11.   if(huart->gState == HAL_UART_STATE_READY)
    
12.   {
    , d9 G0 f- R: v$ ^; J/ x
13.     if((pData == NULL ) || (Size == 0U))
    3 m+ }, h- p8 [7 ]
14.     {
    , }: e3 ~2 R, v/ {3 \% M# Q% _
15.       return HAL_ERROR;
    
16.     }
    
17. 
    
18.     __HAL_LOCK(huart);
    
19. 
    0 h% t& _. |( l2 E
20.     huart->pTxBuffPtr = pData;
    
21.     huart->TxXferSize = Size;
    
22.     huart->TxXferCount = Size;
    
23. 
    6 T; U% h1 w" M
24.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    
25.     huart->gState = HAL_UART_STATE_BUSY_TX;
    ; B- s4 ?8 h0 N- t) d5 S, J
26. 
    
27.     /* 注册各种DMA回调函数 */
    
28.     huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;
    9 D/ E# J; v! E. V5 E- @  F
29.     huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;
    
30.     huart->hdmatx->XferErrorCallback = UART_DMAError;
    ! B, y- {/ P1 h$ q: c* T( a% m
31.     huart->hdmatx->XferAbortCallback = NULL;
    
32. 
    ; A6 b& ^. q  Q% S+ B
33.     /* 使能串口发送DMA通道 */
    
34.     HAL_DMA_Start_IT(huart->hdmatx, (uint32_t)huart->pTxBuffPtr, (uint32_t)&huart->Instance->TDR, Size);
    ) I8 ^# j9 R7 }$ Z, K3 S
35. 
    
36.     /* 清除传输TC完成标志 */
    
37.     __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
    5 f3 I; ]7 p& Z0 l- v
38. 
    
39.     __HAL_UNLOCK(huart);
    
40. 
    : Y) i( N9 `. m3 @% r
41.     /* 使能串口发送DMA传输 */
    
42.     SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);
    8 g6 \7 R! B$ D( O
43. 
    
44.     return HAL_OK;
    $ \$ K( _" j' Q  ^) Y6 Q3 I
45.   }
    . B6 m+ E( r- Y, g  h- D9 D
46.   else
    - z) y1 T% G% o! {$ f  Y" ^1 y0 O
47.   {
    , ?8 w7 {  N* E7 g& |
48.     return HAL_BUSY;
    
49.   }
    / z8 R' C& B; J" l! t$ G
50. }

复制代码

函数描述：
7 r" |- @7 h' c# k3 w) B' R
8 J) [1 L# [* g; W6 v; U此函数以DMA的方式发送指定字节。这里是用的DMA中断方式HAL_DMA_Start_IT进行的发送。所以使用此函数的话，不要忘了写DMA中断服务程序。而且DMA的配置也是需要用户实现的，可以直接在函数HAL_UART_MspInit里面实现，也可以放在其它位置。
) E+ S- u' m/ g# f  I
函数参数：

  第1个参数是UART_HandleTypeDef类型结构体指针变量。
' G7 f" R, C) x; }, K  第2个参数是要发送的数据地址。
  第3个参数是要发送的数据大小，单位字节。
  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
# J2 i4 }2 q" `
4 N0 L1 H" z; p29.4.7 函数HAL_UART_Receive_DMA

' U9 F4 V0 |' U9 I( _/ }函数原型：

& U. w2 H9 Y% V; U2 D: `1 X8 b5 z

1. HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   
2. {
     P' m2 \  r! s, Z
3.   if(huart->RxState == HAL_UART_STATE_READY)
   
4.   {
   
5.     if((pData == NULL ) || (Size == 0U))
   
6.     {
   + @$ r5 N2 I0 x  I! h
7.       return HAL_ERROR;
     r- ]# ?/ L% P) N" G( O6 F& _
8.     }
   
9. 
   ! L, O- _2 `3 V
10.     __HAL_LOCK(huart);
    2 F* r9 f( U* n
11. 
    
12.     huart->pRxBuffPtr = pData;
    
13.     huart->RxXferSize = Size;
    
14. 
    
15.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    
16.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    
17. 
    * q2 Y6 c$ F; |9 ^
18.     /* 注册各种DMA回调函数 */
    % g. _4 l+ ?: x: ]  A/ {& H" b) y
19.     huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;
    
20. 
    
21.     huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;
    $ I, x5 Z; c. ~( j1 K9 O" N
22.     huart->hdmarx->XferErrorCallback = UART_DMAError;
    
23. huart->hdmarx->XferAbortCallback = NULL;
    , S7 z4 j9 }0 H& U
24. 
    ; K& m* G! {2 S* W
25. /* 使能串口接收DMA通道 */
    
26.     HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->RDR, (uint32_t)huart->pRxBuffPtr, Size);
    
27. 
    + x; q+ t6 c9 i1 G4 [+ _  [8 l
28.     __HAL_UNLOCK(huart);
    
29. 
    
30.     /* 使能串口校验错误中断 */
    
31.     SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    , u! k  y8 i! `. b! _
32. 
    . f6 ?4 n* I& ?- w8 J$ B1 M
33.     /* 使能串口错误中断:(Frame error, noise error, overrun error) */
      u  I; R+ v0 l& d2 x0 j
34.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    
35. 
    . Y  d* _" f* U: U5 x  n2 V- n- k
36.     /* 使能串口接收DMA传输 */
    
37.     SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);
    # e: U; r& U6 ?3 [8 |4 T( n+ T5 O* f8 c
38. 
    
39.     return HAL_OK;
    
40.   }
    8 u2 `8 j; c- u% m
41.   else
    & }. P# a9 O2 D  ~3 z, m( F
42.   {
    6 {8 f* D2 ?" g; R& ]/ @2 U& }8 ^
43.     return HAL_BUSY;
    2 x$ x- w' K2 b8 v
44.   }
    : M" e& u- o. R* B
45. }

复制代码

函数描述：

/ ?" w! c7 n$ I' W8 ^5 U( n此函数以DMA的方式接收指定字节。这里是用的DMA中断方式HAL_DMA_Start_IT进行的接收。所以使用此函数的话，不要忘了写DMA中断服务程序。而且DMA的配置也是需要用户实现的，可以直接在函数HAL_UART_MspInit里面实现，也可以放在其它位置。

3 M$ V  z0 ~0 r函数参数：

' c4 H9 b0 v- Z& P" h  第1个参数是UART_HandleTypeDef类型结构体指针变量。
, J; I$ o5 ?% u" Y  第2个参数是要接收的数据地址。
: C) ?  \' f! k) N: [  A  第3个参数是要接收的数据大小，单位字节。
  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
; Y+ t+ I: V- k3 V) y1 w
29.5 总结

本章节就为大家讲解这么多，涉及到的知识点和API函数比较多，需要花点时间消化，后面用到的多了，就可以熟练掌握了。

5 j5 t9 u5 V; A* v: `; n