66.1 初学者重要提示
  学习本章节前，务必优先学习第65章。
  低功耗串口FIFO的实现跟前面章节通用串口FIFO的机制是一样的。
/ U5 ~& I! J1 B8 L1 |" p  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
66.2 硬件设计
STM32H743XIH6最多可以支持8个独立的通用串口和一个低功耗串口LPUART1。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
# m) N2 R0 ?  K( t
6 k  m8 [+ u! \; v! @7 D3 j低功耗串口LPUART TX = PA9，   RX = PA10
% o6 G6 |1 v/ X- \/ O
& x; r) d2 R* B& i0 q, k串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）
/ ~8 q' ]$ ^/ p$ f+ }- \, J: [
串口USART2  TX = PA2，   RX = PA3
! g4 u9 W! \' ?, Z4 t2 B  w
: \3 R1 B, l4 [% m+ l串口USART3  TX = PB10，  RX = PB11

串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

& k0 G+ h+ w# d串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）

7 r6 @" G9 |+ A5 _) L6 }3 N# _4 o, B: e串口USART6  TX = PG14，  RX = PC7  

串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
- W1 M6 Q9 X9 Y* V6 ~
; V$ C. A% J0 ?串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

STM32-V7开发板使用了4个串口设备。
& n/ U9 _% @/ @- S' R) P1 V3 h
  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
* l! y/ ?: U$ _4 n$ w  串口2用于GPS
  串口3用于RS485接口
  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
1 P" m& ~7 n, O6 r* n6 k* R
7 g/ {) ~( j$ B, Q4 x" R

& d: `: o: @5 F' q8 ]关于232的PHY芯片SP3232E要注意以下几个问题：

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

6 v: p; d; b# k

4 A6 Q# ^* A2 C0 [实际效果如下：
, e- S3 S4 G8 a
( @. L8 _8 n9 F* }

通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY

芯片是否有问题。
, M  j- A/ a' z- x2 ?7 q4 {. t+ u, V
: |7 u, w. Y7 v  B; ]  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
* d' c$ h  P, W* G66.3 低功耗串口FIFO驱动设计
6 V# v* E, ^$ W/ ?66.3.1 低功耗串口FIFO框架
为了方便大家理解，先来看下低功耗串口FIFO的实现框图：
( J3 x/ P$ |- @: e  L, q# J

  第1阶段，初始化：
6 I$ C7 {. Y4 {9 r5 d2 \
8 ~7 B7 |7 Q& V8 l/ X% r6 G% |通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
0 k# K  Y/ a. J- K' ^  第2阶段，低功耗串口中断服务程序：

  接收中断是一直开启的。
  做了发送空中断和发送完成中断的消息处理。
( ^+ f& d' N- Z/ n2 ~/ E, s  第3阶段，低功耗串口数据的收发：
7 K! P& A, ]1 M- Z- D5 b/ k
& {4 F9 K6 b7 q/ c+ ^( y低功耗串口发送函数会开启发送空中断。
4 y0 e; y/ m0 c5 X( L低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
66.3.2 低功耗串口时钟选择
' v1 m( u2 L7 a  x( c/ T: B, V  p我们这里实现了三种时钟选择：
0 Q$ i3 `9 W5 M; j( f! \  N
# S2 }* p8 z8 T, U! {, z0 bLPUART时钟选择LSE(32768Hz)
" u) V8 t4 I- Z最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。
& x2 h5 @" s. d! b3 Z- a
LPUART时钟选择HSI(64MHz)
" \) ]+ O' [6 B5 ^3 `: F( @0 ]2 f$ J最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。
- N) S5 ^* u# |6 p0 n  R4 q
LPUART时钟选择D3PCLK1(100MHz)
最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。
. A4 B/ H9 h. I, B% g. I% T. U
如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，程序代码如下，用户可以根据需要，使能相应的宏定义：
3 e% U' T- z5 _$ A1 G; ]; P
8 q2 f9 d; G7 w1 `" N! H6 x

1. //#define LPUART_CLOCK_SOURCE_LSE      
   % ]' A. Y0 f/ R' T1 A7 I0 J
2. #define LPUART_CLOCK_SOURCE_HSI   
   2 X6 |) B5 V$ e' l2 W
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   0 a  ]$ E* Y& ^" y- M9 T
4. 
   " r$ Q- A& Z3 b3 y% J6 I; G
5. /*
   . ]. g( C* b% G6 b4 l) ?2 O
6. *********************************************************************************************************
   0 r) w! q. o8 M( \  r. B4 _$ w
7. *    函 数 名: InitHardLPUart
   
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   4 _( a  p4 {& K2 Q  j, `
9. *    形    参: 无
     @; L* |* |$ ^7 H! J
10. *    返 回 值: 无
    
11. *********************************************************************************************************
    8 b$ A6 [% K9 o2 ~- d* M
12. */
    / P. Z8 y" S% c; n  j& ]5 J, O
13. static void InitHardLPUart(void)
    5 J# @, H2 f; p! ^1 X
14. {
    2 d9 R8 z0 Y- }& m- J
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    2 S; l, ^. i( i. P; v! I
17. 
    
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    5 h- I9 e. _6 k/ S2 _9 n
20.     {
    
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    * C* V# ]: o" H: J$ E4 d
22. 
    
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    7 S9 \! J( d. ^" G
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    - k' Y7 T6 C- m% t
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    
26. 
    
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    ) y+ g. E, C/ x/ O3 M) t
28.         {
    
29.             Error_Handler(__FILE__, __LINE__);        
    
30.         }
    
31. 
    
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    2 ]6 ~4 F/ z; X1 z+ {8 ~
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    
38.     {
    
39. 
    
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    & D# |& F% Z/ P6 l% m6 X- O; v
41. 
    " o; ~9 I; f5 J0 J
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    ; p: n7 Z7 w+ @$ U) X" W; |' {
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    % X' R! V5 q# f  C( W1 x  E# p  X, G0 e
46. 
    
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
48.         {
    0 n; X! s. [+ D0 X; V
49.             Error_Handler(__FILE__, __LINE__);        
    7 W& P4 p2 K) G" o, T+ T
50.         }
    - G  u( k# c6 q- Y9 a+ d- C
51. 
    3 H$ x. a1 m5 e) C: w
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    9 L( X: S9 G/ ~! Q
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    0 X4 \6 P+ k. c3 R9 j" h0 B
55.     }
    
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    
58. 
    * ?- d' z/ Z" G+ j- m3 o: Q, g
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    3 ?5 f0 V5 b8 w3 Q
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    9 g% k3 C' G# L, ]( g! y
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    / Y' s/ f7 T. [; s, m, x" o
62. #else
    
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    3 e$ q% I4 E' Z2 o9 n
64. #endif
    0 _8 j$ R9 `1 N: Y; i1 \
65. 
    6 D0 n, _! Y/ x7 v5 W: S
66. #if LPUART1_FIFO_EN ==
    ' O" c6 }- T$ a' V4 p0 g5 l  `
67.     /* 其它省略未写 */
    0 P9 @( o9 R. h8 B0 B8 Y1 s
68. #endif
    
69. }

复制代码

9 x, ?. y5 a0 f7 c66.3.3 低功耗串口FIFO之相关的变量定义
低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。

; E0 F7 p5 D) [/ [% C' {这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。
( Z% J/ v$ Q, Q
7 V! K  ]. Q4 k8 b) i# @每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

' B2 s& E0 F1 _% i  x8 ^9 V$ }我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。

) t. f  F# p, p' F  M& j

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   1 b2 E6 J/ {9 L, u; g
2. #if LPUART1_FIFO_EN == 1
   
3.     #define LPUART1_BAUD         115200
   % N* m# u1 k# U3 {
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   ' A0 f1 z4 s% v1 y- j
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
   
9. typedef struct
   
10. {
    3 [) U2 `8 I3 g3 X1 h. g, m
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    % k. h) k. ~" `. R
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    0 N& i' w  L2 b4 z1 X/ Z
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    ' x9 @* h& V, v+ Q( m
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    6 q# \9 R: x8 d
19. 
    2 t; u9 I' A& X* X9 c
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    
23. 
      i, \7 [$ z( J$ M2 t% ]4 G4 q
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    $ m; F' z9 I! z/ E" f: \, h
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    / ~$ z6 Z, G2 l1 o9 \# y8 X
27.     uint8_t Sending;            /* 正在发送中 */
    
28. }UART_T;
    ( C; Y5 J1 ]/ ~6 d( n+ E# Q
29. 
    # s. g! k* E3 x4 m! F7 L
30. 
    ; U; n" b( Z8 j/ J0 _9 y
31. bsp_lpuart_fifo.c文件定义变量。
    4 C# t* m* q% W. M- _
32. 
    6 G' N" D7 b; S6 e% K% g
33. /* 定义低功耗串口结构体变量 */
    
34. #if LPUART1_FIFO_EN == 1
    
35.     static LPUART_T g_tLPUart1;
    
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    2 f6 X6 f3 w# @- ~9 P
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    
38. #endif
    

复制代码

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

66.3.4 低功耗串口FIFO初始化
低功耗串口的初始化代码如下；

7 y6 d' f" K& x, ]0 W/ p6 `: d$ }/*
*********************************************************************************************************
*    函 数 名: bsp_InitLPUart
/ V' `  L& u2 w: H*    功能说明: 初始化串口硬件，并对全局变量赋初值.
9 c' G7 E& }1 Y2 u5 \*    形    参: 无
*    返 回 值: 无
+ B* ^, ^- f; j$ s5 a*********************************************************************************************************
*/
, J  ~2 X3 t# L# Yvoid bsp_InitLPUart(void)
" D& H4 h6 ]( [- t' u$ D& f( ~{
, P7 G$ R  |' K5 C1 w2 B# N    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
1 N* ~3 J7 A- ]}
) q! p: e" l, F' C3 Q2 G

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

  函数LPUartVarInit
( P* m0 j  [; g这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

/ v, n4 @6 B$ H) V+ t

1. /*
   5 z: A# G  ~& l6 Z2 u* X
2. *********************************************************************************************************
   & H# w7 P& w$ k4 Y& {3 o
3. *    函 数 名: LPUartVarInit
   / F: q) y3 @* \) M' a' H
4. *    功能说明: 初始化串口相关的变量
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   $ L+ q, M, z+ j4 X# Q- E
9. static void LPUartVarInit(void)
   
10. {
    ' N0 w6 L5 ]# y0 K0 d$ |# a* X8 x& T
11. #if LPUART1_FIFO_EN == 1
    
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    4 p. T* F& T5 b1 V3 Y  G2 m
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
      o  E4 z1 N3 j4 l. i
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    ! M* H2 \  r. E; b1 Y9 ~
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    $ @' Z$ @5 e3 j$ b. H
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    4 m  y! O5 F' t6 _
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    5 v+ b, X. |% q( ^" {5 R* P
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    , W2 d  i+ c- z  O, C: `1 a
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    " P$ j" |, ^/ m, g/ C# O7 n' \/ l( w
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    
27. #endif
    
28. }

复制代码

+ X: _* S& m/ t' v- F
  函数InitHardLPUart
此函数主要用于串口的GPIO，中断和相关参数的配置。

1. /* LPUART1的GPIO  PA9, PA10 */
   4 e$ @' U- C* y: P! u
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   ! j% E4 k, g% D* G: _( r
3. 
   
4. #define LPUART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. #define LPUART1_TX_GPIO_PORT              GPIOA
   
6. #define LPUART1_TX_PIN                    GPIO_PIN_9
   1 O0 \1 R& A1 @; W# S: `
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
    0 H- f8 Y# v8 P9 D0 }! S
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    1 x2 @% c! {: N5 l9 T
13. 
    : n( R5 N6 M, f4 n: c; A9 k
14. /*
    
15. *********************************************************************************************************
    
16. *    函 数 名: InitHardUart
    : N& `/ D5 |: Z/ c4 T: ^9 ]
17. *    功能说明: 配置串口的硬件参数和底层
    
18. *    形    参: 无
    
19. *    返 回 值: 无
    & K; g3 M% S4 A4 M7 R2 Y' y
20. *********************************************************************************************************
    
21. */
    
22. static void InitHardUart(void)
    
23. {
    
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    $ Y# ?: [  j9 o% ?3 v/ S
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
26. 
    
27.     /* 时钟初始化省略未写 */
    & H4 e# H9 J' @! B. b
28. #if LPUART1_FIFO_EN == 1        
    : p) W$ w# n9 y6 u+ p5 T3 s
29.     /* 使能 GPIO TX/RX 时钟 */
    $ K- B+ ~& N3 L6 @, A
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
    $ S( |, w' d( l9 V2 c
33.     /* 使能 USARTx 时钟 */
    
34.     LPUART1_CLK_ENABLE();   
    1 r$ q; ^' y( k$ T$ S( \
35. 
    / `& x& v' V$ n
36.     /* 配置TX引脚 */
    * l( J6 n. k' t$ W6 h! \) }
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    7 Y. H1 j; I6 h; A. p5 @' l
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    ) ~! k# Q% Z. i# T" m2 \7 i: l
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    - \* L3 ]) F2 h* G9 c; f
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    # u4 K) `  `! u. M$ c2 O& P
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    / c, @4 W8 a0 R. E* r
43. 
    ' o. z/ M, j& y& p3 x
44.     /* 配置RX引脚 */
    
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
      E9 X" }% P! {/ m
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    # G0 q5 ]0 L( G
48. 
    
49.     /* 配置NVIC the NVIC for UART */   
    
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    
52. 
    
53.     /* 配置波特率、奇偶校验 */
    
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    3 K5 U  N6 m0 y
55. 
    ' I0 x3 Q5 m& B
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    # e- w* D, c6 @" ]
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    % |* J9 G+ R) S% {0 h
59. #endif
    
60. }

复制代码

3 I; W/ w4 V" f5 v) T* e" e. o; c低功耗定时器的参数配置API如下：
7 X2 `6 g& @1 M3 c1 ~3 B5 _: N

1. /*
   ) P0 a" W  ?* Q' o/ U; P: z
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_SetLPUartParam
   ) V: o# k  c' S& c% V- E
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *    形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   4 P: D8 k8 |4 E( p# u
7. *             Parity     校验类型，奇校验或者偶校验
   2 U2 |3 P: t6 n* G% V
8. *             Mode       发送和接收模式使能
   7 f; L  N5 o) W& [
9. *    返 回 值: 无
   ( I6 U1 w- Z$ \* v8 A
10. *********************************************************************************************************
    
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    ! a2 l* O0 X2 f- `
13. {
    
14.     /*##-1- 配置串口硬件参数 ######################################*/
    5 V# P1 M9 f0 r7 p( C, \
15.     /* 异步串口模式 (UART Mode) */
    
16.     /* 配置如下:
    
17.       - 字长    = 8 位
    * R/ z% F5 M5 h5 ?7 P3 j" L. q
18.       - 停止位  = 1 个停止位
    
19.       - 校验    = 参数Parity
    
20.       - 波特率  = 参数BaudRate
    
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    
22. 
    . w" {* S8 D% o0 ~0 v" P
23.     UartHandle.Instance        = Instance;
    
24.     UartHandle.Init.BaudRate   = BaudRate;
    
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    $ E' Q  F4 r8 d6 N$ V% @+ j
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    ! F7 m  W9 B2 b8 }/ v% N$ J
27.     UartHandle.Init.Parity     = Parity;
    
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    * v7 C$ m. U2 O. c3 M
29.     UartHandle.Init.Mode       = Mode;
    
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    + t7 N9 x0 d; @' L& I1 X) s& X, s9 u
33. 
    
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    , ^' e) A; A8 |
35.     {
    
36.         Error_Handler(__FILE__, __LINE__);
    $ p* I( U; ]. R/ {
37.     }
    
38. }

复制代码

; ~: S6 S+ l: k2 m! `

66.3.5 低功耗串口中断服务程序工作流程
& W) |; \6 n: i! W- x" Q& R串口中断服务程序是最核心的部分，主要实现如下三个功能
  \  d' M+ w1 d
  收到新的数据后，会将数据压入RX_FIFO。
3 _' A/ w5 a# U/ U$ H  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。


下面我们分析一下串口中断处理的完整过程。

当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
5 ]) x1 }" {2 v0 v/ Q/ E9 Z
+ ?) s/ J- @  r! ?& ?" V2 Q我们将串口中断服务程序放在bsp_lpuart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_lpuart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是低功耗串口的中断服务程序：

6 m+ M7 K  l( j. t  Q) t

1. #if LPUART1_FIFO_EN == 1
   $ k/ }7 |$ }# y* v- x3 ~8 k" g
2. void LPUART1_IRQHandler(void)
   
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   $ L5 D1 p4 o' b' B5 r
5. }
   
6. #endif

复制代码

- z  F+ I% B6 e8 \/ g6 w下面，我们来看看UartIRQ函数的实现代码。

1. /*
   $ W. z1 m( A6 E% G8 L
2. *********************************************************************************************************
   
3. *    函 数 名: UartIRQ
   
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *    形    参: _pUart : 串口设备
   1 ~1 D4 V) x/ `  c
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   + b. j: F* J, l8 h" [
9. static void UartIRQ(UART_T *_pUart)
   : y; D( A% ~; f: K; _
10. {
    " _- K. c- O% m. @/ q5 b# K
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);
    $ k2 \( l2 J' `7 s& Z. b" L* r# v3 J
14. 
    
15.     /* 处理接收中断  */
    3 A! R1 G. V0 d$ B* p& f7 b
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.     {
    2 `6 J5 L+ L* o; s" a& O
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    ( W: c3 c0 I$ c, m0 b
19.         uint8_t ch;
    
20. 
    
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    & F2 C7 k9 k) {) N4 C
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    , x/ L( ]& i* `  ?; Q, ]; f4 S. }
24.         {
    / V1 t  W, K& r; k) H
25.             _pUart->usRxWrite = 0;
    
26.         }
    ( ?" z( `4 u) m& w" b4 u- \% K
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    2 v) D1 s6 I. n' {1 p# L  U, a
28.         {
    
29.             _pUart->usRxCount++;
    ) t9 n- n& s" i. P" \' I
30.         }
    % J0 H4 i: s5 e4 i0 h% F
31. 
    + n5 g8 s* S# h( _5 h$ Y
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    . [. ?; f5 i$ L- u6 t
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    0 k) l# @( h$ g* c! m2 b
34.         //if (_pUart->usRxCount == 1)
    6 ~' G4 R+ w/ V  J; e; U
35.         {
    
36.             if (_pUart->ReciveNew)
    5 p& o9 l/ E9 X
37.             {
    8 x; |* O6 N( z' G0 |
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.             }
    
40.         }
    
41.     }
    4 H. M4 M* [0 H+ X
42. 
    
43.     /* 处理发送缓冲区空中断 */
    3 [% t# ]+ U& Y
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.     {
    : Q  ?- G, T8 ]# w3 c3 M! e5 v
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    ) b- S- h( G3 i1 B1 a) }* y: C
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    3 S. A: F3 F& ?5 E8 W
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    $ A/ l; q( y" T. N- }9 y! p* o
53.             /* 使能数据发送完毕中断 */
    
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.         }
    
57.         Else  /*　还有数据等待发送 */
    
58.         {
    , |+ d# f, o0 q( t. O, b% @# h; c, ~
59.             _pUart->Sending = 1;
    , j: |! X1 ?- S# a( H) C/ o
60. 
    $ W+ Q$ J. q. Z  G, N
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    & @7 \( p+ K! @) D7 l2 x4 n6 g! i
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    % n8 K1 J1 z4 A; Z
65.             {
    $ j, }8 D% d6 H: ^7 _5 h
66.                 _pUart->usTxRead = 0;
    : q" o3 Y# k, }# c& j% j4 ]
67.             }
    
68.             _pUart->usTxCount--;
    
69.         }
    
70. 
    $ y/ ]- D& a* m1 T
71.     }
    # R' s0 Z' ~! n5 l: S
72.     /* 数据bit位全部发送完毕的中断 */
    : O2 h7 F  h4 _' R: \  g% f4 b4 e# w
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    0 R% d9 b5 R$ C! \! J, q
74.     {
    
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    5 @7 }" |7 ~1 y  A2 I$ V" P: a5 r' K
76.         if (_pUart->usTxCount == 0)
    
77.         {
    
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    0 b3 v3 I( z0 p$ _1 O* u
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    $ c! H" m6 V7 l& |  B7 z* z) _
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.             if (_pUart->SendOver)
    
84.             {
    
85.                 _pUart->SendOver();
    
86.             }
    ( V, }9 y9 E, |" S6 b' R3 ~6 p
87. 
    ' W7 J' v3 M* z5 K4 r8 z
88.             _pUart->Sending = 0;
    
89.         }
    
90.         else
    
91.         {
    
92.             /* 正常情况下，不会进入此分支 */
    0 J0 d7 E% y! u% a$ |0 p9 ?
93. 
    . h/ {% s- l' r, C& g9 W
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    - T% v; E! `' E/ P3 s' i
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.             {
    
99.                 _pUart->usTxRead = 0;
    , X& _- H; H2 V2 t
100.             }
     ; }8 `# H. D& O7 `" K
101.             _pUart->usTxCount--;
     ! w: r4 V, y# Q) g. e. C
102.         }
     $ V) j" o9 g" f. s9 X
103.     }
     
104. 
     
105.     /* 清除中断标志 */
     
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     ; [) A) R! Y# K% x3 l' N) x
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     % \( z. F, I8 _3 `
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     9 N- h0 z. P: X9 ^# h% ]0 w
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     % @2 _. e. Y- P& F% a4 o3 e$ _
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     # D" S$ D' |: b. L, X4 J* N# G! C( e
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     ( W1 k# [% L: e
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
. u# u4 V8 W  y  Z' p5 ]7 o
! P; H2 l& B( A. \  接收数据处理
3 z7 _' v: _7 J7 A: @$ j) v接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
) X& D" h6 i8 {, U$ Z
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

! ^' Z0 F8 |7 w0 m  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
! B' X7 A+ [, b- o' J- }' ?2 g
9 M4 p# ]% F2 V6 a! F0 o2 m66.3.6 低功耗串口数据发送
低功耗串口数据的发送主要涉及到下面三个函数：

1. /*
   
2. *********************************************************************************************************
   , h4 f; T( N! t1 d/ z" {1 @. C* }
3. *    函 数 名: lpcomSendBuf
   
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   ; ~9 J$ c% d+ u2 J
5. *    形    参: _ucPort: 端口号(LPCOM1)
   , s& G7 N: Y3 F" B2 W
6. *              _ucaBuf: 待发送的数据缓冲区
   & X- l& t- T8 _! L  d$ ~  q
7. *              _usLen : 数据长度
   1 ?2 C; g  H0 B# [! X8 O
8. *    返 回 值: 无
   $ a" K; j" Y) h) G, J
9. *********************************************************************************************************
   ' N$ T/ g5 z0 Z, N1 W
10. */
    
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    % u' d5 X4 ~7 P( d
12. {
    
13.     LPUART_T *pUart;
    
14. 
    
15.     pUart = ComToLPUart(_ucPort);
    
16.     if (pUart == 0)
    
17.     {
    0 W$ d1 {/ Q* B( N' I9 W" o
18.         return;
    % \4 ~) }! S8 l( V' u& `
19.     }
    
20. 
    
21.     if (pUart->SendBefor != 0)
    
22.     {
    
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.     }
    
25. 
    
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    $ {1 `- c; p5 X, ]# C" L6 ^
27. }
    
28. 
    . u# {8 e% {; [2 c) E& B" [/ E
29. /*
    
30. *********************************************************************************************************
    3 E1 l$ P4 ]; F1 B, e
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    1 f8 h+ ?1 r  ^0 A8 ]$ W9 @# l- o. |
33. *    形    参: _ucPort: 端口号(LPCOM1)
    
34. *              _ucByte: 待发送的数据
    " g7 @' i) {3 Q, K! A1 `) r: P
35. *    返 回 值: 无
    7 Z9 a$ T6 i1 R% P# r' a
36. *********************************************************************************************************
    
37. */
    6 o& W+ a+ Z9 r5 o* H9 ?5 l
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    " [" X& {: r; P  a0 p& x
39. {
    ! x) i' a; r1 k3 M( A, l
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    ) ~* G+ C1 L/ E9 m0 Y# i" g2 a  M
42. 
    8 j' e; M& Z# \
43. /*
    " I3 Q$ o4 o1 n. y5 J. y
44. *********************************************************************************************************
    
45. *    函 数 名: LPUartSend
    3 L6 }. z% V$ j4 a
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
47. *    形    参: 无
    
48. *    返 回 值: 无
    3 U4 z  }# a: z, a
49. *********************************************************************************************************
    . G2 W5 k9 q1 ~5 b2 C
50. */
    
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
52. {
    8 P9 O8 I9 E$ H
53.     uint16_t i;
    
54. 
    
55.     for (i = 0; i < _usLen; i++)
    4 R0 s; O9 l2 C# K- \! d
56.     {
    7 S8 A3 [. d) o- C( b! R# w
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
58.         while (1)
    
59.         {
    ' v# {+ l! d; J& `1 }6 n
60.             __IO uint16_t usCount;
    
61. 
    
62.             DISABLE_INT();
    
63.             usCount = _pUart->usTxCount;
    ! `3 h; L" _& S8 m! t* _& |
64.             ENABLE_INT();
    
65. 
    " v  F& l- B1 ]3 ]: j
66.             if (usCount < _pUart->usTxBufSize)
    0 ~+ F7 \+ v( A8 m& i/ S
67.             {
    . W0 t4 Q" y5 {
68.                 break;
    
69.             }
    
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    9 @, V" I& k1 A" c, E. ~$ O; `" r
71.             {
    
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
73.                 {
    
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    ) S, r5 j/ P$ C5 P' c% ~
75.                 }  
    
76.             }
    ' l7 j  z" `! E* o  ]
77.         }
    
78. 
    $ n2 N7 R* Q& k; @) W* _
79.         /* 将新数据填入发送缓冲区 */
    
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    & m5 k+ P* R* U" V# R; o
81. 
    
82.         DISABLE_INT();
    ' X1 L* F2 l/ ~3 v2 K/ r, w0 g
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
84.         {
    9 ^1 A& M7 K5 M5 k( a9 {
85.             _pUart->usTxWrite = 0;
    
86.         }
    
87.         _pUart->usTxCount++;
    4 i( Z  Y8 v& Y. \3 g2 }3 k7 w
88.         ENABLE_INT();
    
89.     }
    
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    
92. }

复制代码

" c( O- O! \+ n2 J. M$ P6 w函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。
6 g6 V* a, g% F8 E- x: l
函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

! K# |1 B) b; {+ x5 v! o/ V  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。
- z( T2 O* j7 r, O6 E, U# o
# T3 _9 V8 C, y( p/ e函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。

  Q* j) b$ X* \6 V# @8 n0 A& E

1. /*
   6 s' x1 y0 ^* G8 z% m6 m; c; N
2. *********************************************************************************************************
   * g$ O' L4 u: _( u. @& P
3. *    函 数 名: ComToLPUart
   
4. *    功能说明: 将COM端口号转换为LPUART指针
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *    返 回 值: uart指针
   
7. *********************************************************************************************************
   
8. */
   9 U; d& r+ W# q8 ^- Q
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   
10. {
    
11.     if (_ucPort == LPCOM1)
    # ?: B4 c6 U5 D7 r
12.     {
    
13.         #if LPUART1_FIFO_EN == 1
    4 P. g) g/ `( b; p! Q
14.             return &g_tLPUart1;
    
15.         #else
    
16.             return 0;
    
17.         #endif
    
18.     }
      k* F$ L; P4 z8 s
19.     else
    3 L) t: i3 [+ s1 t
20.     {
    , q/ q& o! I. h; R; |
21.         Error_Handler(__FILE__, __LINE__);
    & b2 @. M: R$ {/ Z( {( _" \: ?
22.         return 0;
    
23.     }
    7 I5 x! z% U/ h* Y1 J- t; i5 }
24. }

复制代码

, F/ c# a/ ?0 ~. V% O+ w66.3.7 低功耗串口数据接收
  O' y6 Z  w, r. X下面我们再来看看接收的函数：

( F3 ?% L  k* H' i7 f

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: lpcomGetChar
   
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   6 X& k6 o1 D, P/ r
5. *    形    参: _ucPort: 端口号(LPCOM1)
   2 m9 B8 I! f% [; J* u4 s, q
6. *              _pByte: 接收到的数据存放在这个地址
   
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   
9. */
   % X! S5 B: r4 v5 f2 M# Q  R) a
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    ( i& [4 |3 C7 T) A
11. {
    
12.     LPUART_T *pUart;
    : u8 b# v5 @, Q
13. 
    - y$ F# ~/ ^) }" N
14.     pUart = ComToLPUart(_ucPort);
    " y4 r! D7 ]# _, `" L7 C- j
15.     if (pUart == 0)
    " Q4 P: N1 @  t/ E& v1 J; P
16.     {
    9 t  d8 u( T+ t6 p' K
17.         return 0;
    
18.     }
    
19. 
    " T. E( W8 F  G# Y: o: H8 n/ [, A
20.     return LPUartGetChar(pUart, _pByte);
    & j+ r1 ^6 W/ h! p5 K
21. }
    9 z1 I3 @% D  K/ G, {! Q' Y5 R- `
22. 
    
23. /*
    0 {0 G  o% w6 I0 N
24. *********************************************************************************************************
    
25. *    函 数 名: LPUartGetChar
    & a+ K8 T6 U' q. X
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    . f3 P# j; f; E8 L% {! O
27. *    形    参: _pUart : 串口设备
    + ^% s8 l  W' g, a) ?: u
28. *              _pByte : 存放读取数据的指针
    2 i+ o& {9 a9 X. D1 h  b" t) ~& }: k
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    9 N0 b! {! S0 b  z5 {$ e9 s
31. */
    
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    8 Q- N- U% W9 e# Y" r
34.     uint16_t usCount;
    / P( ~6 n5 \& }0 s' L- x
35. 
    
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    
38.     usCount = _pUart->usRxCount;
    5 o7 `, }! E/ k8 @6 ]" n3 y: z" f% w
39.     ENABLE_INT();
    
40. 
    ) B. W: Q/ D$ w: f7 A. ^
41.     /* 如果读和写索引相同，则返回0 */
    2 t+ f* q2 @  o0 a' ~5 [9 `( ^
42.     //if (_pUart->usRxRead == usRxWrite)
    
43.     if (usCount == 0)    /* 已经没有数据 */
    0 b( u# K8 }2 ^
44.     {
    
45.         return 0;
    
46.     }
    2 ]( M  _7 {3 m1 G! r
47.     else
    & R8 r  C. Y2 w  D
48.     {
    
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    
50. 
    . Y7 T; @$ U$ ~9 i- V
51.         /* 改写FIFO读索引 */
    
52.         DISABLE_INT();
    
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    / X7 a$ W0 O, I6 d& r, d+ d
54.         {
    
55.             _pUart->usRxRead = 0;
    # R$ W/ C  l$ \( N4 h' Q. E; ?
56.         }
    
57.         _pUart->usRxCount--;
    $ c) q0 E0 r/ a/ W  S
58.         ENABLE_INT();
    
59.         return 1;
    : \) J' v: a3 a5 Z" u* |  i1 y
60.     }
    
61. }

复制代码

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

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

66.3.8 低功耗串口printf实现
9 s: a( `2 L- k. ?* ~# J; w9 |printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

  F0 n, r9 q9 c为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
: X2 J5 ?) a  v+ E+ n" g) d
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
; p. B; @& {" C+ M. _7 y' s4 @
实现printf输出到串口，只需要在工程中添加两个函数：
: F- P6 U% X7 l- h7 Z9 A& R- e

1. /*
   * K6 |; F6 s* O; o
2. *********************************************************************************************************
   - F! y" e% u' a5 u3 {' {: \1 A+ M
3. *    函 数 名: fputc
   6 H# g! y9 w% h: X
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   4 ^* F2 Z* {# G' r; p/ u
7. *********************************************************************************************************
   
8. */
   
9. int fputc(int ch, FILE *f)
   ) j. u0 z9 v- Z, l: l
10. {
    # o# c3 u$ v5 c
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    1 h+ r" Q5 b9 M8 ~
12.     lpcomSendChar(LPCOM1, ch);
    
13. 
    % |+ f- _% x/ x/ X
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.     /* 写一个字节到USART1 */
    
17.     LPUART1->TDR = ch;
    % L9 S- w$ ?0 J! q* \
18. 
    
19.     /* 等待发送结束 */
    8 V$ U) b7 c( l3 x6 r
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    
21.     {}
    
22. 
    1 h0 ~# E9 R0 d- V
23.     return ch;
    
24. #endif
    / M( }9 E! O/ A" S
25. }
    7 m2 _. t1 W6 y* H
26. 
    5 w4 y# T+ }7 E5 o! @  x7 ?) x( F
27. /*
    3 C# x/ M2 m1 q/ i3 O1 ^
28. *********************************************************************************************************
    ) D& ?+ u7 c! A, U9 P  `
29. *    函 数 名: fgetc
    $ V; e$ ~  _, j, H" ?
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    & V- q" h  x5 }
31. *    形    参: 无
    
32. *    返 回 值: 无
    
33. *********************************************************************************************************
    9 G8 w  f- y# q. M6 w3 i
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    3 D7 S- h3 Y7 A7 z
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    ' R) T2 I+ \% [. t1 X; Y3 o3 O
39.     uint8_t ucData;
    ) Y+ o1 E2 l& c/ J4 [7 ]6 L
40. 
    - d: ~0 B( {7 z+ m3 q
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    
42. 
    3 Y% |) V8 S+ `# V/ S4 I2 V
43.     return ucData;
    
44. #else
    " K, z1 x2 P1 Z' E) P5 f3 y
45.     /* 等待接收到数据 */
    
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    4 F6 A2 D- }1 b+ K8 ]& W4 U
47.     {}
    + j: u. \0 P4 s" g
48. 
    ( ~/ d; P* |3 r! U) V
49.     return (int)LPUART1->RDR;
    6 ]% X3 C; g. s/ O
50. #endif
    8 C: O: y* Z8 ~+ u4 k2 e7 w* L1 {
51. }

复制代码

) ~" T9 R8 w. a& e9 W+ f, N通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
" j, c7 b) k2 G$ k2 q
66.3.9 低功耗串口停机唤醒方式
低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：
, |: U2 K5 B) J: T& c* M* t
  检测到起始位唤醒。
! Z8 P+ q& z4 ]8 t9 u1 o1 |* O低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。

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

9 Y/ X3 J$ G4 N4 K$ N* y* T& h

1. /* 使能LPUART的停机唤醒 */
   1 X3 R% i0 [( E, \; I  q: a; i6 z
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   . c4 b4 g1 U* Q7 j! N# c
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   2 t+ G; f6 E. p
8. /* 接收起始位唤醒 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    : w4 q3 H6 f) Y
13. }
    
14. 
    
15. /* 进入停机模式 */
    & k# |* g5 b. A8 y9 ?
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    1 _! ^/ {$ _$ p
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    : g9 I$ b2 h) X' o4 F6 w
19. SystemClock_Config();
    9 l6 p, y* \: O# r; z! k
20. 
    ; l7 y" N, ?" ]9 Q' }
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    4 w: G6 `. F! i" e, G' Y

复制代码

) M4 a( A& D2 T1 e0 j& v0 r  检测到RXNE标志唤醒，即接收到数据。
低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。

( E8 R; Q- A, r如果想唤醒H7，发一个任意数据即可。
7 O, S/ p" W. v7 h1 @4 B1 @
& s- A! X% |) W* b% q9 z& G3 t

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   7 s+ \; h8 g( o
3. 
   5 R' c8 x" ]' d( ^
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   % F* A- A) m/ ]0 A# E
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   
8. /* 接收到数据唤醒，即RXNE标志置位 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   4 ]& t9 n* ?' J; u3 E
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    
14. 
    * `! c8 n8 ]3 z7 {
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    8 C9 j% z: j# ~7 e: L% d. H
17. 
    0 k8 U& C9 R6 h3 \1 `9 f
18. /* 退出停机模式要重新配置HSE和PLL*/
    , p$ Q7 ^9 r6 K. |
19. SystemClock_Config();
    ' V* z0 n# h. d; W
20. 
    - x! P1 E7 ~- c; B
21. /* 关闭LPUART的停机唤醒 */
    - ?$ s7 {8 M% F4 M: N2 Y9 T% N
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    0 k  F. V( E4 T
23. 
    8 J$ ^) L  T1 M/ r6 T- a7 r) F% I5 I

复制代码

  检测到匹配地址时唤醒。
& y# `1 A9 g: t& B9 J低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。

6 L. E0 Y$ O, b/ C0 u- X# l如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
3 k9 L# Q6 j0 e* y- K

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
     L4 w6 ?6 ^! U& p5 f: A  w! k
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   + m. h. i" ?$ c7 h
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   - G' }7 `( ]* Z( |8 C& x
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   9 A% n2 [1 W/ {2 N( a! }
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    $ V5 d2 U+ F3 U( H3 h! u0 Y
11. WakeUpSelection.Address       = 0x19;
    
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    1 T4 w: i; m% ?4 }
13. {
    2 t: Y' F* j1 v! f, O
14.     Error_Handler(__FILE__, __LINE__);                        
    1 d) `1 }, G* h5 ?$ t8 t% r
15. }
    
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    
18. 
    
19. /* 进入停机模式 */
    
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    - Q" b; O! ?9 ~9 o/ }* n2 ?# B; P8 \' z
21. 
    7 R$ B4 H- r9 r
22. /* 退出停机模式要重新配置HSE和PLL*/
    
23. SystemClock_Config();
    ( e$ E. C0 q1 h( F" f1 k
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    
26. 
    
27. /* 关闭LPUART的停机唤醒 */
    # M  g) g. }; ?. I% `! W
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    & W% g! f4 V; ?2 p+ S
29. 
    7 X) j/ c& N1 O1 v  c" R' X+ X

复制代码

4 x4 H/ q5 l" Z这里有一点要特别注意，程序启动后，调用下面两个函数：
6 e9 X' Q5 {! m
! ]5 g7 d" T5 d1 z- w

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供用户调用：

' _; B! B" F* T% c' R  bsp_InitLPUart
  lpcomSendBuf
  lpcomSendChar
! e  K6 h& l7 o# b0 n& ^  lpcomGetChar
66.4.1 函数bsp_InitLPUart
函数原型：
7 Z, E: M7 Q/ }) j/ y, w
void bsp_InitLPUart(void)
0 D  A" \9 U* r* e, s" o
函数描述：
! c4 r- q0 Q2 U7 L) ^4 O9 ~: W- D
此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
" v5 N. @2 U  p7 E6 _
使用举例：
# `  b$ ^4 I! @/ u
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
" B' r1 I" R4 P  L
+ c0 C$ S/ p" Y' u+ e66.4.2 函数lpcomSendBuf
0 a. B% f! h, F7 p函数原型：

! E' K/ ]; A! Mvoid lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
5 m; z+ C/ S* n- g% r  U* S8 U
" g6 G7 z9 y/ J/ \; ]: j4 M! ?函数描述：
# ^( A4 E" o6 L% W4 A
6 |; D9 I, s: j9 A, p6 p0 o: W6 O: V此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：

  第1个参数_ucPort是端口号。
% G; y' `! E4 \( q) P- q+ g  第2个参数_ucaBuf是待发送的数据缓冲区地址。
4 _: n9 ]( f5 h/ }  第3个参数_usLen是要发送数据的字节数。
. _# w# N' F( a注意事项：

& ]& [' C+ g; U& K: i/ k. _ 此函数的解读在本章66.3.5小节。
# o% r+ L: O- j$ m& m, l. J  s 发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
使用举例：

调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

3 J" `8 |( [3 p# S& t. S

1. const char buf1[] = "接收到串口命令1\r\n";
   3 h0 v  ]2 K- R/ Y, X/ a3 U
2. lpcomSendBuf(LPCOM1, (uint8_t *)buf1, strlen(buf1));

复制代码

66.4.3 函数lpcomSendChar
2 |' s+ ]3 E7 y" ^函数原型：
: L, }- F/ A$ m# a9 W- [5 L
  D# s! }# f- Vvoid lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
( I6 R$ p# {0 D/ B! d$ m3 d
4 T9 b# @( c* Q% K8 f* m7 Q函数描述：

" R4 x5 r0 P& D' F, t此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。

- {7 z, c. {7 M9 f+ w# f9 }函数参数：
  第1个参数_ucPort是端口号。
" s& K5 h6 n0 X8 ]) `" {  第2个参数_ucByte是待发送的数据。
注意事项：
4 \! J, Q+ G3 \: G2 N* X+ [
  Q( ?7 W3 |9 ]  此函数的解读在本章66.3.2小节。
$ ?$ w* B0 h) n使用举例：

. }6 e% I" I( B* N6 j调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：

lpcomSendChar(LPCOM1, 'c')。
; V: I& p7 t% E2 S
66.4.4 函数lpcomGetChar
函数原型：
( S+ u* @! M$ R
% K) n' m: T) J# D% e* xuint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)

函数描述：
. x" t/ O& H/ S4 r4 v1 b
4 \' ^6 c) W/ N0 V: K6 P此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

6 x; t4 z* D. a* R4 j; y8 H函数参数：

; r% h; U- u+ \4 Y  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
6 P% |' f4 A' w, G" U5 p注意事项：
2 i/ S. v  N4 \- v. W2 \4 @
  此函数的解读在本章66.3.6小节。
! e( o+ I8 P$ P- S. g2 Y, m使用举例：
) K; X1 E5 b- X
调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

% V2 J3 @) |8 x: C7 }9 R( _, N' Y/ V比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。

6 |: x5 b3 Y) t3 J66.5 低功耗串口FIFO驱动移植和使用
串口FIFO移植步骤如下：
% m0 C0 D3 d2 d* P( \+ ^6 q2 y
  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
$ f$ z( F2 U$ c! S( t+ c  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
4 I! {, _& I0 F8 C3 R4 q. t

1. #define    LPUART1_FIFO_EN    1
   
2. 
   # a0 d1 R' B1 B
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
4. #if LPUART1_FIFO_EN == 1
   
5.     #define LPUART1_BAUD         115200
   
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   9 k. m3 k* k2 ^8 @1 Q; e7 F. c% C
8. #endif

复制代码

: \9 i  t# U) X9 R6 M3 r  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
; I3 s6 l& E2 e- O3 s( Q; f" n) h! v  第4步，应用方法看本章节配套例子即可。
+ [5 L, \4 |4 Z: D66.6 实验例程设计框架
* v0 z$ c  ?) v4 \9 }通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

4 `, N% K3 |2 z: S7 ^) W9 J
4 k' F6 c3 G& z6 V# Q; `  第1阶段，上电启动阶段：
/ Y) W! z* l) _* |' k9 y9 q
! b7 }7 l/ A7 f+ w/ s; @, k这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
- F* z# ~1 m2 Q5 j- l2 L
  [/ R8 E) K) s& F8 Z, H% I9 C第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
第2部分，应用程序设计部分，实现了三种停机唤醒方法。
66.7 实验例程说明（MDK）
/ S. r8 t% h, f3 _3 B- V/ `" q) t: I配套例子：
) k* ]9 B4 T% c/ K
2 E+ W0 g1 r1 _7 Q7 QV7-046_低功耗串口的停机唤醒（串口FIFO方式）
- g- ~- `& Q2 j! n  K0 Q
实验目的：
% J, q7 x- x% c/ u* ?6 u6 \
学习低功耗串口的停机唤醒。
: Q; u; z* w% q) C9 N" z& G实验内容：
/ L$ ]: x5 G7 G2 }  n- H% Q( U1 i3 D8 g
启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
4 F/ {7 m7 {1 H+ K+ L: K+ u( [; |LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
+ \9 B# U: w/ h! ], M# ILPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

. _6 K+ U5 N1 n& U5 L+ q7 Y4 s2 j& m. OLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。

LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：

" Y& n& i, e$ P2 M& D8 L0 UK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
7 q/ B4 o0 {% v& K; U5 O* c上电后串口打印的信息：
2 E" e2 ]7 Z& g3 r
, |. u! E. K; Y% Q" V波特率 115200，数据位 8，奇偶校验位无，停止位 1。
& U. g9 s; i  `$ N* w. s& I

0 D: k% R0 H& u" d4 H: C
, |( q: p7 b/ q, u; K程序设计：

  系统栈大小分配：
# `% Y' e0 s, c5 A

6 t1 q, v  J; U8 S7 ^# T
$ u/ l! h3 j# H! L' c  RAM空间用的DTCM：

, a* P$ d0 d4 a- l' P: ~  硬件外设初始化
8 \2 g- W) k7 B$ M8 @+ E8 J
硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   ) t( q. Z7 N1 N+ ^& E
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   & \$ Y4 M5 \0 H6 n: d& w
7. *********************************************************************************************************
   
8. */
   6 [# s2 [6 ~4 }
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    ( B- R2 K6 J/ G. v4 O
12.     MPU_Config();
    , a3 w2 K1 ^$ ]) j
13. 
    ( c: S3 T" P) n7 z9 u7 C- Y
14.     /* 使能L1 Cache */
    3 N5 d* y1 J! z7 M5 A' Z
15.     CPU_CACHE_Enable();
    7 ?4 V8 t# ?$ w  u; }) l# O$ o
16. 
    
17.     /*
    5 `& h+ N6 J  O9 @% a/ Z. A0 B2 Z
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    8 f3 i  b( |. b: l& Z
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    8 w4 O* h% |( q
26.        - 切换使用HSE。
    ) W) ~. r  q$ T
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    8 o2 B  j) J) A8 G
30. 
    5 I+ {  n* H( x3 q" [
31.     /*
    ( q- m- g/ f- ?/ d9 R8 r  ^- w0 l; E
32.        Event Recorder：
    5 m- z5 v; m9 @1 Y! ]8 p
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    ( r; W$ _$ T" S) q; I+ N6 H' c
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    9 ^, Y; x7 z7 G7 h* B
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    5 f% ?% E. l' ~  B. i- z0 j
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    0 q9 t3 x7 H, K
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    3 v% a7 J# p0 c
49. }
    4 |' B# y: H2 H) P& T  l

复制代码

3 U8 ~% E7 U- a) z# a, T6 A) r7 U
6 z! Q0 C. j$ c/ D4 C- G  MPU配置和Cache配置：
, I% D# Z7 g: r  G' P5 b* Q
. q0 L+ f: }! U数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   * t5 N2 T7 V/ F+ `
2. *********************************************************************************************************
   1 k* @5 ~& J9 {* l8 _0 v
3. *    函 数 名: MPU_Config
   / }- D% G7 I' k+ w( H
4. *    功能说明: 配置MPU
   , v5 ~* ~) @# ~
5. *    形    参: 无
   % H. T6 K9 {  }. ?- l
6. *    返 回 值: 无
   " g9 c) _, ~7 h
7. *********************************************************************************************************
   
8. */
   ! Q8 @- ~3 n+ `0 J& {
9. static void MPU_Config( void )
   
10. {
    7 h) H8 {0 }8 @
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 x; S* |  q9 @2 S0 {( `; z
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + `: m& y( P. [- |: ?7 Q/ b2 l
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    8 t. e( j8 P& q9 W; R6 G  J
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    " W- e; F* V* @1 ?" S. H  c
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    8 r' M% I! V  M
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    8 G1 J- w# R- Q) r! _
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    $ j9 ?. }  V: ?2 d  p
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    . I% j7 B0 C8 x$ B
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 Q0 N* ^& J/ u" `4 I0 p6 s
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
      _* T6 c! P9 g* l; d
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    5 U0 U* q' h9 ~) [
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ' |! {% T; Q; v( v' v
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    & L9 r( K, N* w: h  M/ r. R  `
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    7 H% v% E8 v: A
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    7 R  }/ }: g# L% Q" z. ^6 y" w
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    . R. R8 T9 h$ f- T
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    . g9 W+ R9 D4 k5 F/ l
46. 
      \( }( I9 V- `$ ~
47.     /*使能 MPU */
    , x' O2 H9 C5 b$ z7 P
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    8 k8 k" V( ^/ i& Y) m3 R
49. }
    + G* r2 O4 [6 S
50. 
    9 a2 Y0 D0 `1 [
51. /*
    
52. *********************************************************************************************************
    0 l4 M2 P# c; z' P3 K6 U' l6 C6 Z
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    " P# ~' `1 h$ A) W6 ?( a
55. *    形    参: 无
    $ O: R& J3 l- V5 |( L/ C- \. f
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    % Q. b& r  H: U
60. {
    ( k9 F2 _, s" T/ F/ @. W
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
( [& a0 }6 |7 \$ K% V1 i8 j
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
- b) u7 ~0 f% j
' K; m: D# A+ S# ?1 U

1. /*
   + b) s1 }. {1 s& b& o
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
     R% g. v+ R, {4 A6 u
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   1 {6 w0 ]9 Q2 N$ W7 R6 c( q
6. *    形    参: 无
   
7. *    返 回 值: 无
   + ]; i* i# S( c  [3 ]3 d4 I; b5 i' v: B* v
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    $ n9 S* I9 a4 N
12.     bsp_KeyScan10ms();
    6 h6 }0 l5 P0 ~5 s
13. }
    5 {- w4 l* z8 {' C% C5 |

复制代码

  主功能：

" \% l- F/ y8 H0 h8 B5 Z主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
7 _- O0 m4 o0 W, Z2 K) e8 SK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
+ `  _" [0 N5 p+ ]( h8 h! u4 }" I( ZK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   4 F, ~) U! R# V8 v
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   + s! g  Q# X) g) O2 e7 h9 ]) a) M
5. *    形    参: 无
   / _% e; `# H) v, S8 j: k
6. *    返 回 值: 错误代码(无需处理)
   $ x  t/ b8 X* N* V
7. *********************************************************************************************************
   
8. */
   3 H: }6 w0 u+ c. L3 E2 f& S; [
9. int main(void)
   # I. E+ g: n6 A/ v! w$ ], A8 L4 k
10. {
    + q: N9 B* F+ m6 i* o
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    
13. 
    
14. 
    7 x' Y% l7 k# y; H4 |6 `# J
15.     bsp_Init();        /* 硬件初始化 */
    ) {- H- P! O1 e& u+ N
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    * M) A2 P0 r3 s5 e: J2 u5 k
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    & U. G3 f2 r9 C5 T4 h
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    & R7 F8 K1 w1 m# O; v# f# N
23. 
    
24. 
      o0 |# {4 ~5 f% L
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    6 }1 {; w4 X- Q. f  D' M" f
26. 
    
27.     while (1)
    
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    4 \- ^" [$ l' N3 D# b$ ^( x
30. 
      p8 |0 T2 p$ K, h: W0 f& I7 s
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    
36.         }
    
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    . A* a4 d1 ^# P
41.         {
    
42.             switch (ucKeyCode)
    
43.             {
    ) @# f# k; P+ c
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    1 h' j+ I* V$ I( Y
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    ' x; C6 [6 F3 d7 s  R
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    . d0 _3 c8 q  c) V+ |
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    2 U& y$ i. t" W7 l/ e  l
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    : {4 x; `4 G# y3 j2 ^
51. 
    2 m% r3 [# s! M" j; f6 s, }
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    ; c: k# s3 C# f. g/ J
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    
58. 
    
59.                     /* 进入停机模式 */
    8 j# @6 K7 x+ c# w9 B$ A, v
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    7 |' y6 L' g) \7 \2 |' J7 u$ y
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    $ p: @# Q# A/ N, s5 {( `
64. 
    " `5 W( Y2 w& O9 S+ p' A$ y
65.                     /* 关闭LPUART的停机唤醒 */
    8 A' j$ Z, i# a" x% U
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    5 X& g# m8 z) x% S8 A5 l
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    : I! [- b4 V# ?7 k
69. 
    - \  E& Q6 O  ^$ b! E" W% J
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    # \. @! `5 ~! r* L! Y3 u# {
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    % b$ o! j1 }! Y' }
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    8 i' k( n4 R# N3 L
81.                     /* 接收起始位唤醒 */
    3 Y4 A: ?9 N% F+ Y) \
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
      x0 w" s# O1 a, e( e! M3 f' C
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    
86.                     }
    " _) P; y8 X& `  _9 t: y
87. 
    
88.                     /* 进入停机模式 */
    ( I3 m& b6 B# u/ `
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    0 f- i8 ?7 r- \. V, ]3 j* F
90. 
    ) @9 `. i/ f: E% I
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
96. 
    
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    2 [7 u+ e- A2 L2 G- ^1 M0 g4 c; i
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    ! L, A3 b5 R* \3 M
100.                     break;
     
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     . {+ P8 l( S. v/ f4 r
103.                     /* 使能LPUART的停机唤醒 */
     
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     5 L; ^; S- H1 }, H( Y
106.                     /* 确保LPUART没有在通信中 */
       B1 o$ U$ b5 F* _  A0 L3 f' d
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     4 [$ X7 V" b% N: X; y" s" |4 J
109. 
     1 r1 h1 M, z2 k4 [
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     - m. L8 c; E8 F4 N* `
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     ; o9 N* n! t1 f0 }) ^2 N. t
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     
115.                     {
     9 k( V9 `0 V" {$ }- V7 j
116.                         Error_Handler(__FILE__, __LINE__);                        
     2 |! Y" ~% z6 K2 n
117.                     }
     
118. 
     ; k/ o' B8 Y& U# d7 u0 q! s2 O
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     / S. [# T! A( k% y' w( R; g
123. 
     0 j8 T# ^6 o( f( ^6 w3 i3 l
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     
126. 
     $ ?5 t8 Y' L8 E* h4 E' ?- a$ j( W
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     ! L  C# e: x  |: s0 b# w
128. 
     2 Q2 @  r6 f9 Q1 g+ w
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     
132.                     break;
     # k8 ]5 |& _6 `
133. 
     & z9 y( ~  a5 v! K8 o/ H5 z, P
134.                 default:
     
135.                     /* 其它的键值不处理 */
     
136.                     break;
     
137.             }
     
138.         }
     , l) _* ^) C; @/ Y; O5 @8 ]
139.     }
     0 j2 X1 W9 w$ e4 i, W
140. }

复制代码

9 ?* T& [5 K( O
66.8 实验例程说明（IAR）
配套例子：

6 \  u; W6 E2 O) I) \. |+ q" HV7-046_低功耗串口的停机唤醒（串口FIFO方式）
6 f- e2 q6 ~6 ^- z: c) e
实验目的：
, D' r0 Z2 w, X" G7 O5 @
4 y6 n+ v6 z) C- r4 i$ b7 m% R! Z; k学习低功耗串口的停机唤醒。
实验内容：
- R0 S, B3 V7 b( C; D' g
8 d6 i( R; U. ]" O9 ^7 V3 o( b2 K% x& C启动一个自动重装软件定时器，每100ms翻转一次LED2。
& N6 z1 B# d7 V5 q0 T2 s当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
% t# K; b; @0 t1 R* U; `# o, EUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
) L) Y4 Z+ n* \* kLPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
  E7 W9 M: l$ ~8 Y, Q
* A' y$ D0 k6 p8 R0 B" ^& j) r# p5 ALPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
$ b7 I4 `, @5 d7 N
LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。
& b6 n# O* Q0 k0 \$ j# S
; @; q! y0 T  q5 o/ v+ M$ N+ o  K实验操作：
1 m7 y3 [- a" c" h  k( r
' ~  h+ G2 w2 _7 P' sK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
2 w# |# x4 j2 a" G; BK2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
7 r, G+ {7 e  @# N! AK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
- z% w6 j0 v' `: J! F* B上电后串口打印的信息：
( v( d* V* w( E0 Q0 T5 Z0 _5 P
) Z& `4 k* C# ?% h# Z3 l' @波特率 115200，数据位 8，奇偶校验位无，停止位 1
- g, r4 Q: l3 R: ~
, X& \+ M! p& I! f5 a5 c

# u' f* G" `- j# w3 |$ G
( n" z" x5 v. c: E/ V( ]程序设计：

+ e1 t& N5 C4 F; d; n, w  系统栈大小分配：

  RAM空间用的DTCM：
) ^; q& z0 g/ X
. J1 S* D8 C  ?3 ^0 q  D6 S

2 W# w9 c/ E6 D" ~  硬件外设初始化
9 f9 K7 u% X9 N3 f* X/ N. u8 N
  F2 r, I. i& k# U' t9 t4 W% i硬件外设的初始化是在 bsp.c 文件实现：
6 a! W8 o  m- @2 ]: [5 I
0 ^1 k8 `3 y& g! b  |! y

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   ! h" N( w9 k  d4 U5 B* L+ F' Q+ R1 ~
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   0 f/ V( R* f- n" s, y( A
5. *    形    参：无
   2 Z: Y8 ], ?8 V
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   7 A* b. b4 P/ T# F3 r
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    6 a7 |" N9 E7 c0 A) s% \1 v4 f) I0 i- }
12.     MPU_Config();
    
13. 
      a" K6 f0 m- e
14.     /* 使能L1 Cache */
    / ~9 H# P# I7 f' B1 D: t! j
15.     CPU_CACHE_Enable();
    5 `; `, y- v3 J0 [5 [# H+ h6 O
16. 
    : S3 C6 o6 l6 Q! O
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    3 R0 N3 S( V, L7 a5 a( O2 b1 G
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    $ I* Y2 m& l5 U# ]. U: A
22.     HAL_Init();
    
23. 
    
24.     /*
    5 [. u9 a  r; \9 I: b9 r/ d
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    . l8 U: w* b2 K) D3 B9 g5 X
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    6 e7 N# m! w" J
28.     */
    
29.     SystemClock_Config();
    
30. 
    : u/ B- k! S3 ]' V+ |
31.     /*
    & M/ d2 B# n. |- B
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    4 V; g0 R; e5 u( S6 R
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    + K; W! i( o  X9 z* x: z8 E
37.     /* 初始化EventRecorder并开启 */
    ( @0 F  l: ^3 T  V0 Y  B6 m- v3 X$ V
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    2 w. M  |& f. |0 ~
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    $ t3 f" v% z! l, M
45.     bsp_InitLPUart();    /* 初始化串口 */
    9 @, r) O2 H: i$ n3 z
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    3 Y7 v2 }$ o7 P' J5 a, ~( @
49. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
7 D6 ?" y; g. i' V) _, _, E
' Q/ ]7 z# T( m: O! @

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   + Z8 x. d( o! l" K1 o# U
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   8 b6 S7 ~5 ?9 s7 d
7. *********************************************************************************************************
   
8. */
   4 [! [' w8 q7 o" o
9. static void MPU_Config( void )
   ! E, T# @% Z* g( m9 {
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    4 T1 S  c. G8 c
13.     /* 禁止 MPU */
    3 M% W9 g6 e- S: E8 k" q6 W
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    , @0 w2 N3 r# y( O: F. E. X
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    % [8 Q8 F; z: e* E% {1 K8 C
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    . n6 n* o; g9 B$ C5 Y+ Q
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    * Y$ d8 a2 }: Q: U8 v9 V& d% |4 B
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    , I& L( |$ }: {5 x% [" J8 f4 c
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    $ |+ ]: ^+ ^! J; ]* g1 y
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    : }9 A" ^( ?- b) g" n0 m
30. 
    ; S5 M# n% m2 g& r
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    / j2 w2 \+ m6 k- Q* D
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ; v7 K# G& R9 j  N2 c
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    * ?4 F  z7 ~$ |+ A6 l% X
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    $ n4 n& p& I( l0 ]6 v  ^
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 f) ]$ Y5 U6 O, E* a: b; Z( e: o
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    , j7 P( Z; K' I6 K1 y9 W) U% N& S9 r
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    " f( y1 c+ X( d2 Q
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    . o+ g! w, h7 u/ u
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    3 W. A2 ^- w' |# u* J
44. 
    : Z% U' y1 r; l; V
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # P9 n0 M; K' O/ C4 k
46. 
    8 G! ?6 g  E0 ?) s9 V2 K7 V
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    , X9 ~( V. W& X
49. }
    
50. 
    1 c. w, z0 Z( }2 y
51. /*
    ' d- E% @& }1 K3 s
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    9 P& r$ Z8 E' c7 [: z% ~& x# v
54. *    功能说明: 使能L1 Cache
    % g- B8 b# U" l$ M5 X3 [
55. *    形    参: 无
    
56. *    返 回 值: 无
    4 t% ^- P: l& i# @
57. *********************************************************************************************************
    ' N# M' M6 d6 I0 E  H
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    & a  t! I1 Q: x; J6 n2 a; k- O
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    9 V$ N& `; J) ~4 S
66. }
    
67. 
    4 d& c1 f) S! P3 j0 z

复制代码

: L) E! c+ X& B9 E% z0 m2 y  每10ms调用一次蜂鸣器处理：
/ a: W" A& E  ^9 d' Y: s2 }
9 o  C1 a: S' T& r8 G# a蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
* p' R4 I+ @; {% E; c
! V! m3 c8 f+ e2 H4 O. f

1. /*
   % h3 V' u  h" t9 I( Z! V
2. *********************************************************************************************************
   - e! k+ E; O3 H$ z% N, U' f
3. *    函 数 名: bsp_RunPer10ms
   ( Z; B7 F; x, |8 e2 }
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   4 K4 o" y$ d) Q% D1 B# \
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   : c8 R' x. u( j1 Y7 {
8. *********************************************************************************************************
   5 `+ j2 s, Q) L
9. */
   # @: |8 P2 h5 e8 r
10. void bsp_RunPer10ms(void)
    
11. {
    , \" _' e/ K9 g
12.     bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：
5 H' W7 r  f$ ]6 I5 a
主程序实现如下操作：
$ M2 }: X8 n, y1 w9 ^
' K6 o+ O( e5 y9 f/ [ 启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
# M" I4 F) |7 U( @& D6 K K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
3 e# J; h% _1 j. V  L, H

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   5 J* d, J0 |' s/ A* D
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   ! m* R: r. @" R' I" Q0 ~' G
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ! O/ b0 |; f; t& k9 p3 A6 P
12.     uint8_t ucReceive;
    
13. 
    
14. 
    3 D) `1 `. \! W' s
15.     bsp_Init();        /* 硬件初始化 */
    : H) ?% g. p  s
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    " ^* M! b3 H+ O" Q
17.     PrintfHelp();    /* 打印操作提示 */
    8 C5 p9 |$ {( N: T3 n
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    3 N6 j4 u( }0 a6 b
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    8 L: j$ P: G6 I+ I" y5 f- ]
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    5 [' F! O4 q% P7 \
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    ( y4 j0 K+ {& _1 q
23. 
    : A& p- L1 M2 n# K
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
      e# f' V! H5 [) ~
26. 
    4 I2 a: j1 i% y8 u2 m3 V
27.     while (1)
    
28.     {
    / ]+ M" B5 A( l0 m
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    
31.         /* 判断定时器超时时间 */
    ( m4 u" J; u& d
32.         if (bsp_CheckTimer(0))   
    
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    * n0 Q- O8 O9 M1 a; h" V
35.             bsp_LedToggle(2);
    
36.         }
    
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    
43.             {
    5 ]5 _/ Z$ u2 F" B( z, T6 Z) x- Z3 ~
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    ) _( [8 \7 T) A& Z
45.                     /* 使能LPUART的停机唤醒 */
    : T+ Z5 O, w) e4 W
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    8 A6 o4 ]; ~$ I. ?! ]1 \8 Q5 _) |
47. 
    ; [. Y- |( r+ G$ E1 N
48.                     /* 确保LPUART没有在通信中 */
    ! q( R" X' i! \  c+ W9 [
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
51. 
    * N0 F. `# x7 }2 K
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    4 q$ o, t. F8 W, r# |6 n
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    5 Z# o' `. X) g( ?+ P& |
58. 
    
59.                     /* 进入停机模式 */
    5 u6 W! [' \3 [. ]5 O# B6 P
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    & K7 q: \; L8 s# E6 ^
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    . p6 m$ N6 b  C  _
63.                     SystemClock_Config();
    0 L( I% k5 n- U* F& P
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    + Y7 T$ `/ J$ j( S$ m  C
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    / D9 ~5 v/ k) P
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    : ]8 k  R* s$ {7 Y/ B5 M8 H5 P
71.                     break;
    
72. 
    4 e3 x( }2 Q2 w& N8 X: ~8 s& L: B
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    $ j  ]" J% _% E7 G
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    % i9 |, t& x% t4 T, @
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    6 ]  f" _: X* ^' j% [) n
80. 
    - L6 t! P% p& [" R
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    . E6 {: v3 D$ Z9 S3 \' `* M
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    . J: C* Q) T2 Z; M1 S' t- D
85.                         Error_Handler(__FILE__, __LINE__);                        
    3 E# z, Q& `3 j$ S
86.                     }
    
87. 
    ; ~: |$ U' b, v8 {+ G8 z
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    9 S4 |1 a' i5 e
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    
93. 
    $ [: \* J5 R6 F" a" \3 {
94.                     /* 关闭LPUART的停机唤醒 */
    5 h$ R. I7 s! y- r$ l
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    # E6 V) q$ l+ y  R9 y% h
96. 
    
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    9 i( |) G; b& [" \- Z
98. 
    2 x' ~  a- ~& a2 Y6 C  H' o2 M
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     ' w# [9 ?2 \: S3 L. y
105. 
     / V$ P0 J, z2 W1 K$ v1 X
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     " i; `$ h/ L' n. `
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     " ~' `6 _$ U4 r" v: m
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     $ p) h; y1 l1 x  h4 J9 l
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     ) s) ]7 V* e, I) E& {+ s- Z
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     0 [# k4 n; k7 n$ Q( {
117.                     }
     # K9 ?5 o8 I( ^8 [- @* H6 G  B3 Z7 j0 ~
118. 
     
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     
121.                     /* 进入停机模式 */
     9 h1 H2 s/ R! b/ F; f4 t8 B5 t$ ~
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     0 e: {3 t, `( X. o$ A
123. 
     * n- z* E/ c( j: O0 }. @- O
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     7 v5 N. H  \$ _, S4 e* G$ d
126. 
     ( P! }# A! C1 y4 o
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     2 T, r$ |' s9 g: w$ s3 |; _
128. 
     * T6 d3 H- g& S4 j
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     ) J" s+ L6 u! _
132.                     break;
     
133. 
     * C$ m  Z! P% |  U7 d' n9 F
134.                 default:
     3 ~# Z% o/ I8 b( N9 s7 H
135.                     /* 其它的键值不处理 */
     # x: h( S2 [- T& y* y% V' L+ }
136.                     break;
     
137.             }
     * m+ J; f9 S# W" c0 Y- k
138.         }
     
139.     }
     0 u2 z$ v2 e' e& f
140. }
     $ m. p3 y  T$ m9 x* e$ A; N: {3 m

复制代码

2 P; H8 U, p; c/ q$ L$ ~
66.9 总结
本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。

% R4 X& S( y8 V" M1 [

  p; h+ r1 \( D$ C$ ]