66.1 初学者重要提示
. h) e' V. |; I  学习本章节前，务必优先学习第65章。
  低功耗串口FIFO的实现跟前面章节通用串口FIFO的机制是一样的。
5 v! E7 ]3 ?& p2 @  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
) v" L0 u7 I+ p4 R5 u. J  p* r66.2 硬件设计
STM32H743XIH6最多可以支持8个独立的通用串口和一个低功耗串口LPUART1。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
+ T# ^4 r, s$ R3 Y" B
低功耗串口LPUART TX = PA9，   RX = PA10
/ q8 _& j: V& |9 Z7 X9 ^: V
串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）

串口USART2  TX = PA2，   RX = PA3

串口USART3  TX = PB10，  RX = PB11
; T+ u7 ~0 P5 W) N' h
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
. E+ `6 s* J; _! C% M
# M" j3 G" b- @+ @. R) v串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
6 C) I$ `1 R0 y6 ]/ m
串口USART6  TX = PG14，  RX = PC7  

串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

* w6 `5 D* a- [7 ?( p, L串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

STM32-V7开发板使用了4个串口设备。
; U# Y8 K! n0 n. H
  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
  串口3用于RS485接口
) j, e3 H" ~; E" {' Q: ]  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
3 {8 q  U) c! W3 g; c2 \3 Y下面是RS232的原理图：
' p5 B; N/ K" _2 a
! W% s8 X& b' y! _' T

关于232的PHY芯片SP3232E要注意以下几个问题：

/ g6 {& Z/ p, M+ o  SP3232E的作用是TTL电平转RS232电平。
0 b. t" `/ o$ Z- p3 J  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
! M' ^8 f8 {  V5 [  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

, t' R! f- C* g2 u- x

- ]0 c$ B+ G" K# `2 X6 I- Y9 i2 n实际效果如下：
- ]! S6 Z  g2 {  w/ c
$ t6 g$ T7 _3 ~/ E( L! C/ [& `

% T- ?) C1 W4 n; Q
通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY

2 Y2 Y" F4 k  X& t$ i/ ^0 Z芯片是否有问题。
# U6 A' D; F6 L/ N* T
, c9 k3 v, K; m) N' j0 v1 M  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
66.3 低功耗串口FIFO驱动设计
* {4 J) b, D) O$ S. s66.3.1 低功耗串口FIFO框架
4 m' l" S' {( W+ y4 \8 K* }: q+ t为了方便大家理解，先来看下低功耗串口FIFO的实现框图：

5 B* _, d. j) x9 _+ w' [0 E5 T
  第1阶段，初始化：
8 v( y; m" Z, k6 e
通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
' @7 o% x" f4 ^" Q* `, C  第2阶段，低功耗串口中断服务程序：

* H1 l1 M6 d& k/ S- R, ?  接收中断是一直开启的。
  做了发送空中断和发送完成中断的消息处理。
  第3阶段，低功耗串口数据的收发：
8 J1 w5 U* ]6 V: l6 \
# s) b8 a0 e  r: a. W: `/ n低功耗串口发送函数会开启发送空中断。
低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
- u5 d( I, Y6 I$ x' i) ], p66.3.2 低功耗串口时钟选择
我们这里实现了三种时钟选择：
# d* C8 H8 a; W& u+ X. V% \
4 B. \- j" @( e  }9 wLPUART时钟选择LSE(32768Hz)
最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
$ Y6 |: f3 ]/ t4 h0 O/ g* {
LPUART时钟选择HSI(64MHz)
+ v# A- S' v: K5 s: Z* Y最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。

LPUART时钟选择D3PCLK1(100MHz)
最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。

1 w) f1 C) E) V2 j/ q如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，程序代码如下，用户可以根据需要，使能相应的宏定义：
0 _; m9 y1 i+ |; w6 `& ~! D  X

1. //#define LPUART_CLOCK_SOURCE_LSE      
   
2. #define LPUART_CLOCK_SOURCE_HSI   
   
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   / S0 v) {6 ^7 K7 G& ^& F
4. 
   
5. /*
   6 q; l# n# w+ Y
6. *********************************************************************************************************
   1 ~1 Z% u! o7 v  l; e+ T
7. *    函 数 名: InitHardLPUart
   , X- v2 D. u" w% a2 k- F
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   
9. *    形    参: 无
   
10. *    返 回 值: 无
    # R0 P6 x0 T6 U- V" R. y
11. *********************************************************************************************************
    6 m: S( g1 M$ A3 k5 _5 O
12. */
    
13. static void InitHardLPUart(void)
    ! F7 Y. z+ y/ d3 x7 [9 W6 ^$ M% u
14. {
    
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    % |% C% M# n$ D  U: z: u. e6 e
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    4 ~9 U, s0 O6 X6 j6 Q
17. 
    
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    & F1 p; ~, E$ P
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    7 |/ Y0 m& K" S! }
20.     {
    
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
22. 
    
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
      k0 Y& U) @& v, [( N8 g' E
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    
26. 
    ; d" I6 a# x6 Y/ U5 {
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
28.         {
    9 {0 p) T. L$ E7 [+ A
29.             Error_Handler(__FILE__, __LINE__);        
    ) h( g7 p2 Q1 P9 j& V5 }
30.         }
    / I. W6 o0 j% l7 A! E2 B8 T* ]
31. 
    
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    - o0 Y- {, L. l. b2 f# m. O6 U
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    7 O1 [  E: O: Q& H7 c
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    9 A" S3 w$ W% A1 G
38.     {
    
39. 
    
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
41. 
    + G3 ]+ H% J0 R6 C
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    & N0 w9 d; u. J) y3 [1 N
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    ' x) r! O# {" V  B( W( i
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    + C9 n8 J1 Y2 n( H5 p
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    
46. 
    
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
48.         {
    
49.             Error_Handler(__FILE__, __LINE__);        
    % K8 [# a0 _% P9 g  K/ ?9 S
50.         }
    8 l' H% U. S7 }" O
51. 
    
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 */   
    ! f8 L+ }6 l# }& d
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    ! `" {1 T6 z0 m7 k6 X
58. 
    
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    2 Y3 x4 W% k; p. H. i
62. #else
    : d# ^) d8 G: w' Q5 V; Q* j
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    
65. 
    ) ^' }) \9 r7 u2 G% _
66. #if LPUART1_FIFO_EN ==
    
67.     /* 其它省略未写 */
    
68. #endif
    3 e# E* S" m/ E0 a) s
69. }

复制代码

66.3.3 低功耗串口FIFO之相关的变量定义
低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。
$ ]( S% x& H) c- v0 `
这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。

每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

2 ^* o1 w" ]7 w* E0 f  I我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。
1 G8 }8 ^7 x; c& \( o4 I  A

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   + G/ E( U, c, g. o; h# T
2. #if LPUART1_FIFO_EN == 1
   
3.     #define LPUART1_BAUD         115200
   
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   $ V4 ?! k) e' \2 {
6. #endif
   $ y) J, l1 V: R# e0 `
7. 
   
8. /* 串口设备结构体 */
   9 Z% c* O. l( h  z5 {) b0 q  L8 f* Z% {
9. typedef struct
   $ n( Y8 v; a! ~. Q5 u
10. {
    
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    - q0 E  v- C, d
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    5 @, L+ \; o+ B+ C% F- h
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    / ~/ B/ e1 c; `5 f' @0 @
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    
19. 
    
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    - W0 S, h0 |1 |# |
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    
23. 
    
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    ) ^9 I1 L, Y5 |0 w0 r
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    
29. 
    * h% C+ ^' n, v5 c1 {: b/ _3 S
30. 
    3 g8 N. u9 w4 K- O
31. bsp_lpuart_fifo.c文件定义变量。
    
32. 
    , i" e% \% H" I( t4 ~$ j
33. /* 定义低功耗串口结构体变量 */
    2 [* f& D6 j$ i6 O6 t
34. #if LPUART1_FIFO_EN == 1
    
35.     static LPUART_T g_tLPUart1;
    3 S+ U+ j6 m+ X! d- u: `9 p
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    + a, m8 [  G$ P' }- j6 r
38. #endif
    

复制代码

# b  G  \+ N: g: m$ ~关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
0 t% z4 a' s) o( r# W* ^3 }9 m
66.3.4 低功耗串口FIFO初始化
低功耗串口的初始化代码如下；
+ K+ w) Z; s" m! W
8 C$ T2 C! q- c7 \+ g/*
*********************************************************************************************************
*    函 数 名: bsp_InitLPUart
8 a; r' @  T0 N. O9 C( _*    功能说明: 初始化串口硬件，并对全局变量赋初值.
*    形    参: 无
( o; O- H& I' B! g. t0 A*    返 回 值: 无
) T% f9 B4 p5 `*********************************************************************************************************
. P0 y* X2 E" Y, w  c*/
% d: N1 u8 W, mvoid bsp_InitLPUart(void)
{
    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
}
  q( B3 L. s3 _

7 W: R% Q6 d+ Z0 F* V& Y下面将初始化代码实现的功能依次为大家做个说明。
7 H, C$ E  }, J
  函数LPUartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
; Z. i  C* e6 g% Q2 }

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: LPUartVarInit
   1 O  @4 M0 H# l* ]0 s! a
4. *    功能说明: 初始化串口相关的变量
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   " }& M# e' i2 j( g8 [
9. static void LPUartVarInit(void)
   : o  e2 |/ d* x
10. {
    / Y$ R$ F% U; ^
11. #if LPUART1_FIFO_EN == 1
    ' A6 T" p4 ?; Q+ o' A5 C* H# C# L; R
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    8 X, H% p0 w  ~4 F
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    ! V- J1 D! ^) A' {+ N
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    6 k' \* F/ v* L% }% F4 {
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    ( K* k+ q# F  Q3 P2 T5 {
27. #endif
    
28. }

复制代码

# |+ B/ `) O& Z( y: K

  函数InitHardLPUart
此函数主要用于串口的GPIO，中断和相关参数的配置。
, n, `" C: g3 R& O3 z5 P6 v/ q
: ]3 M5 L4 |; _, _6 g1 w6 i

1. /* LPUART1的GPIO  PA9, PA10 */
   8 |' j: p+ S5 J+ D) H
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   
3. 
   0 D$ ~* p1 g/ L1 n' W1 L" Y9 w; j
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   3 r! O$ c3 ], F: L
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   
8. 
   
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   5 I9 F8 B7 t4 f/ a2 O4 d5 b
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    1 r: [4 F3 Q. \3 [5 H$ P& s6 C2 x# D: I
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
      ^; [, k9 ~4 j3 _: g8 [% g
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    8 N" _% M* s1 J2 o' ?. w
13. 
    * A5 |7 A+ \/ Z  b) X
14. /*
    - ?9 H& p6 V# ^1 k  d; i
15. *********************************************************************************************************
    
16. *    函 数 名: InitHardUart
      E7 y. ^4 N4 v1 B
17. *    功能说明: 配置串口的硬件参数和底层
    ' j: F! o! i1 s: z
18. *    形    参: 无
    ) N9 m; x2 f  q. M9 s
19. *    返 回 值: 无
    
20. *********************************************************************************************************
    
21. */
    * N' l4 F0 \# Z  F8 u4 u" ^1 E6 G
22. static void InitHardUart(void)
    
23. {
    ; S' o2 J& v' B' k0 @9 @8 p
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    & J9 [# t' B/ t# B  _5 ]
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    0 X; F: G  c, z
26. 
    
27.     /* 时钟初始化省略未写 */
    . {$ F' `0 r1 j
28. #if LPUART1_FIFO_EN == 1        
    
29.     /* 使能 GPIO TX/RX 时钟 */
    : Y9 U2 m4 K  P. e3 I) p9 o
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
    
33.     /* 使能 USARTx 时钟 */
    
34.     LPUART1_CLK_ENABLE();   
    7 Z5 @2 v" V+ v# V0 c9 c$ J* [
35. 
    ; `& y6 b% `; q0 Q8 B/ G, T2 W& K
36.     /* 配置TX引脚 */
    
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    % b# C( v# G: L4 u, V' w9 O
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    % B: q3 z; O5 h0 a4 V, F# J. Z# g
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    % A9 D1 V3 ?* b5 K3 E8 k
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    : ~* n$ d9 u, W$ [% s" d
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    * G2 L7 Y2 `1 \7 o  @9 }, j
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    
43. 
    
44.     /* 配置RX引脚 */
    
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    - o2 t: q2 h+ ]% x1 @
48. 
    
49.     /* 配置NVIC the NVIC for UART */   
    
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    ( L% V- [4 M  n# t, a2 j. t, L4 A
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    
52. 
    3 b, H5 @8 o2 X4 |) U) a
53.     /* 配置波特率、奇偶校验 */
    
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    . s# s: h9 B/ _6 G8 X
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
59. #endif
    
60. }

复制代码

: Z& Y3 ]! C2 q& O( z& W低功耗定时器的参数配置API如下：
) h* W5 n1 c0 D1 A) O+ z
! [* Q3 J$ _& H# U# Z% X8 A3 H; N" X

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_SetLPUartParam
   
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *    形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   ' _2 O5 Y3 G; K
7. *             Parity     校验类型，奇校验或者偶校验
   5 y* u; o% g5 \! A
8. *             Mode       发送和接收模式使能
   3 _9 t, c" o8 t: c( _* `3 q* K
9. *    返 回 值: 无
   8 K/ Z. [% \% a
10. *********************************************************************************************************
    
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    1 U3 }. F& T* b1 l; t6 z/ }
13. {
    4 J' u* Y4 e& f) `- r8 b2 H
14.     /*##-1- 配置串口硬件参数 ######################################*/
    
15.     /* 异步串口模式 (UART Mode) */
    : h  z- G4 w6 S; Q9 s
16.     /* 配置如下:
    6 M$ p* v8 `( v+ p  O+ [  P" z7 {# H
17.       - 字长    = 8 位
    
18.       - 停止位  = 1 个停止位
    ' ]# [# s; s" A0 j; }2 D
19.       - 校验    = 参数Parity
    
20.       - 波特率  = 参数BaudRate
    # G% o$ z8 a* E3 o: S& t' z9 A
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    
22. 
    : K6 `3 G% g$ Q, ?* R5 _
23.     UartHandle.Instance        = Instance;
    
24.     UartHandle.Init.BaudRate   = BaudRate;
    
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
27.     UartHandle.Init.Parity     = Parity;
    ) ~5 S) \. m0 K# C
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    3 O7 I3 C' N) `* n( C% {
29.     UartHandle.Init.Mode       = Mode;
    
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    4 i' y: s& n" h, @
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
33. 
    
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    ) D. G. z+ c/ h  {' [# x
35.     {
    
36.         Error_Handler(__FILE__, __LINE__);
    9 v$ }! {& u9 o
37.     }
    ' a4 v# K3 x% [$ L. J
38. }

复制代码

% B) v/ W+ m0 K
; t% C& z' Q4 V+ E5 W( C# R% I66.3.5 低功耗串口中断服务程序工作流程
9 [& ?2 d" u1 J) E串口中断服务程序是最核心的部分，主要实现如下三个功能

# o  A8 z3 y+ c* P: }  收到新的数据后，会将数据压入RX_FIFO。
  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。

/ ~+ T# f* m- P7 E) c- J. |+ u
* t8 B, Q& c6 U下面我们分析一下串口中断处理的完整过程。
- _7 G0 Q  r" g" i, O% W
当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

0 x% X* n$ y% P' R0 T我们将串口中断服务程序放在bsp_lpuart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_lpuart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是低功耗串口的中断服务程序：

* L" Y/ U( ~# a. j4 f  e9 D5 u1 ^( p

1. #if LPUART1_FIFO_EN == 1
   
2. void LPUART1_IRQHandler(void)
   
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   # o& \/ ~* \$ ~# U% F1 J% z
5. }
   
6. #endif

复制代码

# ?8 A: N- f8 W6 M% Y下面，我们来看看UartIRQ函数的实现代码。

% @/ v4 _8 b+ _  R' N

1. /*
   
2. *********************************************************************************************************
     S% x: _$ _7 ^5 n/ @
3. *    函 数 名: UartIRQ
   
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   $ `( u1 d8 g) `" J
5. *    形    参: _pUart : 串口设备
   ) C6 l9 q, M( Z: F% u) R3 ?
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   8 _7 K6 U5 S6 ~0 e7 z+ x% [
10. {
    
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    % ?2 ^# Y# b, K" o' J9 o
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    $ @3 \' j% R5 Y& U; K. q( v
14. 
    
15.     /* 处理接收中断  */
    * ^6 a( I" _6 C6 j9 |
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.     {
    
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
    
20. 
    
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    # R; R1 I) {7 b- m0 h8 O  G1 ?
24.         {
    4 j3 H1 T, S1 W+ @
25.             _pUart->usRxWrite = 0;
    
26.         }
    
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.         {
    $ H1 p+ K9 e: [! T
29.             _pUart->usRxCount++;
    * V; F7 H: y5 T6 J5 r  N& E
30.         }
    * s: z5 e& z0 T
31. 
    * I  _8 s& ^  g+ Y+ b+ |7 L0 H
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.         //if (_pUart->usRxCount == 1)
    
35.         {
    5 L5 B5 X# E8 p5 l9 n& M- M
36.             if (_pUart->ReciveNew)
    
37.             {
    
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    9 I; Q, C* V+ N: ^/ s/ g4 f
39.             }
    $ O9 S, E: I$ x: b0 z6 c+ ~
40.         }
    8 f1 O- Y; w" `' \' p; F8 ^/ C9 T
41.     }
    
42. 
    # p5 {) \9 ?9 K3 A
43.     /* 处理发送缓冲区空中断 */
    ' K* f. i% j. C% \
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    : f% R: }; p, ^2 Q4 t! v
45.     {
    
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    9 Y" P7 r: {6 |" Z2 l) N- V7 o
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    , }" U8 a: Y! _# J' s
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    : X8 o+ V. u; u7 }! Z
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    4 c' }" B+ \% O3 U" D$ I1 e( Y
52. 
    
53.             /* 使能数据发送完毕中断 */
    
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    ! M' o" z) Y' @: t
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.         }
    * u2 B( m" h- ^# _" z
57.         Else  /*　还有数据等待发送 */
    : m+ J) d2 [# `7 r' s
58.         {
    : u, Y) g; r6 c, g9 ]  e
59.             _pUart->Sending = 1;
    
60. 
    
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    " y, e' `3 P3 z( H  ~3 O
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.             {
    , S! z0 d: `% w( y; ]* D& O
66.                 _pUart->usTxRead = 0;
    / Z+ K  R  j* c1 m9 d
67.             }
    1 }4 u& G; s9 ?! k9 ?: b
68.             _pUart->usTxCount--;
    + {. F: h5 d+ V
69.         }
    + ]& D) B6 B* {' p2 |
70. 
    2 I& F. ?; S7 l! _. u
71.     }
    6 |# q$ u* L+ j1 x! u
72.     /* 数据bit位全部发送完毕的中断 */
    1 z+ Q! i8 C& }$ t8 N
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.     {
    5 M+ ^5 a8 d& S2 w. h9 ~
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    ) ?: h5 c& x% [- p( Z$ G
76.         if (_pUart->usTxCount == 0)
    - B/ f3 l5 b! [: e
77.         {
    
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.             if (_pUart->SendOver)
    $ k# R$ t  w7 k6 e! g; I# B* g
84.             {
    $ M  m8 W5 x$ t/ c. W. e
85.                 _pUart->SendOver();
    
86.             }
    . O6 d) [2 q2 I
87. 
    
88.             _pUart->Sending = 0;
    
89.         }
    
90.         else
    
91.         {
    & N1 O: O; j1 l- k. V1 {
92.             /* 正常情况下，不会进入此分支 */
    % G  Y, ]- \# `7 M. k- Y
93. 
    
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    % c3 n( {- L7 D/ C! G6 g. W
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    ' [& D# r4 b$ R
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    * u+ N  E+ E: M" {- G
98.             {
    
99.                 _pUart->usTxRead = 0;
    
100.             }
     $ H5 k9 b  }4 Y7 _  c- b, X
101.             _pUart->usTxCount--;
     0 H& |- ~1 G, D+ l8 k+ l  _" C
102.         }
     & A' I& N, _! Q! Y. ]# q
103.     }
     
104. 
     7 J  Y9 ~6 u" _: D, b! `  s
105.     /* 清除中断标志 */
     ' q: \2 T7 _+ x0 k3 D8 D
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     $ k- t6 z# n8 W5 O5 X
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     3 u- ^3 v# @( }
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     ' Y  ^- f) U0 ~# E6 L
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     " h/ R  ^0 I! i: K4 {0 t1 M
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     # a6 h( i0 t5 P& h# C- \2 S
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     : {# t% S- x; `6 G" @4 M- ?
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     2 |) F) D) q, m9 d
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
2 ~8 z3 q8 f  p. ?; G! Z4 o0 z
% W' E8 N0 A0 W7 R. h  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
) c: K9 C9 d' O( K3 o
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
  ?3 s" J; s7 u4 v9 Q
, z& F) s3 b& V1 X  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

# u! u: w8 V2 V* P66.3.6 低功耗串口数据发送
$ l; ^) \* \; h2 k, R( I低功耗串口数据的发送主要涉及到下面三个函数：

9 u: @4 F% J- s3 d3 S1 g+ V2 Y% S

1. /*
   
2. *********************************************************************************************************
   $ Z  o! a0 [4 }
3. *    函 数 名: lpcomSendBuf
   
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   : I+ d3 Z6 d3 X8 k
5. *    形    参: _ucPort: 端口号(LPCOM1)
   ( ~% v9 R7 M  N  ]# C: S8 @9 r2 b! \
6. *              _ucaBuf: 待发送的数据缓冲区
   
7. *              _usLen : 数据长度
   3 _7 C  T& y7 M. o
8. *    返 回 值: 无
   , j2 i  w& Y* a5 F9 a
9. *********************************************************************************************************
   
10. */
    
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    8 Y- a+ {8 ?) C6 v& y7 F9 d
13.     LPUART_T *pUart;
    
14. 
    
15.     pUart = ComToLPUart(_ucPort);
    5 W7 F5 f: Q5 t# J
16.     if (pUart == 0)
    : e+ x! }  b# J. c, W. r
17.     {
    
18.         return;
    + d1 |( q7 ?+ U# w1 O$ s; {
19.     }
    ) W, N* j  W; ?# G" ^+ M9 J3 y+ K
20. 
    ' \7 U" p3 T  w- e
21.     if (pUart->SendBefor != 0)
    
22.     {
    7 ?$ S5 o9 a- S
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    # V2 C! N! ?( z9 e! B
24.     }
    / ^( s: F' [6 e
25. 
    5 ^" @) ^+ w" W
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    8 Z' B& d+ b+ m+ Z# _
27. }
    7 \) x% ~7 f3 y
28. 
    , k  d5 o5 s6 F1 W8 |
29. /*
    
30. *********************************************************************************************************
    
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *    形    参: _ucPort: 端口号(LPCOM1)
    
34. *              _ucByte: 待发送的数据
    
35. *    返 回 值: 无
    
36. *********************************************************************************************************
    
37. */
    
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    8 c: c2 |- v( D" J* p  ]" a
39. {
    
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    3 o9 B; T+ D3 a( ~1 p* L- Q
41. }
    ; U: k& m1 L, z! E
42. 
    
43. /*
    ( \* ^* C! H0 W& i! u; ?
44. *********************************************************************************************************
    
45. *    函 数 名: LPUartSend
    5 p7 A1 c0 _% T8 i- s
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
47. *    形    参: 无
    - |7 D; p; R* T+ W
48. *    返 回 值: 无
    
49. *********************************************************************************************************
    
50. */
    & k% B5 l, g5 g0 }
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    + d* Y1 l% f. T  A- a/ @. s
52. {
    
53.     uint16_t i;
    6 q% K  K: J# u. w$ J; r
54. 
    : N/ @, ^( i  g" }9 v
55.     for (i = 0; i < _usLen; i++)
    
56.     {
    
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
58.         while (1)
    
59.         {
    
60.             __IO uint16_t usCount;
    # E* f+ W7 g; |5 [) ]
61. 
    7 Z6 G: S- \+ E2 B
62.             DISABLE_INT();
    
63.             usCount = _pUart->usTxCount;
    $ I9 E" t7 t9 V$ [$ s9 t; p
64.             ENABLE_INT();
    3 |! B" s5 B- B) D+ ]* t+ d
65. 
    
66.             if (usCount < _pUart->usTxBufSize)
    6 i3 ?" |5 Y' g$ R1 O$ p. F* `) _
67.             {
    1 Y& G+ G1 C! [4 K  n8 G+ `, g: i" J
68.                 break;
    
69.             }
    ; Q1 z0 M, K0 W2 S8 s+ [1 U
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    $ R& ~% @6 V) T7 w$ \! J2 Q7 P
71.             {
    1 t/ r* Z6 D4 Q
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
73.                 {
    + F# p( f7 [& B% I3 \, j) q. V
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
75.                 }  
    ) w$ `3 s* ]6 L7 y' f) g% e
76.             }
    
77.         }
    - H5 w. |9 M. b
78. 
    
79.         /* 将新数据填入发送缓冲区 */
    , E0 N" Q, [$ ?2 z( {
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    ! o$ A0 J0 X% z6 I- @
81. 
    : J0 T2 B9 G  C3 s
82.         DISABLE_INT();
    6 `$ @4 j! j* g$ K
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
84.         {
    # L: j$ F; R4 `2 E! [* a
85.             _pUart->usTxWrite = 0;
    : g. X9 l( E% d6 @4 [
86.         }
    
87.         _pUart->usTxCount++;
    
88.         ENABLE_INT();
    
89.     }
    
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    
92. }

复制代码

函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。
9 Z- {& A* o. h6 n1 u
函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
( ?) y$ @, Z" O1 @2 Q
  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
4 a* I. m' l" p$ c  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

* v$ t# ?1 S& Y6 z注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。

函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。

1. /*
   
2. *********************************************************************************************************
   0 n4 I) |4 P# O4 I( p. M: d
3. *    函 数 名: ComToLPUart
   + Q9 U2 N& H8 V- f) z
4. *    功能说明: 将COM端口号转换为LPUART指针
   ; Q8 r$ k' d/ N1 o  L, l$ t
5. *    形    参: _ucPort: 端口号(LPCOM1)
   5 q  N' A; Z+ o6 |5 x9 c) f; ?
6. *    返 回 值: uart指针
   7 T) T$ ?" r4 G3 k0 {
7. *********************************************************************************************************
   
8. */
   
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   
10. {
    
11.     if (_ucPort == LPCOM1)
    
12.     {
    
13.         #if LPUART1_FIFO_EN == 1
    
14.             return &g_tLPUart1;
    
15.         #else
    
16.             return 0;
    
17.         #endif
    
18.     }
    
19.     else
    
20.     {
    
21.         Error_Handler(__FILE__, __LINE__);
    . A1 B3 F% i9 R$ v+ q
22.         return 0;
    3 L! a; u0 f, Q
23.     }
    
24. }

复制代码

/ g* H! q2 M) a, g% D
" V; }9 t0 ]; L
4 S5 M$ Q$ Y% _0 |, Y6 A( r66.3.7 低功耗串口数据接收
下面我们再来看看接收的函数：
& _4 X, K. I- N' I# s

1. /*
   - ]" b0 j, k' K) \: N, y# U* E
2. *********************************************************************************************************
   
3. *    函 数 名: lpcomGetChar
   . l5 C. s+ d& C/ Z
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *              _pByte: 接收到的数据存放在这个地址
   
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   % e/ w3 X1 a. a8 a& F
9. */
   
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    6 l( l; N! }/ g0 E8 e
11. {
    
12.     LPUART_T *pUart;
    
13. 
    
14.     pUart = ComToLPUart(_ucPort);
    ( S) ]6 d7 y  n8 M
15.     if (pUart == 0)
    " h; b1 _! I. @" f, i. E( n
16.     {
    
17.         return 0;
    : Z( m" i: m- S% I* b; C  s
18.     }
    , s! N8 h9 o- c/ v
19. 
    
20.     return LPUartGetChar(pUart, _pByte);
    
21. }
    
22. 
    ( I' P  J, `- }/ R
23. /*
    
24. *********************************************************************************************************
    5 G& b- X* z" t
25. *    函 数 名: LPUartGetChar
    / c& Q5 u( ~3 W( {
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *    形    参: _pUart : 串口设备
    
28. *              _pByte : 存放读取数据的指针
    : E5 m; Y6 y) g4 }. Q. @1 M
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    
31. */
    " |) K3 P5 ~% B1 n
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.     uint16_t usCount;
    
35. 
    
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    ' i2 |  w% K/ `; i! c! r
38.     usCount = _pUart->usRxCount;
    
39.     ENABLE_INT();
    
40. 
    
41.     /* 如果读和写索引相同，则返回0 */
    
42.     //if (_pUart->usRxRead == usRxWrite)
    
43.     if (usCount == 0)    /* 已经没有数据 */
    
44.     {
    
45.         return 0;
    
46.     }
    
47.     else
    
48.     {
    2 X, q" m7 y9 `, j' E
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    * `0 B2 f6 E7 M3 Q7 b, P
50. 
    ! _$ X; l7 S4 b% F0 m7 ^" x
51.         /* 改写FIFO读索引 */
    
52.         DISABLE_INT();
    0 I+ n& N; {) Y
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.         {
    , ?$ I6 K3 s! c2 ^
55.             _pUart->usRxRead = 0;
    $ c3 j& B7 X8 B% Z5 W3 L  k3 _6 f9 m
56.         }
    . N  l! W6 O8 i& }% d6 G! r! ?
57.         _pUart->usRxCount--;
    $ p( o9 u" H( ?. N& m
58.         ENABLE_INT();
    
59.         return 1;
    
60.     }
    * V6 ^5 D5 A$ w5 \% R' h) s
61. }

复制代码

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

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

66.3.8 低功耗串口printf实现
" c5 {/ B7 e0 v! i, V0 @4 w9 Yprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

* l* _) |: i- Z7 E为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
( S+ s6 `0 O1 m/ |- Q& x
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。

实现printf输出到串口，只需要在工程中添加两个函数：
! o+ U9 K) \) C6 l

1. /*
   / d# P* x0 A  Q8 w3 x- y& ?3 P$ y( F
2. *********************************************************************************************************
   
3. *    函 数 名: fputc
   
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   4 f6 o$ Y2 W" R% `
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. int fputc(int ch, FILE *f)
   , R: u$ ]+ n$ _, c8 Z# x& R( W+ G. b
10. {
    . ], R! S  y7 \" }! k, U
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.     lpcomSendChar(LPCOM1, ch);
    
13. 
    , K6 E$ g/ @( L& h$ ^/ m
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    8 t' O: ~5 N: O* }1 x  \
16.     /* 写一个字节到USART1 */
    
17.     LPUART1->TDR = ch;
    
18. 
    % Z( s; M1 q; i3 G. }
19.     /* 等待发送结束 */
    ( G: O( @+ l( X* ^
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    ; D: M! E, e, I. q
21.     {}
    
22. 
    
23.     return ch;
    7 g% K8 |2 K1 B7 g6 r6 {
24. #endif
    1 t% g5 a6 ?; F2 \7 z) p
25. }
    4 v8 \9 V1 I% a6 R
26. 
    
27. /*
    , O; I5 q& _1 f  c! |
28. *********************************************************************************************************
    
29. *    函 数 名: fgetc
    3 f' A8 M/ ], H3 ~3 ]+ T
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    * {4 C4 |+ W. {) c( ^, Q" f8 Z5 F
31. *    形    参: 无
    + K5 m  C  R% G
32. *    返 回 值: 无
    
33. *********************************************************************************************************
    2 E) H3 @( k* r+ m6 B4 r2 ^
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    ! C6 O" m. ?! l  T
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    
40. 
    ) \9 f- ?- C( P# \1 z7 r0 C
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    . h2 R5 k9 c3 K  e  }
42. 
    
43.     return ucData;
    ' y. B% S8 I5 X/ x5 K. R
44. #else
    
45.     /* 等待接收到数据 */
    
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    
47.     {}
    
48. 
    
49.     return (int)LPUART1->RDR;
    ; x3 H1 b8 Z: V6 ^
50. #endif
      W5 @& q0 ^% X3 n" M* y8 ?
51. }

复制代码

: S' p0 g  E, C; O7 w( @; _通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
, ^" D. I6 ^: w
66.3.9 低功耗串口停机唤醒方式
低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：

. U2 l3 M, _" U8 i8 k' F. @3 D  检测到起始位唤醒。
5 V  S+ ~1 Z. ]' h低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。

如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   ; S# A3 _0 |; |  {
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   7 A5 r) i  W* F( m8 D1 u5 y
7. 
   
8. /* 接收起始位唤醒 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   . v' A/ y" F4 ?" {2 R# B. X
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    % n. y6 t. J7 W
12.     Error_Handler(__FILE__, __LINE__);                        
    0 k9 n9 x( m/ E
13. }
    
14. 
    , `2 X* v3 O7 h: j
15. /* 进入停机模式 */
    2 r4 b' W$ ]- e' p
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    8 W/ g9 |) g1 u: D# g: z# `
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    
20. 
    / K$ k/ }- a" R  f3 j& B* {" ^
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    ) N, b' G4 c% \

复制代码

! Q3 _* ^* r4 C
' n5 Q; N9 s$ y8 s  检测到RXNE标志唤醒，即接收到数据。
低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。
0 v6 c) C4 @/ U
& g0 V, @, S8 r0 k# U: O2 g) ?1 e如果想唤醒H7，发一个任意数据即可。
# U! I2 f3 t: n, x) ~9 u$ m% N" m

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   * v; C' B# ^" K5 H
3. 
   
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   9 i" C- p& H4 ~% s
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   0 k! n1 ~$ f" W$ C
7. 
   
8. /* 接收到数据唤醒，即RXNE标志置位 */
   + s1 j) {; L3 d7 w! O  j
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   2 t$ k3 Z: g. N5 g8 ~% L
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    $ R$ D0 {4 b. U; y% V1 ^
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    + x& d. g9 @$ ^: W, V# R1 r0 ?  a
14. 
    
15. /* 进入停机模式 */
    " V4 j+ u# Y5 O- ^2 d8 }
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    . d9 v: E4 [0 c# I
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    
20. 
    0 y% |( o/ E" x+ J
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    
23. 
    , K6 q* j# \0 l( B8 d, l

复制代码

  检测到匹配地址时唤醒。
低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。
0 o% @( q5 b+ l1 ^4 W" U9 k
如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。

: n' o4 j' R% G+ G! ]$ K& T

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   ) e$ @5 G" |8 h- Z; _7 D2 H# h% Y
4. /* 确保LPUART没有在通信中 */
   : n3 g/ |7 ?* o
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   % ^( G1 |$ m0 A6 F( f0 {
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   + G6 V0 |5 W- s: d: K5 ~
7. 
   . [1 i2 n1 f' f# k! {8 M
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   1 c9 J; M7 X4 S' b" J0 T# i$ r- J
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    
11. WakeUpSelection.Address       = 0x19;
    - G$ s; |+ H5 |3 b" T
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    5 z" L1 Z" p; x
13. {
    
14.     Error_Handler(__FILE__, __LINE__);                        
    
15. }
    
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    
18. 
    
19. /* 进入停机模式 */
    " b  B/ E% k0 o
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
21. 
    $ Z9 o7 o) |' G3 k
22. /* 退出停机模式要重新配置HSE和PLL*/
    
23. SystemClock_Config();
    9 q( s  v# `; i  K; M; G. E& j
24. 
    * S( ?9 e! d) R3 I4 v
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    % X* g; t( l  r; y! O5 D6 E( W6 q
26. 
    
27. /* 关闭LPUART的停机唤醒 */
    
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    
29. 
    * A: ^: M) N( n3 a: G5 F

复制代码

0 ]2 u- ?% V" v; ?- s5 W, M- P这里有一点要特别注意，程序启动后，调用下面两个函数：
: R9 O  y% m/ y$ U# ?
3 [9 Y" }) f9 s* I! @* C

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

复制代码

66.4 低功耗串口FIFO板级支持包（bsp_lpuart_fifo.c）
4 d+ |& q& z; ^6 t# \; M. a1 W串口驱动文件bsp_lpuart_fifo.c主要实现了如下几个API供用户调用：

. v  k7 ]% g& n4 O2 ~/ ~  bsp_InitLPUart
  lpcomSendBuf
, j( Y* x4 s' G; s$ i- Z4 S  lpcomSendChar
' s7 R  O, |1 b+ q0 H: ?! L  lpcomGetChar
; K" ~* J' K! o/ O( f66.4.1 函数bsp_InitLPUart
2 [) L) F' M) w# x$ n- a函数原型：

void bsp_InitLPUart(void)

6 H* u$ n5 A4 \函数描述：
" @; O4 r! s5 V
此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
* j- q% F" t1 _+ E
使用举例：
9 |% {- l) k$ l- j: S, B
3 Q' T* b) T. ?/ R# W# m# g+ _串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

7 C: T1 A/ K2 j66.4.2 函数lpcomSendBuf
' q; x! F2 w# h+ W函数原型：
- d/ I! N; X; I, ]7 I, A
# T8 d$ C0 h; I( D1 R4 jvoid lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
9 Q3 w  _9 q7 F  H0 Z
+ a. M) ?6 ?6 u7 t6 o  Q9 d函数描述：
: ?' L: g7 c5 |" t8 T) H8 j3 c
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

) s: a- O2 \, \2 Z8 B1 D1 s: b, i$ R$ g函数参数：
+ ]6 C/ n0 c! h2 `1 e% u
& ?* p; S$ _4 }) \7 O+ x& \  第1个参数_ucPort是端口号。
. L% J  U; v2 y1 |) j  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
注意事项：
+ _4 \: ~9 H. p5 n  V" c
此函数的解读在本章66.3.5小节。
/ |3 t9 ], ]5 a1 j6 S9 z1 u( V 发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
使用举例：

* F0 f+ [" Y& a/ z% ], W调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

1. const char buf1[] = "接收到串口命令1\r\n";
   
2. lpcomSendBuf(LPCOM1, (uint8_t *)buf1, strlen(buf1));

复制代码

: {' p5 ~3 l# ^% p; W8 g' j66.4.3 函数lpcomSendChar
  I7 b% O/ o" A% H4 b$ B函数原型：

. r+ n" c8 U7 p; A  qvoid lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
, _. t# o) b- M& B# C
: a* m" x% A4 ?5 a! @# W7 _函数描述：

此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。
* Q5 `3 p$ S8 I, @1 G- C; ~1 K
# [: o  X! x* g" E+ }  b. F! F+ Y函数参数：
# H6 n+ Q( A$ S, @4 f0 ^3 f) Z- O  第1个参数_ucPort是端口号。
  第2个参数_ucByte是待发送的数据。
注意事项：
- e( ^/ |' f# z' J, P/ R1 d: z' l
  此函数的解读在本章66.3.2小节。
- F1 E, d/ v. o" ^4 G+ a使用举例：
$ y9 g4 h+ G4 B
3 }5 }6 Q+ j  Z) d调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：

lpcomSendChar(LPCOM1, 'c')。

66.4.4 函数lpcomGetChar
( z3 w' e( g; K( K. _, o6 x; Y函数原型：

: n/ N6 e* t3 T( J2 \; E+ U. u1 g7 euint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
- V& E. V0 q9 D; w: y
% R5 p3 r7 j% d函数描述：

" _) b# e9 C4 r# q, h/ n$ d7 j此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
6 R4 z8 t) o  U
1 u, N- H6 N* H函数参数：
" @* f0 p7 ~- H
1 X% i6 q; g0 C5 T6 ]! {  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
1 y6 v4 a+ }  @, E! j注意事项：

' F' L. R+ h4 V( \  此函数的解读在本章66.3.6小节。
" Z: c4 o8 W" k# I/ e使用举例：
8 m/ O' n" j% {# W* a) q4 E& l' I
调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
: |# X* i1 u) a
. F9 U0 O, |$ _2 b) C比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。

! F. X. }, l5 t3 Y- r( x66.5 低功耗串口FIFO驱动移植和使用
" e3 [" a% J* o4 K串口FIFO移植步骤如下：

  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
- F+ j5 k. z9 a* l: k% H% J% f  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define    LPUART1_FIFO_EN    1
   
2. 
   8 R- i3 X& x) `. t' K
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
4. #if LPUART1_FIFO_EN == 1
   
5.     #define LPUART1_BAUD         115200
   % n3 w5 B" d2 `' V: L$ D
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   
8. #endif

复制代码

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

+ t% R0 Q  \, Y5 u

' \5 R, C! ?" X& l3 K
& C) I6 W; B) i; `6 V; p9 v: e0 m  第1阶段，上电启动阶段：

3 P# B% ~( @; k; R9 e; k7 T3 B这部分在第14章进行了详细说明。
6 A# x1 ]7 }0 Q# Q8 \( r  第2阶段，进入main函数：
% d  n+ J9 Z! F3 P1 I7 a
: W4 l9 V# ~4 n" m4 |$ }, r8 o  ]第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
: u! I. \- o. m* i第2部分，应用程序设计部分，实现了三种停机唤醒方法。
' O  f( k' B& w$ a! j66.7 实验例程说明（MDK）
: f* p  `. g7 V, Z配套例子：
) T+ l0 m; [9 O1 H( [
V7-046_低功耗串口的停机唤醒（串口FIFO方式）
" s2 `8 h' T) [8 t' ]
实验目的：

学习低功耗串口的停机唤醒。
: k( L, h! M& Q; B实验内容：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
, T  A8 @% ~9 i, R9 E% D3 B2 G; ]- Y当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
0 s& z2 V) v7 V6 B! e" bUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
9 j& \' C5 V; J! J$ t
* d+ \2 ?, d4 ILPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
) g  h& x4 i# ~0 R) n4 n
LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：

' i4 d4 ]  N( K5 w3 a( RK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
/ i" c# X: _5 I$ r+ ~0 m, tK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：

% r4 ^0 ]' c' z2 L4 m0 i9 j: a波特率 115200，数据位 8，奇偶校验位无，停止位 1。

- D" g& ?4 Z+ P

1 l4 c- S' ^- q* ^0 j- D: o程序设计：
: H% a7 P2 ^/ H( p
  系统栈大小分配：
2 j; U1 A" Y$ O4 i. d6 q' s
8 z9 _; w$ A- W9 X) u$ c0 l% H& {0 r, ~

1 G2 _# q2 b, q! y/ Y
0 z2 u; l0 Q) Q6 d# J, i* p/ s2 o  RAM空间用的DTCM：

1 k# {! G1 b) q

' I9 b1 P& q+ q+ T$ ^! n# \
3 |4 D# m) `& a. d( A. a  硬件外设初始化

5 l; v. J. }: p硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   / ?( F  t6 M6 p" w1 B8 p" f
2. *********************************************************************************************************
   . Y6 `) R. q8 j. L# J
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ; J* n" }* P; w8 W4 b* O. D
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   + N+ S8 c* X8 M6 P2 o0 M; B
8. */
   & h  @( G" j0 E+ q) X
9. void bsp_Init(void)
   3 T+ K: s9 p2 S, R
10. {
    $ w$ K. F" Z3 W
11.     /* 配置MPU */
    " O- ^$ {% B, z0 t1 }  R. ?
12.     MPU_Config();
    " O  x  D0 q- j4 Y# B
13. 
    , H4 S* m! k, `: L
14.     /* 使能L1 Cache */
    7 S8 T: B, Q$ W1 U+ W
15.     CPU_CACHE_Enable();
    1 y7 ~# @9 p3 o. C
16. 
    2 o& g# c: [: c) G% b
17.     /*
    8 W+ |2 Y* T- x1 t
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    8 I+ s! E& O* s3 A4 d2 I' q/ L+ I
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    . j$ ^3 j: y( j  Q2 ?
20.        - 设置NVIV优先级分组为4。
    8 n" f/ R( a" L. ~: d! ?, Z, x
21.      */
    & i4 R) U' h( @7 B2 g5 |8 {
22.     HAL_Init();
    
23. 
    
24.     /*
    * ~: g1 ?. G3 O+ M0 }& u
25.        配置系统时钟到400MHz
    8 Q. e; m2 D9 r0 R
26.        - 切换使用HSE。
    ! v% \# g' P/ t. K
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    / l& v- K2 }8 P. G0 K
32.        Event Recorder：
    1 K$ b$ I$ s5 h( ~4 `
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    1 y5 z) l6 V1 i% E* ?4 X
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    6 f  t2 _+ M& e9 H7 B
39.     EventRecorderStart();
    ! i5 a0 h' {) W2 u, i$ }
40. #endif
    
41. 
    & h* A+ O9 b5 J  @1 O0 W" b, y) Y- M% {
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    8 f. u( ?0 e% I) c6 u& \7 k* A
45.     bsp_InitLPUart();    /* 初始化串口 */
    # a7 V9 ?* I8 u+ S- B0 K. g
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    2 k. [& B' y2 l  A/ L/ ~
49. }
    4 V/ A1 ?" N0 U* l: B) o

复制代码

2 u5 t8 |" f. O: ?; }
  MPU配置和Cache配置：
  O8 ~' S1 e9 t0 U
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

% m" L: K: _- |) m6 a0 W: A9 V

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   4 k  G2 R; _" @; |
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   6 Z2 e3 }; b! K9 _. E
8. */
   
9. static void MPU_Config( void )
   
10. {
      s3 C& Z1 v/ d' d9 ~8 T& Z
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    2 l$ q- D7 W: P5 T4 t
12. 
    
13.     /* 禁止 MPU */
    ( l$ ]$ p, }& ]
14.     HAL_MPU_Disable();
    " i: R7 K5 ?9 r4 d% e
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    ; d% O" |2 Y7 a5 a0 g2 P6 R; z# j
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    7 D' B; x9 _/ o! L( R2 I* `8 G
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    - q. n; w' {  [0 U; P* I% |
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 Q/ F3 Y; a0 Y7 P% L# x
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    3 W; |. Z/ L$ E' n
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    6 R2 r+ G* x8 L; o& c: {6 d
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 W' d) L0 y5 P3 m/ [" }
30. 
    & y9 r/ u( f, |( P+ y" I6 R
31. 
    7 [9 P+ p, K4 ^9 M7 D. i0 ~2 j
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    3 v& I* g( B4 k! U. J5 m
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ' y- Z; m( Z4 z2 b
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
      _# t7 F* T$ F( ?$ h. x
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    7 A- I5 h8 D8 z' Q5 a/ V; s6 q0 ~
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    ( {" N' A$ e) E1 D0 c7 q
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ; ~7 E3 L& p$ v0 s# j
44. 
    / h5 F" ~6 d! y! X3 m
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    % b: A5 Y. s/ d% l' s; b+ C- Z8 b
46. 
    
47.     /*使能 MPU */
    * p8 Q# ?* O$ }0 a
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    / g: v) r& e5 w3 i( }8 B
50. 
    
51. /*
    5 c# U6 t: n+ r1 ]
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    , x7 t  m2 \7 R0 x8 u0 g. t; u8 L; X
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    2 X  @+ D( v# V0 e- y, {8 x& U
56. *    返 回 值: 无
    6 u9 W# b( G% x
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    " V- q) [# U7 e: P# w: ?
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
) U1 l, M4 I  u5 V; ?+ ?
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   ; m- m- w! Y6 V) y
2. *********************************************************************************************************
   ( F/ P+ m% D/ \! N
3. *    函 数 名: bsp_RunPer10ms
     Y& K& ?, q# A; H; @
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   7 B; l! f- _& n4 b4 X/ b- u5 o
6. *    形    参: 无
   
7. *    返 回 值: 无
   ; _+ I) H- n6 i2 [4 H, G
8. *********************************************************************************************************
   % ]8 I. v8 k( `# @9 e, S* N* Z
9. */
   " L+ N; g7 H2 ]% A
10. void bsp_RunPer10ms(void)
    
11. {
    ; M/ i; H) u7 g: p% t9 j
12.     bsp_KeyScan10ms();
    9 p2 x* j  w/ R! Q; b3 z
13. }
    - v& i% c. g2 }3 @

复制代码

' q, e$ ]( N9 |9 o  e- H  主功能：

3 \2 {9 l1 f2 p. _主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
: X; d- n7 |% E5 J: m- t- u5 {' q0 zK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
. x/ E2 E0 O9 l& B1 d- s% P6 A- e

1. /*
   . \! s/ v. f0 k3 \( _) i8 w- U1 x
2. *********************************************************************************************************
   ! d. a6 H1 H6 g
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   & Q! D( q: @1 K( P; Z. n* ?; R7 S
5. *    形    参: 无
   7 L# E) l* T1 i" R
6. *    返 回 值: 错误代码(无需处理)
   $ x  v' s5 K( k1 W6 ]
7. *********************************************************************************************************
   0 f1 \2 c& n1 k8 ]; B) Z- K
8. */
   
9. int main(void)
   
10. {
    5 s  J9 j: S0 m  m* D
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    
13. 
    4 {  I1 ?& F0 P; {
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    % y; e, i  K( o+ s& u; P# o4 @) z
17.     PrintfHelp();    /* 打印操作提示 */
    8 x: s0 f# U$ d" h  r/ f& @
18. 
    - i% j  U8 B! B& D% ^/ a
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. 
    
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
    # a  h7 ^+ }3 a! t8 _
27.     while (1)
    
28.     {
    / F6 u( S% D* e( B* O' a/ K* d
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    - S# \! Q- k* [8 _
30. 
    
31.         /* 判断定时器超时时间 */
    $ L; |- n# @8 x9 V+ {
32.         if (bsp_CheckTimer(0))   
    
33.         {
    ! Z' k& _& b0 v, Q8 w& Q
34.             /* 每隔100ms 进来一次 */  
    7 O8 M7 b" _6 a+ x( N% s  i
35.             bsp_LedToggle(2);
    
36.         }
    ) K# f% y, R* g) F- C" z
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    1 h* A7 y, q0 `5 l9 N
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    # L+ n. g9 }! g( h  m: n: J" N2 ?
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    
43.             {
    7 l. x  r! \. v
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    : I- S5 U+ }3 b/ m2 C
48.                     /* 确保LPUART没有在通信中 */
    4 H: o! [1 N7 z( A
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    + P, G9 r' c- b6 W4 L$ B! |" s
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    0 [7 N( f: w" ]8 Z4 m
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    % E0 Y. f+ K7 H9 T0 v+ e
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    ( w1 n4 F5 y/ o+ n8 B* V0 o  [1 p
55.                     {
    5 K. x0 }1 ?# h4 f( r8 L0 R9 p
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    / x/ r; {$ o% m% O. A
58. 
    1 f, l# `) l0 T
59.                     /* 进入停机模式 */
    0 d( B' l; W# m$ f+ J. a
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    . n! `, n+ g1 M3 j) d& A: v
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    4 U1 v1 H) |+ l+ `$ N
65.                     /* 关闭LPUART的停机唤醒 */
    9 _4 M+ x4 s9 m/ t
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    0 n+ d% S+ o8 y$ O
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    # c3 S! I4 t9 ~% q9 R/ w+ q
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    / c$ H9 b7 ]' G8 A) l
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    5 L9 K" K8 B+ w. z3 v/ f  w6 `
76. 
    ! p" \* z. `' ?; |8 S2 Y4 Q
77.                     /* 确保LPUART没有在通信中 */
    # ]# E% L* I' w( ^+ S+ O
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    1 J' S. U+ ?9 g2 I# Y. d4 |  {
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    + A1 F) R' v- s
85.                         Error_Handler(__FILE__, __LINE__);                        
    0 H- Z4 d- _; X- `
86.                     }
    ' r7 E# @; N1 R
87. 
    
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    ; k6 n- x# ?% [7 b/ W$ P- R+ a
92.                     SystemClock_Config();
    / z/ ?. y5 ^3 E) {/ t* K. Z  r
93. 
    4 u9 _7 m3 o7 I8 s. C
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    . ?0 B/ O2 E6 _# q* X  n, `. G$ _
96. 
    
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    & j: u  b6 q( `/ x4 F- e4 g
100.                     break;
     
101. 
     % p& ?/ n  w7 ~0 g& v& ^" b
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     ( Q: P) e6 e% U- Y8 |  ^5 M: A
103.                     /* 使能LPUART的停机唤醒 */
     , f! k3 J% t) }/ f
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     " n# k8 K1 E% s3 ?
106.                     /* 确保LPUART没有在通信中 */
     # j: b, ]: {, i- |
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     6 [" P& S  P6 ~  }8 C, @
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     $ O' ]; r6 c) T# |
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     ) b' }6 }0 J0 c% G
113.                     WakeUpSelection.Address       = 0x19;
     * [9 U0 O9 o" }, F, D, e
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     1 |7 u' S) }: o$ a0 n" ]2 b$ o
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     # `9 g+ u) j; _4 ?$ T
117.                     }
     
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     ) {8 Z/ e+ P: E) p3 q" d
120. 
     
121.                     /* 进入停机模式 */
     ' K$ g: Y8 E7 D5 O2 t
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     # }% `4 t, k2 N" {
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     # E2 K, P5 y, t) h3 f2 L
125.                     SystemClock_Config();
     ! F. c3 W/ b4 {
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     : ]1 F. v* G( x9 e1 a3 i! b) G
128. 
     ! }  Q. `* q( H3 t
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     ) R! r1 F! ?0 [4 m* g
132.                     break;
     
133. 
     
134.                 default:
     % e$ ]8 |, Y" |8 P
135.                     /* 其它的键值不处理 */
     8 k* P$ P/ ~$ H
136.                     break;
     ' M1 G9 ~: d& n, K6 O% y
137.             }
     3 E' p; q8 Y4 W9 ]# c! U
138.         }
     
139.     }
     6 [# s; N+ |4 w7 L/ N& k( ]6 D
140. }

复制代码

- t0 W+ c0 v( w; ]: I0 m* c
/ |/ I% e4 d& [2 b' Q- Z66.8 实验例程说明（IAR）
2 I* g2 E# V" C: P配套例子：

0 N5 n/ R- s4 G  ]9 A# w$ QV7-046_低功耗串口的停机唤醒（串口FIFO方式）

实验目的：
3 _% o# ~! h8 }* M$ n
. W4 n" y, \. |1 p学习低功耗串口的停机唤醒。
" J) H( {" n& y! j: V实验内容：
& g9 m/ ?, U$ `! b- g- u
启动一个自动重装软件定时器，每100ms翻转一次LED2。
  u1 q% ]; m4 F# Q当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
" Q6 n8 I& ]- {' c上电启动了一个软件定时器，每100ms翻转一次LED2。
/ ~% [  K/ t% J/ kUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
$ o1 l& X; R2 e( c8 ~LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
0 }+ G5 V9 i. q0 YLPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
' N/ M: t6 n" N1 n1 }! D$ ^
6 T: F8 d) z* D' t' dLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
0 m- p+ U0 h& J$ i
2 Z7 `+ V. ^. MLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：

K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
% ^& O2 T' n& W* a2 s# X- SK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
) l, f- _3 M; f2 I6 ]# ^2 [上电后串口打印的信息：
* p2 \: ^( k* l. O, C/ l$ ?
波特率 115200，数据位 8，奇偶校验位无，停止位 1

8 X- H# l: \5 b6 G( `1 u

7 M/ i: q* s, b9 ~
3 e2 K( X; R* c# }8 J程序设计：

  系统栈大小分配：

0 I+ O9 d3 A) @. J

: K) F9 b- p7 K/ x$ U/ g
  RAM空间用的DTCM：

4 @- n( m$ m* _9 h( y% Q

: L# e1 @' ~0 ^8 X( X1 I# J
  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

4 o9 I6 ^3 Z2 n. X- s

1. /*
   
2. *********************************************************************************************************
   ; }1 e$ M) q, C% R  D1 p0 u" ]* D
3. *    函 数 名: bsp_Init
   3 ?7 z5 y/ X4 |0 i
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   8 {! r3 w- ]5 A) V5 L; ]
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    7 D8 E2 q. G3 S# ^
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    0 h! A% @% c" t# A$ r
16. 
    ! M5 }1 X3 b0 a7 a! N
17.     /*
    ( J. g9 o5 E0 D5 M) ]/ {9 l# P
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    # H7 E$ p. b  o: b' h# }
20.        - 设置NVIV优先级分组为4。
    , q, w% f2 r. f2 K7 L" A$ p
21.      */
    
22.     HAL_Init();
    $ t8 S- M3 S9 N
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    7 z, H1 ]/ x* P5 Q, @$ U
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    ; C, H2 J- X& z9 q
31.     /*
    
32.        Event Recorder：
    3 j: d+ M: e" E3 H0 `+ o) K
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    * _+ f& q4 F& E$ }$ D! J
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    4 n$ r( G$ i) _% \
35.     */   
    : Y! J5 E7 E- W/ B+ n- v# d5 V
36. #if Enable_EventRecorder == 1  
    ) @) Q4 X  F6 f3 H& T/ Z  X7 Q1 M
37.     /* 初始化EventRecorder并开启 */
    % [' }9 `$ h8 Q) h" g6 s; W
38.     EventRecorderInitialize(EventRecordAll, 1U);
      ]$ C3 G( a5 P6 \$ [
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    + _. a& g3 H" V7 f: m) p
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    ) {9 m( a! M4 c* T* Z- h
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    6 s% G8 o; W  ~6 N2 P
49. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
- O: m8 U1 i5 m8 u1 r

1. /*
   1 r+ _  y% ?9 F9 O0 n8 o0 U! u
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   + |% m5 _8 n8 e
7. *********************************************************************************************************
   : u: f& M- u% R
8. */
   , ~1 s- s6 I3 l8 A- o+ w
9. static void MPU_Config( void )
   9 {6 A. P6 I. E4 j! ?8 a+ ~
10. {
    0 [5 X% n4 T' _2 N* S. O! w- P
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    ' T7 o# w' ^$ o
13.     /* 禁止 MPU */
    8 _3 k, _% ]4 ^% D6 y2 p
14.     HAL_MPU_Disable();
    1 D- F  K2 D& w# r$ e; F
15. 
    & E$ S+ N# D7 |, e
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + f0 a# _- `1 h7 w2 x/ A
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    5 t5 G! m6 [  e8 O" W6 K0 q' g
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    1 R" m- u! J$ e: Z* Z3 {# t
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    5 ~' e7 g1 P* |6 k# _$ [+ `, t
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 J+ r. I" o1 B7 Y1 y
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    . e2 o# ~+ u: F2 q6 s# ^
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    1 F% J1 i8 e4 ~
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ; n) B$ S7 c6 i7 ~1 U6 b" T
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    " ?& D) ~) G; \  N" e0 V
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    ' Y, f/ N# [- h2 W
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    , ]" s% j6 X  g/ Y0 M3 Q
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    # H4 }" X; G& t  r2 x5 q
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    5 e; m& G3 V5 |  f
44. 
    0 n$ [( W" E+ o8 m
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 s4 L8 @6 h( w4 M8 A
46. 
    
47.     /*使能 MPU */
      {/ p; P5 }6 k1 Z2 ~% o# \
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    5 C& X" c7 s4 L$ V: M5 ]  V
52. *********************************************************************************************************
    & u4 M3 Z' h7 C1 t
53. *    函 数 名: CPU_CACHE_Enable
    6 Q9 H" }6 z; j3 E
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    3 A( z% @% s* d
56. *    返 回 值: 无
    + q- i2 G1 }/ T, h, N
57. *********************************************************************************************************
    
58. */
    * l- I1 {3 S8 T' }
59. static void CPU_CACHE_Enable(void)
    
60. {
    # P' A6 N6 a% V0 [. N
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    % u, }& o$ }" C) h: }3 n) k
66. }
    
67. 
    7 i8 g( \, O  ?7 @. E

复制代码

. ]: ^2 t; u. B  每10ms调用一次蜂鸣器处理：
! K  n$ u1 x  \* d% b9 M0 n
* ^9 I/ Z5 s4 ?8 O4 a+ k! S% E8 W蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
# [0 z' j5 V% ?, Z1 R8 x
! c9 h2 `9 P0 ~) A$ d! N$ l

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   / Q, |. v5 v0 Y4 ^7 |" R, J  E0 K
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   ; }: ~/ G" p( {& ~. [
6. *    形    参: 无
   ' ?& N2 [/ u. {
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   7 p" L* s" C# |' w* \# L
9. */
   # n- @7 G7 |4 Q, V' _, f
10. void bsp_RunPer10ms(void)
    ) h4 o0 y' a. Y2 V+ D+ r
11. {
    
12.     bsp_KeyScan10ms();
    , k8 p, S% E1 t& ^
13. }

复制代码

2 n  a" H" W! J  主功能：

主程序实现如下操作：

& B) M; L( j7 X8 x; ]7 R 启动一个自动重装软件定时器，每100ms翻转一次LED2。
+ R2 m: @: n  ?) N- L K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
" q  f# F+ ~  K) B9 l$ j! \0 X' D K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
# r7 k6 ^1 F. b3 ], Y  d& M9 |; u K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   / u1 ~8 z7 Q- T1 j0 C. q7 l
8. */
   
9. int main(void)
   1 l9 [  V! a3 z  e; R
10. {
    , Q* \  \9 y% t+ i9 @2 |) Z
11.     uint8_t ucKeyCode;    /* 按键代码 */
    : K6 G0 t8 F# L5 I/ p
12.     uint8_t ucReceive;
    ; `- z  i9 o6 ^% }# L
13. 
    
14. 
    5 G3 O. K- \6 @9 _
15.     bsp_Init();        /* 硬件初始化 */
    0 k) L7 N; v6 U+ k$ P- C5 j
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    5 x4 R1 f: I5 r8 Q: q3 _0 e6 j
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    % v/ w  T* x' K. E2 O  k, }6 G
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    . N+ u7 P) e! m) k
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    % h( n' [2 I. N6 w6 W$ D% O( u
23. 
    
24. 
      K4 h% }8 H6 f* E5 o3 I
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
    9 g0 z1 A5 ]1 H: [. A. w
27.     while (1)
    
28.     {
    & `3 g) j, b6 a: [; N
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    5 _; _. u7 m% K0 |
30. 
    6 n/ e% h" M: J
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    , U: f' b/ d$ U. H7 m8 n
33.         {
    * z* \7 ], U2 U! O0 K
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    7 {+ [3 ~3 J% T* `4 ~
36.         }
    
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    
43.             {
    2 _* N' }9 _2 {; C9 I
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    ) E0 u, `& O. P# G5 \: _4 {
45.                     /* 使能LPUART的停机唤醒 */
    ; W& H2 Y" u- h- h5 ^# u
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    ; D" `1 u2 M$ q3 f, I. @
47. 
    ' m3 O) c% J. Z) m2 o8 h7 A
48.                     /* 确保LPUART没有在通信中 */
    
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    / L3 t6 L9 f9 k% S
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    " ?) L* a2 y# z5 K$ p& Q
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    9 i0 \" L- ~9 \' v* r1 X' v
58. 
    
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    9 O$ P4 T: P6 u3 j! V- z" k
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    ) @( Q4 X& Y, B" G' I1 G0 q
65.                     /* 关闭LPUART的停机唤醒 */
    7 j. x9 c2 e! E; I0 b
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    . r  V/ J! D& a6 g' J7 _; t8 q' j
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    - \5 M) S+ @$ ^& ]
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    $ X& \# s; |' C; B- K$ @- J+ o  O
71.                     break;
    
72. 
    / c! O# U' X/ ]- t. y0 ]2 Q4 P
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    4 l4 q7 F" h6 s
74.                     /* 使能LPUART的停机唤醒 */
    ; ~$ j. N: B$ |! B
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    7 x1 s$ S" X" K- r9 e
76. 
    8 K/ J# }2 L, d; h4 K1 z
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    & r  o0 z0 ?6 M; G
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ) n$ N: ]1 o& |% [( ?" [8 k
80. 
    ( I# _  A- u: i5 q5 E# m
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    ( [- M) x. c( ^, L. H  o' H) V5 R
85.                         Error_Handler(__FILE__, __LINE__);                        
    7 F$ U3 Q  T- K6 \4 `
86.                     }
    2 w, a6 e) ]# [. T7 f
87. 
    & v' J& T' t5 m4 ?- A5 M
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    ; u- G" q8 m& p! J8 P! t# a
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    & h6 @% z5 B# d+ a+ q! Y7 A
92.                     SystemClock_Config();
    0 ]- e9 p5 V, m% A; H/ J$ Q% t
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    0 A; X% U9 w( p% q; M
96. 
    ) g$ R8 Y) ?- s+ l; W
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    ! {5 |0 A. J: T
98. 
      Q/ Q0 s( J# T0 t3 N- @- Z/ Z; a
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     " o% J% Q6 T# A
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     ; w$ E. M. e0 K' v$ a
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     * @/ }& p9 r3 K/ a5 q0 d% P
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     1 _: d1 T1 h0 I
109. 
     . U  Z" X2 P) E8 g+ q
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     " R0 a: Q5 G  ]0 g
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     2 x4 x3 X  ?: W9 f( v
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     ) D2 [* L9 e7 v* S& n
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     ! f& W0 l5 M' P6 s  i6 S4 d- ~9 J
120. 
     
121.                     /* 进入停机模式 */
     ) g" `1 w  k6 b& A
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     6 Z$ S! ]9 P( {  ]. T
123. 
     5 v' X7 t! h4 F7 N4 _
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     $ [1 U2 F+ C, H: s) k7 B( B8 v4 E
125.                     SystemClock_Config();
     & A) L8 ?$ _3 g, p
126. 
     9 p6 S% x- @; P+ Z
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     
132.                     break;
     
133. 
     
134.                 default:
     & D2 I' \( Y9 }& d& A
135.                     /* 其它的键值不处理 */
     
136.                     break;
     * S7 V  ?7 Y3 J
137.             }
     8 k3 E7 R0 T! u+ f
138.         }
     , T7 Z' _1 S+ a) F2 T  T5 x! q
139.     }
     # _% A' m$ b) F8 M  ^! t0 g+ R: M1 m
140. }
     6 @% i6 {/ R4 L, P: `$ O" _) {

复制代码

66.9 总结
  x3 \6 q0 [, x; ^- l. D本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。

, }) a, }( h' u9 j
7 {6 ]# H9 G6 j$ K
8 x8 K; V) P+ Y, r- Y