66.1 初学者重要提示
9 H7 M; `0 |5 F5 Y  学习本章节前，务必优先学习第65章。
  低功耗串口FIFO的实现跟前面章节通用串口FIFO的机制是一样的。
  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
: _0 A! q3 |" c/ }- T4 ]9 p66.2 硬件设计
STM32H743XIH6最多可以支持8个独立的通用串口和一个低功耗串口LPUART1。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

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

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

串口USART2  TX = PA2，   RX = PA3

/ l) [0 Z2 e+ `串口USART3  TX = PB10，  RX = PB11
0 s* k! c3 y, \2 D/ N
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）

串口USART6  TX = PG14，  RX = PC7  
7 q" ^, C/ Z) N% u8 r/ X: y: j
串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
9 ^- y" s& ~, e( }3 E* I
STM32-V7开发板使用了4个串口设备。

4 |9 g2 m+ C8 e' E9 Y, O' H- K  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
  串口3用于RS485接口
! B7 e4 B' R" y: _6 o  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
3 A+ L* Y7 O4 A+ d6 R) g下面是RS232的原理图：

1 ?. k0 ?: A$ r

7 i3 a+ i# `7 G9 Q2 O9 C& Q+ n! f关于232的PHY芯片SP3232E要注意以下几个问题：

" s1 T9 O3 z& t" v5 o  SP3232E的作用是TTL电平转RS232电平。
0 C8 t4 m. E5 g: s/ c  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
0 b, l8 }6 ?* ]  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

0 r$ e: `' H) R$ \3 `2 a  E, G2 q

. A5 @/ ~( c: D
" K4 r) j( U( p5 }实际效果如下：

  u& |; o# y9 N6 N- L8 O1 A通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY
7 g6 Y" F0 O3 e% Y8 f: T
芯片是否有问题。
! L) d& ?5 K8 ?! U2 ]' g
( k, d; P* d. X3 d  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
) ?) T, d* R$ a3 _7 h0 @- T3 l66.3 低功耗串口FIFO驱动设计
66.3.1 低功耗串口FIFO框架
为了方便大家理解，先来看下低功耗串口FIFO的实现框图：

; d6 }2 f; t5 c6 s9 d  R3 p

- f1 V) ~. o! B- ?- A! `8 y  第1阶段，初始化：

. _5 v# y! i/ f( x+ y# f通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
  第2阶段，低功耗串口中断服务程序：

- n3 r% p( L- Q5 [' {. ?. y3 u  接收中断是一直开启的。
  做了发送空中断和发送完成中断的消息处理。
  第3阶段，低功耗串口数据的收发：
1 f& I  }5 ^4 n7 ~
低功耗串口发送函数会开启发送空中断。
低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
% \8 r: d& [# b* \3 _( F66.3.2 低功耗串口时钟选择
我们这里实现了三种时钟选择：

LPUART时钟选择LSE(32768Hz)
- G$ h: X6 U' [; P6 F  N% a$ Y$ }* I最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
8 V# e7 C( I$ T
LPUART时钟选择HSI(64MHz)
* k0 X, ^0 q8 }最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。
3 l# G/ D* V* O% {/ ^) ^% Z" _
6 f" h- \( r) G  fLPUART时钟选择D3PCLK1(100MHz)
最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。

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

7 ~" ]" y, g' S6 q% x. O0 {

1. //#define LPUART_CLOCK_SOURCE_LSE      
   & J6 [% m% p+ A$ u
2. #define LPUART_CLOCK_SOURCE_HSI   
   + g3 ~! I2 m; g3 f6 h
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   , _2 [) h0 M& O9 c0 L% B
4. 
   
5. /*
   
6. *********************************************************************************************************
   1 a2 g7 U3 ?: {6 W& Z
7. *    函 数 名: InitHardLPUart
   
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   & q, Z) ]) f& e, L7 a# T5 R% W
9. *    形    参: 无
   * e2 d: `: a5 M4 H$ V/ ^" K
10. *    返 回 值: 无
      O% N! G7 X' N$ k$ r/ w8 G! l
11. *********************************************************************************************************
    
12. */
    2 h1 c2 e6 E3 z5 s
13. static void InitHardLPUart(void)
    
14. {
    
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    6 ~. l, q+ F, S$ @
17. 
    1 ?: R: Q' Q5 g# r. V& g# U
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    
20.     {
    7 T# c2 @( m7 f  n6 v* C2 o- S7 ~
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
22. 
    ; D1 _5 e  e2 Z) h, w# l
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    # ]" ^/ C* R% l" Z
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    % D- s$ e5 D1 P& M7 B
26. 
    
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
28.         {
    $ b% y" {7 X7 L& ^7 D
29.             Error_Handler(__FILE__, __LINE__);        
    5 `* M/ J/ g! I4 Z0 G
30.         }
    
31. 
    
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    & Z, N* q9 J2 V, h
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    ) l8 v2 c4 m( x8 a0 i) A: w
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
      j/ G1 U) A- r9 o9 f
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    
38.     {
    $ Q  V& O; I5 l, Z+ i' i
39. 
    
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    9 p; e& r7 |3 E; L. w
41. 
    $ T7 a1 M9 Y9 a" Y( ~- R
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    ' v$ U+ }6 i2 e8 O! k* k
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    & @) E5 U/ R% W: ]
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    
46. 
    
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
48.         {
    
49.             Error_Handler(__FILE__, __LINE__);        
    4 q1 D. f) @9 V
50.         }
    # o8 Q) w/ X" v; M' Y2 d
51. 
    
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    8 R% ~" s! T3 e" ]+ m3 H
55.     }
    
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    . l7 {$ N7 X9 w
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    5 @: v( n3 j' Y- k" f2 L& c; ^7 {
58. 
    6 v  q6 t( `( T
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    - k( q+ \0 J+ z7 C* D3 D8 p& Z
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
62. #else
    
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    9 p# `5 X6 A6 n  b$ A
65. 
    
66. #if LPUART1_FIFO_EN ==
    
67.     /* 其它省略未写 */
    
68. #endif
    
69. }

复制代码

2 b( [8 C0 m$ M  G' x6 @1 L% {66.3.3 低功耗串口FIFO之相关的变量定义
! g* g7 U- X# ]* O. O- r5 C3 D低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。

1 |  u) v* @) ~6 l# _3 v3 p+ i这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。

5 X4 P, G3 {/ Y* h每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
. D3 w# h9 d) {! l, A5 F
我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。
/ H+ F% N  u- b. U, Y( Q9 n
4 L- |% }4 i9 B9 t- \! k; L

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if LPUART1_FIFO_EN == 1
   4 P9 P7 o% M! A0 y# K4 p
3.     #define LPUART1_BAUD         115200
   1 S. n3 j! Y1 H0 }) Q6 s
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   
6. #endif
   
7. 
   & o* ]7 o/ M! U+ C$ D
8. /* 串口设备结构体 */
   & n  I/ f: ~9 a; \% ~% F
9. typedef struct
   1 H2 @6 t- I  `& D6 ?0 ?3 W" J
10. {
    7 ~+ b- y5 W7 d( I
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
      b2 q0 F9 N* Y- i
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    4 w/ r* U, L% r9 N0 g3 H9 b; t
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    0 U/ Q  Z+ X" X; D
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
      f- J: E8 b" c% s, G
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    ( |$ ?. k* I: }- R6 v; ~! p
19. 
    + _5 M, A' O& I" C$ a' F  Y$ l
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    6 s: Q, `. p2 Z1 y0 |* S: n
23. 
    , x# |4 D, l: p
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    9 |  E- ?- Z" U( ?: X6 U! P
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    
29. 
    5 W  U* y( ]( u# ~, h
30. 
    # o+ `: j. t$ U( e* {7 |8 w
31. bsp_lpuart_fifo.c文件定义变量。
    ; h, H6 V/ a8 T6 X
32. 
    " c  R: Q* b& {7 D5 F2 @3 j
33. /* 定义低功耗串口结构体变量 */
    - E8 u1 s* M7 \& C& T3 y% n0 r8 e3 C
34. #if LPUART1_FIFO_EN == 1
    
35.     static LPUART_T g_tLPUart1;
      P3 ^1 |& k% i  t! v
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    
38. #endif
    / P/ @; Y" v$ x% C; o

复制代码

- m$ Y2 {: s! F& c. P6 w; a+ o关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

  g& Q; f2 ~$ a66.3.4 低功耗串口FIFO初始化
9 o: z2 n2 [" L: Y! [0 X低功耗串口的初始化代码如下；

- f" [! I) P& a2 G/ @1 q/ @2 d/*
9 _& ?1 u: ]; ~" n/ ?  |*********************************************************************************************************
*    函 数 名: bsp_InitLPUart
9 W9 y( D9 X5 Q: V9 ]) X8 ]. g+ X*    功能说明: 初始化串口硬件，并对全局变量赋初值.
, A! _, l! ^' H4 M*    形    参: 无
*    返 回 值: 无
7 h& \2 k' n. ~4 i1 p+ {4 E/ W* s*********************************************************************************************************
( e  a- r/ ^7 c( ^4 X) d; v. p% Q*/
( [( u: D. O! B) t5 ?6 S' Lvoid bsp_InitLPUart(void)
{
    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
; \: @8 x; T& s. t% c& a0 C    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
}


  t* F; X2 H0 K5 P下面将初始化代码实现的功能依次为大家做个说明。
% r1 x0 _. l4 g6 L; O
  函数LPUartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
4 M* D* K$ c" y, _' V
: V9 @, G1 F" s

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: LPUartVarInit
   ( c% g0 ~9 U6 e& e, f0 g; w: g5 ^9 J
4. *    功能说明: 初始化串口相关的变量
   
5. *    形    参: 无
   ' S0 |: `9 U; w4 b, \( g8 k
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void LPUartVarInit(void)
   , [& l! t% B" I- _6 f- `9 u! m8 b7 }
10. {
    3 v6 M& e* f# G6 g
11. #if LPUART1_FIFO_EN == 1
    " N' b% N8 @& R* o  i) O8 Z
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    ) C; P( D" B' i$ @0 x% i
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    3 n3 [+ @2 g; i1 G
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    : {6 z' `* M4 }
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    & x$ Z4 Z- v$ P5 l3 O) H' u
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    ; z" P' Y. @9 V! {2 W- m: p9 q$ e3 U
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    : l0 G1 c4 o" K+ F: k
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    3 |7 N* Z) e: C/ g# \5 g: G& X
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    ; Y& P5 e2 W! Z- u
27. #endif
    # h! U. w3 L. ?" A. V
28. }

复制代码

2 i. h& a3 [" L

& L4 t# n8 p. Y5 Y) u  函数InitHardLPUart
( Z' P1 V9 L+ _  w此函数主要用于串口的GPIO，中断和相关参数的配置。
+ K* j3 R% P( E  g( z
* ]5 u2 R/ Q7 G2 h9 M6 \

1. /* LPUART1的GPIO  PA9, PA10 */
   & y) K  s2 ?6 c* [
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   
3. 
   0 b- ]; O' l! `
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   ) a% l, s) _) K- C( ~4 s
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   
8. 
   % `5 y/ r" q  h5 o
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   6 L6 ~4 Z) G/ B$ f4 A
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    ( l# h. O  e% W3 O
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    
13. 
    - P! _4 Z) G8 c0 o- o" N& `
14. /*
    
15. *********************************************************************************************************
    * R( U  |  u: Y4 I8 q5 H" B8 k
16. *    函 数 名: InitHardUart
    3 Y  t, `$ o. I7 V$ i1 ]& r7 ]" X% g
17. *    功能说明: 配置串口的硬件参数和底层
    
18. *    形    参: 无
    ' h+ ?( i8 |! S; Q8 `
19. *    返 回 值: 无
    ' b$ ~5 F. l# P, O
20. *********************************************************************************************************
    
21. */
    
22. static void InitHardUart(void)
    
23. {
    7 L9 ]4 z. r0 E9 L7 U1 I+ W
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    ) {5 A# B" g, s3 P  C! }. w
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    1 m4 d% @6 R6 R
26. 
    
27.     /* 时钟初始化省略未写 */
    ! u) E- v; ?: D* u
28. #if LPUART1_FIFO_EN == 1        
    
29.     /* 使能 GPIO TX/RX 时钟 */
    / X  ^/ M! M2 e6 F# g& l$ Z0 [* I
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
      i- s$ L) Y: l# |/ l
33.     /* 使能 USARTx 时钟 */
    
34.     LPUART1_CLK_ENABLE();   
    
35. 
    
36.     /* 配置TX引脚 */
    
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    ; s) T: S, X7 Z; I) m# T& n7 {
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    ; |# B. n' S( _- W) ?
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    
43. 
    
44.     /* 配置RX引脚 */
    
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    7 G" l; X9 v4 c/ _! g
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    ' h  c, h+ R4 F1 T' A0 z3 o
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    / a1 |* r9 y% c  s/ h2 i% m
48. 
    ' R# u5 p! ]; A  i
49.     /* 配置NVIC the NVIC for UART */   
    
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    + }" {0 ^# g- {9 r3 U4 v
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    ) K4 Q4 W- f9 w0 q
52. 
    
53.     /* 配置波特率、奇偶校验 */
    
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    " [$ U3 f, Z. y2 L( b# o5 ]. F
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    ( E; }! \" I8 C# E8 t' f4 \
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    % F/ W* N; R2 @
59. #endif
    : B: H( z7 V6 |+ V. e# [
60. }

复制代码

+ j. L9 d9 R8 k3 {; u8 ]$ F/ |1 z低功耗定时器的参数配置API如下：

1. /*
   8 l! e" D9 p, @" b) d9 ?1 R
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_SetLPUartParam
   8 m' K4 u! L$ S
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *    形    参: Instance   USART_TypeDef类型结构体
   ! t# f8 Y2 r$ @+ Q% B
6. *             BaudRate   波特率
   5 X3 R, Z' E; _2 d# r6 Z
7. *             Parity     校验类型，奇校验或者偶校验
   # X! _  d" W( a( ]' W6 J
8. *             Mode       发送和接收模式使能
   ' T+ O0 |0 h- w9 f( s; a% m
9. *    返 回 值: 无
   
10. *********************************************************************************************************
    
11. */   
    ' r2 Y* C' ^; m: g, d
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    , ]8 `7 V/ D* {# s4 e
14.     /*##-1- 配置串口硬件参数 ######################################*/
    5 o8 a4 p% o- D4 ^( A; V; i% ^
15.     /* 异步串口模式 (UART Mode) */
    2 L2 n* r( ]/ [3 d: _, A0 I1 l: r
16.     /* 配置如下:
    
17.       - 字长    = 8 位
    
18.       - 停止位  = 1 个停止位
    , h, S, q1 D9 k2 v5 j
19.       - 校验    = 参数Parity
    
20.       - 波特率  = 参数BaudRate
    ( H0 V: j# O1 k) d/ `( @
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    
22. 
    
23.     UartHandle.Instance        = Instance;
    
24.     UartHandle.Init.BaudRate   = BaudRate;
    / a' ^, F$ ]9 @6 d9 R
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
      I& H6 ?( Q* c" H- }3 H
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
27.     UartHandle.Init.Parity     = Parity;
    % k. W5 a0 o; U; ]# w; N
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
29.     UartHandle.Init.Mode       = Mode;
    
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    ' ~( @( K$ D$ r% T3 i
33. 
    
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    6 H# a  k# Y$ L5 B8 V
35.     {
    
36.         Error_Handler(__FILE__, __LINE__);
    ' }, B$ _( h3 C: V7 K% F* h/ k0 h( ~
37.     }
    
38. }

复制代码

1 _, |: D6 Q; z! e/ G
/ N* d, q; K& Y1 _6 ^5 ~- l# \66.3.5 低功耗串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能

2 q  W1 D) K8 E. q/ Q' Z# G  收到新的数据后，会将数据压入RX_FIFO。
  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
% `: J8 ^; \1 i  R+ W! o- g: s+ [  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
. l) o* a% w5 h9 r4 d

下面我们分析一下串口中断处理的完整过程。
9 y; J7 K8 M$ A9 ?9 ]
当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

我们将串口中断服务程序放在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)
   & J5 [2 j! {# e
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   
5. }
   
6. #endif

复制代码

2 E2 e3 b" i8 B, r/ j( H下面，我们来看看UartIRQ函数的实现代码。

1 ?+ N( o+ g- M9 V2 y

1. /*
   7 M' g1 X; }' Q! n0 x3 n8 t
2. *********************************************************************************************************
   # d5 d& i* A2 d+ c
3. *    函 数 名: UartIRQ
   6 S" M0 k! V# i& i$ `" w  h
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   / l  l$ Z/ N: t* H- E8 T& F. z
5. *    形    参: _pUart : 串口设备
   ( }4 B  `& ]0 B0 X: B: h/ i% @
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   & z/ u0 h/ d9 L: }8 x! ?$ U
8. */
   6 M' w( S7 P( {
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    0 g3 z! L% s6 T9 o
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    2 e1 ]# f! k* X$ C, ]; D( z" M
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    5 f8 Z  U1 C% ~# n, x) S
14. 
    9 o* y0 `+ y) Q
15.     /* 处理接收中断  */
    
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    : k1 K5 b4 d& \) j8 l$ w
17.     {
    7 V. V+ D5 e3 G
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
    
20. 
    * ~0 Y  g" P) h+ m: i
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.         {
    
25.             _pUart->usRxWrite = 0;
    6 `$ ]# G& z7 @  [3 N
26.         }
    
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    7 x0 I- m- P! x( _* E0 t
28.         {
    
29.             _pUart->usRxCount++;
    
30.         }
    
31. 
    ! a& ~( F3 H) W/ D
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    2 a9 o5 O' B7 i# l$ r
34.         //if (_pUart->usRxCount == 1)
    
35.         {
    
36.             if (_pUart->ReciveNew)
    
37.             {
    3 `" Y, O% g; k' y/ R
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    ! p2 q4 m' |2 G8 h3 Q- E
39.             }
    
40.         }
    
41.     }
    
42. 
    ; p; Y& S; v6 J* }' `
43.     /* 处理发送缓冲区空中断 */
    4 O/ E9 X5 S+ [
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.     {
    
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    8 i& P8 R7 O2 |1 \+ M- o- ~" Y0 Y
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    9 x: L4 e# p4 E; T' ?$ X* v# T: S( e
52. 
    ' @# k0 t2 b6 B
53.             /* 使能数据发送完毕中断 */
    5 k! a$ k1 W: D9 H5 z- @- o
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    ) N6 x3 L, i& p( A2 C- d8 S6 o
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    : a& A( l4 k' C: d7 Z
56.         }
    ! M* K$ B6 U! h/ F0 B5 d
57.         Else  /*　还有数据等待发送 */
    
58.         {
    
59.             _pUart->Sending = 1;
    
60. 
    ! \9 e; l! ~" C. |5 U6 V- O- O
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.             {
    ! ]. I- N- F" D5 l1 J
66.                 _pUart->usTxRead = 0;
    ( c/ A+ y; y1 ~% k/ T: A
67.             }
    
68.             _pUart->usTxCount--;
    3 S7 r( a; {; g. `8 t; s/ i
69.         }
    , u$ _, ^8 x# V
70. 
    
71.     }
    
72.     /* 数据bit位全部发送完毕的中断 */
    
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.     {
    
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.         if (_pUart->usTxCount == 0)
    
77.         {
    8 }: B2 ~0 t" M+ h9 i1 B
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    3 l: Q6 h8 I% y- R% a
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    3 E8 w3 E0 ~1 R: Z' l4 b$ o) M9 g
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    " E6 w( @4 S3 Y# u
81. 
    - g$ M0 J2 j$ w2 O: @$ j6 Z' y3 E
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.             if (_pUart->SendOver)
    9 z, D" J# `  I
84.             {
    9 C- j. r( t. Q) T+ z8 D: ?
85.                 _pUart->SendOver();
    
86.             }
    6 A# p, m$ K" U
87. 
    
88.             _pUart->Sending = 0;
    / L6 n. }3 I( B: L
89.         }
    * `9 _# P* I8 }& T
90.         else
    ! A7 J! t' e% w4 G
91.         {
    
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    3 G/ F8 U  g: R; a" t
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    3 Y- {& x# [: H5 r
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    7 [3 J  P2 F! w; {9 M
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.             {
    
99.                 _pUart->usTxRead = 0;
    ' P, e3 ^* w2 ^5 N
100.             }
     & F! D; h8 ^& v8 r5 S/ R
101.             _pUart->usTxCount--;
     
102.         }
     
103.     }
     
104. 
     1 e* N0 H& c( |$ o# B
105.     /* 清除中断标志 */
     
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);
     $ e; D& q, d+ Y) g( M( |* t
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     : n! v6 x8 q  t0 s( Z
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
       l1 n! {% A1 N. y; D
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     ( |( a( h# U2 `" j$ O. E8 s
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     ( k* l5 f! z* f3 h/ }; {( O* X
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     6 @; ]! H- B5 Z
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。

  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
: @. T4 V( j1 q; P
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

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

$ ^5 G9 b9 V- z4 a+ R# O# E" o66.3.6 低功耗串口数据发送
低功耗串口数据的发送主要涉及到下面三个函数：

1. /*
   
2. *********************************************************************************************************
   . R( {  l- ^- j
3. *    函 数 名: lpcomSendBuf
   
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   4 `# h+ q* b: Y, ]3 {! \
6. *              _ucaBuf: 待发送的数据缓冲区
   
7. *              _usLen : 数据长度
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    2 @. a0 E9 Y% v6 R, s1 X# N: ]
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    + Q5 d  h% \% ~, Z6 q  y& ?
13.     LPUART_T *pUart;
    6 K. H9 R& l  w4 v# n3 K0 v
14. 
    " ?; @6 h( `+ j
15.     pUart = ComToLPUart(_ucPort);
    1 [- l) [- e* _
16.     if (pUart == 0)
    
17.     {
    
18.         return;
    ' l3 ?) C1 l/ A& M* D: h7 I
19.     }
    ) S, A$ @5 `7 l: K0 G; l2 Q
20. 
    6 p& I) P5 e0 z, t  j) e6 I; `* D% f
21.     if (pUart->SendBefor != 0)
    
22.     {
    ! y+ S' h9 p6 D6 P
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.     }
    
25. 
    5 }# D; @! o' S. f9 S
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    
27. }
    ' a! m; m) G, Q
28. 
    . ^2 u, O3 K5 @& E2 b; u
29. /*
    
30. *********************************************************************************************************
    
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    ! L# T( O- m5 S
33. *    形    参: _ucPort: 端口号(LPCOM1)
    
34. *              _ucByte: 待发送的数据
    + {( V$ V' B$ L2 W+ _; c* J$ K
35. *    返 回 值: 无
    
36. *********************************************************************************************************
    . c( Q7 G" Z2 K
37. */
    
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    ; Q( v& Z! t. {% ^; l. f5 R
39. {
    0 s3 ]/ K- t- I! r
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    
42. 
    
43. /*
    - T3 `, D* A* Z/ E
44. *********************************************************************************************************
    
45. *    函 数 名: LPUartSend
    , z' [6 B" b4 L4 @0 a
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
47. *    形    参: 无
    
48. *    返 回 值: 无
    
49. *********************************************************************************************************
    2 r' e/ C; z0 i: @; g' p0 N6 b
50. */
    
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    : \  P% x$ D0 E  ~* j6 ?: j
52. {
    ( N- Q. z; e9 V! ~
53.     uint16_t i;
    
54. 
    4 r# ?2 u, p. U$ l6 |( ]
55.     for (i = 0; i < _usLen; i++)
    ; P6 B1 {8 Y. @" m5 {
56.     {
    4 ?6 t) g6 l2 {4 ~
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
58.         while (1)
    0 S( Z4 j1 z' A( X0 {( X* w
59.         {
    
60.             __IO uint16_t usCount;
    
61. 
    9 B3 N" e  _4 n4 j1 G1 R
62.             DISABLE_INT();
    
63.             usCount = _pUart->usTxCount;
    
64.             ENABLE_INT();
    
65. 
      {! {  F4 z0 N: [6 p
66.             if (usCount < _pUart->usTxBufSize)
    1 q1 e0 g0 J0 _& o9 ]
67.             {
    ' |. A$ q* z3 ?' M
68.                 break;
    / U. W0 W5 U/ {* W1 g% \
69.             }
    ! d( J3 {. m! S! z
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    7 f( u1 u; K* m/ I. W
71.             {
    + d- f9 |9 R# [( ?
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
73.                 {
    1 w: P! @. I9 T( H; n
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    1 Z% `! d9 X0 C. c( U6 A# j. q
75.                 }  
    & I2 \& D% h9 Y
76.             }
    
77.         }
    
78. 
    % X7 G# i) y; t( ^
79.         /* 将新数据填入发送缓冲区 */
    ! Y$ b: b5 b3 P) Y# V
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    
81. 
    3 Y* V+ D2 P& ~2 \/ h& O9 x
82.         DISABLE_INT();
    8 c! a) }) T6 ^6 {% Y/ J$ t3 c. F
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    - J  X8 |1 D2 `" F& T  o, d5 R
84.         {
    / f! F4 ~& t* f+ Q1 w
85.             _pUart->usTxWrite = 0;
    
86.         }
    7 \7 W# ]$ ]. ~3 j) v; a
87.         _pUart->usTxCount++;
    # d$ @1 q. x) X- K! n- P
88.         ENABLE_INT();
    
89.     }
    
90. 
    : U( i9 z# v5 M# i; @9 @
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    
92. }

复制代码

函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。

6 x1 y6 R; Z8 @! B函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
/ w" X6 l' G  o" |- F) {
0 Q9 K! i' G! S( z- \. H  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
( H, Q+ Q* r; J+ D  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
% s8 u# m  Z4 @/ Y& j1 \7 Z
2 m  @: A+ \" `( n0 i注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。

函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。
4 @6 I2 |% j8 P1 ?& ]5 P  I" {

1. /*
   
2. *********************************************************************************************************
   $ t8 g) s# d: ~9 U+ k
3. *    函 数 名: ComToLPUart
   " U( ^7 A9 C9 h/ s4 F  M2 p
4. *    功能说明: 将COM端口号转换为LPUART指针
   / X1 [' R+ L: e8 @% p. p7 R
5. *    形    参: _ucPort: 端口号(LPCOM1)
   8 Z0 _# k6 R# w3 D
6. *    返 回 值: uart指针
   " x2 D( n4 c7 f1 j, n  z4 @6 N
7. *********************************************************************************************************
   ; Z$ i1 s! Y+ L8 N- q* Y, x# G
8. */
   . R9 E4 L, E2 m+ H
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   
10. {
    
11.     if (_ucPort == LPCOM1)
    
12.     {
    
13.         #if LPUART1_FIFO_EN == 1
    
14.             return &g_tLPUart1;
    5 X/ @" B! t  y7 W3 ?! s! t# U
15.         #else
    
16.             return 0;
    ) p, u( h( _+ c+ D  P3 ]$ _& K
17.         #endif
    
18.     }
    
19.     else
    # Q( O2 v+ Z3 ^, c0 c: {
20.     {
    & N$ _: `  [( t; `5 \
21.         Error_Handler(__FILE__, __LINE__);
    5 I8 E0 @% [2 }% B$ U
22.         return 0;
    
23.     }
    
24. }

复制代码

0 \9 `2 ]5 y6 M: i* G, x; a
& z5 a7 f: z9 [, |66.3.7 低功耗串口数据接收
下面我们再来看看接收的函数：
: W$ F. \$ b* I/ F

1. /*
   
2. *********************************************************************************************************
   / {3 ], S' c/ Q* i* [
3. *    函 数 名: lpcomGetChar
   ( I" G% {* C! O3 k& u' @
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   7 v: n8 R. r) s0 y& L7 s5 }4 r' U* @
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *              _pByte: 接收到的数据存放在这个地址
   4 S/ s0 R0 j4 h) _6 x
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   
9. */
   
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    $ L/ h) l0 O$ I0 @
12.     LPUART_T *pUart;
    
13. 
    
14.     pUart = ComToLPUart(_ucPort);
    ! _7 i$ ?+ p3 h$ k' W; Q
15.     if (pUart == 0)
    - F9 @+ g* O& ]/ ?5 @6 t$ E
16.     {
    
17.         return 0;
    $ u( j2 c9 p* v( W8 z) i
18.     }
    
19. 
    
20.     return LPUartGetChar(pUart, _pByte);
    9 G( F7 p$ A; n/ t& A! O
21. }
    " G+ ^! E5 |: E* A
22. 
    
23. /*
    $ E7 c4 u+ }( k( N  X
24. *********************************************************************************************************
    ( K( j. p7 I9 }1 V
25. *    函 数 名: LPUartGetChar
    ) F6 w' A9 e  f% K
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *    形    参: _pUart : 串口设备
    
28. *              _pByte : 存放读取数据的指针
    % R( V& H/ Y& E
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    6 I$ e! e  W, E
30. *********************************************************************************************************
    
31. */
    " ]' j/ ^! s* u2 b
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    $ O- C* z) ^4 h" E
33. {
    
34.     uint16_t usCount;
    
35. 
    
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    - R8 Y4 N( i6 e$ P  T, {5 h
38.     usCount = _pUart->usRxCount;
    2 X) s, y; d' n. o2 I' V6 k
39.     ENABLE_INT();
    0 v& m2 I2 r- C
40. 
    
41.     /* 如果读和写索引相同，则返回0 */
    
42.     //if (_pUart->usRxRead == usRxWrite)
    
43.     if (usCount == 0)    /* 已经没有数据 */
    : Q; H, F6 C# P9 _
44.     {
    2 Y! D, x& L: G/ s8 S3 B* G2 |
45.         return 0;
    4 r2 @0 p8 t) t
46.     }
    7 J7 ?. [0 A/ s
47.     else
    % ?/ j' |7 p3 |/ v* Z* @# L* p
48.     {
    
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    7 t, y% F# ^; \
50. 
    
51.         /* 改写FIFO读索引 */
    ) Z9 L. x. _0 h6 f& u0 L. s
52.         DISABLE_INT();
    
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.         {
    1 b( }0 s6 u0 x* t4 _; l# {
55.             _pUart->usRxRead = 0;
    : l1 d5 W8 J# O- g" ~9 b( _
56.         }
    
57.         _pUart->usRxCount--;
    , r2 T4 G% [$ h* b% w* p2 c
58.         ENABLE_INT();
    
59.         return 1;
    : m' a1 d; q5 J6 k% v5 [
60.     }
    
61. }

复制代码

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

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

( K: e4 z9 R# f* Z: o: L3 r66.3.8 低功耗串口printf实现
9 B3 r) M4 g$ Q- i: q5 Zprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
3 `* l% ?- `2 W
为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
" Z, l# s6 h: R7 @. t0 @5 m3 \6 C$ D
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
; l* n' X# m: W/ |" M; t( W6 ]( w
实现printf输出到串口，只需要在工程中添加两个函数：
+ W8 C% V7 S" B0 b

1. /*
   3 M( c  H8 K- ^9 a- }( ~; V
2. *********************************************************************************************************
   
3. *    函 数 名: fputc
   
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   / U' e# @4 W" R( J4 Z; f/ L
5. *    形    参: 无
   
6. *    返 回 值: 无
   / K* |! T& O9 _3 k
7. *********************************************************************************************************
   ) D$ E6 ?3 ^: J
8. */
   9 I  M  b* R/ H: T" m
9. int fputc(int ch, FILE *f)
   ; E1 n' v; l2 l
10. {
    
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.     lpcomSendChar(LPCOM1, ch);
    3 [: e% x" `7 }. K+ _# e2 ~
13. 
    / T3 m8 _+ K* n8 @1 z" V
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    8 P! p1 w8 g. v/ R8 J
16.     /* 写一个字节到USART1 */
    
17.     LPUART1->TDR = ch;
    4 d3 X& Q# ^* B; d% l, j
18. 
    & S7 G# z2 s+ b4 |/ r9 P) n
19.     /* 等待发送结束 */
    : Y$ `8 K: t# ?
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    / o1 p* t) g* g( D! g; X6 b
21.     {}
    
22. 
    8 P3 b# U8 @! g. I) I1 _/ c
23.     return ch;
    
24. #endif
    
25. }
    4 e) |! S0 M# {4 J7 K
26. 
    
27. /*
    ' _$ m' J8 e: p# F+ h
28. *********************************************************************************************************
    8 [/ j/ o8 A* M0 m& L
29. *    函 数 名: fgetc
    
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *    形    参: 无
    & o4 `( z* O. q% V- e
32. *    返 回 值: 无
    * d7 @- I" O' p% X$ B
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    / u9 V) C* b; P4 h' ~, M: F$ M# ]: r
36. {
    
37. 
    
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    - _) h$ f) v) B& @% o' v
40. 
    
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    " k$ C, g6 y4 z: a' F
42. 
    6 x) y) [5 h0 P3 X
43.     return ucData;
    
44. #else
    
45.     /* 等待接收到数据 */
    
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    
47.     {}
    / ~" z% t/ r; u. i8 F
48. 
    : ?1 P2 A- m+ N+ z
49.     return (int)LPUART1->RDR;
    
50. #endif
    % v+ F$ E. f+ L
51. }

复制代码

6 G* X) ~- I9 \4 S通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。

' w' U4 c1 q; p6 {7 F) ^' A. I66.3.9 低功耗串口停机唤醒方式
低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：

  检测到起始位唤醒。
低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。

如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：
/ t6 w! R7 q" V3 X; I% f0 |
! ]  v# v+ |: R0 E. I

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   9 h+ N, P& z2 H+ `: m
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   3 r$ V) K$ y; q0 P
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   7 ~- R& |+ @2 n" o
7. 
   / r( B$ I( G. ?/ ~
8. /* 接收起始位唤醒 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    $ l: {+ j' w; H! R- J
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    8 \% ?& y* @3 g; ~/ R
14. 
    
15. /* 进入停机模式 */
    8 ]2 V1 O0 T6 P$ _
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    9 F9 p6 }8 _- L  {8 B( }9 F- `
17. 
    , x: k( ^& G+ ?' n
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    

复制代码

0 r9 }* r5 G9 a: W5 W' M" A7 L  检测到RXNE标志唤醒，即接收到数据。
$ Q$ z* P3 E8 r+ v8 M低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。
7 b0 `# b3 W5 X, g1 K6 K' q* R
如果想唤醒H7，发一个任意数据即可。

  Q3 o0 s& i: L+ M2 Q& w

1. /* 使能LPUART的停机唤醒 */
   ; u" Y' q$ d7 x. G! ]' C- j
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   ) V8 T( Y) k  m( j% r6 A  E1 L7 u8 _
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标志置位 */
   , _4 M0 k) u% H+ i5 p- |2 e
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   + E# {! W0 p; n. c9 k2 M
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    / R# O. Z# ?2 `) G
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    ( h' x  Z' l9 K3 k4 i* H
13. }
    7 w5 R/ Q# K% k$ H3 t+ N$ T
14. 
    
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    ' d/ d& K1 m  \4 a7 E, Q) ^' b
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    
20. 
    3 _( ~1 Q& s* h& ^
21. /* 关闭LPUART的停机唤醒 */
    ! J; d0 K3 y  z6 p
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    
23. 
    

复制代码

  检测到匹配地址时唤醒。
  U. {. ^* B: q" T" P  e# g低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。
' j$ D+ q9 Y6 J
8 K4 W% m  }2 d$ g如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
; @, z9 v6 M& t1 Z2 l2 @( B. z$ l

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   % S3 O: n& ?) x7 s
7. 
   7 W' n/ g; Y" \
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   . y& o( z" I! X* B; B* k3 ?
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    5 P0 \0 F0 W& E
11. WakeUpSelection.Address       = 0x19;
    & h5 j  L% W: C( m  a* d
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    : l( |) h& X3 u# I1 N
13. {
    . [3 h  N1 Y/ b' k5 o3 S6 c  o! J
14.     Error_Handler(__FILE__, __LINE__);                        
    
15. }
    - m: `$ v9 A' _
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    
18. 
    % A' l' g( O3 M* W% V( |
19. /* 进入停机模式 */
    
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
21. 
    
22. /* 退出停机模式要重新配置HSE和PLL*/
    8 f/ Q1 ^. t! \# `+ E& Q. p
23. SystemClock_Config();
    ; n7 i9 K$ E5 o& s3 G: a2 R
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    ( C7 x" A1 ^' D& T
26. 
    
27. /* 关闭LPUART的停机唤醒 */
    . b. l6 @/ Y" f5 E" \( J
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    ( K; A5 B( u" |4 I
29. 
    

复制代码

$ Y  ?1 U" r) ~: M* @这里有一点要特别注意，程序启动后，调用下面两个函数：
1 G- t. G; L* w% g
: W) k) L/ c! [* O' H9 x7 ?3 Z/ C

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

复制代码

66.4 低功耗串口FIFO板级支持包（bsp_lpuart_fifo.c）
串口驱动文件bsp_lpuart_fifo.c主要实现了如下几个API供用户调用：
, d4 ?1 x6 v& p) d& J& V, t$ C
6 {! t8 H& ~1 g2 a8 y1 x  bsp_InitLPUart
5 @. s" N3 q9 F4 S6 E1 y0 G5 h  lpcomSendBuf
  lpcomSendChar
: K8 B$ r9 X$ `8 B' I  lpcomGetChar
66.4.1 函数bsp_InitLPUart
3 X' o' H/ [6 Y函数原型：
2 p8 h6 |8 T5 R+ P
void bsp_InitLPUart(void)

函数描述：

$ c! V( t+ M6 {$ t, s此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
( ~  @* ^  s& P2 o# R
使用举例：
# W# o$ l, g' P3 U3 p: x' `7 i) H, q
5 @' E$ R! ~! o) V3 ^串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
6 B+ i! k  `# f# a$ T9 q; X2 t, ~2 y
- g( b. n* ~7 ^  T66.4.2 函数lpcomSendBuf
函数原型：
+ Y8 r0 Z# [( i/ X  q# `" K) H. W
void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
9 k4 m6 V; j/ @% X" R
( H2 F/ Y. A5 y4 m0 W8 Z函数描述：
5 q+ B' f0 _+ H) L
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。
4 E# V0 _& s7 R( k
函数参数：

! b: I. j8 o4 p+ W! m# Q$ N  第1个参数_ucPort是端口号。
8 P5 d$ z; j6 X7 q. Y$ y  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
注意事项：

此函数的解读在本章66.3.5小节。
0 M0 u$ s% m( i% u, V# X 发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
& n# D: r1 F6 E, A! A  B0 v6 @9 Q# [使用举例：
3 i5 K& r$ j2 {- D8 U- ]; ?
6 _0 S0 r! L' A% W8 h2 ?( j调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
2 k' v6 V! s- C
3 B5 g5 a' }& e+ K5 {

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

复制代码

9 @: ?: z" T' {0 `66.4.3 函数lpcomSendChar
函数原型：
2 a4 ^, B  k. a4 p
void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
% \/ y  ^( l. y" V7 r3 _6 M! g
函数描述：

; e1 D" F( L0 l' z+ e/ e/ [. Y此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。

: ?% _6 c; E/ T5 q函数参数：
) w8 R2 x# m! i/ T! e) O8 E9 j5 r5 {  第1个参数_ucPort是端口号。
  第2个参数_ucByte是待发送的数据。
9 ^! Y' }* D) q0 A& r3 O注意事项：
# n4 Y& F; A% U
' i! H9 J3 B* k: t  b( t  此函数的解读在本章66.3.2小节。
使用举例：

调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：
( F, D9 S2 C1 P1 `4 C- q0 E8 W" v
lpcomSendChar(LPCOM1, 'c')。
- x* F. W% l0 f
; F' |/ H" {0 }$ T66.4.4 函数lpcomGetChar
, N/ z+ _2 c. G# Z; `1 y函数原型：
/ s2 `6 Q7 B8 A- h1 D
uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
7 ]6 [1 n: Y  y. ^
函数描述：

此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：

  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
注意事项：

  此函数的解读在本章66.3.6小节。
; d1 C7 u3 d1 o9 {. X3 a( k使用举例：

" t: |9 v7 J0 b6 R调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

0 C# i' p% c% Z. m比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。
: l) l0 T3 ]5 l4 D0 p
  |5 _( w8 J, V' y. l66.5 低功耗串口FIFO驱动移植和使用
$ U6 t& o8 `5 j7 ~! h/ P串口FIFO移植步骤如下：
9 t# @* }  u0 N4 o+ r% w
  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
, |2 g. {9 J& M, k

1. #define    LPUART1_FIFO_EN    1
   
2. 
   3 s' p7 M' {7 \$ \) T& Y
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
4. #if LPUART1_FIFO_EN == 1
   
5.     #define LPUART1_BAUD         115200
   ! w* C9 Y8 U0 n7 ^, W7 z* I: v8 o; e+ P
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   2 P  {* e% p- n; v
8. #endif

复制代码

$ Y3 T( z" I: z  I  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
  ?3 `' L0 z5 o1 V; Q! W66.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

  第1阶段，上电启动阶段：
" ^6 v) v, Y1 I  h9 f4 r: }
. k9 j. U9 e/ G( D4 s' J这部分在第14章进行了详细说明。
& q/ @" N9 I$ @- M3 p2 _  第2阶段，进入main函数：
8 g1 A- f" t& v( c- j
第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
( F& e* r% I, F7 `% Q# Z. Q第2部分，应用程序设计部分，实现了三种停机唤醒方法。
66.7 实验例程说明（MDK）
! T0 D. x0 u: H; X' k0 I, j; a配套例子：

7 r7 @# l2 J8 I9 {$ WV7-046_低功耗串口的停机唤醒（串口FIFO方式）
% u, r1 `! d% v4 A" ]- ?" [
- M$ A6 `( ?& v+ j, I实验目的：

学习低功耗串口的停机唤醒。
实验内容：
7 X- P6 t% K9 [% v2 O+ N$ g
$ k: I* ?  a: m# V5 d/ P( I" K& \启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
; b$ M7 j, h- X上电启动了一个软件定时器，每100ms翻转一次LED2。
( d- a) [& C/ l* N- C+ AUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
5 C, i: f& b; J) }7 SLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
' l# N% o0 m2 H  u% R: @3 X
/ g8 u# D6 O+ zLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
/ c; d  X& Z# g- F; c
LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：

K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
" `. H8 j8 A' T! E. l上电后串口打印的信息：
$ A/ j4 M- {5 d# w; {  v* @
. a( a5 S! C9 i! O7 Q" b. N  y波特率 115200，数据位 8，奇偶校验位无，停止位 1。
8 x" _7 r! Q- O6 `7 y. S( n

! X5 ]$ j* y' P& I, a+ G+ @- E; K
& C% j/ @# R+ Z! I- |程序设计：
; }  Z- s( j1 T$ v& g8 v
6 \% w. Z7 K  e! y& ~1 |5 P  系统栈大小分配：
2 x* K! |; b$ S" C: K
& y  I/ x0 K! Z' f2 K

  RAM空间用的DTCM：
5 a2 C; `" `" s5 i: c0 I. h9 g
0 A  A1 e; ^8 t# n

  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
# r# i  f5 r7 J( a* m4 x- h+ F

1. /*
   
2. *********************************************************************************************************
   3 u% J, E/ B' \
3. *    函 数 名: bsp_Init
   & e' o( w7 }1 l5 `9 v; y" L
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   + `$ I( |  I. f4 n3 m( k
8. */
   / ~9 T! O8 s0 d: j9 T. ]
9. void bsp_Init(void)
   . \& Q1 @* }( e2 m8 v' L9 F
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    2 Q2 z$ m  ~- e' v! L
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    " q% a- F* Y2 l
16. 
    ( n3 [$ T6 R. s: f5 s
17.     /*
    $ d- k. T, b" I" q+ f- w
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ! W4 L$ m0 n& J. o  t2 c4 n2 b
20.        - 设置NVIV优先级分组为4。
    9 A2 t; ?  k. ~! Z
21.      */
    
22.     HAL_Init();
    " {, k& n5 A" t5 N8 R$ O
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    4 O3 O- s; s; |8 s' P# B
29.     SystemClock_Config();
    + |8 v* {1 B7 |' E9 c
30. 
    
31.     /*
    4 \6 n3 f# g) R& j8 L/ F
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    + w9 B$ L9 g+ X3 i
35.     */   
    3 a' y& F5 n/ k% Y
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    ! r4 d2 l3 d0 }' ~, H; J" P
39.     EventRecorderStart();
    
40. #endif
    7 W0 L8 O9 |+ @6 M4 e' m6 [
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    % E# f% J  l8 k% x' i) u  y
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    0 f; u5 ]/ e, U! R# P3 w

复制代码

& p) ]) }# U7 p: o8 b9 W. w  MPU配置和Cache配置：

: ~6 j: Y1 Z& T; G: T4 D数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
) d8 v/ ]( x3 S3 {2 o
7 O9 e- ^& p4 V" p9 N

1. /*
   5 N' |+ j  T0 X. L
2. *********************************************************************************************************
   5 i: q/ J& U! q* C' G. E
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   * m8 _. L+ J% N9 P& I0 H
6. *    返 回 值: 无
   5 C- [" k6 f; }
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   : \1 g% x( Z9 _* \
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    # P% @/ r- \' s' x" n
12. 
    
13.     /* 禁止 MPU */
      s. c& _  F) @  B; u
14.     HAL_MPU_Disable();
    
15. 
    ' l3 ^$ D  O! F7 ]+ R! x* [
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;
    2 `0 n  s1 Y5 c; w0 R: i& }: i
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    % V9 X) Y" D0 J7 q+ z
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
      a9 v8 S- F2 f- k# a+ h
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ; t$ r; N' G4 w, Q; [5 S
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    * g5 p6 r( m* u3 Z2 x- u
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    - b. Q6 C" E, r+ E; f* U' H8 N
28. 
    5 S& o4 N- w3 B* n; c+ N
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 x$ v8 _) k6 h; D
30. 
    ; m: a! V* C/ A
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    1 n  s) k4 S6 |' [& e( [: F
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    . x- F+ _1 L7 k
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ( O7 x5 A5 W/ p$ o% i* F% I
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;
    - \' e; w# A) M2 y# i2 S/ S& x
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    3 h) X9 x4 q5 ^7 }8 j
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : {% \+ `- U* E9 [, D5 }
44. 
    ! c! j- d+ [0 L0 Z+ j# K2 |0 I
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ) a, s# _/ ^# l0 R: n2 W
46. 
    ' R0 k# E5 X( o8 c
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    # y1 {( ~5 ~5 u3 f
50. 
    
51. /*
    % a1 p, s3 s6 z% g
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    * e* ?- M7 A1 @7 L$ T
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    * ]. E- ]) ~" _" M
56. *    返 回 值: 无
    : p$ M2 p/ _, t) z" X9 `! j# L
57. *********************************************************************************************************
    
58. */
    - {; t( R) I; J1 G$ Z
59. static void CPU_CACHE_Enable(void)
    6 Y: q2 @" B4 D! i0 q1 l
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    * A# P, O8 ]  W9 p/ w; a+ O5 C4 i
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    ; V' o+ Q7 _2 I- b
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
, g2 b$ `$ o, j3 A
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   6 j0 k4 Y, Q7 k( L- S
3. *    函 数 名: bsp_RunPer10ms
   0 O; w5 O7 ^9 Y) o8 l
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   9 d; d3 [, G) n2 N7 |
8. *********************************************************************************************************
   6 ?7 V6 [: j! C; P
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    9 o* q, ~" M! k4 B" U% J0 x" E
13. }
    

复制代码

* R3 H% m  Z( H  l  主功能：
4 m6 K' D2 W$ n, n
主程序实现如下操作：

# R) g5 _8 d: x" F启动一个自动重装软件定时器，每100ms翻转一次LED2。
7 `9 O7 a/ \# K" X8 h: MK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   ( P7 T& C9 P7 }% s
2. *********************************************************************************************************
   
3. *    函 数 名: main
   2 N) Q9 R) v/ h0 t9 p4 n
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   . R8 k( f' f+ U/ c7 s4 @
6. *    返 回 值: 错误代码(无需处理)
   9 r$ }  N& J  x5 `
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    5 k, q/ \8 X$ Y6 K5 \
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    
13. 
    
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    ' \' h8 w; @1 v. k- a' v
17.     PrintfHelp();    /* 打印操作提示 */
    % ]1 ^$ m) L9 N) W2 `
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    * _7 F' O7 o# y" A* u: ~' W) s! x
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    2 f4 j* v/ ^+ j7 R  `, C
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    
23. 
    3 v5 m  E: F9 T2 e
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    ' L5 |( V+ b: j  P7 d1 C( m& l
26. 
    
27.     while (1)
    ; D+ ^. q' X$ ]2 q
28.     {
    * H) _' e# i5 o' h
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    
31.         /* 判断定时器超时时间 */
    9 q/ [$ Q1 [# O7 K3 J% I
32.         if (bsp_CheckTimer(0))   
    # c! Q  T) z/ ?( |
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    
36.         }
    % l. N% [: |. o& t8 Y
37. 
    6 N3 l* K7 @3 F) i+ C
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    % H& ?) ^+ y/ `
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    5 H" X% ?$ L! x# ^3 N  q5 I: K( v
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    9 n" s: }$ C2 M# F
42.             switch (ucKeyCode)
    
43.             {
    
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    5 W7 d- o! v4 U( f
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    ! ]1 h5 p/ O2 o# r$ n! H9 C
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ) P7 X- y3 v1 F. B* g! q. n
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    - {1 D3 y- k% N
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    4 w0 t9 Y" U' G% i6 [! ?
57.                     }
    
58. 
    , q& Q4 V# [3 q
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    4 E/ h  j4 _/ k; B/ `! ?' u
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    ' G4 @6 u, c8 u. @- x; U6 d% \. m$ S
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    ( z! E, p, }- H
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    " n. `+ G2 @8 X  ~- n5 ?6 B0 f
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    5 c- U7 ?7 ~+ f& c( r2 j
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    ) v, A: ]) I0 s& c& S/ [% ?! A
71.                     break;
    " z$ ]; ~5 h6 }" [! G8 t
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    * v' R. x( t' Y5 j4 {
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    2 b5 r: h7 c2 U
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    # F  N- c; X3 u& X% x* H
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    / P7 T7 X2 j7 }
81.                     /* 接收起始位唤醒 */
    - W& h2 [- f" s% [" Y
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    8 d, k! Q. w; {1 G1 ]2 |! y
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    6 }4 g* s* b' C# k4 r2 N
86.                     }
    ; ~) q# H" Q: g  `( s
87. 
    
88.                     /* 进入停机模式 */
    4 o7 a3 l0 j& y2 m" ~$ Z
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    " D( `; Z1 e3 n9 [( R7 ?) F  Q# O
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    
93. 
    - O5 N" r! P$ v$ A4 m% m
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    * B  D+ T9 e" }7 W% a# k& }
96. 
    : w. G# \% ^/ e1 }6 T; {3 ?
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    4 }$ e0 ?. E3 \. P& r0 v8 y- ?
98. 
    # L% c. t0 Q  w4 t$ N2 ?3 z
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    * D. x6 ]$ d. P" {
100.                     break;
     
101. 
     0 h: ^, x0 o# {
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     & Z9 p4 j# Q6 @' l/ x4 Q/ T9 s
103.                     /* 使能LPUART的停机唤醒 */
     
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     9 B* P7 ^0 Z/ h$ L* A5 j0 X
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     - A/ z' a; E2 {& t/ w9 A$ R
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     . z, J9 K3 a" _7 D, p
109. 
     ) E% S- o4 U# c1 \* U3 r
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     8 @& M+ q$ i# V! m. Y8 @
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__);                        
     . _: w" y/ G1 m
117.                     }
     
118. 
     , S2 m7 l5 t! _2 U% l5 \$ b) l
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     : r. D; e* T3 R# i8 C. g* {
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     & K& H7 T: {) F$ n7 C% y6 ^
125.                     SystemClock_Config();
     8 ~8 v0 u% U9 i( s# u5 {. o2 I6 O
126. 
     / Q: W; X7 T* n0 G
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     ( q! M% a6 f1 ?- p6 J/ \
129.                     /* 关闭LPUART的停机唤醒 */
     1 g+ p9 a9 d3 R% K) ^9 j% q
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     
132.                     break;
     ( b; X1 U3 W9 U( v( k$ p, d: K6 A
133. 
     : K- P  n& T! M  h6 A& C0 T
134.                 default:
     
135.                     /* 其它的键值不处理 */
     
136.                     break;
     * b, p2 K, ?# m1 S0 v
137.             }
     2 m" [* w( I6 z1 ~
138.         }
     5 A; A5 k& ~: S: F) C( t: k; `
139.     }
     
140. }

复制代码

66.8 实验例程说明（IAR）
配套例子：

6 g9 G4 N, @$ m/ \5 p' ?V7-046_低功耗串口的停机唤醒（串口FIFO方式）
  V- e9 p+ m/ n
实验目的：

! {5 T% x6 O1 ~7 \学习低功耗串口的停机唤醒。
实验内容：

. [$ P* }. ~+ g1 m2 H3 c启动一个自动重装软件定时器，每100ms翻转一次LED2。
( V2 {  k' q1 _5 N当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
8 j" t7 t8 r3 I5 [上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
/ x5 O. i, u4 G- W" s3 c- YLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

4 D8 G7 `8 s$ n" {- ^/ V; cLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
- J: g7 ]) k7 o* r/ N" s+ z
0 L6 o: B) A: b  A; d# tLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。
1 @0 o8 T1 \1 z( g- E
: j: V4 o4 c$ g$ R% ]实验操作：
* F) D/ H2 K3 {  T
( |. @. Y; \* V6 DK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
# z5 C* o4 r7 K, ~K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
6 Y/ J$ N/ p. H' K( |6 y8 B. g上电后串口打印的信息：
# K' j* _* F  }6 h" n1 L
波特率 115200，数据位 8，奇偶校验位无，停止位 1
7 `. N: D. z* }0 G! r8 ^
6 f9 e3 x) t0 Q

) @: C$ V! ]) v% i$ w) ^) E- y
程序设计：

  系统栈大小分配：
: N4 Q& k9 _! p5 W; }$ x

  RAM空间用的DTCM：

4 A" R% z" u7 ?/ b  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
4 i" h9 `" P8 c# P2 F% N0 D7 t5 T6 g$ H

1. /*
   7 W) ?5 B* H7 ~" X1 R3 H+ G$ W
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   , S8 _- \) T7 |" b4 D% }2 h% h
5. *    形    参：无
   
6. *    返 回 值: 无
   * r# ^9 Y. l) [% h: a& ?3 ~
7. *********************************************************************************************************
   
8. */
   ' F/ ^; C- s. e" _% e
9. void bsp_Init(void)
   
10. {
    / N* L5 h. P: x" g
11.     /* 配置MPU */
    : f6 _" `! ^; {
12.     MPU_Config();
    + v" u/ J1 a8 }# e! I
13. 
    1 r% ?1 ?) M4 c  r6 Y1 C  Y5 l
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    6 L5 T; C1 Y5 b* m* B
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    4 Y# U; Q+ G4 b' P" I
21.      */
    
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    / ~+ l& b  V  H' H5 f
26.        - 切换使用HSE。
    ! I" \6 `+ K) u1 e3 b7 D9 g3 w$ a
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    4 _. z9 x1 k) p. f
32.        Event Recorder：
    ! q6 x8 b2 D, @% K5 W
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    $ ]+ k# D' N# V' U9 y# w1 c) _
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    # _: }& p* \( M" J
36. #if Enable_EventRecorder == 1  
    - h3 W' d9 [6 Y0 e- ?1 ]
37.     /* 初始化EventRecorder并开启 */
      {- R$ I9 h: z* n+ O' R: L
38.     EventRecorderInitialize(EventRecordAll, 1U);
    * B) ]  Z! p0 h  E& @2 Z
39.     EventRecorderStart();
    
40. #endif
    
41. 
    0 m# U( p% x% ?7 Z! ~$ G
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
      a4 n, p& X6 _" p% }
45.     bsp_InitLPUart();    /* 初始化串口 */
    $ H) Q& {3 M5 l- q3 e3 F
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    & _7 n, a' ^1 G' ]5 ?- m
47.     bsp_InitLed();        /* 初始化LED */   
    1 l+ U* V5 ~9 _) q
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }

复制代码

' R1 Z) V/ R+ k  MPU配置和Cache配置：
( O/ F2 X" `( c+ E- `  E
' [1 |* e( _4 R& }8 x$ J+ K数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

" l5 ]* j' I# Z9 Z

1. /*
   1 ~) K$ N. e! i% Z" A% @+ u" @
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   5 N) u  U$ p  f* h
4. *    功能说明: 配置MPU
   ; q4 E* ~, T# J
5. *    形    参: 无
   - ~. A, w% I8 X; @$ b2 `0 }
6. *    返 回 值: 无
     {/ \# }0 w" v
7. *********************************************************************************************************
   0 q/ r' d# q0 k0 e9 ]' R
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    9 q" z# m! D- R' t: o9 h
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    . [7 l% I3 V- ?3 ?
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    4 y7 n+ h% V3 Q3 k
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;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    0 E2 w) ], w' e1 \
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    0 B% X7 m7 [2 a
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    : C7 [, r$ O1 Z/ E# D
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    & Q. R. Y% M. c7 K
30. 
    
31. 
    ; S' b0 {) r  f% x9 X5 T/ F( X' O
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 d  k* r7 G3 L7 O7 k+ q/ \) `2 x
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ' e8 t; c/ z1 C8 T7 A; N
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; J, x4 n: _1 W! k' R+ F6 Z! f$ T
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / ~* o1 A% F: L* C5 y/ N( G4 p: v- T$ {
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    . J7 w" u9 _3 @
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    1 O& _; U5 T3 n# N1 z0 ?+ [/ Z' ^
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    6 p; |7 y5 W% C0 s: J; m
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /*使能 MPU */
    # |& k  n* I& G4 C9 h5 b& @- o
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    + g5 j% i) P$ Q+ S1 K, O. c
50. 
    
51. /*
    0 g& m" ^2 y/ y" b# {' _- {
52. *********************************************************************************************************
    5 D6 T+ w# f! f8 K$ R# Q/ F& f: y4 J
53. *    函 数 名: CPU_CACHE_Enable
    ' x5 {# o! Y3 j2 A2 [  ~
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    9 Z: t+ e% X$ J
58. */
    % \5 H; @9 l7 m6 G8 f7 u
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    # r  F6 k) R; k2 B
65.     SCB_EnableDCache();
    ' S. j& Y  X* t* R) f" K* W# o
66. }
    & A& a3 n: o& N7 t' X# U
67. 
    

复制代码

) f. h: }/ l5 M# L; G6 w. e  每10ms调用一次蜂鸣器处理：

( Y6 b, w  A+ ^$ R1 F6 j' I6 V; ^蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   % m3 N- E+ T2 [& m  Y
2. *********************************************************************************************************
   . x0 Z: r1 h6 ]
3. *    函 数 名: bsp_RunPer10ms
   , [8 C* T7 [/ d$ G* O& _
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   8 Z% T; {2 H  L, o8 h' f' ^8 N
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   $ \( ?  Y* X1 f# C
6. *    形    参: 无
   
7. *    返 回 值: 无
   ! Y: }( [2 c% q
8. *********************************************************************************************************
   $ Y8 C! v. i$ n! w0 x* ]! Y/ h
9. */
   
10. void bsp_RunPer10ms(void)
    - ]( h- Z* j8 l2 w* E
11. {
    & _" p) x! N0 l
12.     bsp_KeyScan10ms();
    9 s8 U! V: o3 d. b9 L
13. }

复制代码

$ R- E, H7 ]" O; A# ?! X, X  主功能：

) h$ p& [$ I) l主程序实现如下操作：
( i) h) m2 E& O
启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
# ~# ^: f9 V; D- f8 ?4 N- Z0 Y9 O K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   8 |0 {/ ?% h6 d
2. *********************************************************************************************************
   5 g6 _; _( {' ]3 s. l/ \, R* ^
3. *    函 数 名: main
   % h( w( Q* t# j  K) a1 I# N+ v, \
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   . F3 F; n+ l  i" u8 F& {! h
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ( h) `1 {, x+ i. c& v
8. */
   + B4 I4 h2 r/ \
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    * b% `$ c- `& l" q
12.     uint8_t ucReceive;
    ; e3 i3 p; o3 p5 {- P9 ^6 B7 u
13. 
      M, u/ H4 T" u: ~; e& \+ k6 @
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    3 K" H2 w* w7 D% i
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    % C% J  h$ a1 o: u0 M( A) E
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    * e7 S6 e& O' }1 e* [
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    7 p( U' V: I( a/ p% i* Q: `
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
      |* d+ F0 C4 l0 b2 U
23. 
    + M- d8 B) m' m1 ~' e& c1 ~& B
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
    / {2 p; {4 C  q  \" k
27.     while (1)
    - M: Y/ V; L  z% ~. e5 W2 J
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    0 @+ Y, D, d1 M- ^3 b  c
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    5 R% c6 ^. s1 L0 r# s
33.         {
    . [+ e* z: Z  q4 m: F9 D6 c8 i* i  U
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    4 p- v2 v$ \4 W8 e
36.         }
    
37. 
    2 D5 x2 V% n! p$ x! K3 m: g
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    % k: s+ }' N' T# r" {$ O4 l4 V
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    1 ]# x+ T  u% y0 \: ~2 x( H5 X
42.             switch (ucKeyCode)
    
43.             {
    $ Y+ p& ]. C/ u# Z( [  @
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    6 S7 R( c6 s$ X6 U0 U
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    * m+ N" ^5 n; E  s, j9 n
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
51. 
    + x  k) u$ m- B2 N8 J) K
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    " c8 T9 w- g) k: X3 K! g! u1 o
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    - u+ J6 v' \4 B0 c; O, o
57.                     }
    ! m# U6 P$ G( _: y
58. 
    3 f$ }  {3 d& \4 V
59.                     /* 进入停机模式 */
    1 i  e$ p- F0 F& n
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    $ X3 t6 r7 H- Q0 t" t' y
63.                     SystemClock_Config();
    $ P/ o( X! s+ @* `6 N8 A4 L, T4 k- p6 Q* v
64. 
    4 a2 e" u) S, F  K1 ~. O" g0 o
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    . S; v! G5 ~: e4 G' e
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    : z1 j# w; P% x
71.                     break;
    
72. 
      d  {' C! u3 {' [' X/ p# N
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    ' m- S- Q) R. k" S+ r3 [
74.                     /* 使能LPUART的停机唤醒 */
    ! F* ?- y5 v7 @' B8 |
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    ' ~$ D+ Y* K" |
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    " Y( i, |, h* U/ ]* i
80. 
    
81.                     /* 接收起始位唤醒 */
    9 e( X; |) b: z/ x0 t: o- u
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    4 y9 R7 X# z( S6 ?
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    7 ?% z4 \7 R0 D% w. A- P, q" {
84.                     {
    . Y3 G" s) V/ ~; \
85.                         Error_Handler(__FILE__, __LINE__);                        
    * s8 |8 k) Q) f4 E' X( M# X' ]+ _
86.                     }
    
87. 
    0 c2 ]9 F) m( r- w4 }: ?
88.                     /* 进入停机模式 */
      }9 P- u- B. S
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    0 U2 |7 A/ O2 a% \) p% J
92.                     SystemClock_Config();
    
93. 
    . [+ W) P8 x3 ?% f! r$ U
94.                     /* 关闭LPUART的停机唤醒 */
    ; c: O9 J: z1 L
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    4 p+ X) c' y) D, V
96. 
    ( G% F' ?) U, f+ v" U. w. W4 \
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    3 S0 X: y; T0 C' |! N5 K0 y+ A
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    . p9 O- d5 o% l) G
100.                     break;
     " v4 t' ?' R" ?! K
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     0 t* x3 ?  X! U. T0 Y
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     0 G: S. }) P+ j, J/ r
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     & z$ m  E; o- Z  t* I
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     
109. 
     * ~( {, ]- [; P) p. |: P2 O
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     ! U9 ?: T7 q3 E. V
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     ! K4 v6 a! M1 m2 `
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     " v. p4 x5 Z* r; o( h" ^
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     ; V5 D) u- ~' w1 m- J( n
120. 
     " y+ f( K: S0 b) @
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     9 K6 U. o8 L7 q6 F8 x; ^% l8 n
123. 
     + I0 v5 |; L7 q3 ]
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     , w- X, \  a/ K9 Q. x! L, }
125.                     SystemClock_Config();
     " k& m! c, Y/ `, L
126. 
     0 z8 x/ h' w5 ]5 y
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     . r, j& \1 F5 j( F/ R
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     8 N: N3 P- D- K9 x
131. 
     8 P, \# N  e4 p: o2 O) t$ G
132.                     break;
     
133. 
     
134.                 default:
     
135.                     /* 其它的键值不处理 */
     
136.                     break;
     $ U- b' o6 w+ v0 f$ a$ v& j
137.             }
     5 _! d2 j. r# k2 l, @8 _8 V
138.         }
     
139.     }
     ! R9 c' [6 y2 h( |, B+ ^
140. }
     

复制代码

66.9 总结
2 W% M9 n: t) ~% Y本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。
4 k5 ?' O# g1 N! T( a

8 J0 u, |: o  j8 l2 _8 x# |# x" e
1 c) J) C2 e6 w. X: X% m