65.1 初学者重要提示
: \+ G" U; ^5 I0 ]  特别注意，LPUART没有自己的HAL库驱动文件，是跟通用串口公用的驱动文件。
# S- z. \; p) U/ Y" ^9 ~7 V  学习串口外设推荐从硬件框图开始了解基本的功能特性，然后逐步深入了解各种特性，这种方式方便记忆和以后查阅。而串口的通信学习，推荐看时序图。
65.2 低功耗串口基础知识
LPUART的全称是Low power universal synchronous asynchronous receiver transmitter，中文意思是低功耗通用异步收发器，简称LPUART。
+ w  j: N& n. y3 N& b
9 k- [/ H  z+ `65.2.1 低功耗串口的硬件框图
4 M8 A; Q" u1 b! i& f! F4 `认识一个外设，最好的方式就是看它的框图，方便我们快速的了解串口的基本功能，然后再看手册了解细节。
5 M6 {$ E7 Y- b; d

! Q# `9 ?/ Y/ j通过这个框图，我们可以得到如下信息：
! ?( E9 u' J' N5 ~
% P7 x! y# B* t. g( C; f# \! x  IRQ Interface中断接口
+ ]- b6 j  a9 X. O$ L! D用于实现中断方式的串口唤醒lpusart_wkup和串口的相关中断lpusart_it。
2 m& g. W+ f- ]0 O1 I* v
3 B5 ?9 \( \" s$ U  DMA Interface DMA接口
8 m  X2 z- Y; Q. |% r. K0 N1 H7 O实现串口发送lpuart_tx_dma和接收lpuart_rx_dma的DMA方式。
3 }2 |2 K/ l- {2 P. U' K% \
$ J4 H/ ~0 ]& y' k6 l  COM Contronller串口控制器
0 V8 f4 O5 b7 _) T串口相关的寄存器基本都在这部分。

  TxFIFO和RxFIFO
0 |! a  p5 B; Q) w$ |6 Q串口的发送和接收都支持了硬件FIFO功能。

: l5 V6 q* r! j: Q6 c4 `  TX和RX引脚的互换功能
/ ]( E6 ]% g) R: v( f: D* S发送偏移寄存器（TX Shift Reg）和接收偏移寄存器（RX Shift Reg）与TX引脚，RX引脚之间弄了个交叉连接，这里的意思是支持了引脚互换功能，这样大家在设计PCB的时候就可以比较随性了，接反了也没有关系。

  发送过程经过的寄存器
依次是LPUART_TDR -> TxFIFO ->Tx Shift Reg偏移寄存器 –> TX或者RX引脚。
; h" e6 s. n" L- X
  接收经过的寄存器
依次是TX或者RX引脚-> Rx Shift Reg偏移寄存器->RxFIFO –>LPUART_RDR。
% P- N8 `4 R; s7 K" y* a
  两个时钟lpuart_pclk和lpuart_ker_ck
' R2 c5 z# z* v* z# l$ l- [这两个时钟是独立的，作用如下：
1 j$ @% V, P( E7 F/ \
  lpuart_pclk
用于为外设总线提供时钟。

  lpuart_ker_ck
! m2 E2 `; `9 Y( b  `串口外设的时钟源。
7 m9 C# p- J4 Q% I+ z; R0 U
65.2.2 低功耗串口的基本功能
STM32的串口功能很强大，支持太多的模式。我们只需关心我们最常用的特性即可。我们的串口驱动使用的串口中断+FIFO结构，没有使用DMA。因此我们只讨论和串口中断、串口常规参数有关的知识。
; L' n) t& g" `! }( G9 j: y' ?
6 L- o' d" `0 eSTM32串口的优越特性：（只列了举常用的）
1 N* u* [+ m& O) v
  各种波特率。硬件采用分数波特率发生器系统，可以设置各种需要的波特率
  可编程数据字长度，支持7bit，8bit和9bit。
  可配置的停止位。支持1或2个停止位。
  p/ W& g  N1 B; a  C0 v  发送器和接收器可以单独使能。比如GPS应用只需要串口接收，那么发送的GPIO就可以节省出来用作其他功能。
* k) |' L  H: [; W" _+ _- R  检测标志和中断：
0 V9 P+ K% F- }. ^/ }% _6 s 接收缓冲器满，可产生中断。串口中断服务程序据此判断是否接收到数据。
发送缓冲器空，可产生中断。串口中断服务程序据此启动发送下一个数据。
! d1 k( s" g8 W) j3 S1 ` 传输结束标志，可产生中断。用于RS485通信，等最后一个字节发送完毕后，需要控制RS485收发器芯片切换为接收模式。
$ A+ c9 E0 L" _1 p, Z" ]3 _' T其它中断不常用，包括：CTS改变、LIN断开符检测、检测到总线为空闲（在DMA不定长接收方式会用到）、溢出错误、帧错误、噪音错误、校验错误。
% z+ K' v) \0 I! j! N
65.2.3 低功耗串口的高级特性
H7系列的串口支持了一些高级特性，比如：

* D/ D" J1 Q  Z  数据逻辑电平翻转。
  低功耗特性。
  RX和TX引脚交换。
2 D: A  ~# m" Y  MSB位先发送。
  外接485的PHY芯片时，硬件支持收发切换，无需用户手动控制DE引脚。
相比第29章的通用串口，低功耗串口不支持超时接收和自适应波特率。
" S5 s1 \% G! U! ]% ?; Y
6 D1 Q1 F" q* a6 h8 k, N65.2.4 低功耗串口的数据帧格式
2 `/ b9 w: w7 N% `* O串口支持的帧格式如下（M和PCE都是LPUART_CR1寄存器的位，其中M位用于控制帧长度，PCE用于使能奇偶校验位）:
, X" ~/ q; s6 b9 w: V
, ~+ g6 _6 W, L! `7 ?' B

; c0 u3 ^2 A# i  D" ]. ]4 j, r! \这里特别注意奇偶校验位，用户在配置的时候可以选择奇校验和偶校验，校验位是占据的最高位。比如选择M=00，PCE=1，即7bit的数据位。
3 U% c  }4 f8 T4 @2 J+ W0 E: U
  串口发送数据：
如果发送的7bit数据是111 0011，这个里面有奇数个1，那么选择偶校验的情况下，校验位 = 1，凑够偶数个1，而选择奇校验的情况下，校验位 = 0，因为已经是奇数个1。校验位不需要用户去计算，是硬件自动生成的。

3 _0 h$ W4 _& d6 z6 A1 r+ x  串口接收数据：
根据用户设置的奇校验或者偶校验类型，串口硬件会对接收到的数据做校验，如果失败，LPUART_ISR寄存器的PE位会被置1。如果使能了对应的中断PEIE，那么失败的时候还会产生中断。
了解到帧格式后，再来看一下实际数据发送时，数据位的先后顺序：

9 E+ v+ L# A  J$ b5 M! }+ o

& h% f, \+ N( O2 ~4 {* O
65.2.5 低功耗串口的支持的时钟和波特率
低功耗定时器支持如下几种时钟：
0 q! S; }3 j: K  V3 H. [

2 h" L& h3 J, _6 W: V8 @+ S
' Z& ^8 Q  e- [( }" m  L这里我们重点关注PCLK3（D3PCLK1），HSI和LSE。
) W# `7 U8 \# t$ {. q4 P
  LPUART时钟选择LSE(32768Hz)
4 [. X2 Y9 s4 c% a/ P$ q最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
$ ^2 W( Q5 V" ]( F( n2 a+ S
  LPUART时钟选择HSI(64MHz)
最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。

0 w* S$ T3 T+ X; s9 c) p* G/ j" F& j  LPUART时钟选择D3PCLK1(100MHz)
最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。

' p& e: F. F  u0 ^+ ?7 K65.2.6 低功耗串口的支持唤醒方式
低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：

  检测到起始位唤醒。
/ t# i6 G/ X  X" x4 R6 R  检测到RXNE标志唤醒，即接收到数据。
+ h: A: x) p- \  W* u6 G3 _1 w$ }& s  检测到匹配地址时唤醒。
匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发送地址0x99（0b1001 1001）才可以唤醒。
. i) k3 j$ O5 M8 N: Z
唤醒成功时的时序效果如下，特别注意唤醒信号位置：
$ Z  b3 T: t& o/ V

3 L! `3 B7 B3 I
/ V! ^9 A/ ~6 H9 R唤醒失败时的时序效果：
/ v: s! Q( _1 i7 |8 J0 ~- S, ~% h

1 B, R0 @9 k" {  W5 r' M
65.2.7 低功耗串口发送时序图
这个时序图非常具有代表性，可以帮助大家很好的理解TC发送完成中断和TXE空中断。
4 v7 [  ?$ @* }- M7 y, U: R

$ O. H$ Y/ S8 `* D  E* N
65.2.8 单工，半双工和全双工通讯
单工：在一个单工的串行通讯系统中，一般至少有两根线（信号线和地线），数据传送只有一个方向，例如可以使用单工数据传送将数据从一个简单的数据监测系统传送到PC上。

半双工：在半双工串行通信系统中，一般同样要求至少有两根线。这里的数据传送是双向的。然而，同一个时刻只能为一个方向。在上面的数据监测的例子中做了一些变化，可以使用半双工通讯机制发送信息到嵌入式模块（来设置参数，比如采样率）。此外，在其他时候，可以使用这个种连接将嵌入式装置上的数据下载到PC中。
. E! D( a' p  d) C4 I" Q8 U6 P+ m
全双工：在一个全双工的串行通信系统中，一般要求至少有三根线（信号线A，信号线B和地线）。信号线A将传输一个方向上的数据，同时信号线B传送另一个方向上的数据。

6 \# I! e9 y' R% f& [7 X# I65.3 低功耗串口的HAL库用法
: c2 Y5 \8 x/ w% z$ a+ g* [, _# U串口的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置GPIO、时钟，并根据需要配置NVIC、中断和DMA。下面我们逐一展开为大家做个说明。
6 X; F2 \1 ^# Q2 ^! S  \$ Z; \
8 p! j, B) K3 ?+ e65.3.1 低功耗串口寄存器结构体USART_TypeDef
USART相关的寄存器是通过HAL库中的结构体USART_TypeDef定义的，在stm32h743xx.h中可以找到这个类型定义：

1. typedef struct
   
2. {
   
3.   __IO uint32_t CR1;    /*!< USART Control register 1,                 Address offset: 0x00 */
   , m! p+ @0 G! _, o; c5 V
4.   __IO uint32_t CR2;    /*!< USART Control register 2,                 Address offset: 0x04 */
   
5.   __IO uint32_t CR3;    /*!< USART Control register 3,                 Address offset: 0x08 */
   
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 */
   4 i& |8 F4 a& ?( a/ @2 f0 Q
8.   uint16_t  RESERVED2;  /*!< Reserved, 0x12                                                 */
   ) b. U$ Q. f# U% X
9.   __IO uint32_t RTOR;   /*!< USART Receiver Time Out register,         Address offset: 0x14 */
   
10.   __IO uint16_t RQR;    /*!< USART Request register,                   Address offset: 0x18 */
    
11.   uint16_t  RESERVED3;  /*!< Reserved, 0x1A                                                 */
    8 H% H5 L% Q0 B  f$ o
12.   __IO uint32_t ISR;    /*!< USART Interrupt and status register,      Address offset: 0x1C */
    7 m) `+ f8 F1 I
13.   __IO uint32_t ICR;    /*!< USART Interrupt flag Clear register,      Address offset: 0x20 */
    & K1 N: @" R' M9 w' `" G7 k
14.   __IO uint16_t RDR;    /*!< USART Receive Data register,              Address offset: 0x24 */
    
15.   uint16_t  RESERVED4;  /*!< Reserved, 0x26                                                 */
    0 m) Q0 I. C- S
16.   __IO uint16_t TDR;    /*!< USART Transmit Data register,             Address offset: 0x28 */
    3 M. i! I2 }' K( w1 a1 w1 b
17.   uint16_t  RESERVED5;  /*!< Reserved, 0x2A                                                 */
    
18.   __IO uint32_t PRESC;  /*!< USART clock Prescaler register,           Address offset: 0x2C */
    
19. } USART_TypeDef;
    
20. 
    9 b8 q& t# P2 c2 V) d9 ^

复制代码

这个结构体的成员名称和排列次序和CPU的USART寄存器是一 一对应的。
/ l& f) o- E7 s
  P2 y; u3 N* c+ C& j1 P* {5 a__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
! }5 C/ U6 F2 S5 r; |$ u/ w
. v8 z& D: }" _# \) ]" k1 e. y) S

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   ' n* ^8 X7 N* I: |$ |3 q( W
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

下面我们看下LPUART的定义，在stm32h743xx.h文件。
6 M) T; ^6 G  C' @

1. #define PERIPH_BASE         (0x40000000UL)
   9 V7 ~! ?0 B9 T: \
2. #define D3_APB1PERIPH_BASE  (PERIPH_BASE + 0x18000000UL)
   ( d6 o6 P8 r& A8 M
3. #define LPUART1_BASE        (D3_APB1PERIPH_BASE + 0x0C00UL)
   * p/ ^; `8 g. u1 [8 o. w" N
4. #define LPUART1             ((USART_TypeDef *) LPUART1_BASE) <----- 展开这个宏，(USART_TypeDef *) 0x58000C00

复制代码

. v6 U  S$ G' i/ R1 G" ^我们访问LPUART1的CR1寄存器可以采用这种形式：LPUART1->CR1 = 0。

65.3.2 低功耗串口句柄结构体UART_HandleTypeDef
; b1 H2 E5 Y7 L/ _4 s4 n7 C1 vHAL库在USART_TypeDef的基础上封装了一个结构体UART_HandleTypeDef，定义如下：

; B5 Q5 c$ h+ r$ B

1. typedef struct __UART_HandleTypeDef
   
2. {
   
3.   USART_TypeDef            *Instance;               
   
4.   UART_InitTypeDef         Init;                  
   * i( l. C  l3 e! C! H3 r$ j* \
5.   UART_AdvFeatureInitTypeDef AdvancedInit;         
   
6.   uint8_t                  *pTxBuffPtr;            
   
7.   uint16_t                 TxXferSize;            
   
8.   __IO uint16_t            TxXferCount;            
   
9.   uint8_t                  *pRxBuffPtr;            
   " [- s/ k( u! W
10.   uint16_t                 RxXferSize;            
    
11.   __IO uint16_t            RxXferCount;           
      z% P' i; Y7 ~& ]6 q& ~; p
12.   uint16_t                 Mask;                    
    
13.   uint32_t                 FifoMode;                 
    
14.   uint16_t                 NbRxDataToProcess;        
    
15.   uint16_t                 NbTxDataToProcess;        
    
16.   void (*RxISR)(struct __UART_HandleTypeDef *huart);
    3 t: x1 B: F. O6 m' P) ^, w
17.   void (*TxISR)(struct __UART_HandleTypeDef *huart);
    % _3 I" Q# x1 O2 K
18.   DMA_HandleTypeDef        *hdmatx;                 
    1 d2 v$ I7 y& j; @& ~+ b$ e. N
19.   DMA_HandleTypeDef        *hdmarx;               
    5 p3 p3 |2 t* a  p" H0 d
20.   HAL_LockTypeDef           Lock;                    /
    
21.   __IO HAL_UART_StateTypeDef    gState;              
    1 ^. V9 e5 _) y4 u" M
22.   __IO HAL_UART_StateTypeDef    RxState;            
    
23.   __IO uint32_t                 ErrorCode;           
    
24. 
    
25. #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    2 j* @9 \8 k! I% L5 `) o3 I
26.   void (* TxHalfCpltCallback)(struct __UART_HandleTypeDef *huart);        
    
27.   void (* TxCpltCallback)(struct __UART_HandleTypeDef *huart);            
    ! j# Q1 P' s4 B+ L$ D
28.   void (* RxHalfCpltCallback)(struct __UART_HandleTypeDef *huart);        
    
29.   void (* RxCpltCallback)(struct __UART_HandleTypeDef *huart);         
    1 _; a+ P4 a* d7 J. p7 K
30.   void (* ErrorCallback)(struct __UART_HandleTypeDef *huart);            
    1 F: D* W. b4 |( j( [9 e7 P
31.   void (* AbortCpltCallback)(struct __UART_HandleTypeDef *huart);         
    
32.   void (* AbortTransmitCpltCallback)(struct __UART_HandleTypeDef *huart);
    % l( p. c; g: i; B! }3 s
33.   void (* AbortReceiveCpltCallback)(struct __UART_HandleTypeDef *huart);  
    - C) z) n4 s8 W5 T- {
34.   void (* WakeupCallback)(struct __UART_HandleTypeDef *huart);            
    8 ], S0 Z% D5 X6 F  R1 k1 L
35.   void (* RxFifoFullCallback)(struct __UART_HandleTypeDef *huart);      
    / P! L* ^' N: x6 f2 p6 h* J, ?6 G  N
36.   void (* TxFifoEmptyCallback)(struct __UART_HandleTypeDef *huart);      
    
37.   void (* MspInitCallback)(struct __UART_HandleTypeDef *huart);         
    
38.   void (* MspDeInitCallback)(struct __UART_HandleTypeDef *huart);        
    + [9 v  [, b9 w5 }" @% }4 G( o
39. #endif  
    
40. } UART_HandleTypeDef;

复制代码

3 @, D4 n) n9 A, H注意事项：

; W+ M9 r1 Z2 C条件编译USE_HAL_HRTIM_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

. @' _+ _+ M) U' X5 ?; G- h  #define   USE_HAL_UAR_REGISTER_CALLBACKS   1
4 N; {( W* U, l$ `4 C% S% h
通过函数HAL_UART_RegisterCallback注册回调，取消注册使用函数HAL_UART_UnRegisterCallback。

这里重点介绍前三个参数，其它参数主要是HAL库内部使用和自定义回调函数。

  USART_TypeDef  *Instance
! V  x2 ^1 O. s这个参数是寄存器的例化，方便操作寄存器，比如使能串口的发送空中断。

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

4 L7 i0 Q5 p9 G  UART_InitTypeDef  Init
这个参数是用户接触最多的，用于配置串口的基本参数，像波特率、奇偶校验、停止位等。UART_InitTypeDef结构体的定义如下：
! E- r+ |' R2 X* G$ s" `

1. typedef struct
   
2. {
   ) _; C# ]9 `' [" K# U5 t2 j$ F4 J/ L
3.   uint32_t BaudRate;       /* 波特率 */
   
4.   uint32_t WordLength;     /* 数据位长度 */
   * K8 n0 d# t3 S8 G( w
5.   uint32_t StopBits;       /* 停止位 */         
   
6.   uint32_t Parity;         /* 奇偶校验位 */         
   6 o8 ]5 `7 J$ S( R- ]
7.   uint32_t Mode;           /* 发送模式和接收模式使能 */         
   
8.   uint32_t HwFlowCtl;      /* 硬件流控制 */         
   
9.   uint32_t OverSampling;   /* 过采样，可以选择8倍和16倍过采样 */        
   1 n: I3 W1 J' u" `
10.   uint32_t Prescaler;      /* 串口分频 */            
    
11.   uint32_t FIFOMode;         /* 串口FIFO使能 */         
    
12.   uint32_t TXFIFOThreshold;  /* 发送FIFO的阀值 */         
    8 G2 ^9 I% t2 E8 G4 D
13.   uint32_t RXFIFOThreshold;  /* 接收FIFO的阀值 */         
    ! {& w2 F0 t& F+ }0 b/ O
14. }UART_InitTypeDef;

复制代码

3 H/ B! g! f6 T/ w- L9 ^  UART_AdvFeatureInitTypeDef AdvancedInit
这个参数用于配置串口的高级特性。具体支持的功能参数如下：
, x% p1 u/ `* M, ~+ f' n" k! x4 v

1. typedef struct
   ! Q: S5 W. Q+ D% X( q
2. {
   
3.   uint32_t AdvFeatureInit;       /* 初始化的高级特性类别 */
   
4.   uint32_t TxPinLevelInvert;     /* Tx引脚电平翻转 */
   5 W9 S8 e6 H& _
5.   uint32_t RxPinLevelInvert;     /* Rx引脚电平翻转 */
   
6.   uint32_t DataInvert;           /* 数据逻辑电平翻转 */
   
7.   uint32_t Swap;                 /* Tx和Rx引脚交换 */
   , {) h$ f+ [  R
8.   uint32_t OverrunDisable;       /* 接收超时检测禁止 */
   2 H$ N% i. S- D& W: _" i
9.   uint32_t DMADisableonRxError;  /* 接收出错，禁止DMA */
   
10.   uint32_t AutoBaudRateEnable;   /* 自适应波特率使能 */
    
11.   uint32_t AutoBaudRateMode;     /* 自适应波特率的四种检测模式选择 */
    ! }% J7 o4 s0 L! _( Q+ T( d" H
12.   uint32_t MSBFirst;             /* 发送或者接收数据时，高位在前 */
    
13. } UART_AdvFeatureInitTypeDef;

复制代码

& g5 R! [8 w  w; n* i! M- f+ x0 }# I配置串口参数，其实就是配置结构体UART_HandleTypeDef的成员。比如下面配置为波特率115200，8个数据位，无奇偶校验，1个停止位。
6 {2 V7 _0 q9 m- f) k
9 R# `, f. s1 {

1. UART_HandleTypeDef UartHandle;
   ! ^  S7 A  L4 w
2. 
   ) A7 S6 _5 L1 a1 ?  |0 D) q2 S
3. /* 配置如下:
   
4.   - 数据位 = 8 Bits
   ; M! J" m9 O+ |) z
5.   - 停止位 = 1 bit
   
6.   - 奇偶校验位 = 无
   
7.   - 波特率 = 115200bsp
   , s. k; F; ?0 k6 s& l2 j
8.   - 硬件流控制 (RTS 和 CTS 信号) */
   ' b8 f+ c" }2 V- h3 E9 o% e% F
9. UartHandle.Instance        = LPUART1;
   * c6 B7 e" W3 \+ F
10. 
    
11. UartHandle.Init.BaudRate     = 115200;
    
12. UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
    1 ^* X$ z  \( k5 `
13. UartHandle.Init.StopBits     = UART_STOPBITS_1;
    9 l) V9 R5 o  g* G+ G5 R
14. UartHandle.Init.Parity       = UART_PARITY_NONE;
    
15. UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
    " d7 v0 ]3 o/ O
16. UartHandle.Init.Mode         = UART_MODE_TX_RX;
    
17. UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
18. UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
19. 
    
20. if(HAL_UART_Init(&UartHandle) != HAL_OK)
    
21. {
    1 n; b2 j' H: ?) x, c% \
22.     Error_Handler();
    ; l: K4 J% h6 r4 L# z
23. }

复制代码

65.3.3 低功耗串口的底层配置（GPIO、时钟、中断等）
- t: S2 X( x& d5 Q( n串口外设的基本参数配置完毕后还不能使用，还需要配置GPIO、时钟、中断等参数，比如下面配置使用引脚PA9和PA10。
# q' i8 p9 D& [2 \+ j; A7 n0 E4 F
1 _) [4 C! M6 h1 q9 y& e

1. /* LPUART1的GPIO  PA9, PA10 */
   
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   5 L/ B! A: d* U4 X
3. 
   9 _# U' [( b! O+ {. \
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   9 j, R8 S  y4 ?0 v# @
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   6 a8 n) T" y& U# v! H
8. 
   9 H& H4 ]8 H& V
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   7 Q; _2 L3 ?0 p& h$ y0 d5 D3 @5 w
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    ) B) }1 c$ s8 S6 }- m
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    / c6 k) ]8 Z  j) ~9 V! b9 P; h
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    
13. 
    
14. /*
    0 w6 [. b. ?7 a" T4 ~: ^
15. *********************************************************************************************************
    . Q; ?  O9 x% Z. F9 V- e& |3 Z6 {/ y
16. *    函 数 名: InitHardUart
    
17. *    功能说明: 配置串口的硬件参数和底层
    ) k5 f# W% O1 L4 S% f* D
18. *    形    参: 无
    
19. *    返 回 值: 无
    2 V1 S- G& ~( N& ]# f
20. *********************************************************************************************************
    
21. */
    
22. static void InitHardUart(void)
    ; U) n( @4 Q* M- g6 N4 k
23. {
    / I9 ?( @% @8 ]6 B" R; {1 c
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    # j2 @3 m- [) x- A0 w
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    " t( I/ Q3 C6 g' z7 ?: u' j
26. 
    5 a: |. t) d9 K# A4 K
27. #if LPUART1_FIFO_EN == 1        
    
28.     /* 使能 GPIO TX/RX 时钟 */
    ! ?& c! n- N  b6 B( b
29.     LPUART1_TX_GPIO_CLK_ENABLE();
    
30.     LPUART1_RX_GPIO_CLK_ENABLE();
    $ _. |0 C6 |* i% G+ D
31. 
    4 J7 d8 u3 k4 V/ @; h3 l
32.     /* 使能 USARTx 时钟 */
    
33.     LPUART1_CLK_ENABLE();   
    
34. 
    / D0 s& ~1 x1 c; `8 A1 @% l
35.     /* 配置TX引脚 */
    
36.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    / j, ~  m1 ~4 }: H6 N9 S
37.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
38.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
39.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
40.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
      W8 S5 n$ T& F4 u/ S
41.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    
42. 
    ( Z2 w# k1 P/ ?5 T0 o0 I4 Q
43.     /* 配置RX引脚 */
    : I4 A/ T0 L% t0 Q- S/ M
44.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    8 |5 i7 z  j6 |# d; J
45.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    1 @! x3 _$ T/ c: B5 s! t
46.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
47. 
    
48.     /* 配置NVIC the NVIC for UART */   
    3 L( Z2 K! q' r
49.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    
50.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    
51. 
    - r! s. H1 v& y
52.     /* 配置波特率、奇偶校验 */
    5 J$ ~  Y2 m1 X3 Z
53.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
54. 
    & N& a0 h* P3 h$ f8 R+ |) u
55.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    + s* m7 f8 m4 u! U& T/ ]. P
56.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    
57.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
58. #endif
    
59. }
    

复制代码

& T2 R, ]+ R6 m3 D, i' o总结下来就是以下几点：

& f! j7 j& X3 m* ^2 |6 U; b2 {9 T" Y7 M: m  配置GPIO引脚时钟。
# I7 [2 A6 f- |. ?) L  配置LPUART时钟。
3 g/ A& A6 M! ?2 C. ]  配置LPUART的发送和接收引脚。
  通过NVIC配置中断。
& q, T* w1 D, q! w1 M7 z  配置波特率，奇偶校验等，在上一小节有讲。
( L# h4 y4 J% W4 B5 ~! i  清除TC和RXNE标志，使能接收中断。
" E# G2 C! O* K: g# _  N6 y4 k+ q
+ o, |( S7 h' f3 j9 r
# u% k0 V% U5 y9 z) e: o关于这个底层配置有以下几点要着重说明下：
$ W1 ?) L9 m8 ~
% Y2 n+ \; X. |- F& W: u  串口发送和接收引脚的复用模式选择已经被HAL库定义好，放在了stm32h7xx_hal_gpio_ex.h文件里面。比如串口1有两个复用
#define GPIO_AF3_LPUART    ((uint8_t)0x03) /* LPUART Alternate Function mapping */
#define GPIO_AF8_LPUART    ((uint8_t)0x08) /* LPUART Alternate Function mapping */


具体使用那个，要看数据手册，比如我们这里使用引脚PA9和PA10，对应的复用如下：
: K+ B; k6 M, ?

; R% G. L- l* v- I4 c那么使用GPIO_AF3_LPUART1即可。

  根据情况要清除TC发送完成标志和RXNE接收数据标志，因为这两个标志位在使能了串口后就已经置位，所以当用户使用了TC或者RX中断后，就会进入一次中断服务程序，这点要特别注意。
- P+ i% E- H" \" V  HAL库有个自己的底层初始化回调函数HAL_UART_MspInit，是弱定义的，用户可以在其它的C文件里面实现，并将相对的底层初始化在里面实现。当用户调用HAL_UART_Init后，会在此函数里面调用HAL_UART_MspInit，对应的底层复位函数HAL_UART_MspDeInit是在函数HAL_UART_DeInit里面被调用的。
当然，用户也可以自己初始化，不限制必须在两个函数里面实现。
. d) `8 W/ M7 f( o3 ?* O
  上面举的例子里面没有用到DMA，如果用到了DMA，也是要初始化的。
65.3.4 低功耗串口的状态标志清除问题
0 U& }2 [1 @$ K/ O; [注，早前使用F1和F4时候，经常会有网友咨询为什么串口中断服务程序里面没有做清除标志。

, s9 m9 Y# P3 M: ~: a% c. Q下面我们介绍__HAL_USART_GET_FLAG函数。这个函数用来检查LPUART/USART标志位是否被设置。
4 ]3 A3 e1 r, I

1. /** @brief  Check whether the specified USART flag is set or not.
   - v+ A! `5 c; F5 c- [7 l8 h
2.   * @param  __HANDLE__: specifies the USART Handle
   1 v6 e- f& |+ O+ d2 a4 h9 S" n
3.   * @param  __FLAG__: specifies the flag to check.
   
4.   *        This parameter can be one of the following values:
   ' R* T2 n0 R! O6 P/ I; Z4 d
5.   *            @arg USART_FLAG_TXFT: TXFIFO threshold flag
   # j* R* Z6 G+ N! d! R1 Y
6.   *            @arg USART_FLAG_RXFT: RXFIFO threshold flag
   
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
     I8 ^0 n& h' K+ \: z' x' O4 w, C
10.   *            @arg USART_FLAG_TEACK: Transmit enable ackowledge flag
    & t" j! Q4 f7 d0 ~* t
11.   *            @arg USART_FLAG_BUSY:  Busy flag
    + `! ]( C6 I4 r/ C3 z: A7 _
12.   *            @arg USART_FLAG_TXE:   Transmit data register empty flag
    # e+ b8 M: Y; e4 y0 X! m
13.   *            @arg USART_FLAG_TC:    Transmission Complete flag
    " \# |4 W+ i! g% J$ A( Y/ s  Z* c
14.   *            @arg USART_FLAG_RXNE:  Receive data register not empty flag
    
15.   *            @arg USART_FLAG_IDLE:  Idle Line detection flag
    . E/ E: Z3 a5 ?/ B5 V
16.   *            @arg USART_FLAG_ORE:   OverRun Error flag
    8 C* i! o/ k+ p% Y& Q5 T+ u
17.   *            @arg USART_FLAG_UDR:   UnderRun Error flag
    6 t* Q7 s, w# E4 H& P8 s
18.   *            @arg USART_FLAG_NE:    Noise Error flag
    
19.   *            @arg USART_FLAG_FE:    Framing Error flag
    ' y0 \5 }; S6 G$ j7 g
20.   *            @arg USART_FLAG_PE:    Parity Error flag
    ; N3 v5 Z6 U9 P+ p/ G: d
21.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    3 l' c' e0 ~3 |1 ]6 J
22.   */

复制代码

, R* Y! @2 A2 D' X7 r" nUSART_FLAG有如下几种取值：
+ L% w$ ^& j! y  \

) ^$ @4 Y4 @$ i. I9 ?
" I- K/ k5 r( C/ j  t- I

6 a  a8 C  O, ~5 a  D( _9 {6 n

请大家重点关注上表中红字部分，LPUART/USART标志是需要软件主动清零的。清零有两种方式：一种是调用__HAL_USART_CLEAR_FLAG函数，另一种是操作相关寄存器后自动清零。

1. /** @brief  Clear the specified USART pending flag.
   
2.   * @param  __HANDLE__: specifies the USART Handle.
     `' A' N3 }( ?( Z, L# o+ m$ T
3.   * @param  __FLAG__: specifies the flag to check.
   
4.   *          This parameter can be any combination of the following values:
   8 ]7 I' e3 j; i
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
   # {+ v0 F) J- K8 F8 d& |9 C) {. T7 m
9.   *            @arg USART_FLAG_REACK: Receive enable ackowledge flag
   
10.   *            @arg USART_FLAG_TEACK: Transmit enable ackowledge flag
    
11.   *            @arg USART_FLAG_WUF:   Wake up from stop mode flag
    
12.   *            @arg USART_FLAG_RWU:   Receiver wake up flag (is the USART in mute mode)
    % C2 S: G7 A) C
13.   *            @arg USART_FLAG_SBKF:  Send Break flag
    9 O# ]* I9 \  g' Q* b
14.   *            @arg USART_FLAG_CMF:   Character match flag
    
15.   *            @arg USART_FLAG_BUSY:  Busy flag
    
16.   *            @arg USART_FLAG_ABRF:  Auto Baud rate detection flag
    # z  h) Y: M7 R
17.   *            @arg USART_FLAG_ABRE:  Auto Baud rate detection error flag
    
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
    ! S* {) x9 `4 q2 ]
22.   *            @arg USART_FLAG_RXNE:  Receive data register not empty flag
    , l. k; s& j- y
23.   *            @arg USART_FLAG_IDLE:  Idle Line detection flag
    % |2 X$ \7 Z0 V/ a$ R. S: F
24.   *            @arg USART_FLAG_ORE:   OverRun Error flag
    . s, b7 F4 _0 n) [  F3 f% d
25.   *            @arg USART_FLAG_NE:    Noise Error flag
    
26.   *            @arg USART_FLAG_FE:    Framing Error flag
    ! T. e* ~' V7 p' F# n" M/ u
27.   *            @arg USART_FLAG_PE:    Parity Error flag
    6 S$ D1 @. [* ]6 g7 s
28.   * @retval The new state of __FLAG__ (TRUE or FALSE).
    / Q5 S3 C* i, j+ u8 |0 }" a
29.   */
    $ I8 J% z- @8 ^( W
30. #define __HAL_USART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__))

复制代码

0 O4 K5 O- U6 c! [" j- m上面介绍的USART标志大部分能够设置为产生中断，也就是有对应的USART中断标志。我们只介绍几个串口驱动要用到的中断标志：
0 [3 _' |: w( l& o; w
2 J; `/ x  u! a' D4 j- v; B& C/ kUSART_IT_TXE：TXE:发送数据寄存器空（此时数据可能正在发送）。
8 [  C/ t! n* F' w: h& i
4 X5 e3 _& Y* p9 \" cUSART_IT_TC：发送完成 。

/ ~; ]  @. i4 f/ p. TUSART_IT_RXNE：接收数据寄存器非空。

中断缺省都是关闭的，通过__HAL_USART_ENABLE_IT函数可以使能相应的中断标志。函数定义如下：
* n$ F% e4 l8 |, I, B* R8 m9 |+ I1 ?
( y/ j/ o% b, x& B! q7 ^) w7 c/ Q

1. /** @brief  Enable the specified USART interrupt.
   
2.   * @param  __HANDLE__: specifies the USART Handle.
     `1 p; R: a  m" n$ f; B
3.   * @param  __INTERRUPT__: specifies the USART interrupt source to enable.
   
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
   
8.   *            @arg USART_IT_TXFT: TXFIFO threshold interrupt
   
9.   *            @arg USART_IT_TXE : Transmit Data Register empty interrupt
   
10.   *            @arg USART_IT_TC  : Transmission complete interrupt
    2 L/ H0 g" k9 U1 Y( D" s
11.   *            @arg USART_IT_RXNE: Receive Data register not empty interrupt
    
12.   *            @arg USART_IT_IDLE: Idle line detection interrupt
    
13.   *            @arg USART_IT_PE  : Parity Error interrupt
    
14.   *            @arg USART_IT_ERR : Error interrupt(Frame error, noise error, overrun error)
    
15.   * @retval None
    
16.   */
    
17. #define __HAL_USART_ENABLE_IT(__HANDLE__, __INTERRUPT__)   (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1)? ((__HANDLE__)->Instance->CR1 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
    / E/ }0 m  H  p/ p" c* \. M
18.                                                             ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2)? ((__HANDLE__)->Instance->CR2 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
    
19.                           ((__HANDLE__)->Instance->CR3 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))))

复制代码

STM32一个串口的中断服务程序入口地址只有一个，进入中断服务程序后，我们需要判断是什么原因进入的中断，因此需要调用一个函数来检测中断标志。函数原型如下：
! R8 \7 B. h! F3 H8 z0 e

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

复制代码

4 F  j7 P) ~0 B% Z4 |* ]中断处理完毕后，必须软件清除中断标志，否则中断返回后，会重入中断。清中断标志位的函数为：

' b2 |" o9 H8 q

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

复制代码

正如前面介绍的，不是所有的标志都需要用这个函数清零。

4 j& ?" t5 Y; c注意：操作串口的寄存器不限制必须要用HAL库提供的API，比如要操作寄存器CR1，直接调用LPUART1->CR1操作即可。

65.3.5 低功耗串口初始化流程总结
使用方法由HAL库提供：

  第1步：定义UART_HandleTypeDef类型串口结构体变量，比如UART_HandleTypeDef huart。
+ [2 v- e9 U3 f" ?5 L
# R- H2 t, r- w/ M4 q  第2步：使用函数HAL_UART_MspInit初始化串口底层，不限制一定要用此函数里面初始化，用户也可以自己实现。

使能串口时钟。
引脚配置。
        a、使能串口所使用的GPIO时钟。
: v$ k' n- E4 c/ b0 L7 I7 p6 o
  f/ I6 l/ x/ g& S1 O        b、配置GPIO的复用模式。

: h) U( }. g' ]. v& T 如果使用中断方式函数HAL_UART_Transmit_IT和HAL_UART_Receive_IT需要做如下配置。
: \9 [8 ?! J/ X7 a% r9 \: k2 }        a、配置串口中断优先级。
0 F. p+ |' B3 P7 e! D0 B# B8 Y
9 g0 j& i1 x2 F        b、使能串口中断。
- R& G' d& z) N* Y
串口中断的开关是通过函数__HAL_UART_ENABLE_IT() 和 __HAL_UART_DISABLE_IT()来实现，这两个函数被嵌套到串口的发送和接收函数中调用。
如果使用DMA方式函数HAL_UART_Transmit_DMA和HAL_UART_Receive_DMA需要做如下配置。
& W  p5 t, b" j# p. W# C: \        a、声明串口的发送和接收DMA结构体变量，注意发送和接收是独立的，如果都使用，那就都需要配置。
6 m' |" P" E4 p% G
        b、使能DMA接口时钟。

* L$ n: p  `& t3 _7 K        c、配置串口的发送和接收DMA结构体变量。
( y6 j, M  U% R+ z' B$ ?
' p* h# a( K  \* M$ v' C        d、配置DMA发送和接收通道。

        e、关联DMA和串口的句柄。
4 Y9 `) x5 m# I& C- `4 m! M! x
        f、配置发送DMA和接收DMA的传输完成中断和中断优先级。

$ H; N) C9 o# L/ }- h) s! f  第3步：配置串口的波特率，位长，停止位，奇偶校验位，流控制和发送接收模式。
7 }! }6 L$ p7 o6 U  V$ w, R# r- _; G
3 m( N+ y& ~0 }/ T5 ]1 H7 [  第4步：如果需要，可以编程高级特性，比如TX/RX交换引脚，自动波特率检测。通过第1步串口结构体变量huart的结构体成员AdvancedInit来设置。
/ k* r( }% K0 b( ~
; Q+ E: J3 A1 P  第5步：串口初始化调用的函数HAL_UART_Init初始化。
' V; I% H: v$ M+ y$ X
  第6步：根据需要可以做动态注册回调。
' S6 j2 O: e4 C) f! Z3 n  W4 m
6 @& z# s- g0 \/ c' Y+ J/ I首先使能宏定义USE_HAL_UART_REGISTER_CALLBACKS。
3 E- ?( j6 X: t- ~8 g
- F: P5 M* [1 D, Y  P" ~然后调用函数HAL_UART_RegisterCallback() 就可以注册如下回调函数：

(+) TxHalfCpltCallback      

2 U; G$ O8 W$ h# f5 U& w  F( `(+) TxCpltCallback         

0 N# Q# }1 H5 F9 Z(+) RxHalfCpltCallback      

: e4 `+ p- Q! N(+) RxCpltCallback         

7 d3 {& x+ q  [! v& Z& l3 r! x(+) ErrorCallback         
2 X* C+ R: C! F7 b, J; `
(+) AbortCpltCallback      
3 s7 f! x9 o0 _! O
(+) AbortTransmitCpltCallback

8 G$ U: {( Q: b2 @(+) AbortReceiveCpltCallback

(+) WakeupCallback           
1 }1 V/ B9 ^$ h( t
(+) RxFifoFullCallback     
9 z& _3 k8 M( ^3 s! x
. l2 P4 u3 m1 h+ N. G(+) TxFifoEmptyCallback     
/ s  q& U/ k; f4 {8 o
(+) MspInitCallback         

" g  Z+ A9 L0 W- C5 Y! [# [(+) MspDeInitCallback         

2 ?4 c% s) Q! K+ X! {函数HAL_UART_UnRegisterCallback允许取消注册的回调函数如下：
! M; s# u! m& c/ X7 ^% _
(+) TxHalfCpltCallback      
6 b& k! t1 l5 C! K( Z( p
(+) TxCpltCallback         

& I' e- G8 }; k& b/ r" r(+) RxHalfCpltCallback      

; y5 G4 r3 G0 H3 `(+) RxCpltCallback         
& c. d1 `9 b, u9 m/ a; l7 v) x
+ T! _. ?1 j8 g" n9 r7 z- R(+) ErrorCallback         

(+) AbortCpltCallback      
% V( v+ F1 }7 u& g7 f, n* q& n# d
- U6 |; @2 Y& f3 _7 |(+) AbortTransmitCpltCallback

(+) AbortReceiveCpltCallback
* D# |2 n3 B2 e. I7 b! l7 V% C& ?1 ]
(+) WakeupCallback         
- T2 z# _$ B( Q. t+ X. r# n2 ^
1 O# k; r' s! G3 @(+) RxFifoFullCallback     

2 P) T( R9 O. I2 z(+) TxFifoEmptyCallback     

+ B% c# I( p, l' p/ Y(+) MspInitCallback         

% w& ^( \5 z0 \) H, C, G$ Q3 _0 ](+) MspDeInitCallback   
* ?; ]* O( N6 P' L& o' ~
# m: g! Q, A+ q" C" b1 t

关于动态注册回调函数注意以下几点：
) `. T$ O- }5 |
% Q% e! l6 G, P" K4 K  默认情况下，HAL_UART_Init调用后将使用默认的弱定义回调，如果用户注册了回调，将使用用户设置的。
/ V; j3 f7 m& _2 Q  回调函数只能在HAL_UART_STATE_READY状态下才可以注册/注销。
回调函数MspInit和MspDeInit除外，这两个函数可以在HAL_HRTIM_STATE_READY 或 HAL_HRTIM_STATE_RESET状态下注册，这样的话，用户调用函数HAL_HRTIM_DeInit()或者HAL_HRTIM_Init()时，就可以在其函数内运行MspInit/DeInit。
/ n# {6 t7 a9 n; o% x# n用户可以在调用HAL_HRTIM_DeInit()或者HAL_HRTIM_Init()之前调用HAL_HRTIM_RegisterCallback()为MspInit/MspDeInit注册回调。
65.4 低功耗源文件stm32h7xx_hal_uart.c
! `: B+ ]0 }0 [. x/ d. M& u$ c此文件涉及到的函数较多，这里把几个常用的函数做个说明：
  T" {1 v* j0 n/ U# k
  HAL_UART_Init
  HAL_UART_Transmit
  HAL_UART_Receive
# r- y! N4 P9 y! ]7 g7 `: }  HAL_UART_Transmit_IT
! F' X" a+ L8 v! K7 b6 V' }  n' ^  HAL_UART_Receive_IT
  HAL_UART_Transmit_DMA
  h1 ?7 U5 ]/ d6 S' u& R& _4 k' L  HAL_UART_Receive_DMA


其实V7开发板设计的低功耗串口FIFO驱动文件bsp_lpuart_fifo.c仅用到了函数HAL_UART_Init，其它函数都没有用到，不过这里也为大家做个说明。
: l6 A+ Z# A) c' g& J5 G
65.4.1 函数HAL_UART_Init
2 ~% P- G! M7 ]0 R; z' b函数原型：

1. HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
   / ?" G  K" i) T7 ~3 n4 \& j
2. {
   " f3 ?! Z+ n8 K$ w* d
3. 
   
4.    /* 省略 */
   " Q: ], W0 e7 b6 u# Z  G
5. 
   
6.   if(huart->gState == HAL_UART_STATE_RESET)
   ( g2 y* d; z  _' f* ?
7.   {
   
8.     huart->Lock = HAL_UNLOCKED;
   
9. 
   
10.     /* 初始化硬件: GPIO, CLOCK */
    
11.     HAL_UART_MspInit(huart);
    
12.   }
    2 i+ q7 S  n; c& I- d& r
13. 
    ! o) v  j( g8 f( O
14.   huart->gState = HAL_UART_STATE_BUSY;
    ; Y% H' Q5 B# M# b
15. 
    + S1 W% A; i  W+ S) T6 n
16.   /* 禁止串口 */
    
17.   __HAL_UART_DISABLE(huart);
    
18. 
    ; v: q: {# [- d' K5 j* X" }
19.   /* 配置串口参数 */
    
20.   if (UART_SetConfig(huart) == HAL_ERROR)
    
21.   {
    2 [& Z8 y5 u" t8 ?, m! p; T
22.     return HAL_ERROR;
    
23.   }
      r+ R0 i5 J' Q4 i" L
24. 
    " C: e* Y( x) Y# a
25.    /* 配置串口高级特性 */
    5 g$ o& T; f1 B6 G
26.   if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
    & B& l' P# t0 @3 b# b& u
27.   {
    ) C# e" r/ [4 f/ r3 P& j
28.     UART_AdvFeatureConfig(huart);
    1 n6 ?& F0 W1 q# n* w5 b
29.   }
    2 {2 u! M' O/ J' H5 |0 C
30. 
    7 ?. g" \6 D- e& D: w
31.   /* 清寄存器的一些标志位 */
    : p! G, s5 a- `$ N: D! S' g
32.   CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
    0 [; _# b: m* P, T$ u0 [
33.   CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
    8 |( [6 W" e5 H
34. 
    
35.   /* 使能串口 */
    3 j" a* `! K+ i3 B7 U# Y
36.   __HAL_UART_ENABLE(huart);
    
37. 
    6 s+ e5 Z0 U' T% ^. W
38.   return (UART_CheckIdleState(huart));
    + o- K' M( D/ [' G
39. }
    

复制代码

# B9 S  R/ F4 Z/ g
8 r, E9 A7 v9 g9 a2 f0 h$ B( N函数描述：
3 r5 O6 F7 j9 K
3 H0 u+ v" G1 O/ ?! y3 Z: F! v" Z此函数用于初始化串口的基础特性和高级特性。
; i+ h3 V1 N! i( N8 B4 l" X  z, s
7 @6 E% h+ _  p- v2 k  X函数参数：
9 ~9 X8 p/ T. J; z. d, t+ w4 g6 u
6 F/ S( H) o! Y/ {0 O5 ^. R( L  第1个参数是UART_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
( R. a, h6 x& P' e1 C+ ~+ f注意事项：
( P4 t$ y7 d) F; S# \" }! U/ n6 ]5 W; J
1、函数HAL_UART_MspInit用于初始化USART的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。

3 X& j4 `& }2 g2 U( m0 t2、如果形参huart的结构体成员gState没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量UART_HandleTypeDef UartHandle。

对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_UART_STATE_RESET  = 0x00U。

- T6 b8 o' i/ G( D% ~解决办法有三
7 N; N) X( \; B( j; r# u
* }6 u. t% s% n6 G方法1：用户自己初始串口和涉及到的GPIO等。
% f# Z. L) N& W3 M# s# K. D) T9 N7 N
$ j0 b' |; I9 p; ^1 N方法2：定义UART_HandleTypeDef UartHandle为全局变量。

9 g# ]  |5 R+ K方法3：下面的方法

1. if(HAL_UART_DeInit(&UartHandle) != HAL_OK)

复制代码

) A$ r: ~/ Z2 M  u1 P2 Z9 k. [. D

3、注意串口的中断状态寄存器USART_ISR复位后，TC发送完成状态和RXNE接收状态都被置1，如果用户使能这两个中断前，最好优先清除中断标志。

使用举例：
" c5 w8 g& T* ]- g1 ]" p7 a" H  N6 F
/ H8 ]  @# |! n2 D- w2 m

1. UART_HandleTypeDef UartHandle;
   
2. 
   2 H$ D# L/ H& C4 n; `; H- b
3. /* USART3工作在UART模式 */
   
4. /* 配置如下:
   ) C! n! f; A/ ?7 v$ b
5.   - 数据位 = 8 Bits
   
6.   - 停止位 = 1 bit
   + d& ]  V9 s( C( G( [% b7 \
7.   - 奇偶校验位 = 无
   ; e1 X0 e1 }1 |+ @3 [6 P( H8 @
8.   - 波特率 = 115200bsp
   
9.   - 硬件流控制 (RTS 和 CTS 信号) */
   , C. o+ E; Y% W1 u: P
10. UartHandle.Instance        = USART3;
    2 P  u$ e3 j: g$ d0 [( n2 {
11. 
    6 i  U7 V  ?6 Y. {# R
12. UartHandle.Init.BaudRate     = 115200;
    
13. UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
    - r0 ?! a0 }  K; Z3 V
14. UartHandle.Init.StopBits     = UART_STOPBITS_1;
    
15. UartHandle.Init.Parity       = UART_PARITY_NONE;
    6 a8 r- z; }: m4 ^0 K* g
16. UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
    , z- _8 s5 o4 y8 X7 T
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)
    ( [& P; P# U* e9 `
22. {
    9 c* O/ f( b, t" h! P9 \, y) r
23.     Error_Handler();
    * K7 |. u' P  N( b5 c
24. }
      M0 V: }0 C9 A/ V1 r

复制代码

9 o* ]/ O8 ?. [65.4.2 函数HAL_UART_Transmit
函数原型：
. [6 F1 u  ?2 {9 |1 m( b+ R

1. HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   
2. {
   ; ~' ?. D& f& S* A
3.    /* 省略 */
   
4. 
   
5.   if(huart->gState == HAL_UART_STATE_READY)
   
6.   {
   
7.      /* 省略 */
   
8. 
   ; j- R/ t7 c& ~( E9 N+ S
9.     while(huart->TxXferCount > 0U)
   
10.     {
    7 ~5 N% z, p8 s- s. u( v* O& G
11.       huart->TxXferCount--;
    . X, P8 P; G# O4 b# G
12.       /* 等待发送空中断标志 */
    ' B2 ]9 z* ~& t5 q/ W: U" ^0 v
13.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
    
14.       {
    
15.         return HAL_TIMEOUT;
    . q1 E& r1 }- l8 {" F1 N
16.       }
    7 s) m. s2 z2 h6 w$ T
17. }
    & h, m7 ?, N! \4 Q* m
18. /* 等待发送完成中断 */
    # j) r1 l7 I8 y2 q% H! @4 ?
19.     if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
    
20.     {
    9 |9 l- f7 o  {
21.       return HAL_TIMEOUT;
    
22.     }
    8 ~6 \5 y9 U3 u$ C
23. 
    . s$ y6 w4 t. {3 K
24.     /* 省略 */
    : I" g1 D% K1 @. i1 K3 E  v& T
25.     return HAL_OK;
    8 f- J+ F- i/ N5 s% k& I
26.   }
    1 K4 a- F2 z( [6 _' `2 @% ~  M. M
27.   else
    
28.   {
    
29.     return HAL_BUSY;
    
30.   }
    
31. }

复制代码

0 h: v3 n. Z9 m; t" j
+ p, n* w8 i9 I$ Y  W5 v7 n函数描述：

' c/ j2 t0 ~! |3 o1 ]  b' B8 d此函数以查询的方式发送指定字节。看源码的话，程序里面最重要的就是上面代码中置红的两个标志，发送空标志和发送完成标志。发送空标志表示发送数据寄存器为空，数据还在移位寄存器里面，而发送完成标志表示数据已经从移位寄存器发送出去。
: S1 E+ J0 e3 Z, e/ r9 p$ `8 A9 i
( ]" p7 ~+ O9 h9 Y函数参数：

  第1个参数是UART_HandleTypeDef类型结构体指针变量。
  第2个参数是要发送的数据地址。
  第3个参数是要发送的数据大小，单位字节。
' q. J/ E! f$ A+ m6 ~) N# _( j  第4个参数是溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
使用举例：

1. /*
   * U2 Z+ L9 k* d$ _* S
2. *********************************************************************************************************
   ! X, {( R, }8 z' z. v  W' \
3. *    函 数 名: fputc
   
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   % \- }7 l' ^1 j" J& K6 K. k
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   2 @* Y' V6 B0 ^0 N4 Y" c
9. int fputc(int ch, FILE *f)
   
10. {
    
11.     HAL_UART_Transmit(&UartHandle, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
    - D" U) d1 e  m4 @' W' m
12. 
    
13.     return ch;
      P3 {1 N1 E1 D( H  V
14. }
    

复制代码

. w& s9 M2 @% l; o9 Q" g* Y2 K
0 Z+ K& h2 @, ~' U65.4.3 函数HAL_UART_Receive
% B# Q* n2 _) N1 K1 _) C# V3 g& u  }函数原型：
. ~% A4 ?1 I/ Z$ X' o% K; K7 M
5 q+ M, p6 n% D) z$ Q* t( _

1. HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   
2. {
   
3. 
   
4. /* 省略 */
   
5.   if(huart->RxState == HAL_UART_STATE_READY)
   $ H3 I! u. W5 C% Z* F
6.   {
   & \/ T8 d  \, l& B$ J
7. 
   7 j4 R) [2 J* R7 M1 G* c/ k
8.     /* 省略 */
   
9.     while(huart->RxXferCount > 0U)
   4 P" j2 g3 H/ O& {
10.     {
    
11.       huart->RxXferCount--;
    
12.       if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
    
13.       {
    
14.         return HAL_TIMEOUT;
    
15.       }
    1 K  G9 N* h- t# i
16. 
    
17. 
    
18.     }
    
19.     /* 省略 */
    & m9 t: k' q  b
20.     return HAL_OK;
    5 z4 r, {0 c- N
21.   }
    - J" B) \* w' l. b% T* S2 {3 p
22.   else
      c: K: _& W: Y
23.   {
    + E2 H4 E" l5 w# [% U3 m6 A
24.     /* 省略 */
    ) @$ \% L) w3 N. T
25.     return HAL_BUSY;
    
26.   }
    
27. }

复制代码

/ b! h9 q* T4 a- h1 q
7 [* k; I% P" I* A) z! Y函数描述：
: o  I- A: n/ K% L/ h& J
! K* n" F7 j2 a$ w) \" k3 O+ v此函数以查询的方式接收指定字节。这个函数相对比较好理解，就是等待上面程序中的RXNE标志，置位了表示接收数据寄存器已经存入数据。
( m- C" t7 m7 I) Q
' z! m8 V  _  [- a, u函数参数：
, @7 J% e9 a: _9 S' m0 @7 d
9 Q$ h  m6 a" \; Y) W& s! F  第1个参数是UART_HandleTypeDef类型结构体指针变量。

5 D1 n; l* K9 t5 i) h! E# @  第2个参数是要接收的数据地址。

/ Y+ s7 t0 r: ^2 ~5 l  第3个参数是要接收的数据大小，单位字节。

  第4个参数是溢出时间，单位ms。
2 E0 Y+ Y& F- R' h
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。

' ?1 j9 i4 Z3 f- T& W/ z0 I使用举例：
8 G; z! ^1 p) @" _2 C" q9 Q
  X6 y. o! m# T5 u5 q# f

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: fgetc
   
4. *    功能说明: 重定义getc函数，这样可以使用scanff函数从串口1输入数据
   4 m$ y! ^1 N3 `3 L
5. *    形    参: 无
   $ h4 }4 s# o% p7 [3 k
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. int fgetc(FILE *f)
   . l7 i, J) _& f; ?8 i2 V9 S
10. {
    
11.     int ret;
    
12. 
    1 c# i& ^% v$ P! Y6 I0 E/ W4 w
13.     HAL_UART_Receive(&UartHandle, (uint8_t *)&ret, 1, HAL_MAX_DELAY);
    5 q' I! M: B) r- }# @+ I. F
14. 
    ( u; E, L" V' J0 d* z) b
15.     return ret;
    
16. }
    

复制代码

65.4.4 函数HAL_UART_Transmit_IT
0 z6 B# _' G8 x8 A/ l3 q& Z6 M函数原型：
; o8 X, o9 F8 c: v1 i5 [* k
6 G- Q3 H/ P+ @. A

1. HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   & c/ }9 W3 b" ^& e) F2 s. O
2. {
   
3. 
   4 a. ?, g9 w% {  W1 R
4.   if(huart->gState == HAL_UART_STATE_READY)
   + N+ v" R2 d" ?8 a8 D, H! Z9 W
5.   {
   3 f' R+ i6 o2 f
6.     if((pData == NULL ) || (Size == 0U))
   . j8 I3 r7 k( }  G8 a! a
7.     {
   ( f' L5 ~7 ?$ F# y; y5 O
8.       return HAL_ERROR;
   
9.     }
   % P1 i4 L: A- R3 z. Y' g
10. 
    
11.     __HAL_LOCK(huart);
    + e9 I5 j+ ^6 |' a5 F
12. 
    
13.     huart->pTxBuffPtr = pData;
    
14.     huart->TxXferSize = Size;
    9 O" }% B7 o$ i! f0 \) g  z! A: b
15.     huart->TxXferCount = Size;
    
16. 
    ( A. B( q( K8 y# S. b" g" i
17.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    8 E$ s) G" u7 G- Y
18.     huart->gState = HAL_UART_STATE_BUSY_TX;
    & e3 |: L3 y1 u' D& f1 }
19. 
    
20. 
    4 c$ `" M6 g! j+ {. M# t4 i
21.     __HAL_UNLOCK(huart);
    
22. 
    & b3 }8 m" f3 m# G, g
23.     if (READ_BIT(huart->Instance->CR1, USART_CR1_FIFOEN) != RESET)
    
24. {
    
25.   /* 使能FIFO发送中断 */
    
26.       SET_BIT(huart->Instance->CR3, USART_CR3_TXFTIE);
    6 n  ]" x3 t: s0 Y
27.     }
    , B; m& P/ L9 j: z' K# f
28.     else
      y: P0 W# D8 I4 c% V
29. {
    
30.   /* 使能发空中断 */
    2 c) `) j1 ^- X, O: J. }/ N% U
31.       SET_BIT(huart->Instance->CR1, USART_CR1_TXEIE);
    
32.     }
    : K/ E' c! {& b7 K5 }
33. 
    
34.     return HAL_OK;
    
35.   }
    
36.   else
    
37.   {
    # Z9 E6 j' r! {- \
38.     return HAL_BUSY;
    
39.   }
    + j6 v: L) r# y( R: R, u4 U' j
40. }

复制代码

函数描述：
8 ]/ ~1 q' f$ R/ P8 l) \
此函数以中断的方式发送指定字节，可以选择使能FIFO中断方式或者发送空中断方式。具体数据的发送是在中断处理函数HAL_UART_IRQHandler里面实现。
3 Z; H, M2 l. [8 ?. z1 K
函数参数：

  第1个参数是UART_HandleTypeDef类型结构体指针变量。
  第2个参数是要发送的数据地址。
$ Y( ?# F: F& k- z+ ]* A  第3个参数是要发送的数据大小，单位字节。
  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
使用举例：

+ l* X. D) b8 b! F使用中断方式要使能串口中断，此贴有完整例子：

+ P. Z7 L2 k/ v: M% _. G" ]

1. UART_HandleTypeDef UartHandle;
   1 h; L3 K7 x1 J% P$ R8 \, F, }% a
2. uint8_t s_ucBuf[5];
   ' m/ K- \/ b! w0 \9 J0 M8 B8 S2 D
3. 
   : U6 l8 x& U" J$ W% c
4. /* 数据发送 */
     o$ C- q1 {$ K9 _6 e
5. HAL_UART_Transmit_IT(&UartHandle, s_ucBuf, 1);
   
6. HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)"KEY_DOWN_K1\r\n", 13);

复制代码

) T* J, L/ O; u$ [  ?; ^65.4.5 函数HAL_UART_Receive_IT
函数原型：

- R# _7 M+ A6 R( k7 X

1. HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   7 U5 v" P  m5 ?( D) y2 z
2. {
   % ?5 h5 N) h: @" S% D
3. 
   
4.   if(huart->RxState == HAL_UART_STATE_READY)
   5 l2 v! \0 Z% x! A  s0 ?/ I
5.   {
   6 @$ B& x4 g& V0 h6 u' p+ U! V9 x
6.     if((pData == NULL ) || (Size == 0U))
   
7.     {
   ( X2 Z4 u7 K8 T  f* {1 n) y
8.       return HAL_ERROR;
   
9.     }
   : C0 I, b# N$ o
10. 
    1 z$ @+ T3 F, }/ O7 Y
11.     __HAL_LOCK(huart);
    
12. 
    . V8 ]5 o& {8 a; t5 b  i
13.     huart->pRxBuffPtr = pData;
    
14.     huart->RxXferSize = Size;
    9 W0 O, ]6 S4 V8 `+ u. \  S. A& A: g
15.     huart->RxXferCount = Size;
      K1 g+ P. s# {! ?: l
16. 
    
17.     UART_MASK_COMPUTATION(huart);
    " S1 I4 d6 q( C+ c
18. 
    
19.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    5 O) A6 F+ N) u1 q
20.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    
21. 
    + `5 t  e4 j) D- a5 m
22.     __HAL_UNLOCK(huart);
    . r( {! @1 s9 ]6 V
23. 
    
24.     /* 使能错误中断: (Frame error, noise error, overrun error) */
    ; v) o! d( h4 K6 G. C
25.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    6 U7 ^% Z9 w- m$ a9 r9 f
26. 
    7 j& w8 l5 e+ a7 x8 j& T  ]
27.     if (READ_BIT(huart->Instance->CR1, USART_CR1_FIFOEN) != RESET)
    : P, T3 A: M( X8 _; A
28. {
    9 d- d6 Q9 O. o. f
29.   /* 使能奇偶校验失败中断 */
    9 c4 s: F( i. _4 r6 X- q
30.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    # q: F1 `  s8 H. z  W8 c4 B
31.       /* 使能FIFO接收中断 */
    $ J) l' [. S2 z8 M8 N0 h. Q# Z* P$ ~  |
32.       SET_BIT(huart->Instance->CR3, USART_CR3_RXFTIE);
    + ~! f+ ~0 u5 i3 p5 I+ x/ P
33.     }
    
34.     else
      R! ]$ I; p" b1 u: d
35. {
    
36.   /* 使能奇偶校验失败中断和接收中断 */
    9 k  W+ i$ a2 ?6 g9 [& ^8 u
37.       SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
    1 F( ^: I! k5 c  N$ T6 [$ p
38.     }
    
39. 
    
40.     return HAL_OK;
    
41.   }
    % J" \' ^! j+ U8 n
42.   else
    
43.   {
    ' E" Z& x) X& o  J! g$ Z0 M. |' ~
44.     return HAL_BUSY;
    
45.   }
    0 `$ |4 k, L' ?& l: o8 s
46. }
    : ?; `' A; r1 W% X) `% J

复制代码

/ i1 H5 ?! l# u# m
函数描述：
$ `/ N- g* ?2 ~/ N7 b, C+ K6 m
此函数以中断的方式接收指定字节，可以选择使能FIFO中断方式或者普通中断方式，两种方式使能了奇偶校验中断失败和错误中断。具体数据的接收是在中断处理函数HAL_UART_IRQHandler里面实现。

函数参数：

  第1个参数是UART_HandleTypeDef类型结构体指针变量。
, s" X9 ]) a5 R& P  第2个参数是要接收的数据地址。
7 D* v: }2 ?  ?: t/ J, t  第3个参数是要接收的数据大小，单位字节。
: }! T. D# J1 Y  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
使用举例：

使用中断方式要使能串口中断，此贴有完整例子：

( r% a. f# G  T2 Q+ ~7 h

1. <span style="background-color: rgb(255, 255, 255);">UART_HandleTypeDef UartHandle;</span>

复制代码

) ]4 y) y' K' s; u3 ~+ Y65.4.6 函数HAL_UART_Transmit_DMA
函数原型：
7 J) u  a6 \5 P0 o4 U
: J1 ~8 Y& {4 a$ ?8 P

1. HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   
2. {
   
3.   if(huart->gState == HAL_UART_STATE_READY)
   6 w- i  j; G2 X
4.   {
   
5.     if((pData == NULL ) || (Size == 0U))
   
6.     {
   2 e7 F: b9 Y) c
7.       return HAL_ERROR;
   
8.     }
   
9. 
   + w3 s# _- T6 q+ u
10.     __HAL_LOCK(huart);
    6 n. Z4 a2 ]$ k; M# I
11. 
    ( i" S' X: I9 b; O
12.     huart->pTxBuffPtr = pData;
    
13.     huart->TxXferSize = Size;
    
14.     huart->TxXferCount = Size;
    
15. 
    
16.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    ( w, ]7 y% C* W( e/ \$ G8 M+ w
17.     huart->gState = HAL_UART_STATE_BUSY_TX;
    
18. 
    ) u5 k' s( e! N+ [* o# K3 M
19.     /* 注册各种DMA回调函数 */
    
20.     huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;
    # I2 z# R1 f( H. [4 G; \
21.     huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;
    
22.     huart->hdmatx->XferErrorCallback = UART_DMAError;
    * G1 R4 Z" I% T4 c3 {4 Y8 d
23.     huart->hdmatx->XferAbortCallback = NULL;
    9 Z. Z0 r: x( o3 d
24. 
    ! L% j4 K5 f! @+ {6 A* `
25.     /* 使能串口发送DMA通道 */
    
26.     HAL_DMA_Start_IT(huart->hdmatx, (uint32_t)huart->pTxBuffPtr, (uint32_t)&huart->Instance->TDR, Size);
    
27. 
    
28.     /* 清除传输TC完成标志 */
    0 |; y+ N, d5 I2 X
29.     __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);
    
30. 
    , x. p6 f# ^2 z) H: y
31.     __HAL_UNLOCK(huart);
    
32. 
    & p0 n. M8 _1 P0 C& {
33.     /* 使能串口发送DMA传输 */
    
34.     SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);
    
35. 
    
36.     return HAL_OK;
    * S: s/ c0 [# ~) u9 L) g8 s* I' ]6 ~
37.   }
    
38.   else
    ' z( \& R6 f) e) O6 v+ o" a
39.   {
    
40.     return HAL_BUSY;
    4 W! G* J& @- ]& i; @2 r# f0 e
41.   }
    
42. }

复制代码

函数描述：

$ s) }* S7 G8 q' f' Z* m8 V此函数以DMA的方式发送指定字节。这里是用的DMA中断方式HAL_DMA_Start_IT进行的发送。所以使用此函数的话，不要忘了写DMA中断服务程序。而且DMA的配置也是需要用户实现的，可以直接在函数HAL_UART_MspInit里面实现，也可以放在其它位置。
7 }0 _! X& S/ e
( F7 b$ Z! `) V& ?5 Q; Y9 o  d" l函数参数：
! c8 N  b: D; Y# ]" W
  第1个参数是UART_HandleTypeDef类型结构体指针变量。
8 o. p  f5 L, s; E" C7 f  第2个参数是要发送的数据地址。
7 R6 d7 g1 G8 T% C  第3个参数是要发送的数据大小，单位字节。
' T& L3 e9 Y: H; i' i* D/ `! ?/ N  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
使用举例：
  y0 I- a! {+ s1 k7 ?7 v! t, W
65.4.7 函数HAL_UART_Receive_DMA
: L$ c  W! s1 _+ M( P) V! F; }$ M函数原型：
% g: n+ w5 ]2 l" ]7 V
9 y8 N, G) A2 l- {+ w7 r

1. HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
   
2. {
   $ p$ \4 S0 }/ }& {" |, w! H
3.   if(huart->RxState == HAL_UART_STATE_READY)
   0 k* A/ u3 y$ T: i+ X7 j# J/ }! d
4.   {
   
5.     if((pData == NULL ) || (Size == 0U))
   . |4 r  A3 v" c# u- ~5 M- N1 K
6.     {
   
7.       return HAL_ERROR;
   
8.     }
   1 [( n) y  }7 V2 j* Y
9. 
   
10.     __HAL_LOCK(huart);
    # P; g; v0 {" g! m% }" e4 v
11. 
    
12.     huart->pRxBuffPtr = pData;
    
13.     huart->RxXferSize = Size;
    
14. 
    + a/ p% }9 ^" q% d) D2 ?
15.     huart->ErrorCode = HAL_UART_ERROR_NONE;
    ) R! o2 _& L& i: p6 a$ e& h+ u
16.     huart->RxState = HAL_UART_STATE_BUSY_RX;
    ' Z" ^: e% [0 o$ y" P, @5 y
17. 
    
18.     /* 注册各种DMA回调函数 */
    & O9 Z* p( J9 k. c; n5 j
19.     huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;
    ) c  W4 M4 J$ {6 J. U
20. 
    7 N  |$ Y/ t# N" ]6 F
21.     huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;
    8 [0 ^3 z/ D+ H3 d5 e
22.     huart->hdmarx->XferErrorCallback = UART_DMAError;
    
23. huart->hdmarx->XferAbortCallback = NULL;
    1 D) O0 D& }- F) n( X' D
24. 
    
25. /* 使能串口接收DMA通道 */
    
26.     HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->RDR, (uint32_t)huart->pRxBuffPtr, Size);
    : k3 p- F6 V  s- ?
27. 
    
28.     __HAL_UNLOCK(huart);
    7 F. a* D" i& P  E5 E
29. 
    ! z/ ~: `/ j6 M- l, t. B4 d
30.     /* 使能串口校验错误中断 */
    8 ]: s- p+ m5 [+ P3 J4 @6 K
31.     SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    
32. 
    " C0 ~, A: n# w2 R$ ^6 T! }  d6 H
33.     /* 使能串口错误中断:(Frame error, noise error, overrun error) */
    
34.     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
    
35. 
    
36.     /* 使能串口接收DMA传输 */
    
37.     SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);
    
38. 
    
39.     return HAL_OK;
    7 L" |& K, n8 ]" R; p( b% Y  s
40.   }
    
41.   else
    & f9 H7 u9 Z& Z* f0 ~) w
42.   {
    # r' \: A, t0 v
43.     return HAL_BUSY;
    ! ?- |  G2 A- f* f
44.   }
    
45. }
      O- ]7 ?8 ?: S

复制代码

函数描述：
, x2 w* p; O* y# H
/ z9 N4 q) C! |( ^( I: _4 R此函数以DMA的方式接收指定字节。这里是用的DMA中断方式HAL_DMA_Start_IT进行的接收。所以使用此函数的话，不要忘了写DMA中断服务程序。而且DMA的配置也是需要用户实现的，可以直接在函数HAL_UART_MspInit里面实现，也可以放在其它位置。

+ N3 A" X; Q. E- A; c: L7 y; l/ d函数参数：

  第1个参数是UART_HandleTypeDef类型结构体指针变量。
1 {  S# L' A2 Y- a% }2 Y9 Q  第2个参数是要接收的数据地址。
, _/ [' v9 G. B  第3个参数是要接收的数据大小，单位字节。
! L$ j# D! c# h% Z/ U  返回值，返回HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示串口忙，正在使用中。
2 t2 D8 f9 T1 {- i) x  M
8 ^# r  n' u. y2 a8 ]65.5 总结
* Z( }1 y4 E$ N7 K; U# {本章节就为大家讲解这么多，涉及到的知识点和API函数比较多，需要花点时间消化，后面用到的多了，就可以熟练掌握了。

+ P# }+ V1 G0 J! K, }5 I3 Z

) P2 [- n/ z0 I* d( F; T5 W9 Q