66.1 初学者重要提示
  学习本章节前，务必优先学习第65章。
. e0 x) K- O2 M# g  低功耗串口FIFO的实现跟前面章节通用串口FIFO的机制是一样的。
! p9 @: J7 E7 h* _% ~) ]: E  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
66.2 硬件设计
8 H* C7 T4 Z8 uSTM32H743XIH6最多可以支持8个独立的通用串口和一个低功耗串口LPUART1。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

4 [* g* W' V' o5 V$ ^. Y3 F6 A( @低功耗串口LPUART TX = PA9，   RX = PA10

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

8 a9 r: A, A8 Z7 h$ O8 k3 e串口USART2  TX = PA2，   RX = PA3

, c6 D9 i1 E8 R串口USART3  TX = PB10，  RX = PB11

串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
+ U' h4 c8 V8 o3 j
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
* s: C6 ?! |+ ~- j+ t
  u3 e3 O+ }( ^) N( @: Y2 b串口USART6  TX = PG14，  RX = PC7  

8 W7 O+ z1 t+ t! a! I4 b2 ?串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
9 Q- c4 r  @+ U% h* N. m
: y/ g4 u7 J# Z5 E2 {( v串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
/ Q1 p, K1 Z& v; }! r% \
STM32-V7开发板使用了4个串口设备。

7 q* v, {6 ^9 s0 K1 v- n  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
  串口3用于RS485接口
  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
/ `3 i% n! }; \1 r

) l: K0 u1 ]3 k" x5 p* Y
关于232的PHY芯片SP3232E要注意以下几个问题：
7 M' B: M4 C6 O
  SP3232E的作用是TTL电平转RS232电平。
  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
* P+ |1 M4 p8 r6 p' k7 q% g  G
' O3 C6 l4 N9 b+ g! s  v  Q( w/ X+ ?

; M; S, D3 Y: r; |; q实际效果如下：
8 ~5 S/ `) j* \8 B3 q; W: U
. o+ A9 ?$ T! a/ `. k+ C: o- T: \. k8 c

2 V9 e5 q( O1 ]
, u, |5 g3 d5 m' i; w) _通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY

芯片是否有问题。

* |$ B3 G2 J# ]: R3 q5 y' P. g  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
: N* d, J% ]2 d" v8 w: C  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
66.3 低功耗串口FIFO驱动设计
1 s3 w5 `+ S5 ~' {  T' f& X) [66.3.1 低功耗串口FIFO框架
为了方便大家理解，先来看下低功耗串口FIFO的实现框图：
5 O$ g' }' \: x9 R: G4 H
' ]8 J- g' f% I! W- i6 w

; `' ^' u. Z1 |6 t4 L& M
  第1阶段，初始化：

通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
, O" f1 U4 B/ f9 h- ^2 L$ b  W! B( P  第2阶段，低功耗串口中断服务程序：
5 h! j! u) a( H2 Q: \
+ G. ~; R/ e# S- J. m  接收中断是一直开启的。
8 v# e1 e  F1 p0 f5 t1 g  做了发送空中断和发送完成中断的消息处理。
# s3 v5 u. ^4 K  ~  G7 j  第3阶段，低功耗串口数据的收发：

低功耗串口发送函数会开启发送空中断。
低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
8 l3 A1 r4 X# c5 b66.3.2 低功耗串口时钟选择
我们这里实现了三种时钟选择：

LPUART时钟选择LSE(32768Hz)
0 }: c2 p" [+ d8 ?+ U最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
1 I" E/ ]0 b0 n
LPUART时钟选择HSI(64MHz)
最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。

LPUART时钟选择D3PCLK1(100MHz)
/ c7 {% Y; L- I1 g. R最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。

; N% F3 C3 G) |+ U0 E3 |如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，程序代码如下，用户可以根据需要，使能相应的宏定义：
/ k/ e" q$ D8 {' [

1. //#define LPUART_CLOCK_SOURCE_LSE      
   
2. #define LPUART_CLOCK_SOURCE_HSI   
   7 f( y0 B, @" d* W! v9 |
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   
4. 
   
5. /*
   ' _* R1 `, V( T% H; V6 {
6. *********************************************************************************************************
   
7. *    函 数 名: InitHardLPUart
   # {7 U5 l% K+ F
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   3 \  o) i; {- @. d9 n( d, f7 r6 \
9. *    形    参: 无
   
10. *    返 回 值: 无
    5 U% B5 T- W* s! u" A+ k
11. *********************************************************************************************************
    ( B. L3 o! b7 f3 i9 w
12. */
    1 a. o7 f( T$ N5 {( [4 Y, n
13. static void InitHardLPUart(void)
    6 z- i  b: l$ k# I# `
14. {
    
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    
17. 
    9 x4 I& b$ o8 s4 J5 W/ e
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    * W# I6 n% K# |1 X( A7 C/ u6 B
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    ! k' ~+ x  q; V0 S
20.     {
    
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    + G6 w. x& L, v0 S' F4 Y1 h9 D
22. 
    ; C; |' @& o% K2 E5 q4 ^( f2 A
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    1 d( V8 Q& s$ {4 s
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    % v+ J! h  d0 |2 G6 {4 h+ C2 ?4 ^
26. 
    0 d. K, [2 K# C2 I" m+ U) c$ J
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
28.         {
    
29.             Error_Handler(__FILE__, __LINE__);        
    " L$ [' ^$ g5 y$ ?. o& Y5 d
30.         }
    
31. 
    
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
      ~, m# O  e5 V- x5 ^3 d
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    / C7 N# I3 J+ a* I+ K
38.     {
    ; M8 A8 N/ t/ C% p9 J" ~
39. 
    
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    ! p5 v2 {( d* t" {- L+ n
41. 
    
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    * \) e' _) R3 d8 g7 u6 |% H
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    . L- N' Z6 P* e0 q+ \7 H
46. 
    
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    6 m# o, l) Z( k- h: e
48.         {
    2 [& D. T' I# k$ |' g
49.             Error_Handler(__FILE__, __LINE__);        
    
50.         }
    
51. 
    / n% y" X3 C3 v$ _& w2 C, Z# w9 i& e% k
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
55.     }
    
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    0 u3 r, c, y' Y) n$ I/ C$ b
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    
58. 
    1 e- B+ x+ g. q( C3 `; x( w! A1 W
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    ; A. r  E! _+ I- H
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    2 u% F5 I6 t8 }8 g
62. #else
    
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    1 L+ p% r- s. }1 _' O' E
64. #endif
    
65. 
    ' @# L7 J& K% `  J5 o- M9 O0 G1 f
66. #if LPUART1_FIFO_EN ==
    ' B' Q3 j9 ?9 ^/ a
67.     /* 其它省略未写 */
    
68. #endif
    
69. }

复制代码

66.3.3 低功耗串口FIFO之相关的变量定义
3 p- A2 [2 f$ G1 x% y低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。
* a1 D# \; n5 W6 T% V. I+ W
) P6 U& m/ c" _$ r7 J  a4 t8 D这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。
! N+ z# Q5 c* b9 O
每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
0 L* L' m" S& N8 F6 ?
我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。
% N- N, Q! N- a' |2 M
( X0 L/ J% `  ]- J, C2 j

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if LPUART1_FIFO_EN == 1
   , P$ T+ L' a3 B
3.     #define LPUART1_BAUD         115200
   
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   " V& ?8 A! w; I
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   
6. #endif
   
7. 
   - d" t4 q2 Z! g
8. /* 串口设备结构体 */
   
9. typedef struct
   
10. {
    3 h* t! P/ t8 A
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    6 N" W: j8 `5 N% g+ t! Q
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    2 F+ l. ?  A0 P/ W
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    2 }- U  e/ b) l* j! s, p: `
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    ( d+ |1 B3 \1 h8 q! v4 u1 a  n5 l% V
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    
19. 
    7 z) Q' ?$ t. S- }& W9 k
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    1 X( {3 I: b5 W! M
23. 
    - S( z3 _# I  P* g, `2 G- ^) u
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    5 D% s' C& N% ?  I5 S) H2 j& t
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    2 a3 y2 c- C: j
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    
29. 
    + k& P: n% [# O6 h
30. 
    9 ]. U: Z3 @$ Q
31. bsp_lpuart_fifo.c文件定义变量。
    + N/ x! `- Y/ a1 j2 ^. _
32. 
    
33. /* 定义低功耗串口结构体变量 */
    5 C% y  b" d$ ^# P3 ^
34. #if LPUART1_FIFO_EN == 1
    6 m8 [0 e5 L( M' \
35.     static LPUART_T g_tLPUart1;
    ; l/ B( r' B* g7 N  B3 P2 [
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    $ r5 x- g8 t, g7 [; E; b! H
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    
38. #endif
    ' Z6 j! K9 o/ b4 L9 ?+ o

复制代码

6 k* G* n: n. u4 T4 I" v关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

$ e  u+ h* _$ t66.3.4 低功耗串口FIFO初始化
低功耗串口的初始化代码如下；

7 K9 l$ J7 c/ h3 K8 `4 d/*
4 X, u3 }, f* o. q& K/ r*********************************************************************************************************
*    函 数 名: bsp_InitLPUart
*    功能说明: 初始化串口硬件，并对全局变量赋初值.
*    形    参: 无
*    返 回 值: 无
& m9 ~4 v: s4 K4 X! _*********************************************************************************************************
: R7 I3 V8 |8 C  C# n& b*/
void bsp_InitLPUart(void)
3 A  q' {& J1 |2 y$ D1 e{
, z6 g: l, C( C* v0 X7 Y  h    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
) I: q* r( O# p) w6 Y' `    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
* l1 H  C7 S- m) g! Y}


下面将初始化代码实现的功能依次为大家做个说明。
( p9 d' W, t0 U3 ]( D; b
  函数LPUartVarInit
* b2 E3 L7 Z; L! ^% W3 N这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

1. /*
   
2. *********************************************************************************************************
   / \5 ~5 H% h8 Z" K5 p; q
3. *    函 数 名: LPUartVarInit
   
4. *    功能说明: 初始化串口相关的变量
   9 H5 b$ f2 H' P
5. *    形    参: 无
   
6. *    返 回 值: 无
   & E7 {% a0 p$ z( M; `" U" g
7. *********************************************************************************************************
   1 X  Q( ?! P, _( K' ?; l1 r- F
8. */
   # N" Q; q, e, ]4 n+ x3 F, q
9. static void LPUartVarInit(void)
   3 Y) i/ N) _! m3 b( `+ I" e
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;                    /* 接收缓冲区指针 */
    . G- r7 ]/ i0 i# o
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    : G1 q1 L: _) ~' `! W) _
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    5 g6 S1 M5 B% g
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    * G+ h0 n) Z7 ^6 D5 }8 y
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    9 ]+ G+ J3 A) P, ~, _" k
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    $ ]9 D' t) X& I9 o# w5 F" g
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    & O: R( X% i: v5 O/ U6 h& T
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    # t, ^9 C( t) i# G$ x* f6 t2 g
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    
27. #endif
    
28. }

复制代码

. K5 `# }! H: }  h, x% i
+ v2 y" w6 D6 }- u
- H6 D8 o7 P' T# L  函数InitHardLPUart
* v2 w6 Q9 Y8 \7 |此函数主要用于串口的GPIO，中断和相关参数的配置。

% [/ [  R1 Q- [3 S

1. /* LPUART1的GPIO  PA9, PA10 */
   6 c& s# r3 G# m1 _  y- P
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   . V2 d9 A9 s! L% i% n
3. 
   
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   . [3 \: r* F. K# \% v
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   & c. l' Y+ U, N$ Q9 [
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   $ m! y; D+ f; @. a
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   : }  R2 n' K" [. ]' m8 t
8. 
   
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    ) J& C2 `9 h% @+ N+ Y. [8 i
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    
13. 
    - Y9 w( i% E9 t
14. /*
    3 H8 c/ H0 o! I% H7 m
15. *********************************************************************************************************
    
16. *    函 数 名: InitHardUart
    - W# Q% Q7 J+ q. h, J& }9 L
17. *    功能说明: 配置串口的硬件参数和底层
    
18. *    形    参: 无
    
19. *    返 回 值: 无
    2 |" }* i$ n- n2 j
20. *********************************************************************************************************
    
21. */
    
22. static void InitHardUart(void)
    
23. {
    # i* L# M" s% ?
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    5 E8 y7 j- L' H4 t7 g. b6 c
26. 
    . C0 l% D' A; |7 u! _& V$ ~
27.     /* 时钟初始化省略未写 */
    $ r5 d8 b# |% }+ N+ [
28. #if LPUART1_FIFO_EN == 1        
    " Q4 {  h6 G1 O9 H  H
29.     /* 使能 GPIO TX/RX 时钟 */
    4 [4 o7 l0 T7 j! B" I6 N& H
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    . _9 u2 _& _/ ^+ z5 H
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
    . O; U) c, G9 Z6 o: [; n0 Q. I
33.     /* 使能 USARTx 时钟 */
    
34.     LPUART1_CLK_ENABLE();   
    
35. 
    & ~7 k0 y8 ~) \, H: q* e
36.     /* 配置TX引脚 */
    7 v4 E# J, ?* ~! X
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    " x+ H) m. v" \
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    # ?% z7 ~1 F7 c- M7 Q
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    + k, G5 z, V4 L1 L
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    , T1 \& r  ^# |
43. 
    
44.     /* 配置RX引脚 */
    : P, o' k7 g! l1 b6 n; M7 V8 j# q
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
48. 
    - Y8 v! A5 y0 Y5 K9 n$ `- |2 n
49.     /* 配置NVIC the NVIC for UART */   
    % A6 n3 I; a; x  @* U
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    $ [' X- E0 G5 ^" k& U
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    ! p1 a- ?5 H' v( y% Q- H7 Z
52. 
    ' a0 z% T& i5 \! x! K( H
53.     /* 配置波特率、奇偶校验 */
    2 m( U4 k$ y! a) W5 |
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    8 }. q' ?5 u: ?" W" r4 a5 |# p- \: H
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    & w. H  ]  O7 _7 z" f. D
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
59. #endif
    
60. }

复制代码

低功耗定时器的参数配置API如下：

1. /*
   * c, `2 t$ f  T4 z1 ?
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_SetLPUartParam
   
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   # u6 \% R3 K3 Q* @# ~$ I
5. *    形    参: Instance   USART_TypeDef类型结构体
   " A/ e  y0 o3 g8 g* }1 _5 C
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   & j. H% F* n7 ]5 K
8. *             Mode       发送和接收模式使能
   
9. *    返 回 值: 无
   # V, P  K" D7 y3 F6 d
10. *********************************************************************************************************
    
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    $ O- M! b: `1 l1 n+ c
13. {
    
14.     /*##-1- 配置串口硬件参数 ######################################*/
    
15.     /* 异步串口模式 (UART Mode) */
    % n! M, @2 A! s9 {2 y6 `0 A
16.     /* 配置如下:
    
17.       - 字长    = 8 位
    % d# {8 m% x2 p) @7 r" L5 K
18.       - 停止位  = 1 个停止位
    " v- a/ L. }# ?* {/ q
19.       - 校验    = 参数Parity
    
20.       - 波特率  = 参数BaudRate
    * c8 g! F* n  U0 w  B0 g; t; b
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    
22. 
    , ?" `& V" f$ f
23.     UartHandle.Instance        = Instance;
    
24.     UartHandle.Init.BaudRate   = BaudRate;
    
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    2 n6 X1 F+ s4 Q9 X; Y
27.     UartHandle.Init.Parity     = Parity;
    % _3 {3 d2 P+ Z5 J  N
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    0 `, ?0 d* C2 y: |. `4 ?
29.     UartHandle.Init.Mode       = Mode;
    
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    . Q- |; ~  e: [! F+ H
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    7 `& c8 d8 i& x& g5 L
33. 
    # f. A) w+ x+ S
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    + }; y9 g, N" c9 E9 K; P- ~
35.     {
    % T1 P# \% }+ d& Y3 A4 d3 K  B4 I
36.         Error_Handler(__FILE__, __LINE__);
    
37.     }
    
38. }

复制代码

: o  R+ v$ V1 n66.3.5 低功耗串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能
3 k9 u% Z+ {8 @$ {% Y- ~8 i$ W# R
  收到新的数据后，会将数据压入RX_FIFO。
  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。

+ |7 w' c$ V( v% t$ O9 p9 [
下面我们分析一下串口中断处理的完整过程。

, w6 u& n  }4 i# v/ {! e: O当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

1 {5 \7 w4 W" ~/ Z$ z我们将串口中断服务程序放在bsp_lpuart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_lpuart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是低功耗串口的中断服务程序：

1. #if LPUART1_FIFO_EN == 1
   
2. void LPUART1_IRQHandler(void)
   7 |- E  i0 f' ]. w  v
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   " }" @: z1 S- w9 S% y
5. }
   
6. #endif

复制代码

" {6 s6 `2 R' m" V% u下面，我们来看看UartIRQ函数的实现代码。
* A2 z% M+ J, J

1. /*
   
2. *********************************************************************************************************
   9 z+ ^3 g  y3 R/ \# j
3. *    函 数 名: UartIRQ
   
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *    形    参: _pUart : 串口设备
   % C/ H! Q( N9 Z3 a
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   1 w$ U  v+ }( e0 k+ v9 J2 a
8. */
   : ^. c9 [' q* k2 l5 p# H7 ], d
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    9 J% z5 X- K9 f, h6 b
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    & i7 m) s+ \9 P- I
14. 
    
15.     /* 处理接收中断  */
    " T3 w+ A8 ^( q  s) o2 v
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    - h6 o9 K4 y' `" {; e/ F% T- x' P1 y
17.     {
    : A& z: K- i. h2 G. R4 q
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
    + D- [: ]: L5 Z
20. 
    
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    0 ~6 D* d6 Q$ B8 K
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.         {
    
25.             _pUart->usRxWrite = 0;
    $ G+ c* t* f1 D( _! t
26.         }
    6 u8 k/ M9 e' `9 m( B: m4 P. d
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    9 G6 ^3 j7 x7 L) S
28.         {
    
29.             _pUart->usRxCount++;
    7 X! K( m8 \" L- B. ]' ^
30.         }
    ! y! \0 |: |: ^. T, |, O
31. 
    
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    : S9 m. G  B* e7 g/ f1 i% @- }
34.         //if (_pUart->usRxCount == 1)
    5 [$ `. m1 B9 _" ~
35.         {
    " w1 Z; M) c0 D3 F
36.             if (_pUart->ReciveNew)
    
37.             {
    4 H4 w- x# [3 e" o
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    & @: e9 u% N% Q* h8 f
39.             }
    - z7 I4 b9 n$ w+ |
40.         }
    
41.     }
    
42. 
    
43.     /* 处理发送缓冲区空中断 */
    
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.     {
    
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    ! [, l/ |' {5 h6 ~$ S
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    / J5 m- A9 F) M) }( z+ |
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    
53.             /* 使能数据发送完毕中断 */
    
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    & Z0 r! S2 p( k' @" ~
56.         }
    
57.         Else  /*　还有数据等待发送 */
    
58.         {
    " u( s$ f  n8 k5 q  `: P# f* a
59.             _pUart->Sending = 1;
    6 x" ^3 G9 w% t% g  F3 {: S
60. 
    
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    7 b3 ~- N$ f5 e0 z
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    " I" t7 E6 H. ~- t& U% [; F
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    * S3 z5 E9 y* B7 y' F2 |9 E
65.             {
    
66.                 _pUart->usTxRead = 0;
    / \, t- M$ Y4 M7 h$ f+ \
67.             }
    5 C* N( J6 e- }" L9 j4 f
68.             _pUart->usTxCount--;
    
69.         }
    
70. 
    - d1 g) E9 r5 B, [5 d
71.     }
    
72.     /* 数据bit位全部发送完毕的中断 */
    ' Y$ b& r( i+ O. U
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    ) S8 F2 V9 G1 G4 L+ _% [
74.     {
    % w0 n+ K+ X9 e3 z5 P
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.         if (_pUart->usTxCount == 0)
    6 r+ H9 W3 c( ~' D3 D. W% w1 Z8 k
77.         {
    
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    " x, N  y( N0 X# r* b2 }1 y
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    3 o" y& z* `/ {- `& p! L1 v
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    5 w' z% t+ M- `8 I! I& f/ I
81. 
    
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    # Z; s9 a* ^7 |5 f" r
83.             if (_pUart->SendOver)
    
84.             {
    * V$ X7 x- `; u/ W
85.                 _pUart->SendOver();
    
86.             }
    
87. 
    " D  m, z* c8 a( S/ O  B
88.             _pUart->Sending = 0;
    6 r. e* w3 S4 ^! Z3 g; B/ Q. Z
89.         }
    
90.         else
    2 o$ O, O% N5 h4 E; U
91.         {
    
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    ! O1 ]- G" o% Z$ w. O2 x4 v7 m1 u' X
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.             {
    
99.                 _pUart->usTxRead = 0;
    3 M. m7 n0 h4 F
100.             }
     ) I) m; \( X1 F( F$ y
101.             _pUart->usTxCount--;
     & `* A5 R) {& Q
102.         }
     
103.     }
     
104. 
     $ [8 `( ?8 N) k- P2 g; s5 B
105.     /* 清除中断标志 */
     : R" l; E) Y; f) D1 \, k' x
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     6 I; x" k( K8 Z/ b2 Z# _
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     / @( q7 R/ T3 S$ w+ t& m
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     $ R' W% e0 ?" X" x& G. Y7 M" W
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
/ [, E. `5 |( h8 |- P" T
  接收数据处理
+ i1 {* }  S5 m7 h接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
0 `9 n* z$ X: B% P
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
  s" q% |' d1 c0 z+ Q, u' ^
, I5 l) C6 d2 X7 B' {, m8 |: \; D1 ]1 I  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
" K1 [. m# z  a1 a- j% S/ X& e1 J$ d
7 ?0 E$ a4 G; j* D* a66.3.6 低功耗串口数据发送
2 [; S7 @  |1 H6 T; v, S  i$ L! B6 a5 q低功耗串口数据的发送主要涉及到下面三个函数：
$ i0 }6 `' o8 L6 C0 f

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: lpcomSendBuf
   
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   + l3 f% k6 q# Q7 v1 [2 S
5. *    形    参: _ucPort: 端口号(LPCOM1)
   5 v: J0 s% T* l- Q; |5 N* Z
6. *              _ucaBuf: 待发送的数据缓冲区
   $ d" H. Q4 r. u/ n4 Y/ M
7. *              _usLen : 数据长度
   
8. *    返 回 值: 无
   9 g" D1 U! f  v( u/ C' o- {0 O
9. *********************************************************************************************************
   
10. */
    
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    
13.     LPUART_T *pUart;
    
14. 
    # `! q$ U: A; e/ f( P/ S/ m6 U
15.     pUart = ComToLPUart(_ucPort);
    
16.     if (pUart == 0)
    3 l/ A. \/ ?% y; _6 |
17.     {
    
18.         return;
    * ~) Z, @" c$ A+ H
19.     }
    . |! {7 z2 J( D7 t0 j- W
20. 
    1 e$ B' H8 g1 C0 z4 k
21.     if (pUart->SendBefor != 0)
    
22.     {
    , O8 J2 V. `  _# r  Z! Z1 I9 |) g. c
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    8 }) g: f2 b& G7 M; a, |( T
24.     }
    + Y( ~8 l: F) G9 L6 f4 B# Y
25. 
    3 j$ R, S. f+ L8 U' r
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    
27. }
    6 Q8 f2 _  s8 n* M  h$ O
28. 
    
29. /*
    , P( R% Q6 f$ x/ s# D) @# q
30. *********************************************************************************************************
    % M1 a5 a) J. w8 t( T  n  z) K9 N1 w
31. *    函 数 名: lpcomSendChar
    - g7 W+ W6 J9 q% j9 \; ^+ l
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *    形    参: _ucPort: 端口号(LPCOM1)
    - z" l8 [# `3 L; Q) F
34. *              _ucByte: 待发送的数据
    0 V, f  i7 R% l
35. *    返 回 值: 无
    
36. *********************************************************************************************************
    
37. */
    ' j2 x9 [' J) Y" `. x4 S4 l" q
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    , B: b( t% K# U( Z0 o& q
39. {
    : v9 D6 r8 S$ q3 H
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    
42. 
    
43. /*
    + [- x4 b1 d6 \* N* X6 l" ^* k$ V
44. *********************************************************************************************************
    3 D; G8 g/ T" l; |9 e9 i' h
45. *    函 数 名: LPUartSend
    " p8 d$ ~9 P2 T0 k, v
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
47. *    形    参: 无
    7 [: O* Z2 w0 p9 ^
48. *    返 回 值: 无
    
49. *********************************************************************************************************
    3 {# \+ ~# G3 M. W: K. h
50. */
    7 ~& E& e2 w9 }
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
52. {
    
53.     uint16_t i;
    
54. 
    
55.     for (i = 0; i < _usLen; i++)
    
56.     {
    6 N1 Y; U# U# O9 x, R) L
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
58.         while (1)
    
59.         {
    
60.             __IO uint16_t usCount;
    
61. 
    
62.             DISABLE_INT();
    
63.             usCount = _pUart->usTxCount;
    / k( m# }1 }+ ^& U6 L; i. O
64.             ENABLE_INT();
    2 o% w4 y1 A. l* ~; S9 i9 v
65. 
    $ R5 q% |) j0 g9 r8 p7 p
66.             if (usCount < _pUart->usTxBufSize)
    % |' L/ Z" [/ g) k
67.             {
    
68.                 break;
    + R& ]5 K9 T+ K4 X
69.             }
    
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    ' w/ B! s# Q$ d5 e4 m0 T7 v3 C, b0 Z
71.             {
    
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
73.                 {
    ) A/ e  [5 V: H1 d; Y' y
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
75.                 }  
    
76.             }
    7 d% ^. m( D2 ]: \
77.         }
    , y) S3 }) C4 c5 L
78. 
    
79.         /* 将新数据填入发送缓冲区 */
    
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    
81. 
    
82.         DISABLE_INT();
    
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    + [1 D7 {5 w1 O4 m' X/ @
84.         {
    ; E- k; z$ K% I
85.             _pUart->usTxWrite = 0;
    
86.         }
      f* Q4 E. X/ _4 p: ]
87.         _pUart->usTxCount++;
    ) K* U& q3 r. K8 t3 B; y
88.         ENABLE_INT();
    
89.     }
    
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    
92. }

复制代码

8 Y$ F9 a2 E  w# f+ L/ |函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。
9 d# O$ y! l5 f' ^- y7 ?1 X
' }6 W" {3 }7 |( W函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

3 s  Z$ B7 }; X2 G0 Y0 ]  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
4 G2 [, z( d+ _( B: ]  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。
- h4 a6 [  J; P+ ?+ o. L# u
函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。
4 y1 i1 v' G. b$ l) _" i

1. /*
   
2. *********************************************************************************************************
   0 x4 c( C5 D/ J) _
3. *    函 数 名: ComToLPUart
     i2 G! b( h$ o1 m8 i" J2 O
4. *    功能说明: 将COM端口号转换为LPUART指针
   8 W; J) _0 C  t  u9 ]
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *    返 回 值: uart指针
   
7. *********************************************************************************************************
   
8. */
   - Y$ t4 Q# ~+ s: v9 F+ `
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   
10. {
    
11.     if (_ucPort == LPCOM1)
    
12.     {
    9 a2 l% M4 o$ N
13.         #if LPUART1_FIFO_EN == 1
    
14.             return &g_tLPUart1;
    
15.         #else
    
16.             return 0;
    
17.         #endif
    2 X6 W/ r, N4 Y- ]7 Q1 d, {* V
18.     }
    1 p0 R- z# q' v+ T
19.     else
    7 W3 e& e# K+ o
20.     {
    
21.         Error_Handler(__FILE__, __LINE__);
    " ]* z$ n% }3 s2 J
22.         return 0;
    
23.     }
    ' T( A5 B  b- V3 t0 P* j# N, }
24. }

复制代码

8 H) j4 c) m- v  @0 \% p9 ~
8 P: M0 Q' U6 y$ y( K5 O66.3.7 低功耗串口数据接收
下面我们再来看看接收的函数：

1. /*
   
2. *********************************************************************************************************
   3 G& h# n' q' x9 R( n
3. *    函 数 名: lpcomGetChar
   
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   ! |, Y# m+ p" \- y% U
6. *              _pByte: 接收到的数据存放在这个地址
   / O& ^4 c* J' u- M0 g4 k8 D
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   ) b9 f1 s& v  X1 r! W, ?2 e
9. */
   
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    8 B5 J. q% ], K5 h; |8 \" n9 m
11. {
    
12.     LPUART_T *pUart;
    
13. 
    
14.     pUart = ComToLPUart(_ucPort);
    7 o: T. S5 l: x+ S5 D0 j# n
15.     if (pUart == 0)
    
16.     {
    , M" Y6 u8 V# m) J# V
17.         return 0;
    2 k) k* p* u! \* c
18.     }
    - A* x! \+ ]* _/ Q8 w& i/ y
19. 
    
20.     return LPUartGetChar(pUart, _pByte);
    . i8 \* T1 Y5 T4 w1 S9 f9 U+ y
21. }
    ) }: U# R: N" S+ T- J! d
22. 
    7 g2 S0 n! w- O
23. /*
    
24. *********************************************************************************************************
    
25. *    函 数 名: LPUartGetChar
    
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    9 q" d6 b/ y1 L3 J0 k9 t
27. *    形    参: _pUart : 串口设备
    
28. *              _pByte : 存放读取数据的指针
    
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    
31. */
    ! L2 l3 R' Z0 x5 j7 H) r
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    ; c' @6 q" S* Q4 [5 Z. _9 F# {7 w
34.     uint16_t usCount;
    2 a4 @( Q! ^6 ~4 m4 B+ ?$ F
35. 
    
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    , {2 J2 w& k; a3 D  {( r; J
37.     DISABLE_INT();
    
38.     usCount = _pUart->usRxCount;
    4 c$ H  j9 H! _; V0 w( u0 R: c
39.     ENABLE_INT();
    0 a# s+ o. j1 H/ ?
40. 
      U8 \1 W# I2 x& f* `
41.     /* 如果读和写索引相同，则返回0 */
    % U( D# k1 m7 A  h/ h' p
42.     //if (_pUart->usRxRead == usRxWrite)
    
43.     if (usCount == 0)    /* 已经没有数据 */
    ! @$ i1 u6 s. h! x( u$ h" G
44.     {
    
45.         return 0;
    
46.     }
    7 t* l8 g. O' I0 H0 i' O5 t# J  v
47.     else
    
48.     {
    8 r5 Y8 b  Q. h- @1 W. B
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    
50. 
    8 I1 D# j" i+ R- P
51.         /* 改写FIFO读索引 */
    8 j) s4 J- u3 o3 n7 w  B0 i
52.         DISABLE_INT();
      }3 u" c% Z' Q, e1 c( M
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.         {
    7 b, {) w7 m8 S, M3 w) w+ k+ b
55.             _pUart->usRxRead = 0;
    
56.         }
    
57.         _pUart->usRxCount--;
    
58.         ENABLE_INT();
    + ^) q0 v7 d; t
59.         return 1;
    
60.     }
    % R! a# x* O" M% T! P& Z# v! R
61. }

复制代码

" ^8 w! V; A+ z6 k& l) c, Y1 p4 A函数lpcomGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。

注意：由于函数LPUartGetChar做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。

: s& ~8 G$ W/ q2 u2 X8 m9 g66.3.8 低功耗串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
  [- t0 R3 E7 a# {
* x% |' u& Z3 K" [$ }: T实现printf输出到串口，只需要在工程中添加两个函数：
" j( H* R& A( S8 G1 l
5 J) N# O/ [) x1 Q5 n

1. /*
   + g' q6 }; w" G% }& l% T* R- ?/ x
2. *********************************************************************************************************
   ; p- |. z& Z+ ]5 p7 M
3. *    函 数 名: fputc
   $ z& Z5 _* k! ^3 Y
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   * s; y3 s& w8 L3 s* ^+ k
5. *    形    参: 无
   + J* H2 U9 d; R
6. *    返 回 值: 无
   # n- \9 f' I3 G9 P# X& x/ W
7. *********************************************************************************************************
   
8. */
   
9. int fputc(int ch, FILE *f)
   2 ?2 v/ ?5 c/ D/ N
10. {
    
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    + ^3 N& }% Y; X5 c( H
12.     lpcomSendChar(LPCOM1, ch);
    
13. 
    
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.     /* 写一个字节到USART1 */
    
17.     LPUART1->TDR = ch;
    / |# E" H5 U1 M0 A
18. 
      J7 H2 [9 S5 P' D3 ^# W
19.     /* 等待发送结束 */
    
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    
21.     {}
    - a& I6 ]  R# l1 r6 U* F2 B, \
22. 
    ( J1 p- ]" [! P3 F, a
23.     return ch;
    & e5 ]1 X" O$ C( s
24. #endif
    3 ]/ E; ~& L3 h8 h9 H3 t9 Y
25. }
    0 x3 T3 M% b  B  M' T- B
26. 
    $ H& i5 l& Y! T8 C
27. /*
    
28. *********************************************************************************************************
    * g/ i$ V* I( y/ z6 {' I$ b4 _
29. *    函 数 名: fgetc
    
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    ! F1 r+ p8 y1 q8 ~; I' K" W3 T3 C+ g
31. *    形    参: 无
    
32. *    返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
    $ C0 l" j7 I; s
35. int fgetc(FILE *f)
    
36. {
    
37. 
    . @5 h- d( @0 ?3 C" F- J
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    
40. 
    
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    % [9 w) B- }$ ^
42. 
    3 W0 p. |% x# V. v, n/ q: q3 ]
43.     return ucData;
    
44. #else
    & k' k; C0 ]. f* o9 D. j0 n! a- C
45.     /* 等待接收到数据 */
    2 c: L6 Z- a* h5 D
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    , W) [3 K" G$ i3 z# U
47.     {}
    
48. 
    
49.     return (int)LPUART1->RDR;
    
50. #endif
    
51. }

复制代码

通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
  B/ L3 r( A' u/ n# X& [
! ~4 K# D; B+ y4 w; l7 E, I; O66.3.9 低功耗串口停机唤醒方式
低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：
" y. U% l6 a: E, b7 O' {
  检测到起始位唤醒。
$ d6 D1 B' j0 t+ i$ w" ?低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。

6 Y! y# f0 t1 G, h+ @) k如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：
3 q; c- U+ N  H1 T5 r5 r

1. /* 使能LPUART的停机唤醒 */
   ( f4 `- P) Y1 }  l! s2 r. G% u/ d
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   0 y% D" q- T7 w# O0 x
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   8 G# _7 j& _2 F/ P2 L8 @
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   . W4 K* k" `' T/ g& g- m
7. 
   + L9 W5 r- r* d/ u, P; u( ]0 y  C5 s- c
8. /* 接收起始位唤醒 */
   + K( Q6 I# E7 f* Z5 O0 k' N
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    4 D  z% ~# O8 t6 J! ^
13. }
    
14. 
    
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    % n  `+ |; f" F+ T, K) _
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
      N! s" i1 r, c" t" J5 _( O! Y  C
20. 
    % k/ a, V: R" b, y
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    

复制代码

( @+ x1 Z5 N) B+ e1 d1 p) }  检测到RXNE标志唤醒，即接收到数据。
低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。

如果想唤醒H7，发一个任意数据即可。
4 \2 O! d4 j' w- k. F5 d

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   & \7 J* i+ b  Q9 c) P+ U+ }' V
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   
8. /* 接收到数据唤醒，即RXNE标志置位 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   ) E+ ^) n) }$ X# b( Q. W  X2 K
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    / T  Y) [2 k: _1 O  Q
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    . _) Z7 a# C: ], I3 U% @4 @
14. 
    # I: P# ?/ ?- v& o: r
15. /* 进入停机模式 */
    # q9 o9 t) y9 h+ Q6 r
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    ( J8 R1 C  A6 E0 v9 s
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    4 D! f& x! n! k* c  k- @
23. 
    0 N9 S7 f; s2 p2 d# X

复制代码

0 B5 y1 Z2 l, Z+ k  检测到匹配地址时唤醒。
, y4 v% }8 a$ s0 m! Q低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。
9 v6 Q, g( W% t# {# O$ E( y7 D
如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。

7 H2 x' a2 m3 g) }* @, ]' R

1. /* 使能LPUART的停机唤醒 */
   5 P+ u! t2 ~" L. T( w  {
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   5 Z1 Q! t& a; f& `+ x+ R. d/ _
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   / q% w; R. \7 n- W  S7 i+ F% ?: G. h
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   . ?) S% S; a; D/ D% s% \' {7 \
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   + I! r, r' Y. X
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   8 F0 y/ S6 R; ]8 w; o- r: v3 H2 T
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    
11. WakeUpSelection.Address       = 0x19;
    3 {/ v& o& @0 B" C* y
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
13. {
    , \- Q' v' |% R
14.     Error_Handler(__FILE__, __LINE__);                        
    : I( _! Z, h+ |+ D( ?9 J6 v! L
15. }
    & q4 W6 L' J) _  k, `
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    
18. 
    
19. /* 进入停机模式 */
    
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    # v- N  b3 A  _) w+ N) }
21. 
    
22. /* 退出停机模式要重新配置HSE和PLL*/
    $ w0 o  j0 H- z( [* y
23. SystemClock_Config();
    ; e) i+ o( X. ~; W: a% D8 u
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    ; Y5 `, m/ @' t8 E1 v% R+ s
26. 
    
27. /* 关闭LPUART的停机唤醒 */
    2 \8 {7 z0 q& H* K" v4 k
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    
29. 
    - M2 M# y9 K& E- b! ^$ w3 x4 e( ?

复制代码

: t! c6 [) j- u4 _2 x) B+ b/ K  [' Z1 k这里有一点要特别注意，程序启动后，调用下面两个函数：
; g+ V4 H& K# G& M* w/ J, |
5 [2 E- G- q2 f+ O1 x1 e

1. __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
   
2. __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */

复制代码

66.4 低功耗串口FIFO板级支持包（bsp_lpuart_fifo.c）
$ C! S3 z0 g2 H, a( V: Q串口驱动文件bsp_lpuart_fifo.c主要实现了如下几个API供用户调用：
- |2 {. K9 C3 F) E
) I( @+ x1 ~* U3 t. Z  bsp_InitLPUart
  lpcomSendBuf
  lpcomSendChar
; ~. b5 @6 w6 k; X7 F  lpcomGetChar
# A! n! |$ E( L! ]66.4.1 函数bsp_InitLPUart
函数原型：
$ |+ u7 o- z+ J4 h' L5 s  }- z$ H
. ]1 `+ n: G! R- P5 J, q) vvoid bsp_InitLPUart(void)
, G3 e, D9 }0 D( Z; _4 p2 t
函数描述：

# F/ t0 P0 ~9 R此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

使用举例：

5 N# f3 s/ U! R# I  ~# ]6 N. V1 B串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
  [( W# q# e5 s' h0 ~
66.4.2 函数lpcomSendBuf
9 ?0 w/ X( o3 k* P函数原型：

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

3 q, C; w: K$ g1 T: g7 e函数描述：
0 |) D. G  x2 Q9 I6 f4 e4 r
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

' |3 F3 i) x" @' [函数参数：

/ q, G' H% J1 W) V0 C1 F! o( j, ~# A/ Z  第1个参数_ucPort是端口号。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
注意事项：

此函数的解读在本章66.3.5小节。
5 K  x+ Y% `0 u$ h: P3 K 发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
使用举例：
, y" X! u3 R# h! w
调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

1. const char buf1[] = "接收到串口命令1\r\n";
   * e  p. J2 T0 q3 l6 J  U! {
2. lpcomSendBuf(LPCOM1, (uint8_t *)buf1, strlen(buf1));

复制代码

66.4.3 函数lpcomSendChar
0 E: b; I3 u& X* s+ N. b函数原型：

void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);

) [- ]% D6 z0 N) r- E" \, Q! i+ G函数描述：

此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。
3 a1 |' o1 @6 h* F2 }
9 f2 e8 B7 x2 z% X函数参数：
1 r# N/ e' P6 E4 t  第1个参数_ucPort是端口号。
% X- j% ?9 O' }' O  第2个参数_ucByte是待发送的数据。
/ x. r8 X3 W  y! |, [% n! F注意事项：

) b3 H$ ~: b* o6 G- c4 v2 {  此函数的解读在本章66.3.2小节。
使用举例：
1 T  O* [. s& d" h% V3 {
) O$ a% K  e! t调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：
- t1 u4 l2 p# t; b3 j, V0 f
lpcomSendChar(LPCOM1, 'c')。
/ ~7 D- x1 `2 O1 f9 e5 U% _  w
4 V) s5 l6 O+ w+ E9 q9 q1 f3 I/ J66.4.4 函数lpcomGetChar
函数原型：

+ m" J6 k" ?! S: f* e- g7 Fuint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
" D+ c& w' B2 p# e2 i1 T
& V1 z5 S; y2 Z+ n函数描述：
" |: v) K6 W, h" p
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

/ F1 `0 N) u+ P, V函数参数：
5 w9 A" y* X& s4 W
& S8 b) w. O/ X. g* G  第1个参数_ucPort是端口号。
  _$ M$ M8 N* d3 q5 H$ \  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
. t/ ?, ^+ O5 P- D6 Q注意事项：

/ R4 T" D! o* e3 I" Z  此函数的解读在本章66.3.6小节。
+ {: S2 t. t& s. x  e9 w使用举例：
  H: a. w2 [7 Q
9 T( s3 i4 J5 F9 y+ {! K8 R$ \调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。

66.5 低功耗串口FIFO驱动移植和使用
串口FIFO移植步骤如下：
. y( S6 [" c2 S6 T1 }3 @) h& i
% i- w: ~: m& K" B9 c  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define    LPUART1_FIFO_EN    1
   
2. 
   
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   . m5 K. n. X9 A6 w3 |; y
4. #if LPUART1_FIFO_EN == 1
   
5.     #define LPUART1_BAUD         115200
   
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   # b- A" @* C# o4 u4 a  `$ I0 i
8. #endif

复制代码

  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
/ x, N+ k+ v8 ^  第4步，应用方法看本章节配套例子即可。
66.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
6 n  u2 |! S+ p0 {+ Q7 ^

1 t# `3 W- x9 _/ a+ y
0 E; m+ H$ s1 S1 E" ~, a  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
# m" [' F& l1 \& }  第2阶段，进入main函数：

第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现了三种停机唤醒方法。
66.7 实验例程说明（MDK）
5 S; a( }. L3 m/ V/ o! ?配套例子：
5 P% ~. E( j8 r
7 T. O% l: @' `, Z1 PV7-046_低功耗串口的停机唤醒（串口FIFO方式）
; i7 @8 I7 D/ k, ^$ u$ f
3 z6 h4 o/ k# M. Q; j& |. F9 v2 v实验目的：
: \5 d( l* U9 K5 U1 [$ E, i# o
学习低功耗串口的停机唤醒。
实验内容：
- U% p0 ~$ m( I$ |, F
* R* O4 k, U. n) w% F4 p* ^! D启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
. ?( j  B& q9 L- EUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
6 Y9 t# P" m5 h* v; }+ P2 g# s8 _LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

: M8 W' X  u' r% E6 oLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。

9 Y4 [) t& H4 X: ~3 l* R1 [LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：

/ G' Q! z- J; m  `  CK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
5 U) Z/ V$ M+ PK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：
7 R& G* Y: V: I0 P7 x
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

. Z1 T9 h5 `' u6 E# @

1 Y: c  R  v  v  \) s
: R! B1 c4 P8 L1 ?程序设计：
' X- i, r! t* X% A. f- n
3 }. `/ Q' Z  R% }  系统栈大小分配：
; O5 D# U7 l' ?) S% l" H
' b/ O% B/ W. ?# @3 J

2 @6 H* f3 ?' R0 J. I- |2 N
9 v) r* S9 \2 L1 B  }. ~& }  RAM空间用的DTCM：
2 n1 c7 }" ?# [  w; y

  硬件外设初始化
! d& D& H' |+ w2 U* t
3 O! _& N# l' U/ e硬件外设的初始化是在 bsp.c 文件实现：
! w. Q5 b  J3 N4 I6 ?

1. /*
   $ r0 K. e! t( Y3 {/ n
2. *********************************************************************************************************
   ) i1 _5 `* Z" r& i4 ]9 B# D
3. *    函 数 名: bsp_Init
   & ]! W6 ~/ T9 K: {
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   ' F! w. Y9 w& w7 ?' p) C
6. *    返 回 值: 无
   * y) Q* n  R' R' I
7. *********************************************************************************************************
   % w2 S& t% l$ M( e
8. */
   
9. void bsp_Init(void)
   - G! q$ {2 w9 [, I) o
10. {
    # v  N; g9 f, ^  C: e/ u' r# ?; j5 q+ b
11.     /* 配置MPU */
    7 k- G# e" \4 Y9 g4 x* A
12.     MPU_Config();
    5 S( m. v' c% V/ |
13. 
    ( {' M" F  k% t
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
      @) H4 V' H) A
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    / B" M) @# \( e! G+ `
20.        - 设置NVIV优先级分组为4。
    
21.      */
    0 g! w7 G% M0 C% q; t( v
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    : _8 W+ U, y# j; C' f
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    
32.        Event Recorder：
    ! g5 E3 X  H8 t' j# O2 \) T. h
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ) q% f5 r# L# @
35.     */   
    
36. #if Enable_EventRecorder == 1  
    " E$ U, W; }& H' O
37.     /* 初始化EventRecorder并开启 */
    7 _- y! E7 [+ c/ J9 u4 z" A  b
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    ; B9 F2 \* ~( l
41. 
    : e3 p4 L1 N) \- J: v6 T
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    + x9 S: f! E) T$ O
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    0 i/ F% v& H' A; E# P
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    - W& z7 F9 T4 q5 u6 ^
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    

复制代码

9 I! x1 E2 l2 w3 C  MPU配置和Cache配置：

1 D; U! F0 x6 N8 m0 o% J0 _7 J7 ]5 [数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

/ C, A' k) Q( h; \  d

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   ! I) ^( }" W" e1 Y/ |: v
5. *    形    参: 无
   8 d2 Y: T  `+ D4 L- j" j9 m
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ' s. [% f5 l8 f: @
8. */
   
9. static void MPU_Config( void )
   
10. {
    / f2 D, H; p5 I. Q' Y
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    0 T  B9 M8 t% U5 Y! D0 H8 U/ |3 ?/ Y
12. 
    2 w2 A, I8 A, `$ t) T% s$ U
13.     /* 禁止 MPU */
    " f' L: ^& R8 ^, E$ s0 G) F$ R
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) H  Y: g, M. z/ F( h# R) S
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    ' Z0 P+ |( y1 i% p/ \* l5 @4 o$ k
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;
    1 [! i8 b$ C2 G* n
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 i2 F9 Y) x" j4 e" b, q
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    8 L* T' f* {- ^1 c4 s; @
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    7 X# H- \) [9 \6 X3 n" }
31. 
    8 b/ x4 W  H0 W2 @. v+ B: J
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    + L7 C" ]; X* ]* L0 r. D& j
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    , s+ g1 _- k) z% p4 M; A; O
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    # T, I' A4 v) m3 N
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    0 D% X  I: z6 w2 T9 p( v) }  ^
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    " ]/ Q, g6 V2 p  _$ @4 k: o5 U
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    $ B% P. u' h3 u1 ?1 t  ]- I* X0 C
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    . X6 U- ]6 Q" _6 D# k( F* g% u
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;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 ?6 }$ C4 h. I* F$ M1 L5 O
44. 
    : t8 G1 Q* P, o/ q" W# D
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    / k+ M: F3 B0 \5 H9 s+ g7 C
46. 
    
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    7 H" V7 K' g5 l3 K- Y5 \
56. *    返 回 值: 无
    9 }; |& z5 I% n
57. *********************************************************************************************************
    , `: @. i0 e; j9 P# U- M8 W: X
58. */
    : k- {" Z+ {9 x$ q$ P- h9 R
59. static void CPU_CACHE_Enable(void)
    % B" S# s8 H( R9 K+ y# x. Z5 o: y' T
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    % m3 W/ a' e/ v
63. 
    $ ?* j" f! s; I
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    ) f  E: r. ^/ r* c2 u
66. }

复制代码

* h6 g% g. D2 S5 g1 j7 n  每10ms调用一次蜂鸣器处理：

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
/ S% \3 i9 ^, m. C) [
7 X' Y: p) ~/ o- b- j( L6 e

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   1 i9 L1 |8 y5 J; b/ {
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   ; E0 [6 ~7 \3 @  R: B5 m$ d# B
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
     \; G3 |8 Q* ^' y
10. void bsp_RunPer10ms(void)
    
11. {
    ( G3 e6 S5 a8 x. @# L0 X5 T7 g1 v
12.     bsp_KeyScan10ms();
    ; t3 R  B. A. T% r" a! b
13. }
    # s2 o* ]- G7 z! H0 Q

复制代码

  主功能：

主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
- f0 l& o' q" _) AK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
$ F( U; {% I& [8 R0 X8 B

1. /*
   
2. *********************************************************************************************************
   $ _  e: O% i3 @- Y. ]. z
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   ( }/ {( F7 @  z/ R/ c% S  F3 V9 t& j7 w
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   % x( Q- Y& G  `
8. */
   
9. int main(void)
   ) ]6 S, F6 J& H8 E5 r* v
10. {
    9 E5 {+ {/ b3 P2 Z7 p/ ?2 x4 Q: K
11.     uint8_t ucKeyCode;    /* 按键代码 */
    6 J& h4 E, v+ I' J  A* \% R
12.     uint8_t ucReceive;
    ! X) k& j" m. R/ j0 K" ^5 r
13. 
    - u$ ^9 G# B" W3 u
14. 
    # _: k/ i$ j, s: @7 o* V
15.     bsp_Init();        /* 硬件初始化 */
    + B. G* F* F  r: o2 L- L& V% t
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    7 w9 [3 x5 }1 U3 x9 o% I0 r9 z
17.     PrintfHelp();    /* 打印操作提示 */
    6 U: g, Y, k6 l; a) ]( T5 x& I$ |
18. 
    ) ]$ {$ e7 l" z; E
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    3 F5 m3 q5 x( T0 B( \
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    3 J2 N7 O  C0 p, T0 t$ ~2 x, N; {" h& ]
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    - x- ^7 Q$ ~' ?/ _2 w
23. 
    ! J; [1 {1 U* J! d$ b; r. Q& ?) X
24. 
    1 g2 X7 G: f. F) k* C  \+ w) d- \
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
    9 Y/ {9 y% Z3 A$ n) f' E( x
27.     while (1)
    
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    1 [- l, Z! e% r+ }3 W
30. 
    , k7 o8 T/ w5 t/ L/ [5 X2 t
31.         /* 判断定时器超时时间 */
    1 O$ h) h! ^( k8 O! m
32.         if (bsp_CheckTimer(0))   
    
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    0 X' ?2 b/ E# V& b- m' R
35.             bsp_LedToggle(2);
    
36.         }
    & S2 m- |5 ~5 Y, |6 a
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    7 j! H* @+ K, W  V4 v+ g& Z
41.         {
    
42.             switch (ucKeyCode)
      R7 G8 K2 q! V$ k, s
43.             {
    ! K+ O! C3 Y" e4 B5 v
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    , q& L( n0 H/ A( x
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    , z8 {7 q6 h( }; G3 D; \( Y3 Z
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. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    1 W9 y/ r7 u6 g! U5 D; o
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    7 D+ s! }9 n' V& i
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    
58. 
    : q5 q: P: I: u5 I% a
59.                     /* 进入停机模式 */
    ( F& l2 b& P9 t6 o
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    3 H: D% A1 a' E
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    * @) V$ S+ k3 p4 I9 T8 ~& U
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    6 E, a1 W/ D6 l
71.                     break;
    - g& q! b* P+ ]  D
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    2 j% Z6 }8 j0 y/ [
76. 
    6 Q; U0 Y% Y! _3 o5 }. k: z0 E
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    + J! u  \  m0 Y+ w
80. 
    
81.                     /* 接收起始位唤醒 */
    ) q7 O- o# I/ L8 g6 Z
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    # \& K& p. [. [. ]' X( f# q
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    
86.                     }
    
87. 
    
88.                     /* 进入停机模式 */
    * E2 {& O, B0 q, O/ |! Q) w! j9 [
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    : F: R: y+ L$ \  E8 b* ^
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    
93. 
    / S, |8 Y# x# q* d$ g
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    % n* R" m- @# G) d- v
96. 
    7 E# t) D5 _! E2 E7 H
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    $ d4 p' s7 C4 Q6 c: T
100.                     break;
     
101. 
     4 ?/ h& Q" O/ `: [
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     ( D7 e( T. C% p3 }- r; \; ~
103.                     /* 使能LPUART的停机唤醒 */
     
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     . A* X& [9 V, t$ N% F
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），可以唤醒 */
     : n  _! ~4 _, O) ~# q
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     + d* A) W% V* y. G
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     0 Z# [9 _$ `2 `
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     , t2 a9 F, e; U- N0 |+ |
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     
121.                     /* 进入停机模式 */
     & n% ^3 M/ c, Q3 N( F3 x
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     0 k, V* T- y- r1 W: T- t( @; U" P
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     
126. 
     8 t9 v2 s$ J; m+ `+ Z% Q6 M
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     ' ^) ~: a0 K0 x; P8 @* \$ D8 Y
128. 
     6 |! d8 D7 a" [1 D
129.                     /* 关闭LPUART的停机唤醒 */
     , n/ i" \6 A/ F2 j' |0 w
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     ( e: e1 ^* C. U5 o! b3 ^$ N# g# G1 R
131. 
     5 @% O( J6 |3 m9 V/ y* S
132.                     break;
     
133. 
     : ?6 l# ]+ [: G, E  D/ Q. n
134.                 default:
     9 {. J4 u4 b  b' y2 }1 I3 j
135.                     /* 其它的键值不处理 */
     
136.                     break;
     
137.             }
     
138.         }
     
139.     }
     
140. }

复制代码

% P- d. t7 m. I* u. p5 n/ o66.8 实验例程说明（IAR）
9 z! s2 O5 I- y2 J3 D+ [7 d配套例子：
. p0 f) u. G6 Z6 b  H
) M. u! k5 F/ k* y/ ZV7-046_低功耗串口的停机唤醒（串口FIFO方式）

9 E! Q: y, x2 d4 o; N实验目的：

! i( F# L- o, H+ ?学习低功耗串口的停机唤醒。
实验内容：
! o" R1 m: T9 ?* Y
启动一个自动重装软件定时器，每100ms翻转一次LED2。
4 l9 \2 Y7 X8 X( t* ?% q( z当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
! W) d% V" f+ c. @2 v) _0 C上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
, l5 g. X2 u: _* t; o' A: U9 KLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

7 O2 ^: G: i: x+ oLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
9 G2 n/ V) A" Z( ~
( `0 b: X; m; {5 _LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。
: k$ M9 y+ N( R8 S7 ?& [
% V( f0 c3 @1 |# m7 X7 ]' ^% ]实验操作：

K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
5 T! a1 D9 B3 Y1 QK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：

6 P/ Y! q2 ]. [  m+ Q' ?波特率 115200，数据位 8，奇偶校验位无，停止位 1
( n* B* x9 C  R; G: [3 ~

程序设计：

  系统栈大小分配：
, a- k2 H" d; V. Q9 n4 U) u

& O8 d- a- T( W( w- G5 D; c
2 c7 {* ~( U9 o* w# W. r  RAM空间用的DTCM：
0 |7 ?9 b6 P  o  \. O3 K

+ v' |- |# V- n2 F1 S/ a  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
" |8 g. D2 G5 P3 G$ |
# ^" x+ i$ c  b% p1 n& o

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   2 A5 G' Z: o  U/ t( [! p5 |& [9 K
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   3 S5 h; p- z7 V% L5 n) ?1 v
8. */
   $ Y" A8 W7 |+ e
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    9 h+ f5 h1 x. P* k8 t5 C
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    5 P$ Y( ?7 O; L. k
20.        - 设置NVIV优先级分组为4。
    
21.      */
    ' K: j( m7 P: W, e1 z6 v4 u
22.     HAL_Init();
    
23. 
    . O5 ~. u' \' B! C4 S9 ~
24.     /*
    $ i* m% G4 k4 p" U
25.        配置系统时钟到400MHz
    & A' U$ K1 E1 V
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    . }; }5 c  j  b% |  U3 N
30. 
    
31.     /*
    
32.        Event Recorder：
    8 D: V5 B3 P$ c9 h% M0 L
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    7 j! M; ]& S2 M: R
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    * j! ^5 l. d' o9 r, t& O  {
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
      J4 c$ i# }, N" R1 Z& c
40. #endif
    
41. 
    4 N( L( L* y, a2 b( v9 L
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    ) i! r( k6 R) r6 M7 t$ x" E
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ; ?& ^9 F% z% x& C9 p
47.     bsp_InitLed();        /* 初始化LED */   
    ! ^- J  l) J( [- ^
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    9 ?. v& v: U8 k. E
49. }

复制代码

) Q& D* r  |" }  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   ; [' d4 E. W/ y+ y$ s5 X
2. *********************************************************************************************************
   , i9 ?, t( }. w! F% F3 O
3. *    函 数 名: MPU_Config
   ' h5 j) n) J, B* V  A! Z6 q  W
4. *    功能说明: 配置MPU
   % }& {4 R3 Y/ j- f* o8 u0 {! C
5. *    形    参: 无
   
6. *    返 回 值: 无
   6 S8 y  {/ f; T: R* _
7. *********************************************************************************************************
   & c+ ~$ \) B1 O& Y% a% i/ V
8. */
   $ f& R; P( y! B  Q
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    $ K! ^8 \0 J3 X
13.     /* 禁止 MPU */
    8 p% D. y/ W) f
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 D  C/ U( P* D
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 L' v% d: p4 J- m# f* S
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : [! }  H- U( ]1 }  w
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 D0 D# O3 p- Q) z! g: D! R
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ( J# V5 ?) A! I7 r
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    7 _8 x1 j: }) V$ q( Y4 O: a+ K* T
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    ; v9 w9 x8 E: L& ?/ J8 r6 H
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    8 s* c2 }1 g0 |/ w# ^/ t0 X
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    6 m8 e, @2 E( [: K5 Z% A; x* X
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    : p8 b: V1 T- Z; O& m
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    * |* ?: N7 q( |8 a  w, c9 s6 a
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    , m3 ~, n/ \8 K
44. 
    $ c3 ]) \& \. u  b
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    , [; F- Y. Y% {( @+ F' d
46. 
    
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    . B3 D" L& X3 \2 e* }
51. /*
    
52. *********************************************************************************************************
    2 d3 A9 t7 ^$ j' O
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    ' q6 ~6 X% E2 v! @  V% @
55. *    形    参: 无
    : K# \, F, Y6 F  Y& e
56. *    返 回 值: 无
    0 @# a. ^2 w/ D$ u
57. *********************************************************************************************************
    
58. */
    ; ~3 U  K! ^- I; |- p
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }
    # d0 v9 \! Y. {0 V. d! G3 m, [$ w
67. 
      |9 v; k9 q6 F1 Q: Z- {) O7 P& y

复制代码

) R$ ?; N1 I0 `  L" s+ i  每10ms调用一次蜂鸣器处理：
5 ^! {; f3 H- S
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

  e) b( I9 l; e% R& M9 ]8 @

1. /*
   
2. *********************************************************************************************************
   2 f4 P- F8 c0 m7 q; _
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   6 D: j& s* B( g+ |/ }$ M
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    ! N5 N) y% d: r. @7 j  s
11. {
    " S  l) k! x8 d+ [4 g! {  t8 O
12.     bsp_KeyScan10ms();
    
13. }

复制代码

/ z, g( ]8 N: @) ^  主功能：

- F% Q( f% T) l主程序实现如下操作：
* r5 j$ t; ^, Z# u) n  c
启动一个自动重装软件定时器，每100ms翻转一次LED2。
+ Y) w4 A" C1 U0 u K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
  m+ c/ o) o$ Q3 b8 B- Q9 A

1. /*
   + \$ k7 ]1 V) S  k; @4 F
2. *********************************************************************************************************
   ! ?+ r4 r3 o  g# y6 }  F2 J
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   - R5 b7 r+ U, w# h+ W5 }6 q; C- \/ Q! o
7. *********************************************************************************************************
   
8. */
   6 m  N/ m- }6 o3 }: f6 h( L3 c( H
9. int main(void)
   9 p) r& V' v0 r% N1 j" H
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    5 ]/ P& C( p. ?. {, C) ]" J
13. 
    
14. 
    . Z, m& r4 f- m+ h7 |* G# _/ l
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    % P0 q) ~+ k- z
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    7 @0 q* D7 p8 n; w  b! L
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. 
    8 z$ u4 T- |. Q- W5 ^
24. 
    5 Q6 h- f+ O5 o9 }8 a
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    0 W" T' @; J7 c
26. 
    * V# c3 S% f% _+ B' H
27.     while (1)
    
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    : r, K# o- t( q  l/ p) c1 _! n
30. 
    ( U2 w" u1 G' _& S
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    / N* M9 T  b; f1 O6 ]
33.         {
    ' a- Z6 B) i- D9 I" [
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    8 t% N. M  k3 E& {9 T! l7 h" A
36.         }
    * ]8 b. J0 {' d" h) `
37. 
    ( H( [) C9 u3 N# R
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    
43.             {
    
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    3 B1 M* O" t% Z; e
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    + I8 P- H* V( G- [2 X
47. 
    - U  W; n% ]7 B
48.                     /* 确保LPUART没有在通信中 */
    
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    9 {+ W1 Y* k9 |% f' c% R
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ( Y4 c* B" q; b+ k. l
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
      l: U8 ?4 L- ?
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    
58. 
    
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    3 j) ?3 u, Q( B) S7 w% u
61. 
    - b6 E6 Y4 J( Q$ E7 e+ ~
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    - B2 S7 l* W* ~5 A7 Q
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    . ?$ T) f/ r( E: R
69. 
    " Y. i* J% G8 x7 w
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    ) I2 z" S* v9 _
71.                     break;
    & E, ~+ j& n# d  r; `- j# ~" g
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    ( E: x" y- l  b# E9 \) f& r
76. 
    : i( g: ~  S" R% Y0 a/ ^
77.                     /* 确保LPUART没有在通信中 */
    ' L( A3 ]  w% M* F7 \7 j
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    & m% |$ S6 X1 q. O
80. 
    
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    7 k1 x) |+ i- V0 Q) A& f& y2 L' g
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    8 V- `0 A- K  Y( }; |' ?6 F
86.                     }
    : k3 c* x% F! m7 W  {$ n( t
87. 
    4 T% {- G7 {7 c. s7 K; J- y$ T
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    + y  ~: G; _- Z
92.                     SystemClock_Config();
    + x. X! }. q) f- M9 m( d) I' E( y
93. 
    4 k+ f% F. O$ r- Y) [/ {
94.                     /* 关闭LPUART的停机唤醒 */
    ) r, m  A3 A) i
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    9 c% j6 v  p) K* P  c, v
96. 
    0 R- c8 |$ p% V7 N( D: }% z% ^6 Q& ]
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    7 ~: L1 q, b+ I$ w+ s1 B
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     ( k- }# M" T4 x$ w+ |
101. 
     7 y" ~7 C0 ?. R- t1 S  b+ c! c8 Z
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     8 z. L, s+ A" N) G5 X
103.                     /* 使能LPUART的停机唤醒 */
     ) S* l5 J2 n( e9 U! J( u4 N0 R
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     ! g  W9 M- J1 l( ~6 K. J0 |
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     0 a0 @, O- P  i, i1 i
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     ( Y% j$ e" w  g8 [
109. 
     2 X7 G( T( G2 _3 m* m  O7 Y- z2 p
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     + A0 E# I1 Z  @' h- _: o$ Q
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     
121.                     /* 进入停机模式 */
     & \9 \/ S9 d! H1 a$ ], ~
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     0 m) u! X: X0 M
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     8 \, P. \) p3 [( W- ]) Y( G8 A# N
125.                     SystemClock_Config();
     
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     8 v" g! g/ R% I) A3 W( ]
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     4 Y# A: B" I. t4 ^# P
131. 
     # L: {# n5 T& c* K
132.                     break;
     " T. ?: p0 [7 A! X( O4 G1 K
133. 
     
134.                 default:
     3 P( i3 B) H) B& a9 Y/ V
135.                     /* 其它的键值不处理 */
     4 Z% I; T* J; c/ S) h
136.                     break;
     , h& s+ y5 E  c# _7 A
137.             }
     8 Y1 w1 z$ @1 {" T# k
138.         }
     
139.     }
     
140. }
     ' W: t3 V6 D/ Z6 P

复制代码

. Z+ k% W+ E! Z  E0 f% Y
, t$ q- f2 u( r4 @. q! w66.9 总结
& {  @  y/ i# l) Q" L7 A本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。



$ H1 ?: u  A9 s( ~  V( a  _