66.1 初学者重要提示
  学习本章节前，务必优先学习第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。我们常用的引脚分配如下：
. [. H. u! {) T3 o- _1 H+ x
低功耗串口LPUART TX = PA9，   RX = PA10

串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）
! S2 R" n' v" w+ j8 v. Y
: R' B$ r6 ?+ ]' T( {6 C串口USART2  TX = PA2，   RX = PA3

; a) @* _8 z; M3 {4 ~" t0 C$ S串口USART3  TX = PB10，  RX = PB11
; r# a+ ?6 w" o2 q9 X
# J7 r( O) }! V串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
5 T4 p0 \& a4 k. A
3 v# O. u3 X" R- w. T串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）

2 _5 Y5 X1 I( U" z1 d5 J串口USART6  TX = PG14，  RX = PC7  
  }- B1 ~1 y, z- z+ `
串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
% B' \1 J/ C; m; x% t
- q4 J4 ~9 O* ~, Y串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

7 x' ?" f, a2 J# C; CSTM32-V7开发板使用了4个串口设备。
! u( _  A8 R! d* U3 [
- k  `  i4 u8 S5 E! m  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
% [- W- D# Y* @  y  串口2用于GPS
  串口3用于RS485接口
  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
# p. K( U. i3 E1 r下面是RS232的原理图：

' j! |/ }( B. m关于232的PHY芯片SP3232E要注意以下几个问题：

0 X# V0 O( [& g( `0 S/ N) ^  SP3232E的作用是TTL电平转RS232电平。
  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
2 U0 ?$ o% D6 T# w

$ k+ q- u. n9 {1 x) s实际效果如下：

9 v; f3 ?0 m& V' D- H

通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY
, d$ {6 ]0 |% t( M6 s
' s2 @% u" w# L4 k/ y芯片是否有问题。

+ U0 z0 r0 }; `% y3 d+ \  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
8 W" [5 o; m0 w  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
0 J: H6 h: q7 a' n66.3 低功耗串口FIFO驱动设计
66.3.1 低功耗串口FIFO框架
为了方便大家理解，先来看下低功耗串口FIFO的实现框图：

3 b9 U7 J- I) x: ?
  第1阶段，初始化：

通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
  第2阶段，低功耗串口中断服务程序：

$ H' Y' u* M% o  a  \% P" D) w3 z5 |6 Q  接收中断是一直开启的。
% ]& D2 X2 `4 K" j. D7 t  做了发送空中断和发送完成中断的消息处理。
; J  U7 E* L4 U% j% _3 s: R  第3阶段，低功耗串口数据的收发：

$ j% \$ g2 y9 G' C) R, X- q低功耗串口发送函数会开启发送空中断。
1 \8 s' x- E0 R* R低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
$ r' H, {+ ^9 O  c4 ~3 h  _1 r66.3.2 低功耗串口时钟选择
# j3 B; r" c6 p$ t+ I我们这里实现了三种时钟选择：
; U, \: _) J  n4 J0 a( O
2 x: p4 Q" {1 W3 P( YLPUART时钟选择LSE(32768Hz)
' C5 Y: a/ y$ u, d7 g5 [最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
2 g  O# `: N, ~
LPUART时钟选择HSI(64MHz)
9 q: G2 q( p+ R) M* x$ v  F最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。

+ `  E* X: P. ^, H% T- `4 tLPUART时钟选择D3PCLK1(100MHz)
4 I) b8 Z* S$ v5 W- t4 s$ Q最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。

9 w) z3 e. w, e如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，程序代码如下，用户可以根据需要，使能相应的宏定义：

1. //#define LPUART_CLOCK_SOURCE_LSE      
   
2. #define LPUART_CLOCK_SOURCE_HSI   
   
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   1 s- B, o; D; W! M- x7 w: D& B
4. 
   6 i. c9 M. l( l( M* O9 L
5. /*
   : B* l7 E) p) A- q( Z
6. *********************************************************************************************************
   
7. *    函 数 名: InitHardLPUart
   9 C, P. t( T1 G: b# ?) p
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
     f/ t7 u, y* [, n- }6 ?
9. *    形    参: 无
   " I4 K. I1 [: z6 [5 f# T( m
10. *    返 回 值: 无
    
11. *********************************************************************************************************
    ) s2 Q; M# o; H3 r
12. */
    
13. static void InitHardLPUart(void)
    8 {/ [( c% ^* U! a# i: S
14. {
    ' u9 ^3 L. }( j+ I
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    " ~. k5 l9 p. d% W5 X$ m
17. 
    # f5 X+ |: p) C4 w; R' I! [" h
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    ' E' J- k+ V" @+ Z* l
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    
20.     {
    
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    * H6 p- E& T: z' h7 y& k
22. 
    8 f% O$ t6 z+ b/ _7 Q! [* A
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    3 ~; i8 e7 p1 ]) b+ m
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    7 M& R. l1 r1 g/ d! J9 x* i
26. 
    
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    : f( Z! [8 [/ R& C
28.         {
    5 I# D: F+ Z, I) D* A/ w
29.             Error_Handler(__FILE__, __LINE__);        
    
30.         }
    
31. 
    4 n( w2 L5 d9 [( C& v( D. F
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    ; V- k% F) e  ~+ M' j; I0 o
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
      _  [5 R& t4 U' [% I9 G6 ~
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    - p1 Y, X' q& a3 }* t+ g& q/ e
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    
38.     {
    
39. 
    
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
41. 
    
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
      v, B2 A; F1 {# F4 b7 z* j
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    3 m" B! t4 ~4 W
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    
46. 
    9 a7 U2 o7 T  }+ S% e1 x! K+ Q# {
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
48.         {
    1 o/ K- }+ w+ `' L7 }4 {3 ^
49.             Error_Handler(__FILE__, __LINE__);        
    
50.         }
    
51. 
    
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    $ S4 T0 A$ M' u' \" O( E* B% y# g
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    . T; J' O5 A9 h! B8 N1 U& g
55.     }
    
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    3 D7 u( j+ j2 W; R* O
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    9 N2 ?4 [0 l' F9 I2 ]& d  F6 x
58. 
    
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    % Q9 T0 G5 E! g! ?8 x
62. #else
    
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    1 a8 ?8 o- {" S6 f9 n9 a9 u9 I
65. 
    - v# G0 G. G2 E2 {7 T
66. #if LPUART1_FIFO_EN ==
    
67.     /* 其它省略未写 */
    
68. #endif
    
69. }

复制代码

. k6 y: A4 c' \& Y66.3.3 低功耗串口FIFO之相关的变量定义
# ~0 H* Z; k+ R/ \' L# S低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。
$ t2 H( V$ f- S# u$ p) Z6 N' s
/ J$ h+ D5 @5 i& X5 X这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。

+ C( ^; C2 z# k- |5 M! ?+ A. _每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。

5 @5 V. t5 R; [+ [, @4 |

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if LPUART1_FIFO_EN == 1
   4 L( k- T; [( q7 A! D) W: p
3.     #define LPUART1_BAUD         115200
   
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   4 `) ^/ Y7 u2 h
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
   
9. typedef struct
   ' X, \3 N( E4 }& N" ^& U8 u8 N
10. {
    ; Y9 z% k7 B/ x( L- `& U8 U
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    . U, i/ H4 m8 g  M
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    & x. Q6 h3 }" f
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    
19. 
    % {1 Q  J7 W7 `, v
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    % S; a! V0 T3 R% X
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    + R: c9 |+ S: K- \
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    * w# ?% i: H( W( |3 u
23. 
    
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    % [2 h& f  i7 P; j7 X0 Y
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    ( }" A9 e. N) B* a4 D
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    
29. 
    * r2 c2 N6 K9 x: t; H! Q+ s
30. 
    4 [% p/ b6 X# @* E5 Z
31. bsp_lpuart_fifo.c文件定义变量。
    + U; F& L  m/ K- W6 t4 ^
32. 
      z! R; b* {! e" i, L
33. /* 定义低功耗串口结构体变量 */
    " Q1 c& y7 f% x+ c- _
34. #if LPUART1_FIFO_EN == 1
    % @2 P" u4 q% f: l! `5 y! m9 [
35.     static LPUART_T g_tLPUart1;
    * u6 x) O1 l- g5 K5 I0 ?5 I
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    . F: ?9 U' \5 E/ d1 C( Z
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    
38. #endif
    / O1 L" T3 `0 \. o: M! b

复制代码

& F9 A8 x% T: r( t# `
' Z+ H4 ?* x: J3 l关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
/ s5 w7 t, Z) d; w0 |5 [
  ^+ N* k+ a; B" y0 G66.3.4 低功耗串口FIFO初始化
+ S) {* a. t. x+ z6 b0 G低功耗串口的初始化代码如下；

8 ]. C; J: O* w# o) N% Z$ {/*
*********************************************************************************************************
" K' X. R- W1 j* ~: u9 @: E*    函 数 名: bsp_InitLPUart
*    功能说明: 初始化串口硬件，并对全局变量赋初值.
*    形    参: 无
/ }! ?/ z( Z, P6 g1 f*    返 回 值: 无
*********************************************************************************************************
*/
* X2 k4 s/ p8 x; F6 a7 Hvoid bsp_InitLPUart(void)
1 e* I. a( I( Q$ R( d% y7 r/ s{
8 ?& ^: w3 i: J' d: m- G+ m    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
8 v! b$ d+ U" L. i6 |( O% S) X    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
4 s+ X" Y4 A) M; I% c& F}


下面将初始化代码实现的功能依次为大家做个说明。
* u- o/ u- }3 n$ g# l$ Z- f" {: y
  函数LPUartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
3 \; @) \$ K& r) u

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: LPUartVarInit
   
4. *    功能说明: 初始化串口相关的变量
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void LPUartVarInit(void)
   
10. {
    
11. #if LPUART1_FIFO_EN == 1
    
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    3 V4 a; w. X3 {
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    ' A4 S7 D) f) m6 V: P' Q
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    2 }% B3 a0 E9 K
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    ! m# A& k3 C& j6 i' B, o
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    , s/ l) U' |6 i7 n3 w# b& d, L2 e
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    / o1 R* n: [' E/ x
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    7 h5 }' ?5 r& J# `
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    7 B- ?! C+ b4 V  S. Q$ q
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    . |  u4 c, o! n: I3 Q
27. #endif
    
28. }

复制代码

  函数InitHardLPUart
) R; O6 G' ^" q+ p* N3 \$ B& s4 m此函数主要用于串口的GPIO，中断和相关参数的配置。

1. /* LPUART1的GPIO  PA9, PA10 */
   ! {$ Y6 R9 V& R/ j& @
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   ) x8 [7 Y! W) u& D& A+ M+ r* B
3. 
   
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   7 F: A9 C! H: g+ B0 M5 P
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   
8. 
   
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   * `$ A% n8 X; \4 w# w; |6 u
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    0 }0 h# `' V7 X& L
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    * G0 q% L4 `0 T( b
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    8 y9 q4 C' v! t7 N2 [4 ~2 z
13. 
    
14. /*
    
15. *********************************************************************************************************
    ! |( e# ?* ]& \3 q
16. *    函 数 名: InitHardUart
    4 g! g4 \! A6 }
17. *    功能说明: 配置串口的硬件参数和底层
    
18. *    形    参: 无
    : v# x; j) _. u# ?/ `' _
19. *    返 回 值: 无
    
20. *********************************************************************************************************
    ! d, ^+ c. e/ S1 V/ {( G, f
21. */
    4 ]  n# Z7 h; z
22. static void InitHardUart(void)
    
23. {
    
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    " w3 L) w6 ?6 v/ J+ M8 Z" ]) C
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
26. 
    # T$ }  Q* k* g, T; |
27.     /* 时钟初始化省略未写 */
    - R& |2 k5 v  V* ^9 A
28. #if LPUART1_FIFO_EN == 1        
    
29.     /* 使能 GPIO TX/RX 时钟 */
    
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    : f/ _9 m8 @! a+ A! _
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
    / K% j+ W* I$ x0 w" n' ?
33.     /* 使能 USARTx 时钟 */
    9 K" t8 e! Q. L& x* c7 J
34.     LPUART1_CLK_ENABLE();   
    
35. 
    
36.     /* 配置TX引脚 */
    
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    8 I  q" o% f6 b+ V
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    ' m" M2 }( U: m- n! P' E
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    
43. 
    6 E$ M9 p4 t& L; L  X4 B* h7 c7 S/ y
44.     /* 配置RX引脚 */
    - ]; a' T' q& b
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    - N% h( h( d8 y% L
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    5 @7 E, [$ [5 @8 m4 x; L2 T+ K
48. 
    3 G7 K. j; r+ {* u4 i/ L5 Y+ ~7 Y2 r
49.     /* 配置NVIC the NVIC for UART */   
    8 v( b7 U  ?6 j  a
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    * \8 A$ u3 _/ |, l# G9 a: |9 N
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    
52. 
    * x4 K3 x7 Z, ^# z
53.     /* 配置波特率、奇偶校验 */
    $ U0 L! @, {& L" d5 d3 ]
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    + r# k5 Z: f/ m# T4 e! L
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    1 u# V- x6 X5 d0 {) g3 V
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    ; G$ |9 t" w5 Z; S- O+ t) J8 _
59. #endif
    
60. }

复制代码

3 c" V$ [) B9 m: Q3 k( e# \低功耗定时器的参数配置API如下：

3 c! m7 ^3 R7 n. y( m8 ~

1. /*
   8 e$ n5 @' n2 q0 J6 D+ I
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_SetLPUartParam
   ' G5 |- a2 a- x0 n- B6 M5 n; E% r
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   - y; c; B1 G9 Y% @
5. *    形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   # H" n6 u) O( [6 Z# ^( F
7. *             Parity     校验类型，奇校验或者偶校验
   ! i* r/ S' c& `. M. j9 D
8. *             Mode       发送和接收模式使能
   
9. *    返 回 值: 无
   
10. *********************************************************************************************************
    
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    % S$ X2 M) Q+ D3 G/ J+ P# X: C
13. {
    
14.     /*##-1- 配置串口硬件参数 ######################################*/
    
15.     /* 异步串口模式 (UART Mode) */
    % X5 L1 W* r! P0 z
16.     /* 配置如下:
    ( J$ N' n* ~9 `0 I' w3 Y; k
17.       - 字长    = 8 位
    3 ]7 D& D. N& a$ m% D( F/ z
18.       - 停止位  = 1 个停止位
    
19.       - 校验    = 参数Parity
    
20.       - 波特率  = 参数BaudRate
    
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    
22. 
    
23.     UartHandle.Instance        = Instance;
    
24.     UartHandle.Init.BaudRate   = BaudRate;
    
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    8 h9 O) k, J# ]+ Z1 `
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
27.     UartHandle.Init.Parity     = Parity;
    0 n% u7 Z& {! s$ X6 j" g
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
29.     UartHandle.Init.Mode       = Mode;
    2 K  e2 v6 P& B/ w+ ~' ^  D
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    9 t& ?- n$ l/ n" E4 ]7 @( ?, {
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
33. 
    ( \8 v7 [7 e8 n
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
35.     {
    
36.         Error_Handler(__FILE__, __LINE__);
    
37.     }
    
38. }

复制代码

, i* |- [7 X7 G  J2 X) H6 `
2 ^* ?! |2 J6 R4 k$ I$ O" q, `
66.3.5 低功耗串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能

  收到新的数据后，会将数据压入RX_FIFO。
  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
) ~; U3 d: ?* _, D2 f, t0 R  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
+ c4 d% m- ^- B% o

下面我们分析一下串口中断处理的完整过程。
9 m# a4 p8 H! k/ u# P: g
4 Q8 z% M* q$ E. e* ]9 q当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

我们将串口中断服务程序放在bsp_lpuart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_lpuart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是低功耗串口的中断服务程序：
) V/ e! N! @4 L
/ K' O: B3 ~) f, i) `( B7 ~+ r1 V

1. #if LPUART1_FIFO_EN == 1
   $ i, e/ Y  l$ @4 G
2. void LPUART1_IRQHandler(void)
   
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   / _2 P" Q: f- Y5 B9 e, d: T+ p
5. }
   
6. #endif

复制代码

下面，我们来看看UartIRQ函数的实现代码。
  @! q# `4 o6 o' {) {/ n7 [, P
& U0 g5 r: ~3 k3 ~+ f$ w8 b8 i

1. /*
   
2. *********************************************************************************************************
   7 v8 h" N1 o- k- F4 i
3. *    函 数 名: UartIRQ
   
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *    形    参: _pUart : 串口设备
   
6. *    返 回 值: 无
   ) t' U+ b. j( i
7. *********************************************************************************************************
   
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    : n3 i' {$ G; y/ q
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    : ?8 K) v. Y8 n# K
14. 
    
15.     /* 处理接收中断  */
    
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    " }: B2 u7 [- o6 d8 m; Y; b
17.     {
    2 \2 f0 W1 c+ |/ C) a' V+ R
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
    
20. 
    / o' {) k5 F3 M% W3 g; o# f! b$ L
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    & @' {; g4 f) n
24.         {
    " ^( U$ j5 Q8 ~
25.             _pUart->usRxWrite = 0;
    ; W4 @% g' T. d  I6 l: i: S& G
26.         }
    
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.         {
    
29.             _pUart->usRxCount++;
    
30.         }
      ^- \+ s) w& i9 ]6 o0 l
31. 
    
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    4 M8 r. S; J+ k- g3 ?2 H4 O# L
34.         //if (_pUart->usRxCount == 1)
    
35.         {
    # a7 o- K7 U9 H) K  A
36.             if (_pUart->ReciveNew)
    
37.             {
      W, V$ N. E  r; r* I2 G
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    6 q) q7 n7 N- ]) r' T: J# i
39.             }
    
40.         }
    
41.     }
    8 c# m! H8 K  p3 Z! E' ?( H
42. 
    
43.     /* 处理发送缓冲区空中断 */
    9 A1 H+ T0 i& W! h6 f
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.     {
    
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    ( r7 k! W  t3 ^  U
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    + q9 N0 @2 k5 R. r
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    8 q3 S& h& s1 p; s: c: }! v3 \
52. 
    
53.             /* 使能数据发送完毕中断 */
    
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    # X- N: R+ ~& A& m" Z- \
56.         }
    & Q" ]+ v' ~" z% T
57.         Else  /*　还有数据等待发送 */
    0 l1 b& x6 s# S3 W
58.         {
    9 F3 g, k: T1 i: d5 t9 }
59.             _pUart->Sending = 1;
    # D( p& l0 [( t# S% Z
60. 
    . ?9 ?8 I: B8 E" c
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    , K. k1 {( n% ?) y6 _
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.             {
    
66.                 _pUart->usTxRead = 0;
    ( _: U; f  S' R4 ~
67.             }
    % O4 O$ H+ L+ g; a
68.             _pUart->usTxCount--;
    
69.         }
    
70. 
    
71.     }
    ! q+ w  _, P" Z& R# k% Q$ |) B
72.     /* 数据bit位全部发送完毕的中断 */
    $ x6 k5 s1 R* O# I, M$ f1 g0 z
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    # J- s& j0 t7 b( W
74.     {
    + E% n$ t& L, u: X2 N
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.         if (_pUart->usTxCount == 0)
    2 x+ c% Y5 J5 u
77.         {
    ; v' `  K/ y6 c. A& p/ ?
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    5 G5 W& j, ^3 e: j7 x
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    ; }) [5 Y" W+ a7 n) y5 j- L* }& F
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    ( z. m; g) b1 n! u( }
83.             if (_pUart->SendOver)
    ( [4 w+ L0 a6 W9 Z
84.             {
    + G7 j8 o5 y5 d% p; G
85.                 _pUart->SendOver();
    7 \! C$ b- a5 N% k* z4 n! q
86.             }
    
87. 
    2 j7 d7 T3 u) g! c- ?* E
88.             _pUart->Sending = 0;
    
89.         }
    
90.         else
    
91.         {
    9 r. I2 D' y2 ]; @
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    1 ?. H) ?6 y5 b  A, J
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    - s0 Y: y. O4 k. m" u
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    ( F" E* V, {. O) P
98.             {
    
99.                 _pUart->usTxRead = 0;
    ) G& F% q0 w% j: c% m7 l7 i
100.             }
     $ D& P3 r* f8 q0 m
101.             _pUart->usTxCount--;
     ; e( n# `: I* o7 J
102.         }
     
103.     }
     5 D: r6 r/ Y- U6 e7 ~( c1 p# G
104. 
     & @' K" W; _/ ^; n3 K$ T
105.     /* 清除中断标志 */
     " u$ w( A& ]# k7 P+ T* M* N
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
       X! j) f! D; Y3 r8 s9 F; N
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
       r$ r" Q2 E0 X3 P# m3 z, _
108.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     # l6 u0 V3 l) q: W3 j$ b9 f
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     " L3 Y( T2 T5 K  B3 x4 {
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     0 D! D- F" c& k  `1 \1 Q
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     ' g+ U9 t+ n7 Y5 N
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     6 w! @" W$ S) T2 p, y
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
0 c1 X1 G; D% W9 s+ `  _1 v" l' g
4 M: P. i* _& V1 x  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
* q' X% n- _( M: ]6 W1 z
& D( s+ u: P" M2 H+ A2 {$ N9 z5 }特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
/ F* `* e  k8 y* ~6 H3 T9 q  K3 s+ R/ {
$ R" q( _( d# D7 E" a( L6 z  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
# ?3 z$ ?2 z; o; ^9 T
66.3.6 低功耗串口数据发送
# K5 y* `. E+ K4 O8 |( l低功耗串口数据的发送主要涉及到下面三个函数：
# _  ^' G: N5 I+ }$ G
. u9 h6 ~+ I: ?: b# Y

1. /*
   
2. *********************************************************************************************************
   + H  r3 |0 C5 q$ ~
3. *    函 数 名: lpcomSendBuf
   
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   $ E/ n. q! ~# |# k6 w+ i# s* P
5. *    形    参: _ucPort: 端口号(LPCOM1)
   9 M' x& A! [- |" B4 A
6. *              _ucaBuf: 待发送的数据缓冲区
   0 K: l* `$ b: z! j' T5 A/ E4 u
7. *              _usLen : 数据长度
   0 {; e& b- Q" T' l! ?1 u1 W
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    / V  e4 z# _3 K& x, ~& y
12. {
    
13.     LPUART_T *pUart;
    3 I! x1 x  Y# n6 r! |3 ~' k, t
14. 
    
15.     pUart = ComToLPUart(_ucPort);
    
16.     if (pUart == 0)
    " H  a# L1 J% v( k, E
17.     {
    
18.         return;
    
19.     }
    6 @4 u. M/ b) b: d) [. ]7 L/ w
20. 
    ; G! K5 P7 A/ R( x8 r  d
21.     if (pUart->SendBefor != 0)
    " S, k6 `  Z, y/ H
22.     {
    0 U$ _' ^* D+ S4 y
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.     }
    
25. 
    
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    6 `5 ?" Z& Q% E/ Y8 [# C
27. }
    6 W0 [* U- [6 }1 R- }8 P
28. 
    
29. /*
    ! B/ t+ Z7 a1 R
30. *********************************************************************************************************
    8 I6 n) _+ d! C7 h% M3 ?5 Z* l2 _  j. r
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *    形    参: _ucPort: 端口号(LPCOM1)
    
34. *              _ucByte: 待发送的数据
    , V$ k' e+ O/ \
35. *    返 回 值: 无
    
36. *********************************************************************************************************
    8 ?! b# U& Q1 C: N0 }1 ?  J
37. */
    5 Q6 X; u7 {( F0 {' v  ~( ]) \
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    
42. 
    5 w$ ?' A) ]) q
43. /*
    6 L& K- k6 z/ L$ p+ j
44. *********************************************************************************************************
    - N& ?$ C) A% T5 {7 _' W$ x
45. *    函 数 名: LPUartSend
    & n  S7 `" B; n
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    * Y* w" o" {) U" `
47. *    形    参: 无
    9 [) S' \  w. j7 z$ ]* E& K% {
48. *    返 回 值: 无
    * s9 y! O5 C+ V+ M
49. *********************************************************************************************************
      s  P" ]9 T2 d% S% y3 t
50. */
    9 P7 [6 x$ I! S. K) [( Z% n
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    7 s) {& F- n; o, M& U9 U, Z9 j
52. {
    8 K. ]! p. Z( e2 e" q+ a  ~
53.     uint16_t i;
    
54. 
    2 U* U/ T* j7 Y4 R) x# h+ a
55.     for (i = 0; i < _usLen; i++)
    , H; w: Z+ Z0 b- W6 g! o
56.     {
    . s2 s% I/ s- ]0 g9 K3 a. O
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    5 ~& l, Y2 T' `/ P$ Z. j3 Q# w
58.         while (1)
    ; a- [6 w9 ?4 n9 E, b
59.         {
    
60.             __IO uint16_t usCount;
    0 L# [& _  t8 {8 Q
61. 
    * h5 v# L/ D" c4 \. o4 Y% o* G
62.             DISABLE_INT();
    
63.             usCount = _pUart->usTxCount;
    1 R0 P$ B7 Z4 W& u8 U
64.             ENABLE_INT();
    
65. 
    : k4 `$ X% ^2 {- C2 t% {3 M
66.             if (usCount < _pUart->usTxBufSize)
    / i& l+ f- l* Q% o! W; O5 ]2 `
67.             {
    
68.                 break;
    
69.             }
    3 _! |! _9 {1 Z' R1 L+ E1 f8 s
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
71.             {
    
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    , b6 ^6 ~' d2 w
73.                 {
    # f8 a6 A. [! o! r( Y9 g
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    ) W1 k8 K7 M/ Q) s/ ^5 b
75.                 }  
    
76.             }
    
77.         }
    
78. 
    0 s5 C! S' R( G
79.         /* 将新数据填入发送缓冲区 */
    
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    
81. 
    1 A& a$ s7 ?/ r5 L
82.         DISABLE_INT();
    
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    4 e4 \+ e% _8 E- l# P1 d/ y. P
84.         {
    ; A6 a+ T. _7 |
85.             _pUart->usTxWrite = 0;
    
86.         }
    1 \, v9 a$ S! ?+ a% ^- M' a6 o4 L7 G  n
87.         _pUart->usTxCount++;
    
88.         ENABLE_INT();
    & g8 w% B# N% G. D9 E
89.     }
    
90. 
    + R; F4 a/ r4 Z$ X; V3 U% i: c9 @
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    ( s' H! ~8 ~& x9 W6 N( S% T
92. }

复制代码

函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。
# r$ w- m9 Y/ ]) [7 i
2 L4 _! s9 A9 s- [$ S函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

  q" n3 p3 W# |* J2 ^  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
9 M8 n6 K4 b" O- V$ R  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
$ k8 e8 Y; F; u0 S% ~7 x  s
$ Z/ l# l$ z% _5 ~2 |! G注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。

1 H$ d+ U" u2 _& J4 p函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。

1. /*
   8 L7 o9 W7 M0 h+ T) |7 J
2. *********************************************************************************************************
   ( W9 e5 f: B3 }* `' r* e6 X' [
3. *    函 数 名: ComToLPUart
   , L, A% ~# |" J
4. *    功能说明: 将COM端口号转换为LPUART指针
   9 G* Y' G, q! D- ?
5. *    形    参: _ucPort: 端口号(LPCOM1)
   ; l3 u: S  M  F9 E0 U+ n
6. *    返 回 值: uart指针
   # q3 f) O+ l2 p8 y+ I
7. *********************************************************************************************************
   
8. */
   9 g& g  y4 p$ @) W: o3 Q
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   0 P# ^# i  a- ]4 O
10. {
    6 K9 R- c7 z; A
11.     if (_ucPort == LPCOM1)
    ' z$ h) n) n+ @' n6 n5 ^
12.     {
    / H4 J; b% D/ e( H* h5 W* L9 }/ M$ ^
13.         #if LPUART1_FIFO_EN == 1
    # T$ q* R* g2 r6 ^. g
14.             return &g_tLPUart1;
    
15.         #else
    ) @. X- a! X. ?+ s% k* U
16.             return 0;
    2 i% o) U# C3 T) z9 p8 z
17.         #endif
    
18.     }
    % l1 G! V. k4 d. E) w; x
19.     else
    
20.     {
    8 i6 X+ g9 d! K$ |
21.         Error_Handler(__FILE__, __LINE__);
    7 |; s' T+ v! w, P+ a
22.         return 0;
    9 @) I$ u9 E1 o
23.     }
    2 y4 a& b, Z9 K" B" W
24. }

复制代码

66.3.7 低功耗串口数据接收
下面我们再来看看接收的函数：

1. /*
   
2. *********************************************************************************************************
   . u4 s& k  z% r! E* S' |4 q
3. *    函 数 名: lpcomGetChar
   + }5 ^8 J& P9 o/ h5 T# |! q
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   ! m1 Z2 Q- a0 ?0 E4 |" ]2 a
5. *    形    参: _ucPort: 端口号(LPCOM1)
   6 T* f7 R$ p$ \- k$ s! q% G/ R2 O
6. *              _pByte: 接收到的数据存放在这个地址
   0 n1 G) w: W. ?$ V
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   ' i" t% Z1 g- _3 _9 z
8. *********************************************************************************************************
   9 d& z7 n3 }  G; Y
9. */
   4 A% v" L/ U7 S# h  B( z$ {
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    2 Q9 O) G4 }# F3 G
11. {
    & W3 N- y1 x) c! c8 H
12.     LPUART_T *pUart;
    
13. 
    
14.     pUart = ComToLPUart(_ucPort);
    - {1 z) v& k2 G# h4 n2 b& F
15.     if (pUart == 0)
    $ Z1 U* c- v  k9 i. h; U
16.     {
    & x0 y! L7 l7 v) P8 Y' e# A0 d) v
17.         return 0;
    
18.     }
    8 S( l- F: u6 `
19. 
    1 Q& ]8 q7 Q, ^: `- Y
20.     return LPUartGetChar(pUart, _pByte);
    9 q0 A; r: Z5 I) d& [9 j  }
21. }
    
22. 
    
23. /*
    
24. *********************************************************************************************************
    5 B' T6 i3 s# H# I! b
25. *    函 数 名: LPUartGetChar
    ( C8 O3 E6 ?1 ~, ~! ?$ o: z
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *    形    参: _pUart : 串口设备
    
28. *              _pByte : 存放读取数据的指针
    , a% x. H: }/ J$ |  c8 ^
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    ( W2 i' ~: U+ F, E4 V& U
30. *********************************************************************************************************
    
31. */
    
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    9 H2 h" a' U6 e
33. {
    
34.     uint16_t usCount;
      [3 |' L( k& u9 {; e, I! n+ b
35. 
    
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    # Z( H+ s( C9 o# K# L% m6 |% ?; [5 t
38.     usCount = _pUart->usRxCount;
    
39.     ENABLE_INT();
    & N+ Q$ e3 F" w2 S
40. 
    
41.     /* 如果读和写索引相同，则返回0 */
    
42.     //if (_pUart->usRxRead == usRxWrite)
    
43.     if (usCount == 0)    /* 已经没有数据 */
    2 ^! n/ O) b2 c
44.     {
    
45.         return 0;
    
46.     }
    
47.     else
    
48.     {
    
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    
50. 
    
51.         /* 改写FIFO读索引 */
    
52.         DISABLE_INT();
    # }4 i; `. P2 U' M  K' o  d% |
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    1 z$ ~6 X; {  R6 P* t
54.         {
    ) q+ f: h- J5 q1 O; t3 ~1 {
55.             _pUart->usRxRead = 0;
    8 R6 X4 E2 ^( L0 H5 E( {+ ^: _
56.         }
    
57.         _pUart->usRxCount--;
    
58.         ENABLE_INT();
    
59.         return 1;
    
60.     }
    
61. }

复制代码

函数lpcomGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。
8 A8 N5 \. k# \
: `& n7 _8 v; a* a& j6 u: I0 Z3 @. g注意：由于函数LPUartGetChar做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。
# m$ s, ~" h1 |$ K- q
66.3.8 低功耗串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
0 E3 M- \6 R2 M1 {5 R8 J
为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。

实现printf输出到串口，只需要在工程中添加两个函数：

# K5 q4 g' L" ?, b/ o

1. /*
   : P( a4 V9 H7 v7 p$ T
2. *********************************************************************************************************
   . C2 h4 W9 C( X8 |7 S  s! v: I
3. *    函 数 名: fputc
   ) v/ ~9 T" y5 H4 I
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   7 I( l: F+ a/ Z; T
9. int fputc(int ch, FILE *f)
   3 L* _& Z: E* @- L& b+ n" @4 W$ J; i
10. {
    
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.     lpcomSendChar(LPCOM1, ch);
    & U( I* w' ~5 a$ ^
13. 
    ! w/ d, Q9 ?: w. M6 q; t
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    & I3 X6 U5 Q% {6 W( l* x3 A# G
16.     /* 写一个字节到USART1 */
    2 I( G. Q& _4 b4 a0 a& f
17.     LPUART1->TDR = ch;
    
18. 
    
19.     /* 等待发送结束 */
    ' @% K6 n% Z! N& q3 x/ j
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    
21.     {}
    
22. 
    8 \$ J/ n0 Z8 X# X% O  R% i# A8 W3 R
23.     return ch;
    
24. #endif
    
25. }
    
26. 
    
27. /*
    
28. *********************************************************************************************************
    5 q3 A% b! Y' F$ K6 T3 J
29. *    函 数 名: fgetc
    5 u* A' y. N# k; v% X6 E
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *    形    参: 无
    ; L9 J. K1 R/ e# r3 `2 Z, m- E
32. *    返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    $ m  |: u; l* o/ y+ F) s  H
37. 
    . h! |9 U& X, J8 \6 @' [/ [. b& R
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
      z0 b+ p% x/ s
40. 
    # @# {5 M8 ]/ c" }% z% z
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    
42. 
    7 t* X  e% E0 r1 ~8 L! o
43.     return ucData;
    1 P$ w: X) U- o* g: E( M. I
44. #else
    & p! l  Y: F4 B/ F' I# E
45.     /* 等待接收到数据 */
    : S$ C) g1 k4 M, O% r6 J
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    + B. t7 z9 L9 Z& f) Y3 a: o
47.     {}
    0 c9 n' Z! O* Q/ l" P
48. 
    
49.     return (int)LPUART1->RDR;
    ' U3 k" N& I, r( `9 T% S
50. #endif
    $ d2 R6 E# x: P
51. }

复制代码

通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
) x3 Z" ]) b9 j. r0 S& U& q3 I" ]% p
66.3.9 低功耗串口停机唤醒方式
低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：

  检测到起始位唤醒。
低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。
5 X  j, X) m, B2 L) b" P7 ]. Y3 J
% I8 _2 H1 L! t! F如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：

1 z- D% _/ j8 S9 N9 n

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   . P8 s& j# K# N$ s6 u4 t
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   ; v! z. k1 c2 o
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   : n& b% a# p; i" r4 ~8 g5 @+ D6 n
7. 
   
8. /* 接收起始位唤醒 */
   7 F2 {/ A, E/ t& h2 F  H4 x
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    7 Z6 T0 u  H0 g6 h3 g/ R
13. }
    ( ^/ S9 a- Q6 F& C* Q
14. 
    
15. /* 进入停机模式 */
    " @+ a9 f$ d  U# r: ~: ]5 x: [
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    2 j  U: I  o2 ^0 E
18. /* 退出停机模式要重新配置HSE和PLL*/
    5 g# g% [! M6 L
19. SystemClock_Config();
    
20. 
    " ^) Z' u3 ?0 C6 |
21. /* 关闭LPUART的停机唤醒 */
    & ]" v/ g- |. R. u
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    

复制代码

  检测到RXNE标志唤醒，即接收到数据。
低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。

& T$ Z6 ?9 G- E& M' v如果想唤醒H7，发一个任意数据即可。

# N+ _) Y8 q- c6 u

1. /* 使能LPUART的停机唤醒 */
   3 i" P; s! y2 L6 l
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   3 Z: H& l! B7 |: h8 U" w7 i
3. 
   
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   2 q5 {; x3 y8 d
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   $ N) s7 d$ b! Y
8. /* 接收到数据唤醒，即RXNE标志置位 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   & C- w! l, b/ _8 U
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    
14. 
    5 d% R7 p1 u0 C: h2 f2 p
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    0 G3 Y" {5 @# t1 B; S; [3 [* C
18. /* 退出停机模式要重新配置HSE和PLL*/
    ; i4 J& T3 L9 I8 X% }1 Z- Z1 b' n) w
19. SystemClock_Config();
    # a/ i% B% A$ N/ R- t
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    
23. 
    . W- P- u( W9 J, A6 e' D. J

复制代码

! F$ l' ?7 H0 v* R$ r8 f; {  检测到匹配地址时唤醒。
. r! B7 A$ e, G( X4 w. R) ]低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。

如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
6 Z5 u. `" x3 J0 ?- N

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   1 c9 G- a1 b- |9 o9 }# @2 q
3. 
   
4. /* 确保LPUART没有在通信中 */
   3 q5 {! i6 c8 ?1 t. F, l- u
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   9 S6 t7 a$ p( d2 {* _# N2 K
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   9 k. L! d! j$ f3 Q
7. 
   
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    " @' V, t6 l  S  @% {) |6 U
11. WakeUpSelection.Address       = 0x19;
    
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
13. {
    / U  Q. q/ b2 l  H% w" k% A
14.     Error_Handler(__FILE__, __LINE__);                        
    
15. }
    
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    5 R1 f! Q$ J" @% e5 {" x
18. 
    
19. /* 进入停机模式 */
    
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    1 X( b( L$ ^0 d: w7 e- a) h
21. 
    2 v4 E; I/ _7 r7 S; ?
22. /* 退出停机模式要重新配置HSE和PLL*/
    ( w+ G$ p& M' X# @
23. SystemClock_Config();
    
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    
26. 
    
27. /* 关闭LPUART的停机唤醒 */
    
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    ( u0 ^, l  I2 k; g, V# q5 A9 z
29. 
    ! g  _% }0 [! q5 b1 z- k" c8 x

复制代码

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

. f0 M! g& n& Z/ y

1. __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
   0 V/ ]" N$ i9 L+ m) ]/ l" w' v
2. __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */

复制代码

3 I" y7 C2 {4 c66.4 低功耗串口FIFO板级支持包（bsp_lpuart_fifo.c）
串口驱动文件bsp_lpuart_fifo.c主要实现了如下几个API供用户调用：

/ Z4 r/ Z: P# {5 ~  bsp_InitLPUart
  lpcomSendBuf
- Z$ v7 ]. h" G$ S2 c  w  lpcomSendChar
7 f  w* s! R2 }  lpcomGetChar
4 d8 ~& Q& T, w  h66.4.1 函数bsp_InitLPUart
函数原型：

* t7 ]; M5 l1 R" d% Kvoid bsp_InitLPUart(void)
2 w; k* |0 e% p/ N
函数描述：

此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
. q8 D# r0 Z2 j$ H# y9 l; u0 W
' V: y" X% L9 {+ a  F$ C使用举例：
/ o" S- t  X, H
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
) a- h! I) d4 z7 M& D6 f
4 k+ _9 |: m5 {) x66.4.2 函数lpcomSendBuf
2 `% M; r' O( H$ P, S: d函数原型：

void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

. g' J. _7 R- A5 B, _函数描述：
. }, n7 v" _3 J; ]
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：
" k, d3 W* \( P! J- w  [
  第1个参数_ucPort是端口号。
: W7 k* _0 [( E" a$ D  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
注意事项：

4 |3 k# t& w. G( A- n- e 此函数的解读在本章66.3.5小节。
发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
, q" |7 |& \: r+ H; z使用举例：
1 Y8 a, b+ i" ?
$ e+ X/ a  f* ^4 S5 \( g调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

1. const char buf1[] = "接收到串口命令1\r\n";
   ; M" f& |4 `, K2 k/ m: r, }3 }9 I' J
2. lpcomSendBuf(LPCOM1, (uint8_t *)buf1, strlen(buf1));

复制代码

66.4.3 函数lpcomSendChar
函数原型：
0 ]" U8 X/ h3 n
  `0 t& |. K7 f7 Q$ r. vvoid lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
+ l, ?  X8 q: b9 Z" I5 x6 P- y
函数描述：
5 k+ O; l2 B/ |, ^, B7 L3 J' S
$ f3 h* T. S) @) P' \& v此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。

函数参数：
  第1个参数_ucPort是端口号。
. H9 ~$ C2 P8 g% G+ i  第2个参数_ucByte是待发送的数据。
注意事项：

) R0 X1 J/ @" `( @  h3 S  此函数的解读在本章66.3.2小节。
使用举例：
& I) z! ?2 L! r) S' R) N
+ R# J! q: T& w  g9 R/ b调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：
! }3 b3 a9 C* O4 i  X, X
lpcomSendChar(LPCOM1, 'c')。

66.4.4 函数lpcomGetChar
" E# @, v- H- V, Q# {/ S函数原型：

uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
+ Q7 ]3 f- ]1 }3 D0 @! v
4 l, j; Q& A& }# x( P, k函数描述：

1 U. ]% ^0 o3 N3 @2 ]  B- J此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：

& i8 ]5 s( f5 t/ {" d  第1个参数_ucPort是端口号。
( }$ m) B/ l3 l8 @9 S  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
) O/ h! w+ J( y3 E/ _" y% f注意事项：

  此函数的解读在本章66.3.6小节。
使用举例：
+ F1 B* j7 A$ }8 @9 A
调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
% o) O* @, N3 J! _* w
比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。

6 j  [. t* e) D" H+ ]66.5 低功耗串口FIFO驱动移植和使用
串口FIFO移植步骤如下：

  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
1 m4 F! }8 G" I: d" B! L7 S% {! E

1. #define    LPUART1_FIFO_EN    1
   4 N7 Q0 `8 D3 E. O3 v( R
2. 
   9 ]' ^% r0 O( y# q5 X0 Z( \
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   8 e3 T7 ^  }4 W3 s
4. #if LPUART1_FIFO_EN == 1
   
5.     #define LPUART1_BAUD         115200
   ( Z5 d9 X- `; C* z5 f8 i9 f- L! D8 w
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   
8. #endif

复制代码

( Q: c0 c) O0 c  {, R/ G8 T) j, M  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
9 d3 d' F" Q. K- ~( T" e66.6 实验例程设计框架
1 [9 d, o! c0 ?) D通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
  V1 o& S% z- U$ [: m
1 v5 f7 ?) g7 v0 X- Z4 ~. c: L

1 @; B- r0 w; r  第1阶段，上电启动阶段：
* x7 d; R: `; R8 i+ X
这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
  D+ n% V' N' }6 t8 C
$ G; F1 k# F& r, N; @+ a3 h第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现了三种停机唤醒方法。
- f2 w3 _, v" T8 y66.7 实验例程说明（MDK）
配套例子：
) ~/ W- @4 o7 F/ W: A' p+ h
V7-046_低功耗串口的停机唤醒（串口FIFO方式）

实验目的：

学习低功耗串口的停机唤醒。
! D9 t- a( ^+ B# i8 z1 [! f# o. q实验内容：
4 }5 V* O- t& ?, K% N
) n7 E- P! d0 r启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
- h9 v" {; w/ g" f3 `' U6 O上电启动了一个软件定时器，每100ms翻转一次LED2。
( W2 [% }5 A' QUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
* L  T& D" o" f/ M+ a' ILPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

4 M/ \0 {9 ?! k# NLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
  Z* s- C% m0 q0 e
; g0 ]$ _, C( ?4 g0 KLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。
# x0 G; K$ }5 j; e  e
实验操作：

- M& p5 F. A9 B$ q9 ^, M6 gK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
. f0 I4 |/ ?2 P& Y  Q7 Z1 [* C/ C2 LK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：

' O; {  J, Z% G) I波特率 115200，数据位 8，奇偶校验位无，停止位 1。

- U* W% K3 c' q8 x

程序设计：
5 M. U- t& g  n9 x" F
  系统栈大小分配：

$ w( P; i, B+ ^* s
  RAM空间用的DTCM：

8 a- p# r" M9 S$ U' \" E8 B4 A

  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
; E; `3 j7 g8 Z

1. /*
   8 h/ W. f1 o3 o2 [4 l
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   % q2 V' ^- W$ e; s' }+ t* b  K
10. {
    - C1 `) X  [! E0 ?
11.     /* 配置MPU */
    6 o& f$ W) j7 C! Q4 ^0 k3 \# V
12.     MPU_Config();
    1 ?9 d2 R; Z; ]4 E% v! t
13. 
    % \) Z$ |# d* Y7 R: z( n
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    ( x! z  d6 M: u
17.     /*
    , V/ F1 s8 X$ t+ W0 s
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ; @  L* r" K9 c% Y6 q. E. y
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    , V7 t6 ~2 S; V, X, m" {  d
20.        - 设置NVIV优先级分组为4。
    
21.      */
    . U6 w  Y& n- O! L! b( z
22.     HAL_Init();
    
23. 
    
24.     /*
    2 q! M/ @% d* R- D1 ^
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    ' S' U4 W$ W; M" A- C4 P4 F- F2 \
29.     SystemClock_Config();
    5 X4 M. ]6 z: z8 o
30. 
    
31.     /*
    
32.        Event Recorder：
    / r- ?1 u* J) P- @( s$ |/ w6 W  G
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    & `2 h/ j% K) V7 r; p
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    , `& @+ ~/ ]# h/ K+ ~
38.     EventRecorderInitialize(EventRecordAll, 1U);
      {: z- P, ~- Q7 \
39.     EventRecorderStart();
    & A8 h( O* C9 Z" F
40. #endif
    / p5 _6 X8 }3 Q1 m
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    9 @5 s0 S# Q& l* h
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    7 R- G( ?* @6 g
49. }
    

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
9 v  c1 S+ ~0 P" s% @  e$ h& ]- C* }

1. /*
   
2. *********************************************************************************************************
     R: x3 |. Y/ X1 `& A/ i6 c. r
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    5 O. D9 d: X; h/ z4 I( }# E1 e# |
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    : h4 J7 W, \: X% \4 E2 v( A# i
12. 
    
13.     /* 禁止 MPU */
    2 v( {2 I& B0 R5 i
14.     HAL_MPU_Disable();
    3 m! h" k7 Q( c, F
15. 
    3 x& N- g0 T* _" e. h
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    8 K% ]$ h5 H3 z$ R( r
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    . G6 L' D( ?5 n" i: K' H) o* r6 y
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    7 |$ P8 S9 d4 ^/ v
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    5 }: u* ~% C. ]
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    $ L$ }, k* I* h3 |9 e. l
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
      q; O4 {' d* k2 M
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    # I5 z" m% O' y& `8 W: s
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    , R- [: @$ {& R1 G) q. {, T
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    5 J" b+ s* {- C4 |2 |
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
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;   
    : S  K- B' \  Z$ J2 m* M
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ! |# L( }9 @( T( a6 i4 W
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    1 ?( {4 v  r8 h; Q" e* h$ D3 p4 |
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    ; c0 E; w/ F/ R* F, `
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 j( \$ g0 o! k& M) [" ^8 P. W
46. 
    # @9 h# M1 |  B: n
47.     /*使能 MPU */
    # B* y) v! }* U! z: ?) t; A
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    8 z2 S. j8 a5 [9 {+ V! `
49. }
    ; P/ N  O& B6 v
50. 
    
51. /*
    4 R: I+ W% ?, ~: C' K
52. *********************************************************************************************************
    3 S$ S' t, o7 {) L6 h! m7 s
53. *    函 数 名: CPU_CACHE_Enable
    0 k* I+ l2 a2 U  x5 N; v
54. *    功能说明: 使能L1 Cache
    ( x- W) y3 C: H1 u# d2 K
55. *    形    参: 无
    5 u8 @( p" G: D3 S* z9 @
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    1 m# \$ {2 k( j
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    + V& ]- T" u) U7 r
63. 
    $ V- e* M5 i2 I6 f+ r
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

9 J4 r/ D5 a4 K2 ~  每10ms调用一次蜂鸣器处理：
6 V% x( D) m) q) k/ p) a2 u; \
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

# p3 U$ l) a7 o$ I

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   . ]. p/ t. r3 a6 S- s, a
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   3 a& R1 {8 F0 E$ F
6. *    形    参: 无
   5 ~6 z0 }/ z7 ]$ K6 }
7. *    返 回 值: 无
   8 Y8 S4 n9 P6 H( B# K3 h9 e
8. *********************************************************************************************************
   2 e( L' x) i1 M
9. */
   * x  Y- p& s) k
10. void bsp_RunPer10ms(void)
    ; P3 I, s" N8 e4 R* {) m; g
11. {
    0 x( ~2 q: b2 e9 `8 Z
12.     bsp_KeyScan10ms();
    
13. }
    6 J3 B7 S. F# O4 f

复制代码

3 l, }2 a6 B, I' ~9 X8 V  主功能：

; F# ]( }% V* w9 ^, L% ^主程序实现如下操作：

9 ?! T& T" K3 [% a6 O启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   8 X1 k8 Q# p4 l
2. *********************************************************************************************************
   * i# _2 E0 a% a2 J( Q! e$ \7 ?- X
3. *    函 数 名: main
   % Q' o8 e5 c, i% Q
4. *    功能说明: c程序入口
   5 P* R+ s- @* I2 i
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   + ~& A# Z3 N& E7 a/ d
7. *********************************************************************************************************
   
8. */
   ( G0 ~$ R) w, K  r( }2 Q/ p. d
9. int main(void)
   * [+ N% U0 L( S6 ^. P" T$ x
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    
13. 
    & O1 i* C  D# V
14. 
    % v/ \; P1 o; u4 `& D
15.     bsp_Init();        /* 硬件初始化 */
    / b3 v% n& j0 k: B9 h% R
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    9 [* i) L4 m4 U
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    # m# {' M, J4 c. d2 C- f
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    7 P% m9 a9 s4 r1 K7 g( ^2 F0 d
23. 
    
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    4 \( d, u3 _* J0 y& y) j5 v3 \5 n6 K
26. 
    
27.     while (1)
    " L; _; K! e; j4 f% O
28.     {
    . @+ N/ d% d) T) P- U  K: c
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    $ F/ _* G" p; L7 U5 e* ~6 v! G
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    5 h( _+ _9 `3 V* `" |
33.         {
    ' v  p! y8 U$ H- ]2 [  ?; r7 R
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    
36.         }
    + g; a$ o" Z& w/ f6 I! C
37. 
    1 b# j% o! }/ R7 i+ ^+ h
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    . h& y# k3 r" c& F* k" N
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    
43.             {
    + @+ ^  M) C. S; p1 E1 a
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    1 ~& W  F1 N$ w, V/ x
45.                     /* 使能LPUART的停机唤醒 */
    4 \* _6 ]6 r! o6 G! H  G
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    2 i: z; O1 J9 i- L7 L$ d  T- W
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
51. 
    ' u( t5 S7 I6 C2 {6 R
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    6 Y! U& I: g5 v6 d9 h
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    / [8 Y" ~% D! n" |' i% T1 [& H) d+ r
55.                     {
    : J+ P$ x) c9 I% b% j, _2 n
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    
58. 
    1 `! _8 c  m7 \) @$ _  U
59.                     /* 进入停机模式 */
    6 i3 w# O3 n: y6 `
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    3 o# n6 [5 b: }1 Q6 y1 r6 r  V) \
63.                     SystemClock_Config();
    
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    5 q( G. `/ i5 {- i- n$ e% i9 p
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    " v6 X4 _. }. w0 m2 k3 w* s5 n, G
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    " m5 U/ c3 C0 Q  ?* `9 @
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    + ?# Q% e/ ?! E4 {
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ! z2 s3 s7 K3 ?, n
80. 
    : n  r! V6 a; r4 t, X
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    ; P) H) \0 \- {$ [
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    " N  l$ J% b# S6 U# S
86.                     }
    , I# @5 J* U6 M3 M) m
87. 
    - y  a, m  T. u5 k0 j
88.                     /* 进入停机模式 */
    - n) H, P6 T8 a
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    # }) U6 k2 D7 l0 v0 N; @( p' i& z: h
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    
93. 
    : e: N8 A+ V6 x. R: Y" V
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
96. 
    
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    * Z" D# O, ?, T1 ?
98. 
    , I( R* w# P! U# F, T# _
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     ' l- o8 [8 b, r) ?9 r( p
103.                     /* 使能LPUART的停机唤醒 */
     
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     ( @% O8 L4 U% P: k
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     ; M9 \9 e* d6 L5 V3 m" e
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     & a3 E2 f* Y0 @, Q  r' f/ ]
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     / L+ B. c& J- a  G- h+ c8 R
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     7 Z0 e  l* Z: r5 r5 J
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     + v! S0 D7 D2 N+ R
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     " l$ ]: L+ V) N; z- P6 P0 D) i
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     1 U6 [3 ?$ x8 k8 S. T
118. 
     ) W. f' t2 u) ]4 a; c; [. S" W  f: D
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     , b" Y3 e8 {, ?& S
120. 
     1 Y+ h- Y  C6 I2 `
121.                     /* 进入停机模式 */
     ) K% C1 [0 ~7 V- o& v% f! l
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     
126. 
     4 F5 x0 \# g) ?- Z% u
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     4 ^  C5 b$ H3 ]- |4 k0 s
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     0 F2 T5 k) \7 w
132.                     break;
     " H4 I6 `1 h4 E; Q2 M% y3 n
133. 
     , H3 h2 G2 r  M& \
134.                 default:
     
135.                     /* 其它的键值不处理 */
     5 }- B/ l6 b4 M8 j4 j
136.                     break;
     
137.             }
     ; A" w$ }# C8 b& x* @" c
138.         }
     5 t  ~, a8 q: V' {  r
139.     }
     
140. }

复制代码

2 r6 z% m( I* h( ~) g1 j66.8 实验例程说明（IAR）
2 _4 ]) ^  u# Z! ]( z, Z配套例子：

V7-046_低功耗串口的停机唤醒（串口FIFO方式）

1 L% h, P$ @% m) T实验目的：
* H7 h  \+ R" o/ z4 E+ D2 i) y7 t' Z
学习低功耗串口的停机唤醒。
实验内容：

# W# `; Q' @! s7 k启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
* l/ \/ f) x' _) e- @LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
, p0 ]$ R% R  }6 p! a( Z# u" ?LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

1 j3 z6 d+ P$ K3 k- hLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
3 H  \0 Z8 w# v" w; f" h/ l' e3 e
LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

+ Z5 `7 p6 P" r实验操作：

9 ~  u+ p+ _+ n2 SK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
# Q: z. K* Q+ U! b$ UK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

7 n. e4 N3 z: @0 _* D; F

/ [0 v) ^. E& Q6 f5 j: v
程序设计：

  系统栈大小分配：
' b0 i1 Y5 k# @& D, l4 {0 x: G, j

$ p5 q+ }0 S4 l/ J  RAM空间用的DTCM：
% U1 ?0 Y& L; L  w0 e
% p, Z3 Q* P/ l

3 G, T' ?# s; K; d% D
  硬件外设初始化
$ j  f. _, y* _$ q) O
  X3 \- K( H$ ^( g/ n( |. o" l2 L硬件外设的初始化是在 bsp.c 文件实现：
7 E, z" ~2 l8 q; S1 z$ z
. e1 P) J  ]( {) r; Z& T* X( h5 w+ E- Z

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

复制代码

& @3 z/ Q+ g+ i  I2 E  MPU配置和Cache配置：
& {4 {: _/ y2 A1 ?) l/ |5 f9 y
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   / b$ r7 i  i2 A: l4 K
2. *********************************************************************************************************
     J, |8 T3 N% G
3. *    函 数 名: MPU_Config
   - d* @* k( m9 N0 x3 V5 b# |+ {
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   % O7 v2 J2 `" @6 L8 E* R' ]
8. */
   
9. static void MPU_Config( void )
     \0 X$ i+ Z, w1 e7 e
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    / N  \) G# |* ^
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    0 [) p4 [0 W) ], J+ s  j/ F/ _
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    : o* S/ n6 h* j% `0 P& z8 Z
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    9 ^; R/ `6 s6 V. r
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ' Y0 g, J* Z4 K8 _
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    5 L- g* ^! A9 `
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ! }1 ?; S2 Z8 g9 j
28. 
    # a0 e: _6 f7 B8 v6 g$ \, a
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    " c3 M, X! D$ L+ y
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    , \+ R, C- J6 p$ d" ?! O
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ; _  a5 J2 G: N
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      p# i, ~6 f- _. x
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    5 F1 r2 _  j; Y
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    8 R5 h* T- f* `/ F
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    % h1 e) ~( [' x& y5 R  L
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ; w- b+ G  F( o
44. 
    & X6 Z/ l3 k5 @  r& @
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
      t0 F7 i* ?3 ^* _. l
46. 
    . K3 Y1 f8 r$ T: D1 E) X
47.     /*使能 MPU */
    6 C; p/ w# ?/ `  |
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    1 z5 A+ k3 b8 d9 ~8 N7 {
51. /*
    ; W/ z, q5 N" `
52. *********************************************************************************************************
    6 q0 U7 z+ O+ R
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    ! `5 _7 L. {3 D# W. ^
58. */
    
59. static void CPU_CACHE_Enable(void)
    ! r7 c+ E4 U$ W' s3 D/ p% d) s
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    / t/ V* b' ]$ R! {
63. 
    
64.     /* 使能 D-Cache */
    5 x, M8 y2 z. B% f3 _" S$ @
65.     SCB_EnableDCache();
    " z7 i5 h  Y3 [. s& |
66. }
    ; I; K/ Q+ @' R; R2 @, H
67. 
    

复制代码

  每10ms调用一次蜂鸣器处理：
# b, y. d, q4 i3 R1 J1 V) Z
& I. x8 v6 p/ H9 B, A$ ^蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   7 x0 s" f. z& B  g; p
2. *********************************************************************************************************
   . z6 q  u$ [  N" \4 @: ]
3. *    函 数 名: bsp_RunPer10ms
   ' c" W% l/ a$ B0 Z* g  ~0 O
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   0 C+ R" s0 b# i8 I" H) f
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   6 X5 D" M1 b7 F: u
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    - R  S9 p$ l* T+ F8 D" ]8 j
11. {
    
12.     bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：
) v# U' L7 I5 P' U
主程序实现如下操作：
5 I# @2 L% L. O4 F8 O7 b# k; R4 Y
启动一个自动重装软件定时器，每100ms翻转一次LED2。
& a( A& A8 A, G. E7 c( Q1 h$ Z K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
/ r: r. I( O5 o0 c  W6 b- f

1. /*
   
2. *********************************************************************************************************
   % i  v; r% Z6 }1 n! L
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   9 m" L) I, }4 Y6 ~
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   1 P* a0 G% t  {& N0 ?9 t& g
7. *********************************************************************************************************
   + q" ]% n0 B- c/ p
8. */
   ; ]+ v; D3 \2 z- p6 }; e
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ( t" Y5 K$ \3 V, v: w1 H- J
12.     uint8_t ucReceive;
    
13. 
    
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
17.     PrintfHelp();    /* 打印操作提示 */
    1 `/ \2 n+ L! L8 {$ H
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
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);/* 使能唤醒中断 */
    
23. 
    . @. ^, Z0 V* n8 r: I  w2 ]
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    : Y* {& _0 I- a$ b( K% h
26. 
    
27.     while (1)
    
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    
31.         /* 判断定时器超时时间 */
    8 s" I& y) f, D6 g( T% c
32.         if (bsp_CheckTimer(0))   
    
33.         {
    # H+ e: T3 i! W, V5 V
34.             /* 每隔100ms 进来一次 */  
    1 e5 l# ]% C5 p# E; e6 ^
35.             bsp_LedToggle(2);
    3 \- Z  `2 y8 U1 r, d, a$ w
36.         }
    ( |% c, J% {" B0 z) q
37. 
    0 n% K7 G) H7 t) _, d- j
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    : g7 G, r4 [$ k2 _
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    ! A! A7 s6 T5 Z& F/ g3 S
40.         if (ucKeyCode != KEY_NONE)
    # m8 Z' f, C  M' Z5 a; p
41.         {
      v* u- c) e1 b0 ]/ S# a8 \
42.             switch (ucKeyCode)
    5 Z5 J+ \+ e5 V# r0 D
43.             {
    ( I! }2 M" o, _: `0 X
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    . b- z6 E$ y* E8 x4 d: Q; {0 M9 j
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    ' i$ s: ]3 }# \
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ! I8 L. R& |, k8 {+ D) o
51. 
    8 B. u" Z! U" e& a$ z
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    , W% c3 \! u2 i+ _4 S9 n
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    5 Y7 W' c$ s- Z; g, z% h
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    1 D! d  ^* y; C: ?3 p
57.                     }
    
58. 
    
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    7 a  F* |3 o& |- k3 I& W7 f
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    $ B2 D8 m  W* [' g* B
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    / b1 I" S% B+ d& g2 O1 P! F. b* I
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    7 J+ M$ J( [5 R" g
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    " o6 C4 P5 j/ F0 O
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    9 h% L7 }8 u# W. p
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    $ m1 D3 @% P% p  _5 Z; \$ h! u$ [
77.                     /* 确保LPUART没有在通信中 */
    2 C/ k( c! z. |* w! l% o  T
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    
81.                     /* 接收起始位唤醒 */
    ! V+ ~/ z; Q' ]5 E! e/ u
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    1 t1 o7 o# C. R3 E3 h& u
86.                     }
    
87. 
    
88.                     /* 进入停机模式 */
    3 m; R" R+ T  ~  B8 p
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    2 x# c8 m9 s9 N, e$ V
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    4 d& g6 u, W9 i) x
92.                     SystemClock_Config();
    
93. 
    3 O( |7 y+ O: T/ n2 L$ o$ S7 }" Y
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
96. 
    + Z: o8 d5 \5 _* m! n
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     : b! ?/ M# d. v) |* x
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     * n" T. N+ ~5 @
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     7 G0 w; X: M# f$ L6 L" ?- C
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     9 y9 S1 R/ l. c" j! A/ i- b
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     : Z- T! ^' j- E  I$ K
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     : ?- z* s) f2 a; p/ c
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     3 X4 R  f* n9 Q) [% `, P/ q
115.                     {
     ) _! d9 s1 g" j
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     . H- K+ I1 b9 }1 p& z* z2 v1 [5 g8 V
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     1 P* D2 i- U6 ]' U' {  c* Y
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     7 K( U( T2 }. k, @0 I) x' s5 f
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     - p* j6 g4 g0 G
126. 
     ' ^( e, v  [# ?! e7 n
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     6 d4 e3 @% l/ }6 e# q9 J$ l
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     
132.                     break;
     
133. 
     
134.                 default:
     . @2 g' t' U: h1 G
135.                     /* 其它的键值不处理 */
     , ^9 r8 a1 Y* O/ L  n. l
136.                     break;
     
137.             }
     ' U3 I4 ^: j7 u; X/ ~
138.         }
     
139.     }
     
140. }
     

复制代码

1 H3 T- z$ R; b! o4 v) h0 p66.9 总结
1 Y6 ~2 T( E. d8 x9 y本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。
: R, A. o2 r" x6 x9 W# ?
# s% m) Y9 v' ?' M7 G

2 q: S/ P2 n! x/ N3 |