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

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

串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）
2 @+ C9 w, T( H2 R2 S; a! e
串口USART2  TX = PA2，   RX = PA3
+ S( F' m* x6 F
串口USART3  TX = PB10，  RX = PB11
* J# ]3 j( w1 d: i
7 w6 t- S1 G! j# g- I% ]串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

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

8 J" k* R8 t: K串口USART6  TX = PG14，  RX = PC7  
. B3 T- M$ l+ _3 z& K. F1 ]
5 L. s' a+ y5 j7 _串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

7 W: B2 f# k2 L5 d4 M4 E串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

STM32-V7开发板使用了4个串口设备。
9 }, `" j' f! {: n) U* M
6 d& [5 P9 T( i! j3 @: H& X  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
: R0 q: b/ v" N! x) y- ^  串口2用于GPS
" i! B5 z1 g1 D3 a# O9 K  串口3用于RS485接口
$ g' l5 e6 {, g5 s7 R  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
" P9 r. N2 S6 Q9 ^* l下面是RS232的原理图：

  \; ~. |9 {/ I- v9 m6 d$ X" W7 c

# o% R/ [- E! d1 T& I3 v" F8 F& `关于232的PHY芯片SP3232E要注意以下几个问题：

  SP3232E的作用是TTL电平转RS232电平。
  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

& _: [! N5 ?# r" @9 h; Q

实际效果如下：

& ]7 S/ `* @) t2 u/ v6 }  V! f# N

: u. v/ j1 Z  b5 @$ _  |( k1 u! H
通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY
% t1 b3 l! K" I# @
/ {& p( S2 A, y/ q芯片是否有问题。

2 ~" A! t4 q8 [  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
: n" w# T8 {: R9 C8 o& t  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
66.3 低功耗串口FIFO驱动设计
66.3.1 低功耗串口FIFO框架
为了方便大家理解，先来看下低功耗串口FIFO的实现框图：

8 @; U7 ^4 ^+ m' S# b! U

  第1阶段，初始化：

通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
" D; A1 S3 u6 H# {  第2阶段，低功耗串口中断服务程序：
! B* t. ]* n' F
2 }7 H7 b2 S! R: a/ f+ V9 [  接收中断是一直开启的。
; V1 j1 N5 X' f# U1 _$ J: c  做了发送空中断和发送完成中断的消息处理。
  第3阶段，低功耗串口数据的收发：

  D: @) a2 S7 ]. f低功耗串口发送函数会开启发送空中断。
9 h$ k& {9 C% P4 p低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
) `& N6 x) S/ u( T66.3.2 低功耗串口时钟选择
  |, L* v% K$ ?, m0 o% G( H我们这里实现了三种时钟选择：

! ]9 \8 F' f% Z7 N$ X; [' vLPUART时钟选择LSE(32768Hz)
* S1 h. T: y% G$ s8 s. v+ K最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
* l7 Q: ^; a) k& f, _
LPUART时钟选择HSI(64MHz)
最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。
3 d: d- R. z# [1 s
  q0 O$ E) A- s; Y8 A4 VLPUART时钟选择D3PCLK1(100MHz)
. A5 I) w9 E0 z最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。

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

1. //#define LPUART_CLOCK_SOURCE_LSE      
   
2. #define LPUART_CLOCK_SOURCE_HSI   
   1 n! H/ L% I# u* l) j% Q; P9 g
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   - y# ?5 X- C$ U$ e$ J" f2 l7 @% W
4. 
   
5. /*
   
6. *********************************************************************************************************
   ! r& H* h% o3 o: T
7. *    函 数 名: InitHardLPUart
   
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   8 N; E3 f( @# d- w8 X5 i3 H
9. *    形    参: 无
   
10. *    返 回 值: 无
    * y0 t1 \, {) A% _% |4 U6 G
11. *********************************************************************************************************
    
12. */
    
13. static void InitHardLPUart(void)
    ' ^) v' S6 C4 P; `# o9 s  g& u* q
14. {
    
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    
17. 
    
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    ) e, T( }, _) z! j+ f
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    ( w$ C8 G  ^% n  l# b
20.     {
    
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    1 t1 V+ W8 O  v
22. 
    7 S% v8 s$ Q+ D' ]; D9 x- _4 B
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    8 J7 h* Q2 p. h* D7 R
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    , ^0 `( A! ~! _& r
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    
26. 
    
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    2 _4 a: B, d$ M+ y, \  p
28.         {
    - p: m- v& t# Z( w
29.             Error_Handler(__FILE__, __LINE__);        
    " j6 ?. d: ?2 ~, m6 }  X. R7 b3 R
30.         }
    
31. 
    
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
35.     }   
    / B* ^( j1 _" k' `' K
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    
38.     {
    % ^9 C  O, s& B; N8 \5 Q5 J
39. 
    
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
41. 
    
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    7 u4 k# ^- H/ w, U; m9 ~  p; x
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    ) x; x6 S% r$ ]* q7 K, T1 w9 {+ G
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    
46. 
    ' R& N8 K" `, V. w8 D  M- }2 S+ E
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    # p2 v  I  k$ V' L' T6 N5 \
48.         {
    
49.             Error_Handler(__FILE__, __LINE__);        
    + `; Q7 ?3 o, u2 a
50.         }
    
51. 
    
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    / W! d  M+ L6 H3 `. c
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    3 o& l& {8 [" H# u0 o) T% N+ N
55.     }
    ; e9 {2 R$ A5 {' n' t4 G
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    " D- }) R# M( q5 _8 Z* w
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    - ]! `+ u% G$ i( ~8 W7 p
58. 
    
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    2 W) G/ B% l# `( U4 H
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    / z- |2 _; F- ]- F
62. #else
    
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    9 U# n/ X  f  f' u. ^& B2 g1 t. \
65. 
    + D3 Y2 e' m7 v7 ]/ z
66. #if LPUART1_FIFO_EN ==
    1 y) Z3 P: p7 J) w  h% T& q) G( t  N
67.     /* 其它省略未写 */
    2 ]6 y+ G' J, X3 a6 G% x1 O
68. #endif
    
69. }

复制代码

1 x, ?9 k2 I0 M, K6 i66.3.3 低功耗串口FIFO之相关的变量定义
低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。

- [. p9 |7 [% X; d) H; Z这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。
2 A0 `# ~( N: B+ m* s4 V
每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

+ J4 j# k, q9 `: j' `1 J我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。
' t$ `0 H7 }+ G" \- g) P! C' K

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if LPUART1_FIFO_EN == 1
   ' F) u3 {2 p3 |% @" _$ I
3.     #define LPUART1_BAUD         115200
   
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   - Y- _. [% ?; U1 A9 O2 q
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   
6. #endif
   
7. 
   - I8 t2 H5 s6 b
8. /* 串口设备结构体 */
   - A  M! I" J1 R. \* ^
9. typedef struct
   ) t6 [/ Z+ d9 d$ k- ^' Y0 l# @7 z
10. {
    * v4 Z' B6 Q8 A  g& g
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    & _: W- R' x! G- H" s; I
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    0 B6 Q; }* O' A8 r, ~' v
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
      B$ z- c( Z4 C4 o; X: M, d
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    ! @# ~; ~, r  d
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    : ~7 D% V% U7 U
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    1 [# G% v, c4 o
19. 
    & t9 C, \+ H# ?8 G0 T: \6 t. p
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    1 c) n' `7 P" L3 y
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    9 q' ]* O8 ~. f; C
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    1 ~5 |, V$ I$ f; I9 ]' B
23. 
    + H* c' A: j( |0 @
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    + _! U: I* ?& n4 a0 w; o) E
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    6 R( l( ~6 [( m+ I5 p8 y
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    - W. R# r, M5 M
29. 
    ) ?' i0 j& |9 H: k5 j2 D# B
30. 
    
31. bsp_lpuart_fifo.c文件定义变量。
    0 Q$ b; C0 ?7 t( O: Y, a! t. _0 W
32. 
    % \+ a. q0 C5 Y5 t4 C
33. /* 定义低功耗串口结构体变量 */
    
34. #if LPUART1_FIFO_EN == 1
    . e9 N9 o) U% }
35.     static LPUART_T g_tLPUart1;
    0 u% ?' k  f% N$ D/ \$ V- H
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    2 Q' i6 w9 p% z" l4 |
38. #endif
    6 Q% J4 }) h& h6 {# J0 f+ H8 m

复制代码

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

66.3.4 低功耗串口FIFO初始化
' l5 I6 D3 F; z2 `6 |- T低功耗串口的初始化代码如下；
6 _4 N& y8 {: Q6 F) i4 V
$ p* G  G' i: G/ P8 a6 q9 I/*
*********************************************************************************************************
$ x( B8 b( z. D*    函 数 名: bsp_InitLPUart
*    功能说明: 初始化串口硬件，并对全局变量赋初值.
*    形    参: 无
! r% D5 _5 R, ?) o*    返 回 值: 无
$ u8 q2 z/ Z/ w2 t1 G( q- X! h*********************************************************************************************************
2 B0 f) c. T$ d$ ^4 K; A*/
void bsp_InitLPUart(void)
  r7 u+ g3 T) d) G4 N{
    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
* E/ D( l, q  M8 J6 ~* ^6 Y  `4 S, o    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
}
+ {; A3 \9 V! Y: d8 n) ]- V

下面将初始化代码实现的功能依次为大家做个说明。

  函数LPUartVarInit
& K4 u5 l7 ~2 M6 k2 G% e这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
2 k: o3 m+ a4 k
/ q' I) `5 d  `9 D3 |: J  I& c8 A

1. /*
   : B% j' ~' x" P
2. *********************************************************************************************************
   & q  [! ?9 n  O  j5 T7 s* [4 s0 y
3. *    函 数 名: LPUartVarInit
   
4. *    功能说明: 初始化串口相关的变量
   $ q5 B: L% ]1 X
5. *    形    参: 无
   + h; @  A# U5 o; J0 |1 u. j
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void LPUartVarInit(void)
   
10. {
    ) a/ c9 w' F3 t! V" V% }
11. #if LPUART1_FIFO_EN == 1
    + g# c0 a! Y, P& u0 [0 ?
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    6 i9 ^4 O) u6 U4 O3 n
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    ; D7 p! p4 m+ g% O
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    % Q! t$ U+ F& \6 D
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    ' F# U; S& s) c9 _
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    + Z- \9 n  G3 k* y
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    4 i7 H: C* V6 P) j" g# a
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    4 v! e' F: e5 ?
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    . a# w6 [: ?5 E. Z4 @' Y
27. #endif
    $ T2 p9 }0 h7 I6 c  J8 `2 o
28. }

复制代码

' g! @0 M# h, J; V; A/ ]% C8 J
9 t" L# i/ F% f$ B5 f1 Y: [5 F2 V) C  函数InitHardLPUart
此函数主要用于串口的GPIO，中断和相关参数的配置。
& \7 Y& j9 v% I/ g4 t% `

1. /* LPUART1的GPIO  PA9, PA10 */
   
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   
3. 
   , l! ~2 J; g" ~5 m
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   ; C8 v4 X) e0 h/ S) H! c" n9 O
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   # H* @( E/ a5 X; U
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   7 @( s. [7 z5 _# W7 l
8. 
   " W. e1 T* u+ O5 n1 h' C6 f! s
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   ' L' k6 a" s% R' c' m
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    % M% h1 _9 s: y. c( i- |
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    ! l& w% b! G! H
13. 
    
14. /*
    9 h) V/ g) |4 H  E8 K
15. *********************************************************************************************************
    9 L1 E5 f: G- R  L* Q9 t
16. *    函 数 名: InitHardUart
    
17. *    功能说明: 配置串口的硬件参数和底层
    0 Z/ I! X. w$ y! {4 S
18. *    形    参: 无
    
19. *    返 回 值: 无
    
20. *********************************************************************************************************
    
21. */
    ' O# m8 b% r0 C; @( {
22. static void InitHardUart(void)
    
23. {
    , K  r, n# G: H& @
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    ) t6 e8 {. d0 v& ]1 R& G8 P; P% y/ v
26. 
    2 }" A  ?6 e9 O; G7 B9 v
27.     /* 时钟初始化省略未写 */
    . j8 K5 u, j; `' s
28. #if LPUART1_FIFO_EN == 1        
    * a) e' H/ Z7 z% v7 C
29.     /* 使能 GPIO TX/RX 时钟 */
    ; G3 f2 X1 d/ b0 L1 }
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
    
33.     /* 使能 USARTx 时钟 */
    
34.     LPUART1_CLK_ENABLE();   
    . J2 o# w. d: s3 s9 r8 s1 T/ V
35. 
    
36.     /* 配置TX引脚 */
    
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    0 R. E/ f  J0 l. D: A) \$ F
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    
43. 
    + p1 b8 M! a; X! y9 `! _
44.     /* 配置RX引脚 */
    
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    7 G0 e7 ^) Y7 h- w' f
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    : V- j2 a* [6 }$ X( O
48. 
    . A% O, A  H- J9 S# z* d$ H
49.     /* 配置NVIC the NVIC for UART */   
    
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    , x8 I8 T% k" }3 s7 P+ Z
52. 
    
53.     /* 配置波特率、奇偶校验 */
    6 e, l7 D! A  t( X. N
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    3 a% s! b7 d5 Y
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    4 P! W4 [& l1 i8 U0 i: \/ U4 @7 |6 }
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    + ?& Z0 _( j) B* f  H7 \: W, e4 `
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
59. #endif
    
60. }

复制代码

0 f7 Z  R! @' b1 `低功耗定时器的参数配置API如下：

1. /*
   
2. *********************************************************************************************************
   ' g8 f9 c: i  N9 D
3. *    函 数 名: bsp_SetLPUartParam
   2 K) I9 g4 ^8 b6 T4 @; _. R
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   3 V) X' \; S4 v( d9 d( R
5. *    形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   0 S. w: H# l8 P+ u. G
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   ; _1 `9 m7 l7 y+ T0 U- h
9. *    返 回 值: 无
   $ E8 m  V' K5 a3 }3 o/ L7 m) m5 A
10. *********************************************************************************************************
    / M: P- R! U6 F. b' x  [' Z& f
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    
14.     /*##-1- 配置串口硬件参数 ######################################*/
      K  K1 ^  l) }$ k+ o& v4 p# E* b
15.     /* 异步串口模式 (UART Mode) */
    ! d! R; n: |7 M0 x. l; _
16.     /* 配置如下:
    : M, `) {! v+ b7 ]
17.       - 字长    = 8 位
    
18.       - 停止位  = 1 个停止位
    
19.       - 校验    = 参数Parity
    1 x$ Y# R- U) h, S+ o0 L" Z
20.       - 波特率  = 参数BaudRate
    
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    # O# m& g. o. D$ f3 L2 h. t1 d$ [
22. 
    
23.     UartHandle.Instance        = Instance;
    , e0 G. I3 \" D; X  {; ^, k
24.     UartHandle.Init.BaudRate   = BaudRate;
    
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
27.     UartHandle.Init.Parity     = Parity;
    
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    ; E& f' |6 G$ C$ L! E& Z  S0 W
29.     UartHandle.Init.Mode       = Mode;
    8 S- l& K9 S$ \
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    / a; j" o( V, B0 R/ X" P7 X* b
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    , s; ~+ c" o- [7 c8 \1 W
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
33. 
    & B& g+ G2 y( Q" [( c" b  J
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    ! M- D, d* R0 t7 e$ \8 Y% N7 x
35.     {
    
36.         Error_Handler(__FILE__, __LINE__);
    
37.     }
    
38. }

复制代码

6 r6 k9 W  {. L. C
8 }9 ?8 ~2 C, g8 z! b# R( Q
  l; n: ]9 @! k% ~/ j66.3.5 低功耗串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能
/ M6 `/ e% \4 g2 R$ X$ I2 `
8 y' j+ d# a% K( r  收到新的数据后，会将数据压入RX_FIFO。
  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
& }, |. g, V6 l8 ^; g4 y0 F$ @  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
: v4 J) u; Z- f8 a* ?. U0 Z
" J- I+ \; S7 D
下面我们分析一下串口中断处理的完整过程。
  h: X" N  R( ~1 ?" g
当产生串口中断后，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
   - _/ e' u7 a) v& n0 P7 h& A/ d; b
2. void LPUART1_IRQHandler(void)
   . G4 ~8 w2 b. e- O* n0 }
3. {
   ' `8 z8 Y. p; Q$ n; Y/ ?% U
4.     LPUartIRQ(&g_tLPUart1);
   
5. }
   % U: l2 ~* \! @: E
6. #endif

复制代码

下面，我们来看看UartIRQ函数的实现代码。
' V8 `! _0 `% q6 g8 [; |
! D& b% ^" l! S  b5 G2 Z+ J3 y

1. /*
   
2. *********************************************************************************************************
   4 ^5 Q8 v$ p0 b
3. *    函 数 名: UartIRQ
   
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   & R5 |6 t! o4 L! Y
5. *    形    参: _pUart : 串口设备
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   0 |2 b4 M' w2 ]* e: i$ H4 {
8. */
     d4 h, |9 r; w( z/ W
9. static void UartIRQ(UART_T *_pUart)
   + ?5 Z: h# E( v' q
10. {
    ! d" u0 p* T, p. C2 t& X/ {+ j
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14. 
    
15.     /* 处理接收中断  */
    
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    + r) _) Q  r. N
17.     {
    
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    ' s; w$ D# V. f- m8 e9 [
19.         uint8_t ch;
    
20. 
    9 a) a4 t7 C+ W
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    / x. Z+ R- X; m' _4 n$ k6 M
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.         {
    
25.             _pUart->usRxWrite = 0;
    2 x: X* D$ {9 u% |: i' ~( r) T
26.         }
    . L% p: A8 B& h# U
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.         {
    
29.             _pUart->usRxCount++;
    
30.         }
    2 Z/ a# V) d2 c" Q' V
31. 
    & B( \% F; T3 E5 u
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    % i( n/ p- N* J& D* m5 ?. V
34.         //if (_pUart->usRxCount == 1)
    + ?% t. I' ?, A+ i6 F( D, d. e
35.         {
    
36.             if (_pUart->ReciveNew)
    & t1 X/ k4 A2 T
37.             {
    
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    8 D6 E& l, G) w5 |; e
39.             }
    
40.         }
    . @% `2 r: p4 m4 D3 I' W$ O
41.     }
    
42. 
    
43.     /* 处理发送缓冲区空中断 */
    
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    / {) Z7 _; e  l( f
45.     {
    
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.         {
    0 L0 c  D/ [! k2 t' Z0 n
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    & ?% _$ M4 X0 Y
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    : v2 C) `. E8 Q+ T
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    % U, D( l  V0 B' a
52. 
    
53.             /* 使能数据发送完毕中断 */
    ; G, e/ |9 e9 P: s5 j7 I
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    6 W. \' \! L8 S1 R9 U
56.         }
    3 z3 ]& [$ g7 `+ N
57.         Else  /*　还有数据等待发送 */
    
58.         {
    
59.             _pUart->Sending = 1;
    
60. 
    ) q5 s0 f6 r* c8 d9 v2 R
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    / L8 z) N+ A/ ]6 O
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    " ~" t% X1 H& w" G9 l4 E6 k# [6 P
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    + o' H, w9 k; S% x) ~3 A6 k
65.             {
    
66.                 _pUart->usTxRead = 0;
    6 S) k7 E4 I- B2 b' |* V
67.             }
    
68.             _pUart->usTxCount--;
    
69.         }
    ' d" i4 f6 N9 y
70. 
    ! I  _+ w* |$ ]8 l: D
71.     }
    
72.     /* 数据bit位全部发送完毕的中断 */
    
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    ( O; a+ ]+ T% E, T1 f
74.     {
    7 l8 D! X# O  G; D2 f5 X
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    ! h( c7 k3 u2 b* K6 G3 M& `  o4 M
76.         if (_pUart->usTxCount == 0)
    " n8 }( B# E2 m0 [/ v
77.         {
    3 N+ t% x& O4 H% l
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    # Z. x" W  v5 s. s8 c
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)
    " m+ f0 p& a2 A0 ^. I
84.             {
    ' w+ F& I/ l+ d% t. F; [
85.                 _pUart->SendOver();
    # t- q1 z1 K7 G" `3 [1 Z, ?# Q6 O
86.             }
    
87. 
    
88.             _pUart->Sending = 0;
    / }9 h$ a' T; |& s
89.         }
    . x1 C( L! u. l. Z! G
90.         else
    " W# i9 d8 d, E4 g. w
91.         {
    - @$ w3 I  v+ z- R6 j& T, j' e6 ^
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    $ L* d' V5 u" ?6 y3 `7 X
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    : A3 M* u1 F- H2 k! Y
98.             {
    5 n5 Y+ O( V# @, E  |
99.                 _pUart->usTxRead = 0;
    / l7 N4 |  ]2 G: g: s4 z. o& @
100.             }
     # A+ @- S# N) u: e. y  N) |
101.             _pUart->usTxCount--;
     
102.         }
     0 b( v# L4 b8 f% T/ y/ K
103.     }
     
104. 
     - C. N+ d/ y- s6 ?
105.     /* 清除中断标志 */
     3 N% t- {1 L5 F8 p
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     0 I  P# B5 m' {5 ~
108.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
       f1 D1 x! f+ Z9 N3 Y# W0 L5 I/ o/ {
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     ' P/ r9 z, e+ w+ a# R; J2 S
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     ; `( J* w4 k3 U; [- {
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     ! B) _% g# U9 j% f
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     ! D  n: P3 s" J. f* {" v& H' [- N' i
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     6 F" U" E5 A0 |$ _+ v  g/ c
117. }

复制代码

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

$ T( H/ w  b) z3 H. i  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
- q# B# ^% _9 r1 M! ~
% q5 r! |( Q8 V8 b5 `6 E特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
# R3 I, X; T& h% Y# g' U
3 k+ A" _  O: j. K8 x  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

66.3.6 低功耗串口数据发送
5 m. @7 `1 z( t3 r低功耗串口数据的发送主要涉及到下面三个函数：

4 F9 u" X6 g3 F8 {0 p, p

1. /*
   ( d- h! x7 n; A$ W9 q* h8 ~
2. *********************************************************************************************************
   3 |" Y$ N( B( D3 S$ T& R
3. *    函 数 名: lpcomSendBuf
   7 [4 o8 ]% z, F/ p2 t
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   " `' x1 y! G2 _
6. *              _ucaBuf: 待发送的数据缓冲区
   
7. *              _usLen : 数据长度
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   2 @! v9 V% p& l- a; z& {7 A) J( r2 A
10. */
    1 `3 k/ c. {5 h1 t% p# f7 z
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    $ Z  L1 ~9 D& g6 T, Q! A7 q8 t' p
13.     LPUART_T *pUart;
    ( E+ f0 @7 X2 D" D6 E" W7 v
14. 
    
15.     pUart = ComToLPUart(_ucPort);
    
16.     if (pUart == 0)
    
17.     {
    
18.         return;
    
19.     }
    
20. 
    3 m% K6 z% D+ Y& R, C
21.     if (pUart->SendBefor != 0)
    0 o' q3 j( J; }9 P% V
22.     {
    8 s" |# j, X- ~: b3 [
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.     }
    % m1 S! k' p: |: R4 ]. T8 C
25. 
    
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    2 W3 W6 c2 F7 W# H6 G& K! y, a9 O6 s  u  J
27. }
    + G' H# b* b# ^$ M# i# J4 U
28. 
    
29. /*
    3 }1 T4 N6 ?# U
30. *********************************************************************************************************
    
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    ! w  i4 [: Z& |, N" f3 S. U
33. *    形    参: _ucPort: 端口号(LPCOM1)
    * ?( k9 L  d( i. D. P4 o
34. *              _ucByte: 待发送的数据
    0 z8 V$ K/ f. O' s8 `" d
35. *    返 回 值: 无
    ! k8 s- z) W4 m- u% g" `
36. *********************************************************************************************************
    
37. */
    5 ~1 {6 Y/ @1 P/ g" `, Z% |* W
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    + T- ?" Z2 l3 z+ e8 D
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    0 H6 a6 R( m8 Q$ l
42. 
    
43. /*
    
44. *********************************************************************************************************
    
45. *    函 数 名: LPUartSend
    $ p3 l$ K) [+ s7 c
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    3 Q: D$ e& E- ^
47. *    形    参: 无
    
48. *    返 回 值: 无
    ) i$ _+ V+ Z# X* }5 G* D: U
49. *********************************************************************************************************
    
50. */
    & Y2 y4 K% [  @: ?" k0 }
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    / Z3 G7 C: Y% D
52. {
    ; S* J- k3 n" K3 x' N
53.     uint16_t i;
    # K6 M8 w. k% B; l9 v4 _
54. 
    4 h1 ]: w' s( \# F2 K2 v
55.     for (i = 0; i < _usLen; i++)
    - f4 \  g8 I: _; G0 b
56.     {
    + c0 A* @& N9 ?) x6 z; E  I
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
58.         while (1)
    
59.         {
    7 P& U, j0 T7 K' O
60.             __IO uint16_t usCount;
    
61. 
    
62.             DISABLE_INT();
    2 h6 v8 d+ F; Z" e' o5 l% N
63.             usCount = _pUart->usTxCount;
    
64.             ENABLE_INT();
    
65. 
    
66.             if (usCount < _pUart->usTxBufSize)
    
67.             {
    
68.                 break;
    
69.             }
    
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
71.             {
    ' z! W* T; q& _$ B. y9 m
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    , D( a. p3 O' ~+ a8 F
73.                 {
    
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    3 v/ _3 I- K" z7 N4 j
75.                 }  
    
76.             }
    
77.         }
    ' }1 e! f$ m3 u& z5 ^# m- b
78. 
    2 v4 h  E- H( h
79.         /* 将新数据填入发送缓冲区 */
    
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    . I5 F* D8 a( O& R( w$ @2 b/ q
81. 
    8 c0 ?% |$ H/ o$ K3 q  b9 p
82.         DISABLE_INT();
    
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
84.         {
    ( }8 G+ Y7 X$ O& d( y0 Q. D: C
85.             _pUart->usTxWrite = 0;
    0 W9 H: Z7 l5 P: R# A
86.         }
    4 U+ M. o* t* O
87.         _pUart->usTxCount++;
    & A# @$ H( n( g7 t, E6 T3 @
88.         ENABLE_INT();
    2 m# c) {' {7 U4 E
89.     }
    
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    
92. }

复制代码

函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。
' R6 \+ X8 Q; K- L. h
函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
  f; r- C, x4 T# r$ W- Z9 O5 s
. }1 ?- c$ A& C6 M  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

9 n! [3 m% W# t' ]注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。
$ n% X) M/ T! p# l
函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。

9 V& A& D5 b+ y5 k

1. /*
   2 H  U, H' @  b3 r5 D1 R
2. *********************************************************************************************************
   
3. *    函 数 名: ComToLPUart
   % l  p0 N0 f) u) m0 l
4. *    功能说明: 将COM端口号转换为LPUART指针
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *    返 回 值: uart指针
   
7. *********************************************************************************************************
   
8. */
   
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   
10. {
    
11.     if (_ucPort == LPCOM1)
    
12.     {
    - w7 L0 R: i/ |" q" V/ f
13.         #if LPUART1_FIFO_EN == 1
    ' }) p) l8 j( T- d* @& s8 i
14.             return &g_tLPUart1;
    & b- j/ A! z: K
15.         #else
    + h' f; g4 \( O: [
16.             return 0;
    6 D9 X, t  f1 ]) Z1 T: ^
17.         #endif
    ; P9 \, H9 H3 F
18.     }
    5 n1 j9 }" H- Q* t7 S* u
19.     else
    , q; {- O8 `% G# u3 ]3 h/ ?
20.     {
    
21.         Error_Handler(__FILE__, __LINE__);
    
22.         return 0;
    6 G( v# M1 G$ c* H
23.     }
    $ C7 m0 }/ D  y, ]) Y  {/ ]
24. }

复制代码

! k# u8 u$ [$ H

66.3.7 低功耗串口数据接收
下面我们再来看看接收的函数：
2 Y+ \4 Z  W1 q! I+ e$ s  x
  l: v" V; W4 ~6 r' s! [3 Z3 ~

1. /*
   
2. *********************************************************************************************************
   ; T7 N  U7 \* _/ r3 C$ T5 v
3. *    函 数 名: lpcomGetChar
   5 x( b2 t, E3 p" i( [# m
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   $ M3 e; J; D* p* y
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *              _pByte: 接收到的数据存放在这个地址
   & @8 R$ n" u+ L
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   : a& j- d% w" N) @7 H+ F+ }
9. */
   
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    ; W4 h, y+ ~7 ?6 \( w+ u* U
12.     LPUART_T *pUart;
    
13. 
    ( ^6 ]: V( Y& @$ \  c& m6 K
14.     pUart = ComToLPUart(_ucPort);
    0 e% f/ _0 ]0 t0 q
15.     if (pUart == 0)
    
16.     {
    ' _7 Y4 p# c" f# l* g
17.         return 0;
    
18.     }
    / i9 p2 o* z3 a' ?/ D) e  {  [
19. 
    
20.     return LPUartGetChar(pUart, _pByte);
    
21. }
    5 g+ f8 e/ |& m3 Z- g7 Q
22. 
    
23. /*
    
24. *********************************************************************************************************
    
25. *    函 数 名: LPUartGetChar
    
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    , b. T& C) T  g' _; f2 u/ h
27. *    形    参: _pUart : 串口设备
    
28. *              _pByte : 存放读取数据的指针
    % `, {  q4 P* }7 U8 A
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    ' r- W+ Z$ L; p* M6 {
30. *********************************************************************************************************
    
31. */
    * j. o4 v: f: h6 J1 c" }* {/ m
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.     uint16_t usCount;
    
35. 
    2 f1 O4 g* m* s7 @/ Q2 X
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    
38.     usCount = _pUart->usRxCount;
    * G* I; n$ o  x3 @! G
39.     ENABLE_INT();
    / N- }1 |3 y  j1 c( l, Q
40. 
    1 v0 Y& D7 D' g% `% F$ ]( \6 q
41.     /* 如果读和写索引相同，则返回0 */
    
42.     //if (_pUart->usRxRead == usRxWrite)
    2 x# o, z- s' Y3 D" L4 v7 h$ t
43.     if (usCount == 0)    /* 已经没有数据 */
    
44.     {
    
45.         return 0;
    
46.     }
    ; p5 k5 l( Y$ u% a& O5 G% t5 t
47.     else
    
48.     {
    9 o! j9 M! Z$ ^6 i1 M0 P
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    0 D# c+ S9 c0 d+ R
50. 
    
51.         /* 改写FIFO读索引 */
    % H2 {6 i( t) ?2 }3 x$ t
52.         DISABLE_INT();
    
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    - B% o" B6 N# a5 D1 G' H4 D
54.         {
    + ^: |. V' x7 `' u9 g0 x
55.             _pUart->usRxRead = 0;
    
56.         }
    
57.         _pUart->usRxCount--;
    : k" f7 p4 w4 h# q3 Z' F# _
58.         ENABLE_INT();
    
59.         return 1;
    
60.     }
    7 C8 b) ?. d% v( Z9 ~. L
61. }

复制代码

函数lpcomGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。
/ F4 ~7 i8 \6 V; l2 n
# w1 E& Y8 L1 T* b' g/ s% l注意：由于函数LPUartGetChar做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。

66.3.8 低功耗串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
' `/ x! b1 D5 O, v3 n0 L
3 M/ j$ j5 L8 b3 S为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
$ I& q& m# q4 A9 n4 t" M( J" Z
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
3 u/ X" o/ Z! n
实现printf输出到串口，只需要在工程中添加两个函数：

% L+ h. f2 `6 Q8 k

1. /*
   6 h8 e' e; D2 l& s$ e
2. *********************************************************************************************************
   
3. *    函 数 名: fputc
   : o  a1 h  j5 c
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   + m+ M, |2 z, A5 x0 r
5. *    形    参: 无
   / L4 w% v% b5 Z
6. *    返 回 值: 无
   5 B/ c5 F4 }! A
7. *********************************************************************************************************
   ( \7 e- G2 A1 v2 y$ H
8. */
   
9. int fputc(int ch, FILE *f)
   
10. {
    3 [( c% X7 [2 S* {: C) B
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    . Z/ g( B9 F( N0 G4 V( T
12.     lpcomSendChar(LPCOM1, ch);
    + N- _: T! S/ P" B
13. 
    
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    7 K; b& y: F  C" T3 @% y
16.     /* 写一个字节到USART1 */
    ( C3 |  d2 Y0 d1 x$ O! d9 X
17.     LPUART1->TDR = ch;
    . `1 l2 p. @  y5 M9 ?
18. 
    8 g  Y5 f7 h$ C8 ?. A3 D# w$ {
19.     /* 等待发送结束 */
    ' B' ?- n/ \+ [& j2 K
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    5 ]. d4 Y3 T! o! w, x) \! I
21.     {}
    
22. 
    9 ]/ s! E0 t8 M- U
23.     return ch;
    " j- N' F8 y* f) D- P0 I1 T, C
24. #endif
    
25. }
    0 n5 ?$ r" s" ]& |" A. ]
26. 
    
27. /*
    
28. *********************************************************************************************************
    
29. *    函 数 名: fgetc
    ' u6 }7 o: k& E/ Y
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    4 G  n8 w$ \% y- C
31. *    形    参: 无
    6 C( N0 E) P* Z; T( z8 j; C1 J
32. *    返 回 值: 无
    
33. *********************************************************************************************************
    + L& l3 |4 a- i3 E* w% Y3 x. d
34. */
    ( v; G" Z7 d3 j7 O
35. int fgetc(FILE *f)
    
36. {
    / m/ @$ J9 R, H: X4 W' x
37. 
    + `! o( |6 u& c4 }  D
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    
40. 
    , Q7 h' z7 C9 n- a
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    
42. 
    * D  U. H# l1 O( T
43.     return ucData;
    
44. #else
    4 s# b$ k5 R% v9 B( w& }' _
45.     /* 等待接收到数据 */
    
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    ) v. b/ ^1 {1 C% J6 d4 C/ G
47.     {}
    
48. 
    
49.     return (int)LPUART1->RDR;
      ]; t1 w  I% b4 q' Z5 x
50. #endif
    
51. }

复制代码

- s& ~, _: {  O$ K6 h0 E( j通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
8 F( P; E% L: q% ^
! |5 w8 N# r1 i. t66.3.9 低功耗串口停机唤醒方式
( Y6 M( p0 A7 m, ^/ }5 D低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：
! W9 ]& s" q* M6 e
8 Z, J2 M" A" `. }1 y# H: w  检测到起始位唤醒。
低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。

如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：
% Z3 @1 x0 d( v/ @1 I5 o% t
/ @/ K6 }  v0 i6 j+ p

1. /* 使能LPUART的停机唤醒 */
   2 P) g& h+ S1 u' s) b' F
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   4 T3 u+ T! B5 P: G, B7 }
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   ' \: R" |( F' E! g, \' D
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   5 Z' J0 I6 P, r# S9 j
7. 
   + g+ N3 m  \" ^) }# o- j, o& b
8. /* 接收起始位唤醒 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    & S+ X2 U2 d+ @
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    # C  f1 H2 V3 c' v  t; s
14. 
    
15. /* 进入停机模式 */
    $ H( x7 C: ?4 g7 n0 b
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    % K3 {# _5 |% L. U: I& v( F
17. 
    7 C( f9 @" j1 q- }, ]+ o6 D/ x
18. /* 退出停机模式要重新配置HSE和PLL*/
      c; n; w4 O4 t. h$ z! p! K, [
19. SystemClock_Config();
    
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    3 Q2 ~3 Y# I6 w1 |1 v# D5 q
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    

复制代码

/ ?5 E( [8 z2 f- a, \( r  检测到RXNE标志唤醒，即接收到数据。
低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。
1 e; L+ U: e. c: N( R
如果想唤醒H7，发一个任意数据即可。
& T7 A/ w4 Y% X" v2 ]4 I' ?1 e, q

1. /* 使能LPUART的停机唤醒 */
   2 {0 U2 n9 y. _' [
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   + I6 o, B7 x: L: |' \8 x' F
3. 
   % E( _( F% r* N. P
4. /* 确保LPUART没有在通信中 */
     c3 z7 @% g. I+ k9 E' L
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   * G4 |( u/ r# ~0 `. P- R5 B
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   & X. E2 `  G3 c- @, {9 m) `' f, {
8. /* 接收到数据唤醒，即RXNE标志置位 */
   6 e. I5 o' ]8 v, U/ ~, y# k6 b
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   # X5 l: i) r9 t7 a! }: U6 v" a
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    ' ]( g2 D, F, p
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    
14. 
    ; J. p  f; `% Q7 I' i2 b5 o2 K
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    6 }7 l. k8 j8 C2 h5 j5 M
20. 
    0 Z- ?( r# H% l2 Q8 }3 y3 [
21. /* 关闭LPUART的停机唤醒 */
      |" h# M/ f1 I0 k: W. N
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    
23. 
    4 \* A) I1 h/ U$ H, d

复制代码

) m/ f3 ?, H' B: |5 Y  检测到匹配地址时唤醒。
" Q5 |# U0 R: p- [低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。
0 f1 P( n0 ~+ |) v7 J/ K
  N% ]: u" E3 w( ~" [7 _8 {/ V如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
( ^% K6 y0 d; ~6 M2 C0 x" [

1. /* 使能LPUART的停机唤醒 */
   0 K+ q+ |3 j" W9 z$ |4 T7 a
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   * }7 p% O5 [, T$ r9 T5 b- J& {) V+ F5 F0 Y
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   1 G8 T; D! P  ~1 n! p
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   ) ^0 B& F) b5 ^! ~: @5 a9 h5 b3 J
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    $ g0 b2 e( u8 S- A
11. WakeUpSelection.Address       = 0x19;
    * H0 r& F4 x/ C1 F6 O, Q* x4 ]5 F3 v
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
13. {
    
14.     Error_Handler(__FILE__, __LINE__);                        
    ) u$ j- S# q& m8 ]9 [  `; Y1 p4 C
15. }
    " A; K, h3 q5 ~6 z4 Y
16. 
    % S' H( O. X4 O- G: B( ~  D
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    0 U9 L4 z, F6 C+ m  N6 H. L2 L0 U
18. 
    
19. /* 进入停机模式 */
    
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    + t1 M2 O3 @1 ?8 G4 V
21. 
    
22. /* 退出停机模式要重新配置HSE和PLL*/
    
23. SystemClock_Config();
    
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    
26. 
    4 N  O- V( h3 J8 A- n+ f
27. /* 关闭LPUART的停机唤醒 */
    ; z/ j1 M* K. B  _: x( S7 n+ y3 ^6 X
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    
29. 
    . I% n" Y+ t" Z& o8 r9 t2 i/ E$ X

复制代码

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

1 B+ g5 D% y# j! @5 Z

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供用户调用：
8 e9 b. v/ M0 b4 H9 |4 P! b
* d/ ?7 u8 f! C( Q% h& \! x  bsp_InitLPUart
  lpcomSendBuf
8 D# `. I- d5 e- U' @) a/ B4 S  lpcomSendChar
  lpcomGetChar
$ X; m! a) l' l1 R% F% M9 Q' o, [66.4.1 函数bsp_InitLPUart
函数原型：
& u# c5 G6 b$ W8 f( p& W
void bsp_InitLPUart(void)

函数描述：
% U; S' |& n! n, t. w
此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

6 ^% j- [! z* V+ p1 I! o& Z使用举例：
( _0 ~4 z/ ?: f/ y
7 b4 G2 n0 o6 c: e, G0 c1 m串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
" F1 Y) J) b* U0 O1 l
. o: s6 ]$ f0 j66.4.2 函数lpcomSendBuf
) t. i6 c3 e$ h! G0 q7 D3 ~1 |/ p8 N函数原型：
; b0 q$ Z& V5 r% [3 Q2 h; n5 @
  C9 K/ R7 K* l' [void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

0 C) P1 w  G" n5 R5 h$ u, e函数描述：
0 {2 O0 n1 T  P+ g; Q9 a) t
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

' g+ x+ W3 T. q1 X. x函数参数：
0 q8 J5 l+ M. C1 v
  第1个参数_ucPort是端口号。
( e4 v6 R$ G6 M- _6 i4 f  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
) Z1 l( X" W, A# A4 Z4 _注意事项：

" P3 \3 i4 N: S, f9 C( f5 Z) P 此函数的解读在本章66.3.5小节。
发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
使用举例：
8 P: w7 t: i& C% U
/ n# V2 }: x& L8 e% n- Q调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
1 u( \% W& [4 W5 L4 Z
" {2 I4 B8 P, y5 `! j  B

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

复制代码

0 |5 o; E$ A5 ?1 s5 {' p" r+ e66.4.3 函数lpcomSendChar
函数原型：

+ L" [/ ]4 Y1 g+ ^void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
3 ]+ ~3 h; u. v) r5 X0 A. E
函数描述：
0 C& v/ ?. @& b, ?: u8 m: o& u7 z6 y
此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。

函数参数：
  第1个参数_ucPort是端口号。
. W: J6 z" N/ Q( Q  第2个参数_ucByte是待发送的数据。
注意事项：
, x* R% Y4 c" r6 B8 h$ \
  此函数的解读在本章66.3.2小节。
使用举例：

/ ]4 l8 e2 T$ G! p/ B  E0 k! G  T. b调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：
) D" f3 D' ~& g/ o. q5 ~
, S- ^& z# n2 ElpcomSendChar(LPCOM1, 'c')。
. _  ]* F7 O# w% [0 M
8 J  e4 J/ }8 y( _# z66.4.4 函数lpcomGetChar
函数原型：
* }/ [5 v3 L: `1 P9 a
uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)

& p/ C  ~* H; G/ o0 K函数描述：
$ l; O3 }* j, K/ d4 x
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

4 n) _) p* M! D: N6 h% {函数参数：
# k# ^/ t  m- t, w4 C
  f  l: I5 @8 ~: r' H" t  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
( A9 d0 x5 A7 d+ t  返回值，返回0表示无数据, 1 表示读取到有效字节。
3 H. o/ f  n2 Y9 E( J7 w, {注意事项：
. W. _( V  n- Q' `0 e
  ]+ g4 T- g" @1 k: Q/ d  此函数的解读在本章66.3.6小节。
) ^+ j- M8 q# }. p- i4 ^使用举例：
* T0 Z  O- h8 h5 F8 f, t2 w
* T+ x7 z7 D/ r调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
5 y" @, o5 P/ j$ n" N3 G
7 Z" n; q+ x  H比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。
' c9 U1 m3 b% i) \
66.5 低功耗串口FIFO驱动移植和使用
串口FIFO移植步骤如下：

4 Q; @% q' l7 {" q0 f# u; F  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
7 ]- Y8 X4 S* s* t  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define    LPUART1_FIFO_EN    1
   
2. 
   7 b4 V' _4 ^4 {
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
4. #if LPUART1_FIFO_EN == 1
   $ P6 x% b( w% f
5.     #define LPUART1_BAUD         115200
   
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   - f# R2 d  L5 D$ b9 Q, d4 B
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   5 {$ l1 X" g$ E! R6 }: f  L8 ^
8. #endif

复制代码

  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
5 g# w- _* Y2 [2 L  第4步，应用方法看本章节配套例子即可。
' f# i% i; E8 c9 K8 O6 |* e66.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
% }1 _% K4 i% D# o2 L

- B+ N( W5 ~) W8 _* m0 a1 m1 g
  第1阶段，上电启动阶段：
7 ^9 \0 h4 a+ d. f  y" W& b
这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
" o" I1 V3 l) e0 K
第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现了三种停机唤醒方法。
66.7 实验例程说明（MDK）
: O6 K. e6 {/ p  a& j- B配套例子：

0 H$ `4 o( r, t* ?/ @' nV7-046_低功耗串口的停机唤醒（串口FIFO方式）
, c) q5 l1 l8 [! w/ O( [
% s( q# p0 s, |, o( r' \0 U# ~8 y实验目的：

学习低功耗串口的停机唤醒。
: D& p1 [/ d, K实验内容：
% `$ J8 e. a( x  ?1 h: k
启动一个自动重装软件定时器，每100ms翻转一次LED2。
: X4 D% S$ A# G& d8 Y当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
( y$ d( Q3 V& `3 g( X4 ^1 C上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
3 r* j* g8 U5 G0 j: a2 G' uLPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。

, [0 t1 H- T' e8 b+ o4 @. NLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

% ?) {1 n. O( ?( \7 D0 P实验操作：
/ R0 @& l( {" @' N/ \) W- U2 O
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
6 n# t; \( [2 ^  ^8 Q& `5 Y" f' eK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
2 U2 M8 ?- f9 O3 l. \! WK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
( {1 V$ U( P/ r/ n1 M$ M1 ~% `上电后串口打印的信息：
* ?6 w' L0 B% m" s/ o
7 p# S: Q2 j! X# z1 y波特率 115200，数据位 8，奇偶校验位无，停止位 1。

' l0 R4 R2 b. F" f/ E% Z' b

9 O  Q( I! |5 n, x% T  J8 z
( J  t# D4 j, D2 y6 {程序设计：

# w7 K0 _! t4 `6 J5 M: @' J  系统栈大小分配：
& Y+ Z/ Q1 p, W) v! h, e
! ^! S: b+ E( \. z3 q  l0 ^

7 h- Z0 D! R6 Z7 ]  A% @' E) {8 A
  RAM空间用的DTCM：
  {+ ^3 y0 N, i" Y/ _2 k* b4 C
6 c( U' `3 c$ Z5 q0 Z

+ l/ q% I/ g/ _8 Z# K. H- H
4 Q$ e; W. Z7 R1 {' p* m, ~0 P  硬件外设初始化

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

5 H% I9 X% Y  f' o; w% w

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   4 }! T$ G7 }: C. x3 g% I' b! E0 j
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   - t7 c3 s( z/ U0 X$ Y8 O7 a/ G
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   : B0 K( q* K! ]+ ^2 |
8. */
   1 S6 [( E. _) h% ]
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    , F- ]& w" W- O$ v/ [/ C2 h5 K
16. 
    
17.     /*
    7 R3 `! k- {/ A' V+ @* p) Y0 T, _
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
      w9 q8 \+ v: \$ f- q! Z
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    0 O$ |3 k# v% e" N  y! |, u
20.        - 设置NVIV优先级分组为4。
    + c1 k1 ^9 H( ~4 s' p( X' @
21.      */
    . J$ s6 X+ W) D3 {
22.     HAL_Init();
    
23. 
    
24.     /*
    , g5 q+ n: m( E  W
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    & `, y! Q. V3 A0 J$ i% w4 h. ^! \2 d
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    2 [. O: o; ?7 O: F. ^1 H4 g! A0 y( S
29.     SystemClock_Config();
    
30. 
    
31.     /*
    : O2 r8 i; K+ {$ P
32.        Event Recorder：
    . T& r0 f/ C, [3 O/ x$ ^; C
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    + h! {, C; }4 i: J
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    + B( n7 V5 x; q" u
37.     /* 初始化EventRecorder并开启 */
    ; j6 g+ h+ H# s0 Z/ {0 b+ x0 L6 B# L
38.     EventRecorderInitialize(EventRecordAll, 1U);
    ( a. S& W( |3 D0 D7 x! [
39.     EventRecorderStart();
    
40. #endif
      L& J/ d1 a; W8 ]- |! {7 t5 ^
41. 
    & U- d& x8 [; [( q+ w4 T2 b
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    - g4 {, _. w+ j1 Y+ p
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ' {9 M1 W# W! E. s5 [8 Z8 @1 ?
47.     bsp_InitLed();        /* 初始化LED */   
    7 `0 |& C  n3 }. ?
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    7 t/ S% P- n) r- k$ M8 L4 K$ B
49. }
    

复制代码

  MPU配置和Cache配置：
& Q! F: n- |& }6 j
8 N- w$ k  ~+ o( _  L数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   4 i" z3 L/ }% d6 N. f
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   : L# o" k2 W& w; r- Z4 Q! E. v/ t
6. *    返 回 值: 无
   % W5 x: d" b* Q  d- ?8 q  l, y
7. *********************************************************************************************************
   
8. */
   & j2 Z: W" j" ^8 f7 b  a
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    1 q' R: z( j3 Q) `
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) Z7 @; ~& b- d7 I( y8 M& z
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
      b2 q" u/ @  y! X1 [. t0 N
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    " R+ O! I) @. C  b- O3 _' R* U
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    % Y' z7 y4 \) F& B: U5 {* H2 a
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ( Z5 b; l' e+ }8 g! [
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ( |% l! ^4 M2 h0 {" q( n+ Q
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    # G6 i% X6 h7 f5 ?0 D
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ' n) `9 E% x6 f2 j' r
30. 
    # q0 o: e0 ^, u6 r
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    " {  R8 s8 u$ C, m6 d4 u4 _
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    % [1 A! K9 S' T2 h2 E1 y
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    # u! V* N/ j- P! C  V
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    , o& p2 p+ Z2 i+ P6 N; a
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ) j  E% g5 u( I( Z+ T" K0 A: H
44. 
    6 F0 N6 j/ N# t
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    $ W  h- [; o. w. O+ e) L+ R
46. 
    ) X6 V! q. k) p2 [
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    4 a4 e: m: g) a7 M8 Y% r$ T
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    6 a9 H& Q- v/ M* n% L) W
55. *    形    参: 无
    * q/ S$ P% Q' b! S3 N* e6 F# {7 h
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    $ G( n* k5 A0 r1 F. |4 z" T: U% b
58. */
    & d- Z4 ~. \: c+ k- n3 O# \; `
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    + G2 Y2 V6 a0 c' {3 E: A* Q
62.     SCB_EnableICache();
    ; y5 ?4 l0 r6 Y* r# s
63. 
    
64.     /* 使能 D-Cache */
    0 E2 |  Q( `# W* ^
65.     SCB_EnableDCache();
    ' y1 B0 H6 M) L" w
66. }

复制代码

; u5 h1 l. x8 W4 E. m) ]  每10ms调用一次蜂鸣器处理：
9 j6 |4 j9 X( u5 u
4 P. ~* U4 a0 ]) a蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
8 W& \$ x: j$ p

1. /*
   
2. *********************************************************************************************************
   1 R* u0 U; `8 h. \2 y
3. *    函 数 名: bsp_RunPer10ms
   " n! t6 J5 m5 O: {
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   ' I% ~5 H6 V! b4 `( P+ Q: `
6. *    形    参: 无
   - e4 Z- k' C+ l% c; X
7. *    返 回 值: 无
   $ o) t7 P' h& v, ^, @2 N+ `
8. *********************************************************************************************************
   ( i$ F7 g8 S" Q' M
9. */
   . x- v( P) A" \  H! Z, I$ T) m
10. void bsp_RunPer10ms(void)
    
11. {
    ' ~0 w8 D7 L3 h3 j1 V, F/ W# R
12.     bsp_KeyScan10ms();
    
13. }
    8 T4 S8 W6 j) N4 W* k+ c1 A8 f

复制代码

  主功能：
4 r5 f; R/ ]$ P) c8 u3 j5 f( u# ^, ]
0 h. b1 Q4 E6 |! w: V6 F主程序实现如下操作：
9 q( d2 z* E8 B8 j% g
启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
: W4 ?* L1 {. S8 t  @K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   
2. *********************************************************************************************************
   ! Y/ `. G. h/ _2 D, Y
3. *    函 数 名: main
   8 z. j% N, S. @8 q5 m
4. *    功能说明: c程序入口
   7 I) u  _) m: x. e2 M
5. *    形    参: 无
   2 b& N* e" A" d, }* x2 v7 x; E+ B
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   7 I9 w3 p) ]' R7 z
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    3 j) f; O' Y5 w* H$ F
12.     uint8_t ucReceive;
    ! y1 H1 r9 Y/ U  O; f
13. 
    8 S" i- y; h+ p& k! Q' q
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    ( a' C8 {) V+ W0 L6 K
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    * c* \; c0 U/ E. }
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    ! A' {% _; c' h- Z$ T- R# G$ M+ p5 I
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    
23. 
    ' H; \9 l- i2 n1 g( A
24. 
      o9 s, ^/ `; w
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
    7 d# K" i+ h  c2 L8 D6 [) T
27.     while (1)
    
28.     {
    ; L2 N. b' B# F* v5 s" B
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ; ]8 p6 q: w( I9 l
30. 
    
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    
33.         {
    ' O7 ]) f  O& `- ~+ ]
34.             /* 每隔100ms 进来一次 */  
    ' a; L8 I3 N: P8 A7 l
35.             bsp_LedToggle(2);
    
36.         }
    2 ?1 C) K  Q8 ]) D" t1 `4 i) f% C
37. 
    ) {9 F2 G9 C4 c: l2 J
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ( S5 |# y% z" G. T5 [8 m9 u1 B3 c
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    . J' q3 N" F4 V+ E
40.         if (ucKeyCode != KEY_NONE)
    . E  \0 i' b% o. R$ A) D8 q
41.         {
    
42.             switch (ucKeyCode)
    4 c( p8 X  J4 L( T
43.             {
    
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    5 q1 p& Y+ R# I  ?+ a
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    + X: A" H" [1 v- V
47. 
    1 a' ?: c3 v. Q+ x* ^
48.                     /* 确保LPUART没有在通信中 */
    ; |6 r+ S" ~/ p5 ]5 ^
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    8 m* H5 u  H6 R4 Q2 @
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    & P9 t6 h0 q6 c% d2 |9 j1 D* s* f
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    
58. 
    1 o) J( c6 K- m& N: Y
59.                     /* 进入停机模式 */
    5 n9 i0 N( C, y: ?2 z( l: s- B' Y
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    & B0 N# `- V- @. y4 l9 J- {5 p
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
      o, n! n# p) [" k
63.                     SystemClock_Config();
    
64. 
    9 D# C) _4 p: O! `; {- I5 _7 R
65.                     /* 关闭LPUART的停机唤醒 */
    4 T8 p: k+ `3 |% O
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    # {( P, I: B. p6 b' {* d3 h
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    # Y% |6 K4 k( \; G4 X6 U
71.                     break;
    
72. 
    + i2 @1 j" N, [" Y. C- ?( C
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    / P; f- K( U( }
74.                     /* 使能LPUART的停机唤醒 */
    ( y( \2 S9 ^# |
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    $ g' a! }9 Y% ?  k6 N1 o" j
76. 
    ; {1 r. r8 o( d2 i! J+ ]
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    8 f/ P- z7 U. G% `4 K4 F0 q
80. 
    
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    % r4 r; q8 |9 [
86.                     }
    
87. 
    
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    + K$ `# n- u' @) H5 S0 y
90. 
    : c3 U" d- D! k. ]+ a% f( W
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    4 R* j/ |- l: ^
92.                     SystemClock_Config();
    ' |# `6 l  J- q5 N* h
93. 
    1 j: B; r5 {. Y6 ^; i% G. M
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
96. 
    ; v3 g' b( Q9 d$ }
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    % |- s) U. K( g9 W5 f
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    ( ~+ m! J4 k& _/ Z; d
100.                     break;
     4 y. K4 z$ t7 u+ k$ x
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     8 V0 X( e/ E6 X+ w
103.                     /* 使能LPUART的停机唤醒 */
     
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     , ^  E4 G, E8 `7 S* E$ `9 @
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     3 h' y# b* e. \: L7 m
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     
109. 
       J2 T; q7 Y, a, c) s
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     # [; d! I0 B4 r: O1 r% |' I
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     + S; F# m$ z1 N9 P
115.                     {
     , L7 F3 \4 K7 k1 u8 Z
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
       G: v6 M- z: c  u
118. 
     4 z) B9 }+ E5 O2 R( c
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     # ]; M$ v! L5 Q: q) f
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     $ i4 i# c  z# C+ K" U7 h
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     ( P* U( d8 m- C7 E
125.                     SystemClock_Config();
     
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     ' w: u' ?4 o1 [  ]# F
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     6 b7 h$ E1 y( A! q- L& g7 e
131. 
     ! q2 ~3 L( x. x  K- `5 M
132.                     break;
     / r5 ~- K% q0 u' U3 y
133. 
     " A" n: e& b3 k2 ~' `8 l
134.                 default:
     0 b) Q4 L- Z% w; @, P4 ?
135.                     /* 其它的键值不处理 */
     
136.                     break;
     * e1 K# N  I5 X
137.             }
     
138.         }
     ' V% y  C4 U( k/ `" w
139.     }
     9 _. W; p5 J6 T% E
140. }

复制代码

0 N' i( P0 Q% @6 `
1 Z/ x9 {- a- a7 l66.8 实验例程说明（IAR）
配套例子：

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

7 I/ u9 J# o+ q+ B9 M实验目的：
4 T; }# O+ t& y) A) U6 ^
学习低功耗串口的停机唤醒。
" c3 }. o! b+ b$ y1 \) |实验内容：
! l8 v1 @( j$ |) z% w. w
启动一个自动重装软件定时器，每100ms翻转一次LED2。
6 W5 `4 L: e5 B$ H2 c% k当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
: C( u4 v# {+ g6 Q9 ^7 d/ a上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
2 e" g( b0 r. ~" g- X
$ _* U  i8 Y/ }LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
+ N7 H8 J7 L  N/ N# B
# \  }9 g3 D1 R% QLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

4 h; V0 O* h( j# D4 l3 n) r0 M实验操作：
7 w0 K/ K8 Y' g3 }9 h, U
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
% q# f  f" S% NK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
$ b4 A) j% r. P" n* I+ hK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
' ^& z. i  y, c0 U上电后串口打印的信息：
5 @, J3 s' Y* M- w1 ~+ G1 u
/ L* ?1 _4 w6 Q* V波特率 115200，数据位 8，奇偶校验位无，停止位 1
8 ^1 @7 I; g) n+ [( `

& c# \. J: F3 Y* m0 l
6 k7 u3 l1 g) x/ q3 q/ X. A程序设计：
0 ^' h+ ]; ~$ V
  系统栈大小分配：
- ]2 {3 s8 c" c' m/ t
1 e9 `. i* g' H: g7 a9 E

* \, r9 _2 _& V7 A& O, {
  G/ d- h+ s! B$ Y9 a  RAM空间用的DTCM：

" S4 N- e2 {% q; d7 \1 P
  硬件外设初始化
2 O. u3 `' l1 \* E) {% P( q: w0 C! n
硬件外设的初始化是在 bsp.c 文件实现：
5 Q3 d4 w1 h, W- x! x, c

1. /*
   + m& d9 d: P. L/ n5 u* I
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   : s+ R  g9 T, r' N; W
5. *    形    参：无
   ! W5 ~3 F2 |' [- z* X/ t6 e* a
6. *    返 回 值: 无
     @4 C2 h7 g7 P7 y
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   ; e2 E, F  H. J* f2 z& d- ?" V
10. {
    4 x9 S2 u; {% e- |
11.     /* 配置MPU */
    0 ?: Q+ O# q, a. J
12.     MPU_Config();
    & x: a/ F# U1 u0 i! P
13. 
    
14.     /* 使能L1 Cache */
    : U1 Q3 R; a  X
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    4 C$ n$ f8 r8 P2 y; B) K4 L
20.        - 设置NVIV优先级分组为4。
    6 X7 `$ J+ V) N$ `( B1 Q8 y& T, _6 l
21.      */
    ' M- }' O# W+ W+ }' r7 g
22.     HAL_Init();
    
23. 
    + _3 d  k/ W' X
24.     /*
    7 I6 T, a( C/ O: A3 _4 I) B
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    6 q* f; [" {1 I# H5 S/ I9 [
29.     SystemClock_Config();
    # c# h5 |# L! Y3 ?% w7 o
30. 
    ! c  Y2 V+ o; Y0 }  j: j
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    + `" T6 o" E0 V# ~
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    & f' O5 b4 V* y
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    4 Z& O( y$ X, d  U6 e. J% d
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    - \2 b9 u. W, G; T. R
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    ! m4 G) Z  @1 M' b) D( `( Z; e2 e
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ( l# P* n" e5 f
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }

复制代码

: u* R/ P7 W( M* p  MPU配置和Cache配置：
4 ^) ?3 l! g# s! @! n7 c
# \, R% S0 G" Y% b数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
4 y) O3 r( ?% [0 Y- {
* {; B# B+ }/ J' q' j0 [

1. /*
     n' \$ u1 C# f; i; \
2. *********************************************************************************************************
   ) W8 ?! }0 d3 Z! L) Y
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   2 `7 ^+ E8 |  `* ~/ O
9. static void MPU_Config( void )
   + F) W7 B9 u7 s' p6 t$ c0 s
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    4 G$ ]& c' D" O$ x) U. F8 Q
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    % t# E+ ~6 \* z8 j
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ( Y& A8 ~3 F/ K1 `2 e
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    7 e- o' E: _) S* B; R
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ! b/ z; X, b1 l& m- E+ E
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & T* a5 y/ A1 b7 r% \! }% e. A
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    , `/ c' h. J8 k) n6 ~' L5 o- E
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    4 b" h$ w1 U. A5 K
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    / Y. D% c: \! V7 v5 w/ ?( t1 F
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    ) Y. F" {8 T( o4 ]
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ; b& f( V8 |) \! D% U+ Y  c. g
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    ! `  F( q& I( C. m; \& L: p
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    - _8 x4 K) o) v; k0 ^
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    0 m3 ~! i; |: w, ]* Q
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;
    3 C9 u4 X9 Z" D# L
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    / u/ Q* g' |4 c) {
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ; h! C$ A+ h) q! T
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    4 g/ f0 k# j) x
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    - j9 K- R; k1 q5 z0 @
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    / G; R* |9 O; i" ]3 V( P; C
49. }
    5 i7 ?( q+ h: U2 t
50. 
    7 C$ w/ g! z4 N8 c; G7 r5 z3 K
51. /*
    9 \5 w' |1 _5 O
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    3 S7 f, h4 Q1 A, T
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    8 ~4 V4 r% s4 v6 A# m6 S
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    ) b' y# W- ?3 j" H
58. */
    6 u# ~9 Y# v& [: O% o7 A/ V: S
59. static void CPU_CACHE_Enable(void)
    
60. {
    7 O5 P% K; W9 d' H6 i
61.     /* 使能 I-Cache */
    ' p1 t# V* b2 v; _' k
62.     SCB_EnableICache();
    & h& E5 ]/ ~3 S3 N
63. 
    . L" K6 O7 V/ o
64.     /* 使能 D-Cache */
    # H0 y2 i6 M8 N9 i" O
65.     SCB_EnableDCache();
    ! T4 C5 j" P- [, S! g+ A1 [
66. }
    
67. 
    

复制代码

! c& j7 p8 S" N/ W  b  每10ms调用一次蜂鸣器处理：

5 V7 ]2 T$ K1 t3 L; x, w蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   - C" A% y+ M! K0 |6 R9 k
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   0 s2 B( \. h' w& I' S( s
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   - M- P! p1 U) g6 ?. f* }
7. *    返 回 值: 无
   5 p# O4 [/ m! d5 V
8. *********************************************************************************************************
   5 U% j& M& B" i+ r
9. */
   
10. void bsp_RunPer10ms(void)
    . \' e1 L& r- f# L: B
11. {
    9 C; w8 V" T& J9 }& a. @1 P
12.     bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：
3 l( u% R5 ]) _, P# c" |, @- s1 P
; v+ n* J# Y/ c8 v2 z9 M. s. g主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
: I3 q9 i2 `# _8 S. X4 K; q K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   0 n3 G' t4 \' p/ N, ]4 ~6 g! u
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   - y( r9 }$ X( r! H
7. *********************************************************************************************************
   
8. */
   6 ~- p: ^- H( r) `
9. int main(void)
   7 m4 `) ^) I* X2 ^; }3 s2 H6 m
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    
13. 
    
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    ( Y+ |9 R' y. R+ z+ D: e
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    & w( R; C, ?$ @8 G& {+ p
17.     PrintfHelp();    /* 打印操作提示 */
    8 P- J: t: O9 t: o/ `7 j
18. 
    * |) F9 I- c: z( G
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    + N; i  Q3 s, B5 a) R. Z
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    : _' W- l- K6 c
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    & c2 K4 D& a& ?& X1 j. R. u% L
23. 
    1 B& J! E( K  E/ s; F
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    / L7 a3 S" Y7 V8 a3 Z
26. 
    9 T3 b) b7 C/ t( {5 M5 u
27.     while (1)
    ' J! Y' B; w( V( ]; }% W. U% i$ [& L
28.     {
    1 }9 T; q) C# R7 p! @* W
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    
31.         /* 判断定时器超时时间 */
    - l0 I; r. i. @
32.         if (bsp_CheckTimer(0))   
      K7 w/ z2 |4 X0 ?
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    7 x: \% T1 Y4 S2 W
36.         }
    
37. 
    8 C/ T- I  r" G
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    * [. E8 a1 A7 s! D, k( }$ U
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    $ h! R4 C7 k! }- g# z( o
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    & o4 s  C. S) X' f- K/ k8 ~) A$ y
42.             switch (ucKeyCode)
    
43.             {
    3 ]: N- a! a& @8 L6 W5 W
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    * ~; Y9 a) y0 n2 }( |  \7 Q
45.                     /* 使能LPUART的停机唤醒 */
    ; N! G1 H/ X2 ]( f, W& s, _" P
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    5 O/ ]" C3 }9 p0 h9 m8 F
47. 
    9 p0 c( o( s4 r9 \. J5 Z' s6 x
48.                     /* 确保LPUART没有在通信中 */
    2 Y7 o4 R! G( ^
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
      {6 Q: L. C; W% v
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
      Q/ R. Z# ]2 |5 Y! ]$ q
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    0 ]& p$ ?" @& Q' H1 O; F
57.                     }
    8 J* q# D/ o% R/ A' l+ @
58. 
    1 m% M; c. p/ C1 X
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    6 q- {$ U! s/ [8 M* K+ ^, [" Z
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    0 O$ C* b5 F7 K- l
67. 
    7 W0 k3 ^4 x0 c* |" p+ ?* F9 e
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    5 c+ X9 z+ o  j4 J
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    " H9 Q) o' E  v6 m7 }0 ]& _
71.                     break;
    8 C. b% Z- Y: l% W
72. 
    . Z- ~4 F9 A" b% ^2 t4 B" L) D8 j
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    ) m7 M  b/ S# i8 L9 ~
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    $ ?2 |& C2 B7 n5 p4 H3 B% \% S
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    
81.                     /* 接收起始位唤醒 */
    ' g- Z3 g9 t  k. y6 P
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    8 I6 s; W- }/ n2 v
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    
86.                     }
    
87. 
    - F+ m1 s$ r  a
88.                     /* 进入停机模式 */
    . ~; c; j- Q) ?) ^( U
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    + W7 e6 d+ m3 B$ _! S
90. 
    6 a9 W8 e7 h) L  V! J) L9 e
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    : D3 O: O  q" k+ x
96. 
    3 @3 ^, g6 P$ d
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    3 o8 X% W; O9 d/ e2 I" e
100.                     break;
     - H- x+ [+ Z9 _% |/ [& j# g& d  _9 }3 H
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     , V4 h% {" i) _3 m
103.                     /* 使能LPUART的停机唤醒 */
     & [! C; \0 H- D" H3 c1 d! J
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     1 e5 W8 \- g- r/ ]/ a+ U
106.                     /* 确保LPUART没有在通信中 */
     : M9 d0 N: I, E4 }& ]" [! i0 Q
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     & c  t! A2 y0 _/ v8 f
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     , u; ^4 P3 Y. |
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     2 ~# |' t$ b% T: |6 N# _" ]
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     / c; L. J2 d3 q( M; g+ q* i
113.                     WakeUpSelection.Address       = 0x19;
     ! C4 e" g+ E+ Z' r3 f% O' B9 C
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     ) z5 e9 s; ~# d3 r9 w
115.                     {
     3 v- y) P2 m, x+ l
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     . K7 V! P, F  M
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     . ^. W3 z* G- q) v0 @0 S  ]+ q( @
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     0 ^$ ?, W) H/ l
123. 
     % U& }; D$ h  t3 I
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     
126. 
     # U  N4 Y% S9 A) O& H9 b/ ^! t+ i
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     ( C; e' l& t- x$ _( a
128. 
     3 g3 k; H2 A% `6 Y1 i/ m2 d- n
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     7 b2 [) n: r2 y
132.                     break;
     ) v$ m, M9 `7 S7 I- u
133. 
     
134.                 default:
       o: J# z9 d4 L/ l
135.                     /* 其它的键值不处理 */
     2 V) r8 e6 r$ ?8 K
136.                     break;
     
137.             }
     / q7 r1 R2 z( {0 ]& m
138.         }
     
139.     }
     / ^; r( o" |) u* W
140. }
     " R& x& e( r1 d1 r

复制代码

66.9 总结
: Q) N: W1 X. M( G. G; Z本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。
$ P* K) Z* v% W' n& c" J

' ]9 S6 T: R$ I  P