66.1 初学者重要提示
  学习本章节前，务必优先学习第65章。
5 `5 H% B+ T0 _( g% S2 b1 e  低功耗串口FIFO的实现跟前面章节通用串口FIFO的机制是一样的。
, U: O8 \- w5 F  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
66.2 硬件设计
STM32H743XIH6最多可以支持8个独立的通用串口和一个低功耗串口LPUART1。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

. D7 R+ n: K, G6 T低功耗串口LPUART TX = PA9，   RX = PA10
! i- J0 `  t+ S% i
串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）

串口USART2  TX = PA2，   RX = PA3
& y3 h: g5 z4 n4 j$ N# I0 R: N; ?
串口USART3  TX = PB10，  RX = PB11
4 n; v  m5 v4 ?0 q; G5 D
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

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

/ j6 r# c, U8 d7 c( M  i串口USART6  TX = PG14，  RX = PC7  

. L) n: v; n1 I8 n8 u# ~5 X& r) h串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

. q4 O5 X5 H0 BSTM32-V7开发板使用了4个串口设备。

& I. C9 k! O; r  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
; S: x# h5 T" @6 F% Z: ~  串口3用于RS485接口
1 K% G8 ^) Z( r4 F- ?  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：

. G. i7 p+ T. R( D

2 O  x4 B0 N. p+ Z; `& @, r
关于232的PHY芯片SP3232E要注意以下几个问题：
- p! q9 z+ i* V) X. }. [6 q. h5 c
* `! ?$ l8 I5 ]' J5 u  SP3232E的作用是TTL电平转RS232电平。
6 ^5 ^  q" {+ i$ x/ j7 J* O; j- G  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
, b0 _% _# V: n' Y) _% c

实际效果如下：

0 `. F9 O; W! O9 T% i& k

( _; K7 W- u* o, G2 f
通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY
. c) f0 Z- ?% f# j9 r% _+ P( W) b7 f
芯片是否有问题。
7 p! Q, }/ T+ ~1 ~  D+ a
  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
" L" Y8 E* c/ {* f  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
66.3 低功耗串口FIFO驱动设计
- r7 [1 N7 \9 Y% s5 T1 b1 S5 A: e66.3.1 低功耗串口FIFO框架
+ ]# Y, O# b. Q' d, E# J' X8 H为了方便大家理解，先来看下低功耗串口FIFO的实现框图：

9 J7 l, [$ a: Z2 s; n0 g

  第1阶段，初始化：
! I- Q3 U- t6 a% n& @8 z. i- @( }
通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
& A7 c4 w" F5 p5 I3 ]  第2阶段，低功耗串口中断服务程序：
5 d+ j: ~. S% m
  接收中断是一直开启的。
, l9 o5 m4 u. h3 j0 R' e  做了发送空中断和发送完成中断的消息处理。
6 r- V1 y2 J( Q* `  第3阶段，低功耗串口数据的收发：
, T1 M/ I% Q( G9 Q0 n* C: x
8 a9 g$ L! E  ?! b& |2 G0 [5 H低功耗串口发送函数会开启发送空中断。
* P+ y. q! f! v5 T( k低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
7 P/ b$ U- S0 I/ w4 e1 o, A66.3.2 低功耗串口时钟选择
- `4 Z9 E; X4 `/ U; f我们这里实现了三种时钟选择：

9 c) V- C3 b  ~+ y, ?' ]. w# nLPUART时钟选择LSE(32768Hz)
最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
; ]4 _* l9 Q& B8 k% V
) O) x; k" k9 BLPUART时钟选择HSI(64MHz)
最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。
- M1 Z0 Z  d6 g' ?/ U1 P
* V4 r0 M' F% A4 {5 V! f6 i+ MLPUART时钟选择D3PCLK1(100MHz)
# d% V" Q, G# W最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。
6 J; t1 p) h- C7 o6 s
2 H$ R: ?1 y: O  `1 `8 E5 T7 t1 q如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，程序代码如下，用户可以根据需要，使能相应的宏定义：
1 q5 G; S4 z# e5 Q/ k/ I

1. //#define LPUART_CLOCK_SOURCE_LSE      
   ) F2 b6 f, }' L& `" D5 u) L
2. #define LPUART_CLOCK_SOURCE_HSI   
   
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   5 b7 \6 r1 \( _) J0 R- Q6 Y- r
4. 
   
5. /*
   
6. *********************************************************************************************************
   
7. *    函 数 名: InitHardLPUart
   
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   0 I, d( s) Z. e7 V
9. *    形    参: 无
   2 S) y) R3 \& A; o
10. *    返 回 值: 无
    
11. *********************************************************************************************************
    5 i3 U) s: m$ M
12. */
    
13. static void InitHardLPUart(void)
    
14. {
    # V) ?* Q# i2 R+ K
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    
17. 
    % Z. |  {$ p: F. e+ N! o6 c
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    0 r; d; h9 r4 @# F) D  W
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    
20.     {
    6 m1 s9 D7 X, Q2 a
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
22. 
    6 Q6 I$ J0 y" b
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    3 t# A5 F* d; l
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    . q& J' {8 |/ x( y3 a
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    : W6 W, I$ R: t/ i1 D% `
26. 
    ) v: O+ p8 }) y6 j9 K. K
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
28.         {
    
29.             Error_Handler(__FILE__, __LINE__);        
    
30.         }
    
31. 
    
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    2 w. o% }- a6 p8 t4 i
35.     }   
    , v" e. @5 x1 a( {* t& p
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    0 D# J. t7 R: N0 [8 T& B
38.     {
    9 p4 l$ j% L! v: ]2 l, q$ l2 p# r
39. 
    3 c( M& r$ m/ `1 F
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
41. 
    9 W% O1 P6 \$ R$ }3 z, c
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    $ ^, {+ ?3 g) b7 P
46. 
    & y' ^& f# G  V; l" @
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    ; i* i# O  ^; v1 \5 v
48.         {
    
49.             Error_Handler(__FILE__, __LINE__);        
    * q9 c% h/ S$ W  M. B% Y5 L5 y
50.         }
    
51. 
    7 E. y" f7 Z: b* a$ p; k
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
55.     }
    
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    
58. 
    + E2 V/ n9 Z% L% L4 ^9 [1 D$ L
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
62. #else
    , T# q; V4 D1 w- Z" P
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    0 J) d1 a) X. T/ h; q! k% F3 y
65. 
    & y2 i# v+ }* J1 }* a
66. #if LPUART1_FIFO_EN ==
    + e. p: V; N. v( d, l: D# f5 |
67.     /* 其它省略未写 */
    
68. #endif
    
69. }

复制代码

1 M: Q- u% s2 W. |3 i" y# T66.3.3 低功耗串口FIFO之相关的变量定义
低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。

  `* {1 [  V3 R8 i这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。
1 G  M% k; X! x! |; }) C8 t
& @3 ~* t( E1 z# i2 H5 ^, q8 j7 q- e每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
: A  L" N7 r7 M3 h) }& ]: Y
1 O5 R$ a. R$ N: H我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if LPUART1_FIFO_EN == 1
   
3.     #define LPUART1_BAUD         115200
   
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   ) |0 n3 e# G( T! W
6. #endif
   3 b! O* K' k! }: q. ~
7. 
   ! n6 r: [7 p3 T+ _/ W7 h" {& c$ F
8. /* 串口设备结构体 */
   + Z$ I' k! \2 @" a/ c
9. typedef struct
   
10. {
    
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    5 t% e6 t1 a% r4 j8 Q" |2 i
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    6 X! y, \0 M6 z6 @2 r/ f
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    " ~2 I3 Y. _( ^0 K  P
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    ( T1 Z5 m6 |% `% L7 X
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    1 s( N( @9 F% v  n
19. 
    7 j! J2 o+ F) c) n4 G8 l
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    & ?; P& d5 l6 }3 F
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    1 f) y& y  ^" j0 a5 e
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    0 ]9 M% }! b  A5 C3 s1 \2 P
23. 
    
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    0 Z3 u3 w0 k. p
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    ! a6 C! w$ h) |5 v# d
29. 
    ) i1 z& f$ q! J6 n7 {
30. 
    
31. bsp_lpuart_fifo.c文件定义变量。
    
32. 
    6 L) ~6 g4 d& _
33. /* 定义低功耗串口结构体变量 */
    
34. #if LPUART1_FIFO_EN == 1
    ' R# |( t" i+ B& r6 D2 T4 \3 q8 y
35.     static LPUART_T g_tLPUart1;
    . a; ^7 g, D( q
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    + H' d% F+ _9 _- J9 c
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    
38. #endif
    

复制代码

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

0 n. D% x( C+ v' ?: l2 m. Z& X66.3.4 低功耗串口FIFO初始化
低功耗串口的初始化代码如下；
5 @" p- i8 s3 \. K% f$ C: p
2 X  ]  G- Y, t' ^5 i  |5 w  N) s/*
*********************************************************************************************************
6 T. S' |7 G4 h7 z- J$ h*    函 数 名: bsp_InitLPUart
*    功能说明: 初始化串口硬件，并对全局变量赋初值.
*    形    参: 无
*    返 回 值: 无
# B+ S6 {1 K* j' g6 B+ t*********************************************************************************************************
$ q$ _# O. I. u7 ]4 Y0 t7 f3 F4 u*/
; I& `) J! M9 b- Rvoid bsp_InitLPUart(void)
( @8 Q( c7 ^; k2 |( e{
    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
0 N+ c. a* B" v1 M/ X3 y7 X( h    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
}
% J; b& k- f2 R% N! _5 m; t7 g' @
, a. K0 N' o% J7 S/ ^
下面将初始化代码实现的功能依次为大家做个说明。

* w! ]% T8 R4 M& |3 s( ?) _  函数LPUartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

$ M+ ~2 ~6 k; f& V9 I4 M7 B. V

1. /*
     G& R: m# @1 S) x
2. *********************************************************************************************************
   
3. *    函 数 名: LPUartVarInit
   # |; |! D$ |' y; T/ g. h
4. *    功能说明: 初始化串口相关的变量
   ) S8 o( E( E  B: j
5. *    形    参: 无
   + E$ Z6 O& ~, [  q' ]. O
6. *    返 回 值: 无
   
7. *********************************************************************************************************
     |+ D% d! x- l( U6 K8 |
8. */
   
9. static void LPUartVarInit(void)
   
10. {
    ( W- ]7 n) D  e! `/ b
11. #if LPUART1_FIFO_EN == 1
    % X; X* |7 g  A* K- @/ l! z: ~
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    & A! ?! h0 b) Q/ G
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    , T% L9 `" H/ ?1 \+ C
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    # \5 N! W3 G% P9 R4 n4 d
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    " N: ]( H- N% M) g4 w, L6 y
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    6 n: p0 ]* R' N* W% v5 q
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    ) _# _% K% N4 l; u; h
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    8 _0 w; \& J/ }# e4 C% ]
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    
27. #endif
    
28. }

复制代码

8 S8 i( L$ \* H
$ Q1 H0 M2 k0 E+ s6 s  函数InitHardLPUart
此函数主要用于串口的GPIO，中断和相关参数的配置。
. S6 O9 c) j, q0 h5 o
2 c4 A- H9 V  v5 j! k, |

1. /* LPUART1的GPIO  PA9, PA10 */
   / b4 }8 p, C5 D! ]2 I8 d7 t: s) ^& C
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
     b9 _! x1 T1 y, z  d; C
3. 
   
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   + s6 |6 T. b8 p( j* y
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   
8. 
   
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    # V$ S/ W, }. E1 ?& ^: V1 V- R
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    
13. 
    + v" U6 d3 e# a1 C$ M- E4 @
14. /*
    4 y0 J4 t1 c9 F1 e
15. *********************************************************************************************************
    * F) G# _4 B& ~3 [: I; ^
16. *    函 数 名: InitHardUart
    
17. *    功能说明: 配置串口的硬件参数和底层
    
18. *    形    参: 无
    . e: E7 L+ B7 j- R
19. *    返 回 值: 无
    7 q# n4 l+ J  \
20. *********************************************************************************************************
    
21. */
    
22. static void InitHardUart(void)
    
23. {
    2 ], L* I9 f! `! }1 ]
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    ; p. g! Z5 m# i' e: M8 N2 z% A  t
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    4 `7 Q7 O  W8 T( O+ [' O
26. 
    8 w- _9 L, x) ^6 g) g. O3 H  P) n
27.     /* 时钟初始化省略未写 */
    
28. #if LPUART1_FIFO_EN == 1        
    - ?5 Y: k  U3 d& M3 `
29.     /* 使能 GPIO TX/RX 时钟 */
    - e8 R8 N; H* P: E+ I/ I+ ~
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
      _* p5 ]0 t( }& R) ~0 m3 v9 A* V
33.     /* 使能 USARTx 时钟 */
    + p8 [4 k, o' O& i! U: \. T
34.     LPUART1_CLK_ENABLE();   
      \, J( F+ \  n  o. A: [; s9 T1 K6 |
35. 
    
36.     /* 配置TX引脚 */
    8 t8 v5 S$ P7 c3 {0 @
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    6 V( Y9 m4 n0 \8 ^+ x3 w
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
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);   
    ' |6 Q4 ^  l! C& S9 v
43. 
    
44.     /* 配置RX引脚 */
    
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    1 |) Z" A  K0 B* |. B+ e5 y
48. 
    
49.     /* 配置NVIC the NVIC for UART */   
    9 ]! a4 I- g1 G8 F, A
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    & E9 g6 c" D* ]. |1 G
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    
52. 
    ! U. ^% f0 X# A$ q
53.     /* 配置波特率、奇偶校验 */
    . G, d: t) h: d: `5 o0 h1 j" g: y
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    ! b7 e/ B. @, y" ^
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    7 m  K, Q, {- I! s$ T7 m: y; z
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    ' R9 l& @* M  Z' y1 S/ c
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
59. #endif
    
60. }

复制代码

低功耗定时器的参数配置API如下：
4 V8 Q1 e3 @/ o: z# U

1. /*
   
2. *********************************************************************************************************
   , D$ `, G* _+ H- {( c& \/ ]8 s9 A- u
3. *    函 数 名: bsp_SetLPUartParam
   8 O- l! S; H/ p1 h7 Q+ _
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   7 g/ w# K: g' z% @
5. *    形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   5 ]# T2 R0 y2 M, Z1 E% S) L
7. *             Parity     校验类型，奇校验或者偶校验
   1 F0 q$ A' }) v/ _! k+ i
8. *             Mode       发送和接收模式使能
   + v) E% p( i$ S3 b/ A  d
9. *    返 回 值: 无
   : |( b+ q  N8 N% L/ h1 e
10. *********************************************************************************************************
    
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    
14.     /*##-1- 配置串口硬件参数 ######################################*/
    
15.     /* 异步串口模式 (UART Mode) */
    ; v) Y. i0 i. m) b9 `7 Q
16.     /* 配置如下:
    ' l( n# e2 `3 P& j9 N- m" H
17.       - 字长    = 8 位
    " ?  v6 ]( h0 j  u
18.       - 停止位  = 1 个停止位
    
19.       - 校验    = 参数Parity
    
20.       - 波特率  = 参数BaudRate
    ) U' g/ z; z/ K
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    
22. 
    
23.     UartHandle.Instance        = Instance;
    
24.     UartHandle.Init.BaudRate   = BaudRate;
    , V: }/ z3 [3 D4 F% n
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;
    
29.     UartHandle.Init.Mode       = Mode;
    
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    - u/ J7 S/ e0 H5 m: H8 |  V
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
33. 
    
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    ( I1 B4 F  L8 O' I
35.     {
    ; [# D: w3 Q2 f0 D, F- m* F
36.         Error_Handler(__FILE__, __LINE__);
    
37.     }
    - Q% y8 T1 k2 _
38. }

复制代码

( X/ f2 ]+ ]- y66.3.5 低功耗串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能

  收到新的数据后，会将数据压入RX_FIFO。
7 j* K7 ~/ d& T  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
5 Y1 j2 z3 G2 O0 T5 s$ i  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
- `9 h# |/ i( \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)
   . T( G' U6 S# f8 Z
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   
5. }
   : P! b$ T- e. S4 w* }
6. #endif

复制代码

下面，我们来看看UartIRQ函数的实现代码。

1. /*
   
2. *********************************************************************************************************
   6 z: m( A2 Z0 R9 d+ L4 h- K/ j
3. *    函 数 名: UartIRQ
   * y( j4 ?( q3 K* T7 |4 B
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   # O( v6 |/ l/ d- d
5. *    形    参: _pUart : 串口设备
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   " O' b& y$ \/ {$ d! y4 g
8. */
   5 p9 X! u. F6 Q4 e+ b4 n
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    ( v6 c, N# \. U6 W7 [
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);
    + N, j- T  P* P' I
14. 
    + V4 u% q1 e* n: o7 A( G( f" ~
15.     /* 处理接收中断  */
    
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    ; ]4 g" E  L, l1 w% f+ I
17.     {
    9 F% |; |. x' y- U$ [4 @$ c1 d0 a
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
    ! x2 O) _* q9 y
20. 
    
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    . W& q- |9 d  E- ]* U/ Y7 W3 ?! P
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    ) ^# ~: x( a8 ~& l/ p
24.         {
    
25.             _pUart->usRxWrite = 0;
    , B% P' @5 o- [5 p+ W  ~
26.         }
    , L2 q' J1 c4 n" R) W
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    0 |% E  H4 Q! @# {; a$ R$ y. }( r, i# p
28.         {
    8 g8 O/ r' ~% G5 j, ~$ G
29.             _pUart->usRxCount++;
    : d6 l7 _* G( c! ?, W6 a
30.         }
    2 U1 O: ?, x2 k: f
31. 
    
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    3 Y7 m' U6 [- V4 l
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    % f' G7 O  {, j; |6 Z
34.         //if (_pUart->usRxCount == 1)
    
35.         {
    
36.             if (_pUart->ReciveNew)
    
37.             {
    
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    & m- G* t2 {/ _% Z# H4 {
39.             }
    , ]/ G9 _5 y. N. e  x$ v* Z! V
40.         }
    
41.     }
    
42. 
    
43.     /* 处理发送缓冲区空中断 */
    
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.     {
    * a9 v" P  r, y
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    / b! C2 N( i; H: u& e) Y# h
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    * w5 e4 R! m' m
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    7 p3 L/ s* p5 s4 w. e8 R
53.             /* 使能数据发送完毕中断 */
    
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.         }
    
57.         Else  /*　还有数据等待发送 */
    
58.         {
    ) y! D& O! s$ c
59.             _pUart->Sending = 1;
    + y; X- z4 _. ^
60. 
    2 w' ?* h. s1 B8 \3 H; j  k2 v
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    1 y/ |# M1 n5 D1 s1 @1 u: E, r
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    4 V& U  U5 G' H' e& D0 H9 Y
65.             {
    
66.                 _pUart->usTxRead = 0;
    
67.             }
    
68.             _pUart->usTxCount--;
    
69.         }
    ; ^9 M. m. ?  n. j  g% W
70. 
    ( n  P6 Z/ \! {8 l& F; ~
71.     }
    5 {( R8 R* I5 P) U& R" a
72.     /* 数据bit位全部发送完毕的中断 */
    1 E+ n- N  F0 ?. `8 N5 j
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.     {
    
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    9 v( o( c% W1 e
76.         if (_pUart->usTxCount == 0)
    & `" e5 v% S7 q$ M
77.         {
    2 W5 t/ l) S: G  x2 t/ D. N2 V
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    + H8 z7 @- H+ e7 S# K1 @
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    3 I; T2 {' N- r( @6 g( O* Y
81. 
    , q; R* t; h1 r- x+ Q8 c5 B/ r
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.             if (_pUart->SendOver)
    
84.             {
    
85.                 _pUart->SendOver();
    
86.             }
    7 Y# j, Z* x) W6 V
87. 
    
88.             _pUart->Sending = 0;
    
89.         }
    $ i& c# c5 W7 c$ v5 ~5 U
90.         else
    
91.         {
    4 X# m; ^; [6 S& |* A
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    / w3 C1 M9 z: H. z  i
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.             {
    
99.                 _pUart->usTxRead = 0;
    ) E0 I( v1 G+ m, {' P: h9 a
100.             }
     4 G" u2 T+ V/ c: g% g
101.             _pUart->usTxCount--;
     " k* O* z% g" [: X) K
102.         }
     5 H7 |9 O  A9 O! o
103.     }
     ) Z! h# k  {9 j# v+ v
104. 
     
105.     /* 清除中断标志 */
     
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     " F( h" }4 n! y* ^5 D! ?2 g
108.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     5 t9 ?6 a, c* j
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     * ~% `# N5 W: R
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     * C! a: [& U  W! T* Y
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     5 t, N3 n& K4 @0 y
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
* P5 H, O1 t/ ~6 q7 c& c& s, A* P
# I7 v, |3 f7 K* I  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
* v' W8 k+ z# {
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
) y+ z, u5 f! V( ^2 k9 j% L7 T
  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
) t) ]  n/ r, o# t, O+ j; g8 X
66.3.6 低功耗串口数据发送
低功耗串口数据的发送主要涉及到下面三个函数：
: h3 V+ e$ \; }( A0 X+ ~, q! J
1 u, D8 M& n7 I! l7 ?

1. /*
   ( Z0 w0 |' G- K. \* @
2. *********************************************************************************************************
   + r. n* ]" n& Z" X, S! J! o) K
3. *    函 数 名: lpcomSendBuf
   ) M  W; L* S1 z/ Q- x( _5 Y
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *              _ucaBuf: 待发送的数据缓冲区
   
7. *              _usLen : 数据长度
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    + c& F2 t& x! U; a' W) W0 z
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    
13.     LPUART_T *pUart;
    
14. 
    % ^/ P% b1 W: i$ m1 i$ A7 |
15.     pUart = ComToLPUart(_ucPort);
    2 {1 F) w6 G8 J9 D  Z! E
16.     if (pUart == 0)
    
17.     {
    
18.         return;
    . |/ t0 \+ l) v3 c3 ], s0 f
19.     }
    
20. 
    * ^. g# l, w1 r& K4 p, y1 `
21.     if (pUart->SendBefor != 0)
    
22.     {
    $ u- J# t* S! t. r0 q3 v
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    . h+ D4 V% x0 H  G9 a$ p" r8 W% k% h
24.     }
    
25. 
    
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    7 }+ x/ w1 y$ K$ Y- u0 S
27. }
    
28. 
    
29. /*
    
30. *********************************************************************************************************
    
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *    形    参: _ucPort: 端口号(LPCOM1)
    / o" z% v7 k- f/ ^" `4 u
34. *              _ucByte: 待发送的数据
    ; S" g' C, q3 Q- K% n8 m
35. *    返 回 值: 无
    + I# }( W$ Z1 A$ x
36. *********************************************************************************************************
    
37. */
    8 @# t" l9 |+ G* ^& Y  c/ c
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    2 R+ o" Q) i7 d0 M7 h, [# i2 x
41. }
    9 j; Q  _- k% E/ d, l; U0 f
42. 
    
43. /*
    
44. *********************************************************************************************************
    
45. *    函 数 名: LPUartSend
    ( \- R" A/ C3 D7 w
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    ; P! p- S7 S1 W. e/ J! D
47. *    形    参: 无
    $ \/ _7 G/ D+ t5 M
48. *    返 回 值: 无
    
49. *********************************************************************************************************
    # N6 w+ v; @5 U
50. */
    6 @5 [' U8 D5 r% k# b/ ?
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
52. {
    " ~8 j. W6 X9 R
53.     uint16_t i;
    ' |- {8 k. E3 N" E9 C2 r
54. 
    
55.     for (i = 0; i < _usLen; i++)
    
56.     {
    
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
58.         while (1)
    
59.         {
    9 U$ [( K! g/ q$ [% [! h* D9 J
60.             __IO uint16_t usCount;
    
61. 
    
62.             DISABLE_INT();
    
63.             usCount = _pUart->usTxCount;
    
64.             ENABLE_INT();
    
65. 
    # O( c4 N: o5 d: _: h  G
66.             if (usCount < _pUart->usTxBufSize)
    1 I( G) `- ^" [% i  P. X( S
67.             {
    
68.                 break;
    
69.             }
    ; ]' I- L+ {- v7 y6 J( W8 A$ W
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    # K0 I5 k" T& W$ s: d. ~
71.             {
    0 {6 {  Z! \5 y9 y# e
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
73.                 {
    
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    6 L1 R8 r9 h- u2 K2 F0 W. n
75.                 }  
    
76.             }
    # @% c% G- m3 @& x
77.         }
    2 H  }  p" l( o( G# q
78. 
    
79.         /* 将新数据填入发送缓冲区 */
    
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    
81. 
    
82.         DISABLE_INT();
    2 a0 T9 U7 p) h) Y( z# |. W% a4 V! v0 Y8 Q+ W
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    : t; R! {" n6 ~8 _) g, e3 E/ l" t2 r
84.         {
    0 y) H+ l0 X$ x  U9 d, d% V! g6 C
85.             _pUart->usTxWrite = 0;
    
86.         }
    
87.         _pUart->usTxCount++;
    
88.         ENABLE_INT();
    ; K! {6 D: S3 [1 ]8 B$ f4 Y; G* N
89.     }
    
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    
92. }

复制代码

/ D& Z: o2 C, K* e  u函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。

" I( B, Z$ N( l- b  c- D函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
5 S  t, }: p, @, A. l7 V
2 m# c" q1 P4 x8 ~  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
  _$ Y  N9 @& q- ?( r; K  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

3 a  o2 k7 d  T0 g, u注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。
) l# @8 h9 P6 Z+ D9 F2 g% D9 B
函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。
* D- M, O, n% [/ l. a

1. /*
   : P$ k8 v; |, Q3 P, e$ u
2. *********************************************************************************************************
   
3. *    函 数 名: ComToLPUart
   
4. *    功能说明: 将COM端口号转换为LPUART指针
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   , d; L6 y$ Y, G' Z$ A
6. *    返 回 值: uart指针
   
7. *********************************************************************************************************
   
8. */
   4 [/ O9 D. [2 h- o( @# B, q
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   4 F. H- f4 x6 a7 r
10. {
    6 d! E. K* ^0 f8 X; P3 F. r, t
11.     if (_ucPort == LPCOM1)
    
12.     {
    
13.         #if LPUART1_FIFO_EN == 1
    
14.             return &g_tLPUart1;
    
15.         #else
    3 i- T2 D  }* x# b/ w# s
16.             return 0;
    , ~3 e# y# d, L' c
17.         #endif
    0 n# O1 r6 V9 @; V2 @. A
18.     }
    
19.     else
    : n3 E6 ]8 w' E; t# g) h
20.     {
    $ S+ a! |- V5 h7 e3 `7 J7 G
21.         Error_Handler(__FILE__, __LINE__);
    / S5 e$ _' G' ?% n/ w
22.         return 0;
    
23.     }
    0 D  X4 a- E3 n, L7 |  G  o+ S
24. }

复制代码

% S' j# x2 _0 a2 d7 R
- D$ k/ z- ^8 G9 D: t
66.3.7 低功耗串口数据接收
! W% y& N% o5 M! N, [1 M# |0 a7 h: \下面我们再来看看接收的函数：

1. /*
   
2. *********************************************************************************************************
   ' @' u& `: }  e$ M) p
3. *    函 数 名: lpcomGetChar
   
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   * u' g8 m9 V/ w) F0 d, t
5. *    形    参: _ucPort: 端口号(LPCOM1)
   5 t2 b+ s  b& O9 |% J! R
6. *              _pByte: 接收到的数据存放在这个地址
   - a. e8 M, x4 e$ X
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
     f( s. @$ y, L' d
8. *********************************************************************************************************
   2 ]& N% ~, V# P# [( i4 x
9. */
   - e& A4 s# q) b' \) t  t
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    ( [+ }3 v9 |. p9 ~
11. {
    
12.     LPUART_T *pUart;
    
13. 
    7 `/ a# m# Q9 b) Q" h! _
14.     pUart = ComToLPUart(_ucPort);
    2 Y1 H7 [1 G$ M2 O! x0 g/ S, J
15.     if (pUart == 0)
    0 @# @5 ~& L4 `( f6 X; y
16.     {
    
17.         return 0;
    
18.     }
    
19. 
    7 v3 n6 {  J: k* j
20.     return LPUartGetChar(pUart, _pByte);
    
21. }
    
22. 
    ; V7 V: C  e2 E, i2 ~7 m; X/ E
23. /*
    - }7 u3 ?1 g8 b' H+ o# j
24. *********************************************************************************************************
    3 O( V. L8 Q" b5 p4 U/ |% o
25. *    函 数 名: LPUartGetChar
    , y- z+ E& _  V
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    : r1 [; j0 D" l
27. *    形    参: _pUart : 串口设备
    & F7 f/ P2 X& x$ z
28. *              _pByte : 存放读取数据的指针
    
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    $ i" }+ p" Z$ m
30. *********************************************************************************************************
    9 t8 h* A8 ?" {, W, D: o
31. */
    
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    " g2 n6 i$ D! L+ T& |! w. [
34.     uint16_t usCount;
    : l* H5 |7 E& |/ A( r* P
35. 
    / Z$ y, r) U5 F9 v0 N' f
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    ' I6 x# w( n7 t) }3 J1 O+ R( R1 P. M
38.     usCount = _pUart->usRxCount;
    
39.     ENABLE_INT();
    " u5 G* o$ Z1 x3 P
40. 
    7 i( H  y: N& ?" F
41.     /* 如果读和写索引相同，则返回0 */
    9 ^' l2 @2 ~, I+ |% p7 B
42.     //if (_pUart->usRxRead == usRxWrite)
    
43.     if (usCount == 0)    /* 已经没有数据 */
    
44.     {
    
45.         return 0;
    2 D  E9 b6 Q- v6 \4 D% Z5 }
46.     }
      g' U! O1 Y: V7 z0 d" l3 e
47.     else
    5 |: K$ @6 W2 H7 v5 N
48.     {
    
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    
50. 
    $ f$ {/ ]9 m* K3 q7 y
51.         /* 改写FIFO读索引 */
    * I* N  |# [- V: `: @3 S
52.         DISABLE_INT();
    : C/ W' ]1 \4 P6 E+ R
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.         {
    
55.             _pUart->usRxRead = 0;
    8 l+ _- g' o  G% t9 E+ W
56.         }
    
57.         _pUart->usRxCount--;
    / C! D; @" a1 q" \& j, R/ Y
58.         ENABLE_INT();
    " ]5 t) U5 O# R- Q
59.         return 1;
    ' c1 f+ ~1 `, O) B8 J$ c% f& h/ ?
60.     }
    
61. }

复制代码

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

. W: k* Q, y2 C) b+ ]5 k$ e' j注意：由于函数LPUartGetChar做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。
# H" ^  u) w( {5 G  M' `5 Y
66.3.8 低功耗串口printf实现
1 Y( T% F$ y. c; R& A/ G# {printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

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

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

1. /*
   
2. *********************************************************************************************************
   : N7 `" w( V- T) a2 V: L
3. *    函 数 名: fputc
   4 V- E7 V9 L0 Z" Q3 b5 R
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   ' o& |1 i% o& \
7. *********************************************************************************************************
   
8. */
   ' O# ]. f; w% p* p
9. int fputc(int ch, FILE *f)
   2 p6 L; W. L" v
10. {
    * [& W$ S+ r6 h# U1 E( _
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    1 a" k  L- O- q, |
12.     lpcomSendChar(LPCOM1, ch);
    2 Z% s1 i2 U& X' D
13. 
    0 k5 d! ^* b# u- u/ H6 }, A% |
14.     return ch;
    ( T4 K/ U' T; p( d9 s
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.     /* 写一个字节到USART1 */
    
17.     LPUART1->TDR = ch;
    
18. 
    
19.     /* 等待发送结束 */
    2 m4 V0 l$ |- u& q7 `, M
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    
21.     {}
    : G2 R: E; O; h% E4 ^9 S: ~3 n
22. 
    
23.     return ch;
    
24. #endif
    6 ?! x, Y; B9 I& P6 ~
25. }
    
26. 
    7 Y0 P% r' T  ?2 ^9 _  V" z$ j; E
27. /*
    
28. *********************************************************************************************************
    ' N- ~& Z$ A3 {' `% N' b7 O! V
29. *    函 数 名: fgetc
    5 |7 R( k1 ?) F5 N% W
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    ) a4 }+ ~6 Q3 Q! G7 ~. A
31. *    形    参: 无
    
32. *    返 回 值: 无
    2 y3 A% L0 X) ~/ g" L/ {* ^7 K; K
33. *********************************************************************************************************
    ; @0 R3 V: n- z1 s3 u+ V
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    ! Y$ X$ [) L5 k5 Y
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    " r4 Q- ^9 c! X5 e$ r; P; v2 m3 W6 o
40. 
    
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    
42. 
    
43.     return ucData;
    
44. #else
    
45.     /* 等待接收到数据 */
    ( G' ~; {1 u1 y) w( d
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    
47.     {}
    ; k/ n" O/ X  z! w/ R) ]
48. 
    , {2 L6 Z" J- e, o' {  Z  e- O% d
49.     return (int)LPUART1->RDR;
    
50. #endif
    & x) R$ E9 P3 _& A7 K0 w
51. }

复制代码

2 d5 s# u# e8 M4 V$ @9 w通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
  t: M- @# @4 v- a
66.3.9 低功耗串口停机唤醒方式
低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：
( \; y: h  D! A) D" w, D
  检测到起始位唤醒。
. l- T2 e; w  ]# S/ ~6 g低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。
) W8 R, F: I: u0 h$ }
# z7 g) M4 b6 ]" l* f4 s如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：
% d0 I5 {# ?& o: e/ U$ g! c

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   2 u3 ~9 g4 m. h  P  P+ x
3. 
   
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   % d; J5 z( @( m: @  F. y' p! U
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   " Z1 D$ V2 A: X9 t, z& f
8. /* 接收起始位唤醒 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    7 m' c$ y) ]/ \  E. l% Z/ R) f. g
11. {
    8 y" d, Q+ b, _; A; y9 i0 z
12.     Error_Handler(__FILE__, __LINE__);                        
    ' c& z- I0 n* P- P( c) h
13. }
    5 _: s0 D" O1 q$ a+ ]+ ^; X; }
14. 
    
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
      {! O' k9 z/ P/ V9 @
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    

复制代码

  检测到RXNE标志唤醒，即接收到数据。
  s1 U, t/ A) Y0 C& e低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。
) R8 J# i4 ]; `$ C( w# v2 k: M, m; A
2 S2 v" D1 |& m6 r  K3 W4 y如果想唤醒H7，发一个任意数据即可。

1. /* 使能LPUART的停机唤醒 */
   / j* I2 ^9 S$ E" S
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   ! a* u0 J( Q8 _& I# u. T
4. /* 确保LPUART没有在通信中 */
   # r- ]9 x: K" B; b1 x# Y7 s
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   / [# m/ Y! g/ R& _: \& m
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   
8. /* 接收到数据唤醒，即RXNE标志置位 */
   7 e6 K/ F- q+ K% p5 `" d0 `
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    - l( x# n5 `8 F* E% d
14. 
    ' _  y1 G7 f0 A
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    ( \- t! H% u6 Z* I
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    " ?, O" V& b. c- r+ p. Y7 \
19. SystemClock_Config();
    
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    ' d9 N" c7 x9 }) ?
23. 
    3 t6 Y  X9 ]3 n8 F$ G% J/ Z- D1 j

复制代码

  检测到匹配地址时唤醒。
低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。
! }  ]6 {- X, }! i; R9 ]
如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
1 V  v6 X) n$ p/ J  l
5 x! U2 f. U& [+ a& r

1. /* 使能LPUART的停机唤醒 */
   " O; o8 M' W4 n9 H% W
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   - t3 m. a. A  B
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   0 T4 B$ S/ L  W9 P$ T+ A$ l
7. 
   - n3 m; ?7 o7 `' L- S* `
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   3 n0 r: o, D  _$ ]: _0 y/ l
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    : M: }4 w$ d0 ], F# o6 n
11. WakeUpSelection.Address       = 0x19;
    ' F" K5 Q! ?1 S8 T& y
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
13. {
    1 l, B% v! B0 @# W$ G  k# g4 L
14.     Error_Handler(__FILE__, __LINE__);                        
    * `3 L1 W8 _, @" C8 d7 t- k9 L
15. }
    ; r' k5 R: C" l9 ]9 Y
16. 
    ' Q, E/ K( g  c
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    # k% V8 c* ?5 E2 g
18. 
    
19. /* 进入停机模式 */
    
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    8 R! c1 h  W; K- _: I
21. 
    6 n8 M, P  \$ ?' w, k
22. /* 退出停机模式要重新配置HSE和PLL*/
    ! T$ L2 F* z5 F! q) U( Q
23. SystemClock_Config();
    ' x' |: U  }+ S3 ]. n' |
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    
26. 
    
27. /* 关闭LPUART的停机唤醒 */
    
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    & S2 G' P  Y  W; q* a9 L8 b6 u
29. 
    6 x  D0 S: c5 n4 ^* B9 T. o7 z7 j

复制代码

/ }+ O3 ?) ^! ]- C  k这里有一点要特别注意，程序启动后，调用下面两个函数：
, `* G0 ~, ~* k2 Y# _+ P

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

复制代码

) q8 n* o3 _1 ^8 m3 z: P5 O" O66.4 低功耗串口FIFO板级支持包（bsp_lpuart_fifo.c）
串口驱动文件bsp_lpuart_fifo.c主要实现了如下几个API供用户调用：

  bsp_InitLPUart
$ a( y& f& d( u" }* q0 R# p  lpcomSendBuf
$ b6 L3 w4 |+ m& t6 T$ N! V. Q  lpcomSendChar
  lpcomGetChar
66.4.1 函数bsp_InitLPUart
6 M3 T% \# v5 p6 x. C函数原型：
/ T3 V0 i4 X2 d3 `2 s$ c
% X- |; m6 H: n& lvoid bsp_InitLPUart(void)

函数描述：

7 L3 F1 M8 s4 b! H, C此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

使用举例：
, q/ b2 H' E( J/ h6 [
: B4 Y) D! }6 B& k6 P. {串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
- A& A1 ~  h" ^# j" e$ e; [
66.4.2 函数lpcomSendBuf
函数原型：

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

7 k# ^7 H# R1 ]& K! Q函数描述：

此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

6 c$ l# l! Q, |" R. P函数参数：
4 f' r  w% ^1 i% H7 z: N6 n
& u5 g0 M  K; Y; F( g  p  第1个参数_ucPort是端口号。
" z( U' o$ f. t! y" j+ }/ k" w; V/ h5 T% ^  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
. }7 ^/ Z( h( M; |注意事项：
+ m' y. p% v- z, N! D1 m% I
此函数的解读在本章66.3.5小节。
, [: ]1 x4 s+ a( W- a1 W$ h+ f: ] 发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
# R$ s; T6 _' |( ^: o4 @使用举例：
& X9 @: A3 g$ S0 O: @2 W
调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

1. const char buf1[] = "接收到串口命令1\r\n";
   6 E- h9 @/ @* d% I9 Z% g. K; m
2. lpcomSendBuf(LPCOM1, (uint8_t *)buf1, strlen(buf1));

复制代码

66.4.3 函数lpcomSendChar
函数原型：
8 S! C) v- r4 J% x( S
void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
* q4 D5 G) ~& z& @
函数描述：

: A. i, K0 U* \& m& q. j5 b此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。

* E3 Y3 d  c" @" l/ N函数参数：
  第1个参数_ucPort是端口号。
  第2个参数_ucByte是待发送的数据。
0 g; D" \7 M, K& m1 h  a7 h注意事项：
5 W5 {% P( w' V- ]9 @
5 A1 l- d  U; ~/ e6 q6 g& R  此函数的解读在本章66.3.2小节。
! g% J/ g# I$ W# G0 i使用举例：

' H; m+ r& m. e- Z: E& g调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：
) m  k. H& h# T- H1 o& X: _
lpcomSendChar(LPCOM1, 'c')。
& ~: ^. A! C% f; Y( L. ?
( T+ b4 [9 \# K" ?66.4.4 函数lpcomGetChar
4 C/ r9 u* @1 w% u% R函数原型：

uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)

函数描述：
' R- n3 b( h/ I" s+ e* }6 y
9 ~3 o% n5 j2 P, y( W4 s+ Z7 C此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
1 C1 J4 F% ?1 F
函数参数：

( U' d* Z$ z$ v5 m# }  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
0 [1 ]* @# D5 S/ m- h  返回值，返回0表示无数据, 1 表示读取到有效字节。
注意事项：
  F1 h0 w# ]) e( c
  此函数的解读在本章66.3.6小节。
使用举例：
. \) d( W: g+ b" N
1 u+ t4 `& n* N/ c( B调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
4 `' o  S- Y! }0 F( R/ B
比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。

- H0 o$ d, z; `1 e/ Q, _66.5 低功耗串口FIFO驱动移植和使用
7 m: Q/ }- c5 E9 k# W1 ~串口FIFO移植步骤如下：
$ J% }( b# W8 A. J, S% m
  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define    LPUART1_FIFO_EN    1
   1 e' G" h  ]6 l4 t
2. 
   ) `6 a$ w9 M8 z! R1 {
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
4. #if LPUART1_FIFO_EN == 1
   6 C/ A# e5 H6 l; I# c, R" g! F/ C: A
5.     #define LPUART1_BAUD         115200
   
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   
8. #endif

复制代码

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

, A" O" z; i9 Y4 z
9 B6 D8 O8 k( C* j; U# {  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
  第2阶段，进入main函数：

3 w% p6 t# K# }# E  F/ o) h第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现了三种停机唤醒方法。
66.7 实验例程说明（MDK）
配套例子：

7 h0 [* o; Q5 |; O# uV7-046_低功耗串口的停机唤醒（串口FIFO方式）

% b! C8 y2 ^  q实验目的：
0 j: g( l$ E4 M; ~$ H
8 y( U$ p+ K( i( S3 L2 p学习低功耗串口的停机唤醒。
实验内容：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
0 Q7 x5 }0 ?% m0 t5 ^, h当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
/ j7 ~. b) i" O; E% aLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
( V( K2 \# Q& w) }( t! P) t
9 Y! l; c1 L- {LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
& X: l- l9 n/ Q  t- |( d+ l
2 Z* c/ Q# T. V# J. e6 ~LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。
8 z8 [. T1 A+ N2 d0 s
3 A2 B  k3 D/ }& f/ X实验操作：
7 A7 Z5 L/ h+ q9 N+ U
- x, L6 |! Y  j% H8 hK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
1 j& T3 m6 y" XK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
$ W/ B9 B/ g3 q$ p& W8 C: LK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
; _5 `( z/ f1 h5 ]9 q) U5 R! S上电后串口打印的信息：

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

% @" [3 s! R/ |4 v' n8 g8 _1 n

5 y4 E) d& E1 H/ X. L2 ^, J- F
程序设计：

/ t, q3 [+ _; c7 y) C$ J6 t  系统栈大小分配：
1 U2 w+ D" f2 X
: \! U2 l/ v, T0 b) f: H! Z

  RAM空间用的DTCM：

0 [4 A: C7 R; K" w9 h( o

  硬件外设初始化
, N* Q% s3 {7 _1 f" `+ `
8 ]5 P9 p* N4 s* h硬件外设的初始化是在 bsp.c 文件实现：
. R2 U1 b# X) d# b/ j$ r
- \. x3 C) E4 Y* H7 u" c7 a

1. /*
   3 }# W- L6 u5 r  b( K
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   ) K: O# G3 W" ~6 z4 O3 e
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   0 H$ ]8 w; h" u2 O: u& z
7. *********************************************************************************************************
   7 s( Y" A: J' a8 B% \  D1 E
8. */
   . x. T2 ?7 }) H4 Y9 o- W2 a9 m
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    ) @5 `$ g  |( G5 x
12.     MPU_Config();
    ! I; a+ C+ o2 g$ j, h, S3 r, S
13. 
    , L. Z) }! s, B7 M
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    8 j6 G% p; i5 @4 V6 [2 G. W
16. 
    # I" N2 m9 X9 S. o) L
17.     /*
    3 g- }0 _" s$ f! i/ @
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    2 e; @9 S& S, I$ m1 A
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    - w, Q% M4 u. V0 A! c2 F. A2 t* E& C
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    $ ?7 R/ Q$ {3 P% X9 Q$ m- E$ W
28.     */
      y) [% m+ t  c8 J1 {1 \  O
29.     SystemClock_Config();
    
30. 
    
31.     /*
    * K% |& z  `) d( Q+ o$ O
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    2 R2 W9 j. u% b0 F
35.     */   
    
36. #if Enable_EventRecorder == 1  
    5 {+ a0 u/ K- ^1 L: A
37.     /* 初始化EventRecorder并开启 */
      u% I+ r- i% b
38.     EventRecorderInitialize(EventRecordAll, 1U);
    $ I. `* B1 ~! D
39.     EventRecorderStart();
    
40. #endif
    
41. 
    * Z. @* B# T( \0 Z( {. O5 v9 J
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    / M  z# J) X' N$ `  E. E
45.     bsp_InitLPUart();    /* 初始化串口 */
    - w% r+ D- Q7 j6 L% i* _
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ( p8 i- g- ~0 a
47.     bsp_InitLed();        /* 初始化LED */   
    ( d/ |8 P. C' o7 B& \2 P
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    % _+ k! A, a+ C2 W. C# [$ ?
49. }
    

复制代码

! H- N- B. L! @4 F
  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
0 w/ G: O" w3 \1 Q

1. /*
   2 s6 Z* y: O' g
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   5 Y" i4 J3 n. n
4. *    功能说明: 配置MPU
   / k/ T3 Q  i+ q) N' D
5. *    形    参: 无
   2 n/ X. d' ]0 }7 C; M
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ; r+ S8 P: c- d+ e# A1 s  e/ e
8. */
     S7 S9 q( x; {/ C9 ]
9. static void MPU_Config( void )
   * u0 h  @" V! D1 ^7 m$ i
10. {
    * {: q$ i$ S: c8 g1 U
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    # m$ F5 {4 @/ K3 Z6 w8 e
12. 
    7 ?" q4 `* T: F! ~! e0 ^
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    ! k3 a7 n* L" \) O5 `( C5 i" P$ t
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 R  t9 D! s% p- E! b
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    " r# b- m, M& g9 Y
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ! A# }" o! U: N+ i$ k
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    # N4 w0 m# D0 T6 k
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    1 p2 v$ ~9 O, c$ V! _
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! ~) r$ n+ ~, D  X( x6 o# J
30. 
    
31. 
    2 T/ X3 @" {$ O; V. p, Q& ~
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    6 X$ o, `1 i9 t; u% D+ j- ^- {
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , S5 D( [' v1 j" @
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ! m$ Z. s9 Q% n' Y4 w. k+ y! b
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    8 a2 C, Q4 v: T  i
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
      D7 N( i% @4 n! z1 @0 }
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    5 B# l8 R" p) W! X4 l
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : K* m* @( C- R) n( g
44. 
    9 A0 _2 V& ~2 T7 u+ v2 c8 [- q! C
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    % N- n$ B9 i; e- e
46. 
    - |/ Z8 K$ q1 c  c
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    ( i  P: z' K+ _8 {1 N/ `
49. }
    % R" U6 ~6 n* g. c( C
50. 
    $ X" ]- A2 {! ?1 \6 U6 U# u
51. /*
    
52. *********************************************************************************************************
    ' x8 S8 t& g. E
53. *    函 数 名: CPU_CACHE_Enable
    . d# a5 D( c( R! ?& b# `. ~9 b
54. *    功能说明: 使能L1 Cache
    . y7 U$ @2 L5 e; e# f# x
55. *    形    参: 无
    ; `- u- `) C9 F; {( @7 s
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    8 u6 `; u6 [+ N$ S, h+ Z8 m" _+ D
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    2 d. b6 L$ T+ Z
65.     SCB_EnableDCache();
    
66. }

复制代码

3 E( M0 ^/ S! a' K  每10ms调用一次蜂鸣器处理：
2 }0 Y+ w6 {& u) A
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

! H" [) V" \0 H. f  U' p

1. /*
   $ I, p" e/ i! Q" @  m
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   . P* ?) N' d" i, E. i  O
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    & \! v/ p" I2 U7 {8 \
13. }
    

复制代码

  主功能：
  z8 O# x8 Z1 v6 J1 Z
主程序实现如下操作：

5 W0 z# I) q' q9 |, }# m, ^启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
  d  P# j; d! N* E/ P0 k( p" i/ wK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
0 F( D2 {$ b) F& m- _% u! U6 HK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   ( ^+ N- G( g+ `. [- o9 @- P
5. *    形    参: 无
   & R- R* B& X. O; m( F+ I( O
6. *    返 回 值: 错误代码(无需处理)
   1 r7 h7 Y/ T0 S0 E  A( R# d
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   % `. l& q  C+ j
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    
13. 
    
14. 
    7 Z8 n0 z& x8 d; z+ K5 g
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    ' `* ]+ C: g, h
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    - o$ N- n+ R" l$ g$ _& t
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    7 X5 v* M0 f) b5 Z; X* U! a3 @
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    ( J* e3 O. r: ]# T& w& Z7 t
23. 
    
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    8 _( H- ^+ Y! e$ p0 ~" f
26. 
    
27.     while (1)
    
28.     {
    - `# @- D' J! g$ O( e
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    # V: D8 x  v2 y! f
31.         /* 判断定时器超时时间 */
    , E/ e9 Q: ~" B3 d* Z- i+ C
32.         if (bsp_CheckTimer(0))   
    . Q3 M, k% ?& S' Z# C
33.         {
    / G0 Q6 H6 e5 N1 b3 h
34.             /* 每隔100ms 进来一次 */  
    : b7 m" \+ B0 f+ d$ G
35.             bsp_LedToggle(2);
    
36.         }
    & Y2 q9 S6 r4 e0 C% K2 H3 O
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    : ~$ b6 x8 j' _& G! X
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    3 q, w. V2 w& o) H
42.             switch (ucKeyCode)
    
43.             {
    
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    . b' C# x* b3 U4 t7 _2 z6 G. w, c- H
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    4 C1 k* S! h+ u( |; {& _( l
51. 
    + P* C" E" C8 S1 R) e: n7 L
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    , `8 x, A( l- h# T$ S; W' i
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    ) K8 I" P* l! `, G8 i! i
56.                         Error_Handler(__FILE__, __LINE__);                        
    . m4 @5 c& p% v( D
57.                     }
    
58. 
    3 T; p$ ~) g& \* Q  y
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    " P- @- T* @: r, [( B1 Z
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    8 A  b$ M0 j; N3 L2 G
65.                     /* 关闭LPUART的停机唤醒 */
    * y! w& z' y1 ]8 b
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    ' |5 p2 A0 R% ^& [7 {0 N
67. 
    ' A( _, A% l2 ~9 {7 T$ k
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    3 B% L) J3 B4 b3 t: ]
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    
72. 
    ; C2 e+ K9 d4 p  F
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    # `5 |+ F( Q2 M  |/ `7 S
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    $ b5 Z- d' a  h, j8 K3 i6 i
80. 
    ' b7 r" i( w" Q# k( R6 i+ Q. [4 \
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    : |* M- D3 W4 [$ k/ e
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    9 \7 r4 f" n$ q  Y7 ^
85.                         Error_Handler(__FILE__, __LINE__);                        
    $ l3 p" n* V2 b9 p3 w3 F
86.                     }
    
87. 
    
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    5 N3 a8 d2 b! R, c9 u* ]0 |
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    8 c3 i2 |) M) a* V* U; W9 S
93. 
    0 A- Q6 y: ~$ P
94.                     /* 关闭LPUART的停机唤醒 */
    / H7 t+ b) w: @" |! F
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    1 {  S! {7 m: X
96. 
    
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    2 P' q3 g" A8 s' e& X: e  X( W; \/ `
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     : N0 x% }1 U" ~! t' h+ x
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     2 }( n+ T( U! Q$ s/ e' G
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     9 `( e+ F$ E3 m. n: J8 F
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     4 ~. f! W9 |7 [7 _* y
109. 
     # G! u, Y# ^* D+ }3 O% v, O
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     8 ^5 B8 R& v9 _- u- m
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     % {6 q; A1 {1 N5 ~2 Y
113.                     WakeUpSelection.Address       = 0x19;
     5 X$ f3 N0 }  \: ?' ]- H3 [
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     
115.                     {
     & m" A1 j- Y. k- v% P+ h: V$ U
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     % `$ F+ F. T) i3 S' n
118. 
     3 V0 u9 O, s* _" `5 P/ X
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     6 ~: L1 c" |2 c# X9 j  B
120. 
     3 K; i4 }% b' g
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     
126. 
     / p# |* y, |9 T( \7 l1 d- K8 |( d" O
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     , V2 @$ y% e+ k) \) S4 I
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     # ~9 D9 X! {+ p% I! r
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     * q+ V& Y4 f4 E5 X  x
131. 
     
132.                     break;
     
133. 
     
134.                 default:
     
135.                     /* 其它的键值不处理 */
     7 v& P2 \7 Y5 S( n: s) g. s: G
136.                     break;
     
137.             }
     
138.         }
     ; M1 F+ }5 J8 y: g) @
139.     }
     
140. }

复制代码

' K9 {% ~/ ~5 ~/ D3 M
66.8 实验例程说明（IAR）
配套例子：

. k' ?0 m4 U- [& _7 C) k# V9 qV7-046_低功耗串口的停机唤醒（串口FIFO方式）

! q/ p, o" d. K" h) T实验目的：
" y) F5 d/ k( p0 Y2 ^
5 f" ?# T  Y8 |/ K- w5 b学习低功耗串口的停机唤醒。
实验内容：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
+ V# f$ @" u; ?. c: q* dLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
8 F+ h  y/ l# G" `5 eLPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
/ v6 v) ?/ X# Z4 [, n' o/ ]
) e0 D0 \* }! w7 V) n# nLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
. S: N  W: k$ e6 e
LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

* f/ u; `" t# ]+ f6 D2 n实验操作：
2 g& Z; t: L9 G' t7 \
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
) X5 F" m- X2 X& `2 r4 p4 V3 j5 qK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
3 d: Z* i+ T' {5 V: a上电后串口打印的信息：

' r" X& {- l+ r: a& Z波特率 115200，数据位 8，奇偶校验位无，停止位 1

  g( N+ w1 _! K3 I

程序设计：

  系统栈大小分配：
* {( x# B  n2 }1 d) ^& c+ A) p2 D

- n' U( ~% s" x% V3 c( h  RAM空间用的DTCM：
# A/ W" L3 _! b6 M6 r
( m* ]% D- f8 W3 F7 F& F8 y+ b

7 v, n% B2 ]/ @) E  硬件外设初始化

' V+ i% J8 p, N: f1 ~" a硬件外设的初始化是在 bsp.c 文件实现：

( e- u1 a- Q) w1 C' r6 A; b& B

1. /*
   
2. *********************************************************************************************************
   % e- U+ L% s2 t, q2 R
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   " y  a1 P! [$ U. g! w! \# g
7. *********************************************************************************************************
   
8. */
   ' ^1 Y: _% B$ ~- I' v
9. void bsp_Init(void)
   ' {( ^% H) c5 r5 u. H
10. {
    - N# v7 Y6 @- w6 |
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    + f; t" ]/ ]& o/ G( K. [& @9 M0 h5 h
14.     /* 使能L1 Cache */
    ' `6 `) M$ a. J% a1 Z, s0 Q
15.     CPU_CACHE_Enable();
    " p6 Z8 S) ^7 `. L$ }
16. 
    
17.     /*
    7 W' U0 v# |2 [
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    . Q0 z& n5 c9 }5 C& {. z4 p
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    & H" X+ z" p0 d' e/ u
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    7 F( F' X; G* @5 w9 Z/ t8 N
29.     SystemClock_Config();
    7 F, i; A7 ^2 X% @/ F+ s+ [, C7 G9 s
30. 
    / s  _6 z6 x5 D8 M2 q/ j. G, F
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    ' i0 {! U2 l! p* y
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    ) t. Q! p  z2 i# u
38.     EventRecorderInitialize(EventRecordAll, 1U);
    1 c  g6 K7 G# a7 F2 X$ E
39.     EventRecorderStart();
    ! @" g/ c3 \) ]7 \( d. W
40. #endif
    1 [& |0 @& ?# O5 j4 g7 @
41. 
    % x* C+ |6 `# @, d: g( b" e+ j
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    7 p" f' _8 f! ?% d
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    ! v2 x. I* a8 ]  L0 R# k8 M. K
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }

复制代码

  T; o3 C% a( |. U' k! Z  MPU配置和Cache配置：

7 M# y; N* _' o, k1 q+ y数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
' u$ q: D5 N. H4 c6 f
8 _  B" ?0 k, f: y( H. j

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   , ]5 ^) A  L2 e3 }* K
8. */
   * T" S) l% f/ L: X1 A
9. static void MPU_Config( void )
   ' w1 s5 p5 l* ]0 A8 T! P3 q) Y/ t5 O
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    ; l! V; N( b3 [! D0 ~& o$ R* M
12. 
    , A  D5 W  ]" e0 q2 u( |
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    ' l9 E. ^/ w% {, x; j& Y+ m7 e6 i
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ) _5 M$ c7 S" s! Z, D
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    - u" U% O8 y" a! d. {
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    + `& R0 ]" t3 ]# o$ b1 c- e, m
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    * G$ b- q0 h- V: q4 d1 M. E* o
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    0 V8 d7 j: e( G* e
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
      F9 H" _/ i; g7 k$ L9 \# R7 s
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    # [2 i* U; V% m) v4 W; _
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    1 I2 J$ [1 }# B& K2 P7 `! i
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    8 a- E# Y! u4 |6 R& V
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    $ m6 e; N; U9 o
30. 
    ) Q) T: A/ Y6 J  J: R9 G
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    % f3 ?; Z# ^2 [5 B3 o, Q3 ~; Z+ c
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 I) [3 `. u; r  c" L
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    " T; r% y, L. A
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    - y+ p7 q4 d$ a7 q, T6 ~
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( |2 Q& \4 J& m7 m
46. 
    
47.     /*使能 MPU */
    , p0 W/ I6 h- N. E* N9 P# L
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    2 P. z4 H: c4 {) Q3 n
54. *    功能说明: 使能L1 Cache
    " R( e: L5 ^3 I0 @& E
55. *    形    参: 无
    0 W1 Z, ?. l# W& f) i, Z
56. *    返 回 值: 无
    . d/ T/ V+ H  x
57. *********************************************************************************************************
    ' k7 Y" L: a! [3 c- X
58. */
    # @4 e4 Y& [9 z: Q$ H* ~3 e; n
59. static void CPU_CACHE_Enable(void)
    
60. {
      n5 R0 T- c8 o( I; a# ^; w+ U7 [- W
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    - u, N$ l, A& s3 X! V( ?3 U
63. 
    + m: a+ i7 |; }/ f# w& B3 h! L7 _
64.     /* 使能 D-Cache */
    ' S( U2 k1 s+ Q% X& P
65.     SCB_EnableDCache();
    
66. }
      I* I/ S6 ^( ]; |5 N6 f
67. 
    ( w3 @& d5 W9 m. S0 ^2 {# f

复制代码

7 ?! S  \$ {& _  r% J  每10ms调用一次蜂鸣器处理：

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
, D) O/ j) ~' D7 o; {" [, W: Y, W; }: l

1. /*
     ]* q; E( _( ~' ^( a
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   ! t9 r. A' M5 I; W1 u! ?4 U: D
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   * \  v5 q: F' [
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   7 P) P1 U) ]' j1 x
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   8 q; }0 U: D1 {. V
10. void bsp_RunPer10ms(void)
    
11. {
    $ v$ p+ E7 ]2 C+ e, k
12.     bsp_KeyScan10ms();
    8 e1 j' H. }3 a( I4 f
13. }

复制代码

1 s+ g" e+ ?' `6 n( h& P; N' b8 F  主功能：
/ j' w5 w$ J+ u, `1 X* B- S7 C" f
! b% N) s- S. j' N% J% Q主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
& l% e# \- y8 Y- z) @; \, j$ q K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
8 }( T, y9 ]# t( D$ M K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
$ W& R2 D3 [$ p& J

1. /*
   
2. *********************************************************************************************************
   $ c  r* H2 N! j0 X2 {; Z( t# V
3. *    函 数 名: main
   + E( Z* y$ F7 Y
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   # D' ~( l/ D2 F: W
6. *    返 回 值: 错误代码(无需处理)
   & P' ]- p8 Y2 Q" w0 U' S( l1 U
7. *********************************************************************************************************
   $ M- Q& G/ n( ^7 _+ B! U
8. */
   
9. int main(void)
   % B; T% A* X' [( v% f- @( S4 s) g
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    9 v! H' Q7 D. ~
12.     uint8_t ucReceive;
    
13. 
    
14. 
    & I, ]5 i8 w/ j4 }: m/ s7 _7 }
15.     bsp_Init();        /* 硬件初始化 */
    / b3 b6 t% N% K, ^  V8 F6 I2 M
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    , |* L# I& k6 e8 O9 b
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    # z% C$ a1 {% n4 e& U9 Y6 E# g
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    $ ]1 b6 C+ t. O! O9 `9 g1 F
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    
23. 
    + Q4 F; `  n1 ^' ?
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
    0 X1 _- V: C; J7 D- v" l
27.     while (1)
    ) f  C4 ~' L, P. G6 v' f( s, t6 D
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    ( A$ E1 l1 f+ [: B( R) e# ^
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    ; F3 W* s* G, c: e/ I. D+ P. O/ r
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    / C1 N! Z; t# y0 V6 W
35.             bsp_LedToggle(2);
    
36.         }
    
37. 
    9 c( O5 u$ u' c! Y( ^$ J
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    6 }8 ~' q- y8 U3 }: I, |
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    " {. ?* V, l6 u# [% Z
42.             switch (ucKeyCode)
    - Z8 p# e! O5 u4 g2 N8 g" _+ E
43.             {
    ' R2 A$ W9 ]9 r5 h; A6 r
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    8 o; J7 y. M: t0 {/ w  e8 D$ I
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    5 u0 X8 g2 h5 z
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ( _) A4 ?0 m5 `9 @' t) ?9 M
51. 
    0 w( @# {8 E. u" a! c; n- I
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    . n6 i9 V7 f9 ?! g; {
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    0 b" I& N$ K  c! _" f
56.                         Error_Handler(__FILE__, __LINE__);                        
    & A: Y# R) A) ^! e0 O% ~
57.                     }
    
58. 
    
59.                     /* 进入停机模式 */
    
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    6 i5 X: G8 i! t5 a$ s" W7 T4 ?
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    8 H7 ^) m/ G% g+ k
63.                     SystemClock_Config();
    
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    . t' _% w) z; I2 K5 U, Q; N$ r
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    8 f2 G, x1 w* m6 f
71.                     break;
    
72. 
    - t* N! Q; p3 k7 ?; A: M7 k
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    : b/ g% o/ p3 H6 ~- d( Q/ B
74.                     /* 使能LPUART的停机唤醒 */
    9 Y. ~# n" E0 i0 Q( e
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    ; x& r) }+ H6 ~  D* @: ^/ L
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    7 x' X" q2 e4 g$ g* D
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    " }/ G" a- f1 Y# C& H' `1 B* C
80. 
    , y) g* m6 V! |$ T  _7 |6 b
81.                     /* 接收起始位唤醒 */
    8 b9 n' P0 y% ~% |  f$ O1 N; D
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    + S: A5 H* C7 c# w" v
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    % ^( k8 D0 M6 @' v& N
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    9 {6 B! `* a! D' z. y
86.                     }
    3 k8 v; D. a% u7 C" a% U/ j1 T( H
87. 
    
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    , ~- a3 B" _* {& u+ j, J
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    ; e+ E5 j( L/ s+ k$ I$ G0 R# k% |2 j
92.                     SystemClock_Config();
    / w6 z1 [: Z2 O0 Q4 @4 j
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    . l3 U0 @9 S$ I+ Z
96. 
    1 G2 k4 S4 o0 D% s, P5 u' T  f
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    # h) `& E5 m+ l/ P* X: m& F9 _
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    ! I# V+ N5 T! {6 g/ j
100.                     break;
     
101. 
     4 A( R5 {( [: N. ^' m% L
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     ; ]! d% c, |0 u- H6 [; B
103.                     /* 使能LPUART的停机唤醒 */
     ! J( J* ?8 U6 }( l
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     # R: o9 c( }" N5 ^6 C
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     + {  Q: ?* C; Z; t/ u6 r
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     0 T+ n7 w* S& I: b
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     / D( `  P# @/ u$ B5 B  i0 o
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     , [4 V: @5 I* W4 f0 [9 \
113.                     WakeUpSelection.Address       = 0x19;
     8 {* i7 o. Q5 b6 t5 H0 V4 r
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     
115.                     {
     " p7 n: f7 u% C  _! Y5 m3 T
116.                         Error_Handler(__FILE__, __LINE__);                        
     7 d- _+ Z) R* D& E, R( {
117.                     }
     # i* r# a8 K* D3 N! E) I
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     * q3 a+ v" A( e4 G( ^# F3 C
120. 
     # a% k: R! a2 b, I9 A- B( D9 `
121.                     /* 进入停机模式 */
     , z" }. w- F$ W( m7 j/ P# L
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     ; n9 K0 C8 y' K2 G6 ]+ u
123. 
     8 h5 l6 E# i5 t* v( r: f# j8 f
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     3 m, Q8 X: Y" O# W! T0 ^( G
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     3 G$ N5 A4 o! m9 y) r
131. 
     
132.                     break;
     
133. 
     3 l3 ?2 e/ M* v0 V, g% i
134.                 default:
     
135.                     /* 其它的键值不处理 */
     
136.                     break;
     
137.             }
     6 v# ^3 a, n( D' I
138.         }
     ! k5 k, H( [2 d4 p' x$ I) {6 Z* ]
139.     }
     " W" s7 B* k3 O3 |' k6 B
140. }
     

复制代码

  o+ r1 ^' I* }2 @6 o# k0 C
5 Y  J% `- I7 c. ?. i0 e! ~! ?66.9 总结
5 y6 g2 A$ w) w本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。
% o  v( I( {8 z% E

$ n, o; O6 q4 b4 K5 h