66.1 初学者重要提示
3 P: n( z: T  p7 ?* u- @: r  学习本章节前，务必优先学习第65章。
  低功耗串口FIFO的实现跟前面章节通用串口FIFO的机制是一样的。
  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
66.2 硬件设计
STM32H743XIH6最多可以支持8个独立的通用串口和一个低功耗串口LPUART1。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

低功耗串口LPUART TX = PA9，   RX = PA10

串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）

串口USART2  TX = PA2，   RX = PA3
: g8 f1 L2 n7 v4 V. [4 W, N) n. T- i
3 O7 k+ N+ M) ~2 P8 s5 s串口USART3  TX = PB10，  RX = PB11
$ n* _" N  }. G+ x; g$ A
9 w: G! h9 [7 u( A$ K5 e串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
6 F/ Q& [+ {; z  v$ h& b
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）

9 v- _" j0 c  Y串口USART6  TX = PG14，  RX = PC7  
" ^  E, ~" O  E  B' D$ T
5 D& n6 T. ~7 c/ y# E串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
+ R$ X, n2 }" q: P3 j' ?
$ v6 |' a, {% m串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

$ F! h( O) W, jSTM32-V7开发板使用了4个串口设备。

/ J$ U& ]( f- c0 M: w2 h/ s( I  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
# Q8 L1 {6 m  F+ K& l6 B  串口3用于RS485接口
9 }! _' V9 v" T" `' q  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
9 L2 A2 y1 \# {* x# Z

4 {4 t+ R- k7 P9 D) ~
关于232的PHY芯片SP3232E要注意以下几个问题：

  SP3232E的作用是TTL电平转RS232电平。
* ^0 V. i4 L5 j4 k- a1 C" x2 r  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
8 g$ v/ Y& s5 N6 `  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
" b$ P7 s/ \# `

实际效果如下：

% l! b% k0 t8 x  ~

$ }: B. v  `! H) Q通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY
& ^) j2 n/ ]( q5 U/ f  `) m
4 X9 j: n* I; q3 t1 y芯片是否有问题。
" y; S9 F! x% _( g2 k
  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
66.3 低功耗串口FIFO驱动设计
+ u$ J( q% h0 W66.3.1 低功耗串口FIFO框架
为了方便大家理解，先来看下低功耗串口FIFO的实现框图：
2 ?( l3 a1 p0 I8 B) f3 g- d

4 i" w$ G7 Z/ U" P8 @% A2 y
9 j( G+ F" r, R% R- F9 ^: H" _9 A  第1阶段，初始化：

通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
  第2阶段，低功耗串口中断服务程序：
# z1 y3 {. A) ^' I# A' v: M
  接收中断是一直开启的。
2 V. e+ D6 Q7 e  做了发送空中断和发送完成中断的消息处理。
  第3阶段，低功耗串口数据的收发：
( D3 t$ a8 a- E' u) v3 V1 F% }
/ Q; I" D# U4 d0 A" V% R低功耗串口发送函数会开启发送空中断。
: W: {" B" r  ~. W/ L3 h8 Z0 x低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
66.3.2 低功耗串口时钟选择
我们这里实现了三种时钟选择：
4 L% D1 F# M2 k! D- Y( g% X6 o/ Q* @
( N: u% y" R; C0 T0 @3 XLPUART时钟选择LSE(32768Hz)
8 _. F& E& A) k# E3 j最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。

LPUART时钟选择HSI(64MHz)
最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。
( Y1 b5 S" i6 e) \8 [9 x
LPUART时钟选择D3PCLK1(100MHz)
" q# Z7 ^  g# c: [最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。
6 _+ o7 t1 T* a/ r" G& B; ?8 {
如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，程序代码如下，用户可以根据需要，使能相应的宏定义：

1. //#define LPUART_CLOCK_SOURCE_LSE      
   
2. #define LPUART_CLOCK_SOURCE_HSI   
   ' k1 C; X/ I4 y
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   . [* |# ?, B8 N* f
4. 
   
5. /*
   0 V% k2 f) w0 G% o) W7 t
6. *********************************************************************************************************
   2 f& w. Q. V, P1 C
7. *    函 数 名: InitHardLPUart
   ) P+ N4 X/ f1 _$ T) \0 p+ E
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   
9. *    形    参: 无
   5 C6 e9 I+ S2 Q' @* g5 j
10. *    返 回 值: 无
    
11. *********************************************************************************************************
    
12. */
    : |, G; j' z( z4 f% d5 \
13. static void InitHardLPUart(void)
    - B+ h& ?: F% f1 [" d
14. {
    # E! T7 t: n3 ?" d; L4 g
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    % R9 O6 N& x4 W& v) e; d$ v
17. 
    % Q8 o0 t4 M2 e7 C
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    
20.     {
    / ~& R5 G: x$ p8 m  b+ z" H
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
22. 
    * r0 p3 [4 R) n# V1 w
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    ) G, t6 v  x% s5 A$ D: e
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    0 {) P$ _) Y* d4 L, u/ h
26. 
    ( }" M2 @4 p  V1 a" i! i
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
28.         {
    5 z' c+ m5 X- v5 L* O, U
29.             Error_Handler(__FILE__, __LINE__);        
    
30.         }
    
31. 
    
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    ( w: K; F" g' t8 l
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    - B7 c' m! k" C6 n& X1 R
38.     {
    * W* y' q, v$ u0 j/ e1 g5 i7 Y
39. 
    5 |/ N6 E: R1 u
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    " _) O, Z6 g9 N
41. 
    
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    , E# I( ^! }/ b& m* b3 g# V% B
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    1 H' q' i6 O8 }! e6 V
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    
46. 
    
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
48.         {
    9 \5 s7 l7 e! a8 n
49.             Error_Handler(__FILE__, __LINE__);        
    
50.         }
    & l" l6 s( Y2 K+ s+ m- ?
51. 
    
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    ! t, I; Q# T: V
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    9 ^. K  O* V7 Q- A& o
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    . \7 P) n+ }( D& O$ q, z- U
55.     }
    6 r) |. E' a6 o3 [+ N# H3 d
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    
58. 
    * a. V  X3 m+ c
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    8 X( s! P$ E4 C9 c
62. #else
    . U+ k& Y- M& e/ M& u7 B2 d3 u) C( y
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    
65. 
    
66. #if LPUART1_FIFO_EN ==
    8 o; ?8 ?: h( r5 a  o- V
67.     /* 其它省略未写 */
    & [7 {, ]* U- U, Z
68. #endif
    
69. }

复制代码

$ d. H5 R, k* w66.3.3 低功耗串口FIFO之相关的变量定义
低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。

5 a9 ]  |' ^* v1 f6 o这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。

$ h/ C5 |0 q1 T0 i2 m) B# r( w! Z: F+ w每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

7 D* j. \: n/ k( I我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   0 g, K% w! _) b) o0 r7 E3 U- L
2. #if LPUART1_FIFO_EN == 1
   $ P, r, P5 L/ r( w- e
3.     #define LPUART1_BAUD         115200
   , f$ O/ U( o$ X2 o7 C0 d
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   8 j8 v6 T# p, ~( F7 Q$ r
6. #endif
   
7. 
   + F. ^+ A8 C6 Z- D6 m
8. /* 串口设备结构体 */
   
9. typedef struct
   2 Q: V6 G* H1 f- d$ x6 L
10. {
    8 m3 |+ Q( e  o9 }6 f8 X; s' m
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    # v5 @! J, e- I- b3 o' t
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    + ]: \; b* |/ [# `2 h6 ?
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    5 `$ a. ]- ^8 r1 U
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    % y* b# ~# _# m9 {8 O
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    7 d" U6 f$ [: [& @; W+ T
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    
19. 
    9 O. x2 D0 }! O
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    
23. 
    6 Z) s) M0 i6 K5 `' q7 D( N
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    7 m  \3 |% F$ Q# J/ X
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    / [& r- L8 t( S( }% S; ~
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    0 P4 H6 z* l% {( v* b! i! t/ {
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    ! T5 m: y# \) @- W. W7 ^/ B2 m
29. 
    # Y' |% R# u# [9 Z2 e
30. 
    # m  t9 G1 {4 t7 D3 \
31. bsp_lpuart_fifo.c文件定义变量。
    * }. j/ n6 d5 @& N1 o& E1 k$ ]
32. 
    8 a( U3 e* `# e8 d. W
33. /* 定义低功耗串口结构体变量 */
    
34. #if LPUART1_FIFO_EN == 1
    
35.     static LPUART_T g_tLPUart1;
    
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    ' i  L( p9 J- M! X- v
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    $ N  q, q5 h: |4 |
38. #endif
    

复制代码

2 E; }( p- P$ i" X( w) M% l
关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
' `" S# z+ K9 v( e, X& h$ ?
6 V5 c# k- M# S& S66.3.4 低功耗串口FIFO初始化
3 |0 |  X1 W7 q. X: g* p低功耗串口的初始化代码如下；

/ k0 L  B. O# `! s/*
*********************************************************************************************************
- T! N7 Z. r" i% g8 c*    函 数 名: bsp_InitLPUart
*    功能说明: 初始化串口硬件，并对全局变量赋初值.
- Y, `( @. Y+ {  u*    形    参: 无
) i8 ]: y1 L, x; n; x+ Q$ j*    返 回 值: 无
*********************************************************************************************************
*/
5 L6 W* T* e+ N8 S  M! [  ovoid bsp_InitLPUart(void)
/ q' s: }( R$ @7 {% x2 F' o0 _( A- Z/ i{
    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
$ h" l$ X" |' p, Q) R    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
}
8 }6 ?. \4 U0 z+ }; e. ?
/ t7 J# K5 j8 t. [4 [' H$ J
下面将初始化代码实现的功能依次为大家做个说明。
5 O; t  V* @6 m) a0 {2 P2 Q# B
1 V  _5 B; W- K" D4 ]  i4 f' [  函数LPUartVarInit
( e) H/ G/ _5 q7 V# _. X这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

1. /*
   * P# I  w6 h* c: x: J# C
2. *********************************************************************************************************
   - m" |! i% u4 x1 d
3. *    函 数 名: LPUartVarInit
   # G4 T) {* L* {0 Y3 z/ D
4. *    功能说明: 初始化串口相关的变量
   1 q% S6 I) u- a2 B
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void LPUartVarInit(void)
   
10. {
    7 t; Q4 F/ w& J( S! e( _: ^' z
11. #if LPUART1_FIFO_EN == 1
    - ]9 M- i& S2 @- s7 Y' D# \! @- u
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    ) r' v, S, O9 T
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    ( m, a' X1 f  z
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    . T# }0 u1 B6 j; M- C; I* K
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    1 r3 i" d3 k" d
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    $ }1 b! r0 H* }" s$ q2 K% y8 i
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    3 r8 A3 W; w  J, o. S0 P. }
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    & W# ]8 I/ ~0 v* v0 n( D
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    
27. #endif
    1 i1 q& z6 G7 l  Q$ x# n; q/ d& h
28. }

复制代码

0 H$ k6 y; j# z" C' u% y$ [  函数InitHardLPUart
+ A( t1 `3 ]) o) F( O- G此函数主要用于串口的GPIO，中断和相关参数的配置。

1. /* LPUART1的GPIO  PA9, PA10 */
   3 E) b( r9 y8 d& y
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   
3. 
   # O% f5 O9 j  K2 B$ s# c  z% A
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   * x" i1 W1 ^/ f0 M: a5 ^8 b; h  j
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   
8. 
   
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    # c7 x1 \: K: ?6 s$ R) v1 R: }8 h: X
13. 
    & [, l* T* Q8 V9 b7 t
14. /*
    % v7 Q& a$ ^/ p: N
15. *********************************************************************************************************
    - M1 j4 d. h' I. l# r1 R
16. *    函 数 名: InitHardUart
    
17. *    功能说明: 配置串口的硬件参数和底层
    3 r7 r* A: i2 L5 c2 l+ P; w3 g
18. *    形    参: 无
    
19. *    返 回 值: 无
    & X: e: t) v" ~) Z
20. *********************************************************************************************************
    
21. */
    
22. static void InitHardUart(void)
    ) r! R) `8 W- q( c
23. {
    
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
26. 
    
27.     /* 时钟初始化省略未写 */
    
28. #if LPUART1_FIFO_EN == 1        
    6 F) H0 k5 E7 ^# N* i& v7 z& e5 O- G
29.     /* 使能 GPIO TX/RX 时钟 */
    , P8 l/ |) f3 `; G0 _7 V, q
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    ; g6 Z* s' r) K
32. 
    
33.     /* 使能 USARTx 时钟 */
    / g6 Q" a* i6 Y9 N' `: y
34.     LPUART1_CLK_ENABLE();   
    * q/ E8 @" h1 l% @5 \9 ^7 |, @
35. 
    4 x# Y( X; ~' t- L. T8 D' ^
36.     /* 配置TX引脚 */
    
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    , B+ A! J" w0 z
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    " t  i" Y) a4 u/ V$ m3 i
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    & m% l: P4 `! g+ y
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    ; L! O& A% k; E, J2 {% u9 _* f
43. 
    ; {* t4 E, n: X  K% g+ o+ F% D
44.     /* 配置RX引脚 */
    
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    ' }4 O8 B" ~$ Q7 f# A% g
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    / b3 ], ^0 F2 U4 E# E. e$ _1 n
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
48. 
    3 m: ~5 K( R) {' r% v. `' R
49.     /* 配置NVIC the NVIC for UART */   
    
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    ; w3 D4 J* L1 c, l$ O# g& u/ l( y+ B
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    ( Q7 w: D" u8 {6 b+ J, D+ i
52. 
    
53.     /* 配置波特率、奇偶校验 */
    , r0 _+ P3 F' j7 T3 G
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
55. 
    9 V, h$ x0 s" k0 L. ]7 l% Z% n
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    0 ]+ H. p, r% E7 ]; y
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    & u5 n% D# }% ^1 K: X* A/ R
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
59. #endif
    ; x8 D# m3 I; m- Q
60. }

复制代码

' t. I0 X& ?1 y0 Y( T. h. `低功耗定时器的参数配置API如下：

1 t$ O" e: r* I5 u7 l6 f+ v

1. /*
   # O8 X6 U. T8 e# x, B
2. *********************************************************************************************************
   0 t, e% T" K4 O2 L$ }
3. *    函 数 名: bsp_SetLPUartParam
   ! V$ q) @" a+ o) U8 j0 _
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   4 ?* c/ \* Z7 G- b& }8 Z
5. *    形    参: Instance   USART_TypeDef类型结构体
   6 b0 z/ {) T# A# ]
6. *             BaudRate   波特率
   ' n7 E% E$ A; d: |8 @1 P; a
7. *             Parity     校验类型，奇校验或者偶校验
   ' P0 k! j7 A: c0 }; S( f
8. *             Mode       发送和接收模式使能
   $ w/ M) R! ~: \) S+ R$ |5 T+ |
9. *    返 回 值: 无
   
10. *********************************************************************************************************
    2 d8 x3 N3 o  ?, L" ^- f: h, A# ]
11. */   
    * O* m4 ~; a1 }+ `' g
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    3 e, c' X' d$ i
14.     /*##-1- 配置串口硬件参数 ######################################*/
    
15.     /* 异步串口模式 (UART Mode) */
    * [# b( k" c1 L. y, L" |0 T
16.     /* 配置如下:
    / E3 s2 u4 u! Q% Q6 b
17.       - 字长    = 8 位
    
18.       - 停止位  = 1 个停止位
    
19.       - 校验    = 参数Parity
    
20.       - 波特率  = 参数BaudRate
    ' Z) g5 ^6 _/ r, l
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    4 `, k! H* H+ b) }+ Z! Q' g
22. 
    8 U+ W2 V5 I) O) d' |0 D) {2 m
23.     UartHandle.Instance        = Instance;
    6 {# ~% n$ Q9 s: X6 c! k
24.     UartHandle.Init.BaudRate   = BaudRate;
    ; f7 Q$ v2 Z( U; j6 M2 d/ A$ G( D- \
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
27.     UartHandle.Init.Parity     = Parity;
    
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    " k. {; H! b. S: s$ `( Y
29.     UartHandle.Init.Mode       = Mode;
    " D- \" k6 K3 a  \* l# v
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    - K& a$ q" w% y1 b( }. X
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
33. 
    
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    & M+ K0 \7 @( {+ X9 t: f% P1 I9 P# |9 O
35.     {
    4 C5 C4 C, v6 ]$ f) M
36.         Error_Handler(__FILE__, __LINE__);
    
37.     }
    - ^) w' K  q: B/ ]& Q# n0 y
38. }

复制代码

% n7 n- M6 A. A  d& S8 d$ m5 b; V' |
# }0 e" _2 f6 l; i6 T
/ C- X7 R; _7 h3 K4 v4 t66.3.5 低功耗串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能
- A; l4 u; U+ J" o6 E7 m3 n# e
  收到新的数据后，会将数据压入RX_FIFO。
1 X& ?6 ]8 j2 I  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。


下面我们分析一下串口中断处理的完整过程。
. A, X% M9 O" T& ^
当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
& N1 d4 w* D" N- J
我们将串口中断服务程序放在bsp_lpuart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_lpuart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是低功耗串口的中断服务程序：

1. #if LPUART1_FIFO_EN == 1
     g# e) @# q% g4 _2 N. ~
2. void LPUART1_IRQHandler(void)
   ) R6 O) _# t4 V1 }- E3 N
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   
5. }
   . q2 o3 I" A# M( H
6. #endif

复制代码

. I: p; ~2 @  ^& \1 a下面，我们来看看UartIRQ函数的实现代码。

4 Q# c6 d( \" }) j

1. /*
   
2. *********************************************************************************************************
   + V, l( n; T- N$ h* C% j
3. *    函 数 名: UartIRQ
   
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   5 O. F4 F1 Z, B2 W6 J
5. *    形    参: _pUart : 串口设备
   # F0 S! M+ \$ u4 @8 w
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ! R- R  P* _( k4 N, l/ H2 k
8. */
   & U7 O$ ^; J8 G* p, Z1 x
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    8 P) [8 Y  o+ \8 I
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14. 
    % b6 ~+ G, i% w3 z7 z9 e% a8 V
15.     /* 处理接收中断  */
    . b3 v2 \  _  i5 R5 \3 e
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    . \2 x- F9 ^; [5 P# U4 @0 x+ j0 @
17.     {
    
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
    , x3 c' @% s+ H- X: D2 X
20. 
    6 l) w9 `. A$ I
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
      u! d2 [( |! z3 k$ Z: ^
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    " M# c0 g7 f: O) y- x: }
24.         {
    
25.             _pUart->usRxWrite = 0;
    
26.         }
    
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    % i+ L  @* G$ n( q3 T. g% f
28.         {
    0 H8 z8 q$ t' d3 T  O
29.             _pUart->usRxCount++;
    6 w  _3 Y- h- K! t( D2 X
30.         }
    
31. 
    
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.         //if (_pUart->usRxCount == 1)
    
35.         {
    0 r9 q! y5 O2 l
36.             if (_pUart->ReciveNew)
    
37.             {
    , x2 @4 D" [. @% ^
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    ; t3 c) e0 o* w/ G  T% L/ w  o
39.             }
    
40.         }
    2 [9 [# j8 o& t- W4 l# f
41.     }
    
42. 
    5 I! c. A5 J' f7 V! k
43.     /* 处理发送缓冲区空中断 */
    6 Q$ P, g4 j0 n* r) B3 p
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    * s2 s6 d2 V$ @8 k0 \' g1 E
45.     {
    
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    / f) H, s+ ~3 G. r( i
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    0 B" T4 Q  ?$ O* d  l, M1 h* T) Y
53.             /* 使能数据发送完毕中断 */
    
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    , y2 p$ M# ^7 V; k* E/ f
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    - h( e& m: m& h# m
56.         }
    
57.         Else  /*　还有数据等待发送 */
    $ K, O0 t: x" |7 A5 E
58.         {
    
59.             _pUart->Sending = 1;
    
60. 
      K( C' @# _! Z0 h9 B
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    . ?+ o( J% N; n# |2 u& V; C6 `5 n
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    , w% K8 ^5 ^4 X9 M1 K4 \
65.             {
    4 ?- w1 d$ d3 C  ~& j/ N
66.                 _pUart->usTxRead = 0;
    
67.             }
    
68.             _pUart->usTxCount--;
    
69.         }
    
70. 
    
71.     }
    
72.     /* 数据bit位全部发送完毕的中断 */
    . b/ o- S5 z8 M; E4 k, Y
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    . @& ~  v3 M, y! e
74.     {
    
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    6 r, W' x0 a7 m5 }
76.         if (_pUart->usTxCount == 0)
    
77.         {
    ! s' k% P: I" {
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    : j$ U4 N" H  ^+ ~3 c/ J
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    + o# G7 _) `5 Q6 u
81. 
    
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    % {, P; ?9 u# U5 t9 [6 Z, Z3 ?
83.             if (_pUart->SendOver)
    " |) M+ p* h8 G7 S# o$ b7 I
84.             {
    
85.                 _pUart->SendOver();
    6 g. `# ^9 o1 C2 z
86.             }
    * ~9 x! {$ v1 k9 p% ?
87. 
    8 s3 E) g9 n; m
88.             _pUart->Sending = 0;
    
89.         }
    5 t& \- c3 z' N& m/ q4 M: }
90.         else
    6 }6 a! g5 k# F3 @+ ~4 n2 a! I) N
91.         {
    . x1 t# R/ v+ ?# r$ q
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    9 l4 P/ J5 |7 L
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    $ M6 {! ]: M0 _- l7 O
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.             {
    
99.                 _pUart->usTxRead = 0;
    . t/ \  I4 `  ~6 D0 n& A& `
100.             }
     ( q$ G8 S2 T5 o9 w2 i9 |# P( [) q
101.             _pUart->usTxCount--;
     6 B/ V) U$ k3 b* q, E+ z) G) k
102.         }
     
103.     }
     2 L) \7 A; ^9 _' g9 Q
104. 
     
105.     /* 清除中断标志 */
     * K7 J# G$ m$ e" W# }' U
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     - `1 N( h9 i" e* S6 U& i
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     # E: t7 H9 \2 @- K2 |3 M
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     9 J& A, u$ f3 O. Q! A. [4 a! g
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     ( D, m; b3 q8 p( p% O
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     , K& B' i+ b( w1 ?, l; L7 W
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     9 J$ ^% u3 ?1 M* G* x( b/ x2 m
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     6 J* J$ t0 e' [$ ^: ^
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     
117. }

复制代码

6 }! K/ Y+ \. b- g& c中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。

0 k, y+ H4 v/ |' Z& H$ c  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。

特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

5 m4 h: ^, d& K7 d% D& f  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

66.3.6 低功耗串口数据发送
低功耗串口数据的发送主要涉及到下面三个函数：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: lpcomSendBuf
   
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   ( j5 ]* i5 J( W
6. *              _ucaBuf: 待发送的数据缓冲区
   0 \4 w- X7 E8 `5 n6 R: u- V& K
7. *              _usLen : 数据长度
   - A4 d4 @! n2 M0 g  z# ~, X
8. *    返 回 值: 无
   ! O  L! Q  r- O+ p
9. *********************************************************************************************************
   
10. */
    
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    1 X: ]7 f* P# k" R& y# q
12. {
    2 x, }  U" H  r0 s# j1 D+ q! ^
13.     LPUART_T *pUart;
    ! F- h& |$ R; [; b. R1 ^! H8 ~
14. 
    
15.     pUart = ComToLPUart(_ucPort);
    
16.     if (pUart == 0)
    
17.     {
    
18.         return;
    $ D* c( l; A+ d3 ]& r
19.     }
    
20. 
    
21.     if (pUart->SendBefor != 0)
    
22.     {
    " ^% l* A# t3 k/ i
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    : \5 t' t: U8 u  `
24.     }
      Z: A" w. ?4 x" k7 ^" n
25. 
    / H2 Z/ `  X4 F3 F; l7 b+ T) @
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    
27. }
    & F) ?( n) k# ^9 ~0 p9 Q
28. 
    1 E9 C; U; c) O, \# s. F
29. /*
    
30. *********************************************************************************************************
    
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    ( ]5 u7 ^6 N4 D: T, D! I
33. *    形    参: _ucPort: 端口号(LPCOM1)
    
34. *              _ucByte: 待发送的数据
    
35. *    返 回 值: 无
    0 }, Y5 t) L. U6 g: q  b+ y
36. *********************************************************************************************************
    8 e7 f- |1 F" P7 p( j1 y& |" a
37. */
    
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    4 v& i) G+ R7 J( K2 y3 ]0 e
39. {
    & [, e, Y5 j/ C3 m# `- r8 R' D" z$ j) J
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    5 T; |( G6 J7 S+ \; O
41. }
    2 J$ I4 P* S5 N- X3 q
42. 
    9 z) U! b- J% u6 G
43. /*
    : m4 Z: S  ?. s9 k9 g6 e" a( Y3 {
44. *********************************************************************************************************
    1 l, p& V6 ?9 D. M2 V
45. *    函 数 名: LPUartSend
    
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
47. *    形    参: 无
    2 ~) S/ E0 f* K* q' h! p
48. *    返 回 值: 无
    
49. *********************************************************************************************************
    
50. */
    2 d  @5 T+ Y% y6 a3 N
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    3 U; J; Q- {) u' d: H. z& p
52. {
    
53.     uint16_t i;
    # ^; K' X- ^; _) N# S4 D/ i
54. 
    
55.     for (i = 0; i < _usLen; i++)
    ) E3 z( w) `2 g7 `
56.     {
    . L/ U" C9 m( E0 g# _7 \( w! g
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    5 W7 _8 k: K7 E" f& l
58.         while (1)
    
59.         {
    
60.             __IO uint16_t usCount;
    
61. 
    
62.             DISABLE_INT();
    8 f1 S! @9 ^2 {- `6 |/ f
63.             usCount = _pUart->usTxCount;
    5 Z2 r3 y0 s  f! X* u" I+ N
64.             ENABLE_INT();
      I( {/ j3 p0 [0 j" m5 r# @( l! n
65. 
    
66.             if (usCount < _pUart->usTxBufSize)
    7 ?% X& A+ Y0 M" E
67.             {
    
68.                 break;
    
69.             }
    & o% S3 K, |1 b5 k/ R
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
71.             {
    . @9 ?+ T, P! [/ e, g: E
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    : q2 x% f" Q5 {
73.                 {
    
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
75.                 }  
    
76.             }
    
77.         }
    / n4 @- d/ l. Q* c
78. 
    
79.         /* 将新数据填入发送缓冲区 */
    4 [1 _1 J2 w0 I9 V' {
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    
81. 
    / F0 l$ j* r- {- c* m2 ^. P1 M. w. z
82.         DISABLE_INT();
    % }) I  m0 e) A$ L) d
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    ; F. a: ~, _* O0 t! D! H
84.         {
    + q4 K' g6 a8 ^
85.             _pUart->usTxWrite = 0;
    
86.         }
    + a3 r; _* z7 F7 Q
87.         _pUart->usTxCount++;
    
88.         ENABLE_INT();
    $ f0 Z" w* X* p& y% N# \8 w
89.     }
    4 D2 ]6 L3 H( n
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    % Y5 V) c- I- y; e, K+ o+ g3 k/ i
92. }

复制代码

& A* H" W% g- L; v函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。

函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

# ?( w2 v5 k$ M7 b7 d' ~0 d  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
1 p% h, u( C2 H$ K( N  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
' e- _5 N# D! R& ?
注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。

4 [1 |: q( p; l# @3 g函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。
' k6 ~' t+ ^' m( \( b
, ~; Q# V  X" F6 ^

1. /*
   7 _1 B8 d# H  R3 R9 p
2. *********************************************************************************************************
   8 p4 w. {9 `& g+ T/ x: g6 @
3. *    函 数 名: ComToLPUart
   
4. *    功能说明: 将COM端口号转换为LPUART指针
   + q0 O; ?1 K/ y, P* q5 t
5. *    形    参: _ucPort: 端口号(LPCOM1)
   ( e; R0 }) r+ V$ t5 Y1 ^: i; r
6. *    返 回 值: uart指针
   8 U! d- h( ~( e! T' x
7. *********************************************************************************************************
   2 U, G' y: q9 z' q
8. */
   0 }4 A6 W6 S! y2 {7 z4 ^
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   1 {( Z, d3 c9 K/ l: k
10. {
    
11.     if (_ucPort == LPCOM1)
    
12.     {
    / c6 x$ X7 K, N% S3 i3 W; b$ u
13.         #if LPUART1_FIFO_EN == 1
    - W5 K. O0 h3 w& y4 l$ z& M: D
14.             return &g_tLPUart1;
    * w7 c6 W$ ~# Y0 t( I3 W
15.         #else
    
16.             return 0;
    
17.         #endif
    
18.     }
      r- a, z1 A8 x$ h5 P3 p
19.     else
    
20.     {
    
21.         Error_Handler(__FILE__, __LINE__);
    $ ^4 O: v. [" k
22.         return 0;
    
23.     }
    
24. }

复制代码

1 R. ^, i; A  l0 P( N7 j
" P3 b1 g: [+ Z1 ?$ @0 q3 l8 O9 Y
66.3.7 低功耗串口数据接收
下面我们再来看看接收的函数：
  a7 w# H7 l6 s% W6 I. D7 ^

1. /*
   ( P6 k8 P; ^9 o3 w
2. *********************************************************************************************************
   9 r6 @" Q5 n4 N- ^
3. *    函 数 名: lpcomGetChar
   
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   2 j" t1 ~  U+ U2 M' e. u
5. *    形    参: _ucPort: 端口号(LPCOM1)
     ]+ y$ d) j8 e: Z& S6 x
6. *              _pByte: 接收到的数据存放在这个地址
   
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   ; A) k  C. v3 a  f
8. *********************************************************************************************************
   * L0 e5 ~0 T) f) D! e
9. */
   + s8 w3 G, I) e9 X3 K
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    
12.     LPUART_T *pUart;
    * H$ C: Q, g* e
13. 
    
14.     pUart = ComToLPUart(_ucPort);
    ; m) @" f6 \  f' k) W: h
15.     if (pUart == 0)
    9 Q' H! q3 p3 A8 R2 b. Y
16.     {
    , N& S0 v" L( v4 A' ?
17.         return 0;
      F- D. a- \# Z1 N& W
18.     }
    
19. 
    & _8 K9 a8 R: z$ ]+ e
20.     return LPUartGetChar(pUart, _pByte);
    
21. }
    * U  V7 f# k# c4 h
22. 
    
23. /*
    
24. *********************************************************************************************************
    3 f# Q8 }& i4 C; b
25. *    函 数 名: LPUartGetChar
    
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    " ~1 X% a3 E3 N( P" P. ]8 m
27. *    形    参: _pUart : 串口设备
    
28. *              _pByte : 存放读取数据的指针
    
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    
31. */
    
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.     uint16_t usCount;
    # Z, ?0 w( Z% o, P5 p
35. 
    
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    
38.     usCount = _pUart->usRxCount;
    1 }; z8 q0 q5 J7 j$ i# ]+ P
39.     ENABLE_INT();
    
40. 
    
41.     /* 如果读和写索引相同，则返回0 */
    7 e5 e! _$ l- z) t* `* v1 W
42.     //if (_pUart->usRxRead == usRxWrite)
    
43.     if (usCount == 0)    /* 已经没有数据 */
    , S; M/ ]0 M% h* N! w4 O" O
44.     {
    * k# N. D/ Q; d4 g& L0 ~' m
45.         return 0;
    0 v/ b% R' w2 g7 a4 r
46.     }
    
47.     else
    / H7 i/ E$ l% w7 V, W# C
48.     {
    
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    2 b. u, v+ H! o$ G% w0 A
50. 
    * |; q! \9 U$ w5 |2 v/ g3 J" p, ^4 C
51.         /* 改写FIFO读索引 */
    
52.         DISABLE_INT();
    $ @1 q$ I% h5 H2 Y# ^/ h3 e
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    2 F: `: p$ q+ @/ A
54.         {
    
55.             _pUart->usRxRead = 0;
    
56.         }
    
57.         _pUart->usRxCount--;
    - o0 M* h" V* Q
58.         ENABLE_INT();
    
59.         return 1;
    
60.     }
    1 S& r. @; O+ I, D6 T1 m( s" P6 Z& m: y
61. }

复制代码

函数lpcomGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。

注意：由于函数LPUartGetChar做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。
8 s) }; ~6 A; N- e6 D% P
5 i- |9 b& M5 N* O+ y0 y66.3.8 低功耗串口printf实现
) V7 {, m* I0 U5 x1 T! vprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
0 s6 ^% s0 h3 r8 D2 B! }- [
为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
2 @! a  ^5 J  m2 s: R
2 V: J) h( {" i  K5 _实现printf输出到串口，只需要在工程中添加两个函数：
- i- w% ~. t) H5 U6 _& K$ z5 a

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: fputc
   
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   ) Z  \  ?; M& n3 K7 p+ Z. P: g) ^) }
5. *    形    参: 无
   1 A4 X0 {) s; b1 B0 Q4 B
6. *    返 回 值: 无
   2 I" ]2 `8 c3 b# Y$ ?
7. *********************************************************************************************************
   
8. */
   
9. int fputc(int ch, FILE *f)
   
10. {
    * o/ [7 _7 O- P3 `% [4 f
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.     lpcomSendChar(LPCOM1, ch);
    
13. 
    / q! `' w3 E1 l, |- u. |7 n
14.     return ch;
    6 ^* W3 _, f# P* h+ m0 v
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.     /* 写一个字节到USART1 */
    
17.     LPUART1->TDR = ch;
    2 f" C& K3 `9 p# ~0 R9 N. D- D
18. 
    
19.     /* 等待发送结束 */
    : E, N: n. K' `2 \2 ?# z; G- m
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    + m" k0 d8 c; P) F4 Y
21.     {}
    
22. 
    : ~5 p# \, N& i" J& \6 W- Y
23.     return ch;
    
24. #endif
    : C$ q/ v, N4 e! R" N# D
25. }
    
26. 
    
27. /*
    
28. *********************************************************************************************************
    
29. *    函 数 名: fgetc
    , ^* k: h" n. Z
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *    形    参: 无
    6 E) q* L; {; h! `9 }2 \
32. *    返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    1 ^# \' G" m. k6 ?3 P
37. 
    ) w+ n# q& ?* v
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    / Z# d5 z5 E' `& x+ e  X! K8 @% s
40. 
    * d$ q3 I0 N" g# ~; z& E6 r6 I
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    
42. 
    - w# Z, p& g( o
43.     return ucData;
    2 C; n# z6 _8 g
44. #else
    9 @( `+ K  s5 r1 l# n( o
45.     /* 等待接收到数据 */
    6 Z: C, w' f" h0 Y; ?' z! A/ e6 a
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    3 `; I( R- m1 T! H
47.     {}
    
48. 
      J# I# i3 y; O" K" o; o9 U; M7 U) x; S2 }
49.     return (int)LPUART1->RDR;
    . h$ b7 O8 ^' [) d
50. #endif
    $ v6 q4 E  M% d0 }
51. }

复制代码

; Z. y1 ]6 \% a( p通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。

66.3.9 低功耗串口停机唤醒方式
' V% Q4 u5 T" M" ~低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：

% R+ U/ h& V. N- F5 _8 F4 _  检测到起始位唤醒。
6 W/ C) B  u* u# p8 n: W$ O0 t& b低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。
6 F; Y9 _8 e  t5 {  r
如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：

1 X* Q6 Z& s1 [

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   8 ~8 O& H( X9 y+ f. ^
4. /* 确保LPUART没有在通信中 */
   : m. y/ c' p: d2 F! v4 c9 B
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   ) A; c, B$ U2 v! J" e4 g
8. /* 接收起始位唤醒 */
   % z9 L% U7 e3 Z3 d, _
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    " E! K. \& V6 {3 ~( r$ Y
11. {
    " k; p0 u! B( {. f2 d9 z! ~
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    
14. 
    ) u6 {& B& d8 I! ?
15. /* 进入停机模式 */
    1 A# J- R' Y7 w2 I( e& ^, {, f
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    . n/ R/ S" I" w  Z' J" s
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    ' W# B2 G( {$ T& Y) \+ e- }4 X2 ^
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    7 Q# z' d5 i3 p' u
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    

复制代码

  检测到RXNE标志唤醒，即接收到数据。
7 a: P" z% O# V- Q低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。

3 P$ H5 B; ~, Q* B  ]  ~; K$ M, B如果想唤醒H7，发一个任意数据即可。
, x3 j; B. ]" F
1 k" ~# a7 {( C4 p6 v9 Q" g5 Y

1. /* 使能LPUART的停机唤醒 */
   # g& c$ n) ^- Y4 e7 i# e- @3 y
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   8 O( s6 B6 @+ H! I2 X7 k  m
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   , `) S6 j* W2 d, D0 Y1 ]% i
7. 
   , v  S: F& Y9 W& B4 T( Z
8. /* 接收到数据唤醒，即RXNE标志置位 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   ) E. C8 {8 l0 S7 b6 [
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    
14. 
    5 p7 I. w. Q* y* b; z
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    " x' S) m; K: l: K, o/ U
17. 
    + [0 R# g% e" @
18. /* 退出停机模式要重新配置HSE和PLL*/
    * U8 M0 L! f- m9 `" S8 n* H
19. SystemClock_Config();
    
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    ' x7 A9 w, u8 q! \+ R9 U8 o3 O* {
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    4 x# ~2 W% L) t: H" t
23. 
    

复制代码

  检测到匹配地址时唤醒。
% m) M; L; r) ^, _低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。

如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
- p5 a; i7 `7 k" D+ M, M

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   3 J8 U( l6 V; m. @1 G# G& b1 I, r
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   . s2 k) U1 w4 a& @$ v
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    
11. WakeUpSelection.Address       = 0x19;
    
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
13. {
    
14.     Error_Handler(__FILE__, __LINE__);                        
    
15. }
    / h6 ]" ~1 b3 s2 B* B
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    # U5 [+ @* ]8 ?! G- _- [
18. 
      y' E& x" j" t2 ?1 I' f
19. /* 进入停机模式 */
    / p, g% v# `' {; U2 t* B2 X2 b3 W
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    - ~/ I7 r* u2 [* V0 l
21. 
    
22. /* 退出停机模式要重新配置HSE和PLL*/
    
23. SystemClock_Config();
    
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    
26. 
    ( [9 ]3 J8 _3 f2 b
27. /* 关闭LPUART的停机唤醒 */
    & G/ d5 u  _6 z* T# C' _
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    
29. 
    6 _1 |# R! g& ?/ S. J8 ?

复制代码

这里有一点要特别注意，程序启动后，调用下面两个函数：

1. __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
   " S0 |# N( A% {" v4 _- d
2. __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */

复制代码

' L* a' ^+ R4 D6 Q: y& T66.4 低功耗串口FIFO板级支持包（bsp_lpuart_fifo.c）
+ r8 }9 a; x0 Y串口驱动文件bsp_lpuart_fifo.c主要实现了如下几个API供用户调用：

9 h" _/ l0 z. ]4 ?/ r! V% R! q  bsp_InitLPUart
  lpcomSendBuf
  lpcomSendChar
  lpcomGetChar
66.4.1 函数bsp_InitLPUart
函数原型：

void bsp_InitLPUart(void)

$ n! Y" S" j: s; A  V函数描述：
7 W3 n- X0 \' Y' V" v0 A  `
; t6 o- a  W/ c  @; i; u" Y+ Q此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
: ~' p' G+ q/ E
. k! ], d; t4 @$ [# g8 {% S使用举例：

4 b& r( K+ y/ d# R$ q" ^串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

66.4.2 函数lpcomSendBuf
函数原型：
8 [0 l6 P& ?9 _
void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
2 R6 v7 U, K( c/ p+ y2 w
- p; N* Y0 q0 a$ @2 N9 \4 u2 ^( v函数描述：
9 Z2 @, f" Q$ K5 t, F
( @1 o+ R' k: G4 J此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：
" C+ G3 t/ I9 g/ r
  第1个参数_ucPort是端口号。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
注意事项：
) n/ B% n5 k9 s2 J
此函数的解读在本章66.3.5小节。
发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
. e+ n2 }1 M0 E* r2 n/ ?- t使用举例：
% E! O# O# o, v& g$ C# P) i
调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
8 x, v' _8 l7 p' k$ z# D
& g. }! t6 W; o7 s& V

1. const char buf1[] = "接收到串口命令1\r\n";
   8 s% D. F# P% |: l' |) Q$ k6 ]
2. lpcomSendBuf(LPCOM1, (uint8_t *)buf1, strlen(buf1));

复制代码

" r* y) u6 S! ?66.4.3 函数lpcomSendChar
0 M! q) E3 W5 \  T# n) G函数原型：
, E! c5 h4 h0 X' n/ R
void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
7 B% r3 h# L1 D2 r' Q7 d
- a, m' E; |7 I4 j. ^函数描述：
% V( W2 W- w6 n
( q/ a+ M1 e6 m/ W' q/ l1 q, u! s此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。

函数参数：
0 o4 Q) G5 \8 {# q$ }  第1个参数_ucPort是端口号。
" S) q3 W; d1 M/ u- {1 F! i' F  第2个参数_ucByte是待发送的数据。
注意事项：

% a4 m9 T' E7 Y1 M$ c  此函数的解读在本章66.3.2小节。
使用举例：

% |* x- n* Z8 }$ l调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：
; _# j2 F5 r1 Y! v
lpcomSendChar(LPCOM1, 'c')。
* V* l7 u% {* f3 n+ n, z/ v* P
66.4.4 函数lpcomGetChar
函数原型：

uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
' K& x! _/ ^9 e( Y& ?5 m$ r
函数描述：
  ?# l$ H7 M$ ]9 U
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
6 z! _6 @% `% u, Y& o. g6 d+ B2 x
) m( x& D1 I9 a- i* G& n函数参数：

- o- j! y. m* ?3 T( j  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
( @1 F  g( c' a' k9 B7 {7 X  返回值，返回0表示无数据, 1 表示读取到有效字节。
注意事项：

  此函数的解读在本章66.3.6小节。
" B4 o1 Y' b7 S9 z1 ^使用举例：

调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

! S) y. k  H# a- _, w( h比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。
, o$ [( Q' b* X
7 L3 V$ n/ P' m7 u+ o9 q/ f66.5 低功耗串口FIFO驱动移植和使用
1 R4 s5 h7 p- h' l2 v5 v串口FIFO移植步骤如下：

  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define    LPUART1_FIFO_EN    1
   
2. 
   . G/ g8 Y5 n; b. \* \
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   / s; H5 _( H5 S5 p/ R4 f# q) Q& q
4. #if LPUART1_FIFO_EN == 1
   
5.     #define LPUART1_BAUD         115200
   ' C  c+ t$ f* r. L. |
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   % e+ G' l- f! G  v7 Z: z
8. #endif

复制代码

  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
' }4 V1 x% I9 O- i+ {: A" o66.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

/ B: i% ]# f' A( m3 x) R

3 U$ y$ c+ P1 c  第1阶段，上电启动阶段：
* Y6 r/ H7 Q+ e4 M
这部分在第14章进行了详细说明。
6 g( N4 h+ e6 W! d2 I4 k  第2阶段，进入main函数：
* q+ P! ^) S( W. f+ k! V
第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
) O( k, Y2 {3 ?1 Y3 v* D6 f第2部分，应用程序设计部分，实现了三种停机唤醒方法。
66.7 实验例程说明（MDK）
配套例子：
& |% m1 j( J# E* t# ^1 {
' L5 @" k  [3 t1 k8 [V7-046_低功耗串口的停机唤醒（串口FIFO方式）
/ `2 @9 ]) d/ j4 D
实验目的：

4 A- w0 k1 B/ ]( ?9 P% S学习低功耗串口的停机唤醒。
实验内容：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
% s5 o2 F: Z! }4 k7 _9 K当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
+ J0 @: m5 g0 P6 w, R; z# uLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
2 i4 Y7 U! K- n# NLPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
7 u( R' r7 O$ M4 m* H  J" y
/ k3 v3 t! M& J) O  F3 k& tLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：
+ s2 f. N6 B( ?; A: P* j
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
# F8 D$ Z% |( Y& \K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。
% e) _# [" i/ B1 b( d6 c  D7 g
5 R( j( n. p( Q) p

程序设计：

# h* X' l' n1 ]$ e8 {  系统栈大小分配：

* f) l& J  \# u9 Z1 J- Z  RAM空间用的DTCM：

" r) [7 p2 t# ]7 s$ @7 }
! y* |. _# i2 j* `3 u; j; }  硬件外设初始化
' x9 b% F& ^# ^( l7 H) X
硬件外设的初始化是在 bsp.c 文件实现：
! ^& E$ H# Z: x: t" u; v
+ Q9 L, X4 f4 ?  A" D; y$ v4 `

1. /*
   
2. *********************************************************************************************************
   ( E+ X+ W' z4 C1 h
3. *    函 数 名: bsp_Init
   % N& @) o4 N& e/ ^
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   # B4 @" x) O7 N$ \% g+ K
5. *    形    参：无
   ( e2 s# o4 N% V* e7 A, k
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ' A! V# T0 M9 J2 f0 {# `
9. void bsp_Init(void)
   6 }& Q5 J/ `) Y- B6 ^
10. {
    3 ?" E# b( [) O2 M, L- [" ^- q1 j, j, i
11.     /* 配置MPU */
    ) s4 {1 R& g4 M1 Z- {
12.     MPU_Config();
    4 k8 ?0 Y& h1 U( c, c
13. 
    ; M/ J% K; W- C- a; n& z& l: Z
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    6 f& h" E+ J  Q6 C5 K
16. 
    ) p& {: Y# j5 E' r' V5 c* [
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    / o! p. c8 Y( D( R& A9 ^- n
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
      n3 L) V2 d% `
20.        - 设置NVIV优先级分组为4。
    5 I. {: H0 J: s( a( p
21.      */
    
22.     HAL_Init();
    
23. 
    7 E( L+ {% F( ?: w9 m! [
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    1 X5 F# [3 p5 m" S" D
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    * n9 p4 ^( P6 L% y. \) r
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    5 ]" k$ m. {4 x/ F% `
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    
41. 
    0 L; y+ t6 {1 O0 Z2 B7 k: d1 w
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    # @& Z8 u3 w) N" ~
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    ( w, A1 x' H! F1 z, W
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    5 T8 C- d* c/ N
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    

复制代码

/ t. [6 e* J# E" O0 x
! k) D+ Q% B2 L  MPU配置和Cache配置：

6 x& G4 b3 y4 Z! `; K0 f3 E& C- {: Z数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
8 t6 G; p. ?- R/ L" ?8 |  O$ h
7 e$ Z8 `5 W5 q& j

1. /*
   8 H1 l; |8 o" f9 j* h
2. *********************************************************************************************************
   $ P; Y9 o2 c) p- a/ b5 p! ]
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   ( Q1 Q7 v# i! M, Y. Z
6. *    返 回 值: 无
   # J+ e/ N# l  c7 ]
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   / |# X* ?- I4 L7 A4 u; U- w
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    " l  M- W/ ^  P. s9 N$ C
15. 
    # w6 ^/ ]  }9 T' Z
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    : Z6 @0 m4 v" L
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    7 K2 e9 _( y1 H/ e! l+ z
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , V; L! r- v- p! ^9 O( V3 R
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ! b" ~" D+ @9 b# v" J0 A0 w5 J
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    : M! Z  |5 a! o; E! n5 ^
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    2 s$ @) k; ?$ v/ F4 K1 N+ c1 t  x
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    5 Q9 t2 }' _% D  x
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    : a) _: p& O4 G2 [" j
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 N( Y+ D$ h& y6 O
44. 
    ( o  M6 G9 W- U8 s& h* j
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    ' m6 y( C6 S2 D% R3 ~, J
50. 
    - s( E% x( W+ w/ q; y0 c* n: K
51. /*
    5 S% ^# |* J$ |& A
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    ( w+ H" u+ |9 J- P
54. *    功能说明: 使能L1 Cache
    : @* _5 l! i& Q8 L) j/ ^
55. *    形    参: 无
    ; O3 u% {$ a4 ~) a/ S$ `
56. *    返 回 值: 无
    4 i8 N; \/ K+ ^# ~
57. *********************************************************************************************************
    8 B  t! a! ~8 L& a$ L0 C% x
58. */
    + N" h, m3 b/ K! u3 N
59. static void CPU_CACHE_Enable(void)
    3 J3 v! u6 o6 T2 m
60. {
    9 `7 t) O' c" _6 U: E
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    ; V6 _( I' ]/ A
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    0 ?& @. Q* u- C5 E* E1 m
66. }

复制代码

! i, ~3 r7 {* ]3 P  每10ms调用一次蜂鸣器处理：

5 P" S" m7 p3 A+ Q0 q% G蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

9 Q- K( S$ f9 S. p

1. /*
   
2. *********************************************************************************************************
   & y: H# B& p$ @( h" \/ B8 ^1 H
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   2 C) E" `& k/ X  D# L& @/ ]
6. *    形    参: 无
   2 U# c# v& ^7 R( z; O8 N8 y
7. *    返 回 值: 无
   7 W0 C7 }) l! D* Q5 N$ H! v
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    % e  s4 B1 J. A. R  Q
12.     bsp_KeyScan10ms();
    * O9 k" F6 O; R7 M* z) h
13. }
    

复制代码

  主功能：
8 L2 k- F; R& `3 O1 l5 e( K# q
主程序实现如下操作：
! A/ E+ ~* i9 Q, G$ ]6 _+ y
启动一个自动重装软件定时器，每100ms翻转一次LED2。
- d, p' F4 I$ a' Z, W8 s# ?  sK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
& |7 y) ]" R6 H& ]: V' U& cK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   3 `, ~( [$ j$ v* O% H! {
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   ) m) c1 m, W, |0 S3 i/ o
6. *    返 回 值: 错误代码(无需处理)
   7 T/ c; Q6 O& h* b+ Z& \2 v
7. *********************************************************************************************************
   $ Q4 j6 U1 g- B  M4 `+ T3 o
8. */
     `$ `/ @: [- U/ l( }  G
9. int main(void)
   ) Q) F4 Q% e& r) u; G5 Z# i/ J
10. {
    * `7 d, Z; K0 }2 e+ }1 h0 j
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ; z9 y6 R" U% M9 s: o
12.     uint8_t ucReceive;
    
13. 
    % h3 g0 E  J4 h: F' ~+ P7 i2 j* P
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    9 s# ~" L1 z9 R
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
17.     PrintfHelp();    /* 打印操作提示 */
    0 P3 u5 _& J6 x+ F
18. 
    + d* [/ G+ y$ ~+ Z" c. I
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    # L. T+ s; f, {5 |: |+ N
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    + T! h" i3 u: Y& [3 {3 i* a
23. 
    0 [! `- V' }; p% v, [. z$ b* t
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    2 ~4 _& I9 o. s) V+ V  ~
26. 
    
27.     while (1)
    ; i7 \4 [, W0 m* v3 i
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    + R- i3 y* g( j# H! r  I4 Q
30. 
    % p6 X  h5 _% y6 B# ^9 h1 V
31.         /* 判断定时器超时时间 */
    , i) c7 o0 Z9 o; s) m  ]
32.         if (bsp_CheckTimer(0))   
    
33.         {
    / Q. |6 _" V# q! N- b1 u! C2 W
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    2 J  i" K8 S9 {* e& g( C) c
36.         }
    . P6 T$ W% g$ ~
37. 
    6 _3 @- J/ [2 Q- b2 a
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    ) {6 D% Y2 O# d$ y4 D0 n& u
43.             {
    
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    8 k6 |8 b6 \2 p- A  ?/ s& k: o, M7 X
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    . q  K5 p7 y6 C. Y2 o, A8 B
48.                     /* 确保LPUART没有在通信中 */
    4 E  p" s6 E" M7 h
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ; \+ ?( v7 }/ D. r1 b
51. 
    7 I2 q8 P4 x7 v; n( I
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    8 j/ p& \) o# p$ `. C! i
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    % N* c3 E2 L* \; F
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    ; W$ `& [4 ?8 {" y  R: m1 }2 M$ Y
57.                     }
    . }  f& b: A- d* i4 y* [9 F
58. 
    
59.                     /* 进入停机模式 */
    % x6 K3 ~- S/ `9 A
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    9 a5 E6 t4 L& V; D
61. 
    + T7 [4 K" C) _. P+ T
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    5 q+ C. I/ \* M  W+ S7 w
63.                     SystemClock_Config();
    5 v. N$ ?" W4 g
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    5 C1 e' t$ H5 P0 O- Q4 S6 R% x
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    ) N5 [7 ^1 U9 C  o  Y3 y5 }$ O
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    9 ~: v5 k% B3 O" I/ a8 u
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    5 Z* P5 j: i; ^: z" {
71.                     break;
    
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    & O' ?7 x2 G; O5 f: f% V: [& N' @
74.                     /* 使能LPUART的停机唤醒 */
    7 w- |+ I* c* [+ N5 c. Y+ v& _5 e
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    9 z1 L, G& e2 |$ X$ i/ F
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    - a+ G* D# h0 P7 L  A. R5 ~
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    # s  c* ?1 b% f4 x
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    1 v& S3 y1 W# |
86.                     }
    : z- g, G5 w; e: x3 h4 l- A3 P
87. 
    
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    8 F4 J: F0 f  V  j6 y
90. 
    - X( P9 |+ M9 _/ X7 e+ b
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    4 ^! G, y  q# b
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    % t$ \  w% v+ q3 }7 j
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
96. 
    : P& j4 u5 A! ]5 V" c& d
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    " T6 ?9 }7 s7 [% x: V7 @
100.                     break;
     
101. 
     . V* h* X* D0 Y6 L3 S
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     / r  F0 U& l1 b# z! S6 @  H
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     6 y2 D) _5 T7 w) T, V8 o, Z1 P
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     ) D3 b# T- Y! q0 v! j+ @1 h3 W
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     " u, B4 ^7 |2 v$ u: P$ q
113.                     WakeUpSelection.Address       = 0x19;
     3 ~0 ]5 s5 R- U1 T% j% e7 ~
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     
115.                     {
     * R+ p$ @6 Y" J
116.                         Error_Handler(__FILE__, __LINE__);                        
     ; `3 J7 w" b7 l% ]0 G) T
117.                     }
     % n; ^: \: e! q8 J# N
118. 
       p6 E" C1 |8 F4 |* _
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     $ d. {3 D- ~% p/ i) w1 \" _
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     6 M: x3 R8 U. C* o, w6 h% f0 T
123. 
     . l" j5 \7 r: h" i) Z
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     ' T0 ^0 U4 A; l0 K( r7 ]
126. 
     1 ^2 Z% s- m, T% p
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
       l( @- ^% q& p
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     - Z0 i  E; \' {4 {6 y2 }( a
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     3 s# c( _$ ^( C
132.                     break;
     
133. 
     0 b/ I( [& q) L2 }/ O! x* A* a% i
134.                 default:
     
135.                     /* 其它的键值不处理 */
     ) e* c! s7 S0 R; f* ~$ R$ @; f
136.                     break;
     ) A# ?4 N8 _  F7 h2 A' l, N7 x2 A+ Y
137.             }
     # I. r8 }* N7 \2 @1 U( Z
138.         }
     
139.     }
     - W- m" \* J6 L- n
140. }

复制代码

5 w0 {9 R$ K) ]" M. Z: w- ~+ G0 j66.8 实验例程说明（IAR）
, W% R) ?' W. Q配套例子：

  v  D" M- Z" u% H0 wV7-046_低功耗串口的停机唤醒（串口FIFO方式）

实验目的：
! T; a: S7 z+ M' H' z& @" s3 S
. U$ M4 F# @# S+ n学习低功耗串口的停机唤醒。
实验内容：
3 r6 x$ F! N* i$ Z: I
2 s/ s& L. q7 N) L启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
( @5 b. S  }7 d! \4 \USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
" _6 g) H, c- \; f; ELPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
1 o/ ^' {, E& q8 c; `LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
  l% b/ I% _% v/ k8 H& j! J
LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。

' _: }, ?) o4 t1 ^# @" eLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。
2 {( E3 E, }1 Q) C
1 N5 g0 ~; _! C3 {* X! ?实验操作：

% x( V- n" T* q+ KK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
/ h8 a5 F* S. B; r7 KK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
+ P  d" x. q" }7 x% g6 |- rK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：
6 N- G# H6 L1 k! E
波特率 115200，数据位 8，奇偶校验位无，停止位 1
4 w4 s6 H4 e6 R# j
4 _) L$ s  a0 a1 `

程序设计：
  r& s6 r3 I5 G) P
  系统栈大小分配：

' d1 q0 o9 k4 B# M, d
2 E( f1 T! V/ @: |' ~  u. @  RAM空间用的DTCM：
$ W: Y  ^9 R- J2 K, V. a; B7 P
8 S2 d& V2 [, |) H, E

- Z$ f, V8 ^8 Z2 K; M; h
  硬件外设初始化
& n: w9 P; y/ m8 x% p
硬件外设的初始化是在 bsp.c 文件实现：

! l# G$ a( w; _+ P+ z- t9 Q

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   4 C* R2 o1 A8 W" B' }; p! }
9. void bsp_Init(void)
   
10. {
    + x/ w$ @, C% }9 ~9 f
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    0 w1 d. o4 C* O& G" u" ~
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
    * `" k) B. Q+ l
24.     /*
    + {- o5 J& {7 l1 U
25.        配置系统时钟到400MHz
    8 S! c7 p0 |2 M( X! g
26.        - 切换使用HSE。
    % @; B' C, Y+ k/ d% r& B5 T
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    1 t) a( R$ b- J( _: }: x# Q6 y
28.     */
    ; z& Q3 a3 w, m% s
29.     SystemClock_Config();
    
30. 
    
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    * ?4 Z1 a0 C6 d& s
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    , X; s/ J( X' _$ S5 E* f0 {
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    1 I( W2 U% A! Z. U' a; ?+ j
47.     bsp_InitLed();        /* 初始化LED */   
      ?) f# ^7 ?# d& w* }! N
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }

复制代码

1 h  f* w/ q% m* y* L; o( o  MPU配置和Cache配置：
4 V9 J9 j' G. |/ d+ O! b  y
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

4 U% Y! R" U- `0 F

1. /*
   ! Y# p9 T- |" j
2. *********************************************************************************************************
   * c) S9 D% K) V* g* c: |' v$ L1 m+ z
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   # b' h' x& v: Y# P. m+ j* |: ?
7. *********************************************************************************************************
   . |6 }* P/ A0 L4 X' ^
8. */
   * E8 B7 Q! P5 N4 k9 {2 F+ u5 k
9. static void MPU_Config( void )
   3 k3 t! ]5 _; m
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    6 u3 T, j# V+ B2 c! H, s2 o
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    - `- O4 L9 G- s* H2 }5 U, p  U2 N8 y
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + A9 ?& N2 {* @+ W9 v
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    # Q- G  m$ r$ H# ]* {
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    4 Q: r/ A9 w' Q) m" D
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 T% Z2 `) _. A# p# m" B9 N' b$ W
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ; o( D: R6 g6 W$ f( e2 v( {
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    . Z  y  q- b. `* J) j" i5 ?; n
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    % I! L4 I, z+ q0 W& `
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    : J& Y3 w% I- `4 h' X3 H
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    , T3 k0 E$ y, Z: u
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    2 ~: M8 Q0 I5 x/ G
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    & C* r0 r2 R' ?
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    6 s- k( ?4 c: P4 U8 }
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & |: l, O5 `" @7 d% c5 {* a1 w
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    : P5 e5 s- V+ q( e: a* F
47.     /*使能 MPU */
    # _2 l/ Q  z5 Y1 u! N
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    . m3 ~; P- Q4 r- H' k7 `
49. }
    
50. 
    
51. /*
    5 u9 D. r) N3 u; p8 _! q" P" A
52. *********************************************************************************************************
    ! Y) h( j" j2 w% X& Z" \
53. *    函 数 名: CPU_CACHE_Enable
    1 A, K- ~1 i+ l" A  U# Z/ `
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    " p* _9 |5 a) J5 o' Q6 X
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    / J& V2 }+ j/ C- A, u" t+ q
58. */
    ' l. W' f. N, a' U1 \
59. static void CPU_CACHE_Enable(void)
    
60. {
    : [. w' r# i# A5 ]
61.     /* 使能 I-Cache */
      s  s# Y/ [0 t4 E$ C; I7 E
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }
    # G# _; J8 f/ [+ e, W
67. 
    % c! C+ ]+ ~$ @

复制代码

+ o2 m$ W: T* g& D) e! }% P' O/ y7 h  每10ms调用一次蜂鸣器处理：

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
+ }4 @/ K# K1 N
; `" l1 G  Z  {" [6 P

1. /*
   : P4 X" n8 H/ [/ B4 f' n9 x
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   9 X" t& [# `' C5 c' |8 m% K7 c% h! ~
8. *********************************************************************************************************
   - F2 C; M. ^4 I$ V
9. */
   2 k  P% g8 Z2 J2 e" v# ]" L4 E
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    9 c2 y4 ?; g& x
13. }

复制代码

  主功能：

主程序实现如下操作：
  m9 f8 s) x- [# f3 r; C
启动一个自动重装软件定时器，每100ms翻转一次LED2。
0 y& e; T; z+ u# N/ T& Z, w3 @ K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
3 G( G$ p8 O' p* u3 B' p" o K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   $ W+ J6 x4 D( e$ |" x1 {
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   8 u4 d8 B: `- Q/ u* L, B
9. int main(void)
   : |" \5 M; ?/ f, I' i1 v
10. {
    5 K3 n8 Q  q* q1 d( y9 ?( @
11.     uint8_t ucKeyCode;    /* 按键代码 */
    / U1 _. Q7 [! ]) t- P& W
12.     uint8_t ucReceive;
    & n; u8 x' o4 a6 ^
13. 
    
14. 
    + I; f. H+ H4 G( _" v  A
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    / k. M' |5 G; F$ _- w( ?: L
17.     PrintfHelp();    /* 打印操作提示 */
    - Z1 a1 w$ O1 u2 B, j4 h, {& p1 U
18. 
    : Y" O0 B* W) o& x( Y4 \
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    4 ?/ x% @* Q, j. U
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    * Q/ l7 {: d/ s9 w) M
23. 
    9 H( J% U4 `% ^8 h4 \
24. 
    5 a' c0 N+ _  x+ u  [9 j3 W
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
      M1 R* M+ X' ~) `( `* t
27.     while (1)
    & w1 X6 L1 x/ N' T# \' K9 q4 h/ v- D
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    . Z& m* [+ j( m
35.             bsp_LedToggle(2);
    
36.         }
    9 T) W6 V- i' O2 I( a
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    / t4 H% T* l$ t& l
41.         {
    5 a# Z* |! G" M- t1 ]9 e- z6 M2 ^
42.             switch (ucKeyCode)
    
43.             {
    
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    $ Y1 o- f9 g" {( b& ?" [# g
45.                     /* 使能LPUART的停机唤醒 */
    1 m" i. O% I* J( `  }( m+ t
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    6 J: b8 W  v, q% s/ Y: E# \& f" }
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    , ~& h% h0 b2 N+ H$ O$ w  j* M% n, r# E
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    ! B5 e6 D0 H# K$ @  U: d9 V/ Z
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    1 I5 E: f  S3 O
55.                     {
    . B( ]! b/ O' H8 ]# T& D4 u& r  Q
56.                         Error_Handler(__FILE__, __LINE__);                        
    / R+ r9 o" ]' J4 u* e' j" h6 t
57.                     }
    # z* ]9 |. l, S* p/ Z
58. 
    
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    / s2 M. I9 E( K6 T
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    6 F4 f1 e( N% e
63.                     SystemClock_Config();
    * G; b+ o" q+ j' J: I( R
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    3 c* _  K$ Z; {1 g9 H& F: n. _$ t5 R
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    2 h1 F* B9 H$ G7 a: t
72. 
    ( t' r/ p8 f7 M- U. ^
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    3 E7 }& G% v( k: Y( a
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    5 @% r" P3 r4 v& M9 K9 t
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ( ?* Z9 z8 h7 d% H6 i( _$ d: F, L
80. 
    
81.                     /* 接收起始位唤醒 */
    % y9 S8 v. j. V" X5 j
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    8 C1 f4 `5 y' ]; y, r
85.                         Error_Handler(__FILE__, __LINE__);                        
    
86.                     }
    6 N2 h/ `& Z$ U9 x- V0 G' U  p
87. 
    % i4 g" f) G, C  a0 j& `+ W/ H
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    ! _  p& x6 y! r8 K
90. 
    , |+ F9 k: A: Q( h+ H
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    
93. 
    % A1 F# u' y, J
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    ) \8 x$ `' R) [( f( U0 T/ R
96. 
    
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    % ?0 y7 `6 H; O( _
100.                     break;
     ! B7 m) Y$ O& w2 {/ k" G9 Q
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     2 j& e: `. n# r: }& z; a5 v/ p$ M- a2 t( ]
103.                     /* 使能LPUART的停机唤醒 */
     . Z- h/ a. g0 g3 M+ m, q
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     5 x# z" z; Q' \  G- s, J* v! p
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     ' L  }' v4 j" ]( d
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     " ^. X+ d; S1 \$ P6 W
113.                     WakeUpSelection.Address       = 0x19;
     4 ~- z* Q: r* h- G
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     1 ~* o! g$ X! U% }: O* Y4 g+ S
115.                     {
     ' h1 B4 R5 l* X: i7 c
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     % S2 c* ~2 T, U/ S
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     5 s! U. N/ a* V- g  k8 u6 a
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     4 W. g, v, ^. e8 X+ H' H4 z) I
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     5 Q. G$ Y; p, i4 @
128. 
     + D3 Y8 s9 p( w5 E* d: N
129.                     /* 关闭LPUART的停机唤醒 */
     6 n$ ^- |: k! I9 E3 l
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     8 @/ h9 ]/ @7 R7 _1 d
132.                     break;
     
133. 
     
134.                 default:
     
135.                     /* 其它的键值不处理 */
     
136.                     break;
     - g8 p) `9 ~1 {4 Z* ~$ y' ]- i3 X% E
137.             }
     
138.         }
     
139.     }
     
140. }
     

复制代码

* i6 o! {" F1 G2 f6 f( ]+ g5 L& r
. z4 [3 E0 D( V' Q66.9 总结
本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。
, d0 z8 Y. V( {* k: \! ^8 c* o" J* W
' n. M  W4 e" O6 P2 o* i
- a/ e+ n6 N5 r% D/ q
  ?: N7 }( P% Z# g' R