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

) R4 @% l9 A, b  f& O' i4 H, a. I低功耗串口LPUART TX = PA9，   RX = PA10
  G* u, p; ^& O9 C: }
4 q+ v: D5 n% X/ H串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）
, ^% k7 y: j9 W. C' r) G+ Y0 G
串口USART2  TX = PA2，   RX = PA3

串口USART3  TX = PB10，  RX = PB11

* ?: s' O! \- S串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
% b" z' O2 A, O& O7 C( S) R$ S. J
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
) q/ X& f2 G% a* j3 r  D' R7 X. O8 V
( }  Z$ j$ y) v" B6 D; c6 m串口USART6  TX = PG14，  RX = PC7  
4 U1 L; f! j6 \) x3 b& R6 s( o
. a& n( N+ i+ u3 f串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
) b. q$ E1 Q  e# @
串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

STM32-V7开发板使用了4个串口设备。

8 U  p2 e# u: {* h. n' P0 U9 f  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
  串口3用于RS485接口
  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
& W+ y  J  L. Z) ?/ V5 ~/ D

. ~* p' I, c" ]) G4 T  A
/ m( d8 o- i' a% p' ]+ E关于232的PHY芯片SP3232E要注意以下几个问题：

  SP3232E的作用是TTL电平转RS232电平。
  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
3 N4 b, a* f4 z; ]% C  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
) ^* p9 G4 {4 ?  T( Y* o4 F: ?
# y8 H0 K9 V" X

实际效果如下：
% Q, k3 N1 ^- N- _& B+ E) m
) o8 f, L: B' }$ W: r! ?9 u8 M

( G+ [. n1 w) T/ E# [. j# O& d3 T
, j* h$ E& b3 @7 l. O- |3 a  c( I通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY
! `; Q' W5 U( E2 V; c- d
芯片是否有问题。
. J( U$ c$ ]) Z9 B
% d! s0 O8 S4 ]4 H  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
! v1 `# k0 p/ n, W1 w8 w% x  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
4 H( _- ]( G8 C66.3 低功耗串口FIFO驱动设计
66.3.1 低功耗串口FIFO框架
5 D" ]' Y; U+ _& i' Z为了方便大家理解，先来看下低功耗串口FIFO的实现框图：

  第1阶段，初始化：

通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
- ?8 r8 |) H+ R9 ~  y& u2 N  第2阶段，低功耗串口中断服务程序：
% o% h& I8 X! ~# U( }; E6 j) P  o! [
# o, p9 n6 j( ?; S0 d& ?, v  接收中断是一直开启的。
  做了发送空中断和发送完成中断的消息处理。
  第3阶段，低功耗串口数据的收发：
$ ^" X( k* o' q, s& n4 b9 o! D9 z
低功耗串口发送函数会开启发送空中断。
低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
66.3.2 低功耗串口时钟选择
9 d. Q$ ]/ q! L! \( g$ x( I& ]* l我们这里实现了三种时钟选择：

LPUART时钟选择LSE(32768Hz)
5 e4 `: [" M- W3 k" \& ^最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。

2 Z* O  _% l- m4 @+ dLPUART时钟选择HSI(64MHz)
最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。

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

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

1. //#define LPUART_CLOCK_SOURCE_LSE      
   5 G& o$ L% r( I( d+ j  b  [
2. #define LPUART_CLOCK_SOURCE_HSI   
   ( Q2 V# ]6 A1 t; j! Z3 h% T8 v
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   
4. 
   + X4 G. [+ N, \, L7 J3 l( e& X
5. /*
   
6. *********************************************************************************************************
   - n' B6 O2 v' k7 z# z
7. *    函 数 名: InitHardLPUart
   
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   
9. *    形    参: 无
   
10. *    返 回 值: 无
    5 }: i' o0 @+ y
11. *********************************************************************************************************
    
12. */
    
13. static void InitHardLPUart(void)
    8 d+ y: K" i; }
14. {
    $ b7 ^5 {# B2 f2 k) K- `. y# e
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    * d1 N. U, j5 a, k7 J/ s0 Q* \
17. 
    / Q0 J8 v- h6 i* V
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    
20.     {
    
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    / ^  ^- K9 h4 f- s/ \+ A/ q% T8 f
22. 
    
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    + F) S5 @' r  s+ l
26. 
    
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    - u$ n" I' R7 Z) t  u
28.         {
    
29.             Error_Handler(__FILE__, __LINE__);        
    
30.         }
    
31. 
    + u6 C: G" a  ]: u: A2 c
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    3 o  L, M" r% [$ g9 ?
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    " y5 y) A# W$ m& Z
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    + ^! Y$ l2 y; ?4 z& j" N5 b
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    ; k8 u; j* ~3 K. O: i4 Y" f
38.     {
    
39. 
    
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    
41. 
    5 v$ W; P. I! J( X+ H
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    " e: t4 J  \# X- _3 h# o8 n% x
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    ' o+ {8 t7 M/ G; t9 E$ Q) t( k
46. 
    $ Q' y: A8 r9 M3 W4 _+ V, h
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    8 z/ Q9 H! L8 b- f2 l
48.         {
    
49.             Error_Handler(__FILE__, __LINE__);        
    + s5 O! P/ L0 f1 g
50.         }
    
51. 
    
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    8 M# F& Y, Q8 z# l
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    , W( f6 h  ^# D
55.     }
    5 E) m. Q4 S/ g% h) O
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    
58. 
    & b9 S- ]) n& R
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    ; Q' _: o9 ~0 k/ h6 D- p& A& b
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
62. #else
    8 A% Q6 r8 H- ?
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    ' u" p7 f# L' @- a
65. 
    
66. #if LPUART1_FIFO_EN ==
    / G( X' F) P# w" q
67.     /* 其它省略未写 */
    & w. ^& v# I" x9 s( p4 g& Q9 |# m
68. #endif
    
69. }

复制代码

66.3.3 低功耗串口FIFO之相关的变量定义
低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。

这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。

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

我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。
+ A1 Y$ S, R5 U& }) A3 R

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   7 D) {! z( H8 @5 o( T% ~& N
2. #if LPUART1_FIFO_EN == 1
   9 i  n6 D7 u+ ?: K2 f4 Y5 ^
3.     #define LPUART1_BAUD         115200
   1 J' A  M  U, N7 V
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
   4 G6 t% l$ l4 e1 s
9. typedef struct
   
10. {
    6 J8 N1 \, j) }9 D# t3 C, r) n  Q
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    ! O: |: z) J; u6 E& [% U0 M
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    2 U1 o6 ~9 u0 ^
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    7 u2 V- i2 Q& o6 a- J( B
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    $ s  F# ]/ W' M: W
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    % x1 z3 }5 M, r! `9 c
19. 
    
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    
23. 
    
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    
27.     uint8_t Sending;            /* 正在发送中 */
    8 T& A# ^* e( q4 x, S2 ^
28. }UART_T;
    ( ^+ f# v2 I: R/ [- @; P& h
29. 
    3 O" d9 e% V( K; r5 q# C
30. 
    
31. bsp_lpuart_fifo.c文件定义变量。
    
32. 
    8 r# Y2 q% Z: \9 T8 q* m2 S& g
33. /* 定义低功耗串口结构体变量 */
    
34. #if LPUART1_FIFO_EN == 1
    ' W0 r8 R* e; I% n; v/ ]: B" k
35.     static LPUART_T g_tLPUart1;
    
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    
38. #endif
    $ M" a8 y# _0 D. n

复制代码

0 Y/ e/ X( @3 z
8 }& p. O; c* |# Y* _; r关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
1 ^- b, y9 o! O: {$ f3 R3 l$ \
: S- U) _6 y6 i5 k( r& l$ h( b0 D66.3.4 低功耗串口FIFO初始化
/ Q6 v! d! a% F低功耗串口的初始化代码如下；

3 H2 u+ y9 ]3 c/*
2 _3 B! z, u/ U7 Y$ z# r*********************************************************************************************************
  d6 h. [" u: A3 R/ d7 e) Z*    函 数 名: bsp_InitLPUart
*    功能说明: 初始化串口硬件，并对全局变量赋初值.
*    形    参: 无
& c* k1 @8 r& i" n7 J*    返 回 值: 无
*********************************************************************************************************
*/
void bsp_InitLPUart(void)
{
" _( Z* ^5 _6 `0 |* X9 X    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
. ]- ]( J' v9 P$ |3 G    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
}
  b+ j3 z3 X1 c9 x

/ F( a% |: E0 i( ^下面将初始化代码实现的功能依次为大家做个说明。

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

2 M& E7 X2 Q: E8 d) {" H; L- |

1. /*
   6 ]3 d" h6 z  |
2. *********************************************************************************************************
   
3. *    函 数 名: LPUartVarInit
   4 G/ p: O. Q; c7 E$ Q" h* a
4. *    功能说明: 初始化串口相关的变量
   ; f7 f9 O$ `) B0 B& L
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void LPUartVarInit(void)
   2 H) y0 u7 h8 c1 ?' G
10. {
    
11. #if LPUART1_FIFO_EN == 1
    
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    - H* `4 u. [  ^" R4 Y/ c
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    # x/ V( Q0 ~1 k, b
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    % Y# l: S. a0 d
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    $ h8 d! U1 b- m
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    ( B2 B* S; }6 m9 _& ]
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    1 \+ m* g6 H! U
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    ! K) n. j/ D* j* M# H  J' Z
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    3 t3 B  t4 h2 y2 e1 O/ S
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    % W' X+ i% D* h' {# ?
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    8 G  q+ h! G& r: u. o
27. #endif
    
28. }

复制代码

% `2 w5 \8 M5 P
1 X6 Y( N7 @: h% o; n# `/ a  函数InitHardLPUart
% `/ [/ a2 C$ I5 }$ T# s' _此函数主要用于串口的GPIO，中断和相关参数的配置。

4 ~2 ?# m/ @5 r- ^  j5 U

1. /* LPUART1的GPIO  PA9, PA10 */
   4 S5 z9 @5 R. j, N" S& s( T7 M
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   
3. 
   " v: [" y9 N+ \% a
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
   
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   : S" n/ J9 _' S7 ~7 N
8. 
   + S" }, U8 \+ B1 [( g( O7 y2 p
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    
13. 
    ; o( e: P) ~! f+ I" }: `
14. /*
    
15. *********************************************************************************************************
    
16. *    函 数 名: InitHardUart
    0 `+ }4 B- K  p& O
17. *    功能说明: 配置串口的硬件参数和底层
    * r( m* x; k# i" o4 z  q
18. *    形    参: 无
    ! |. K9 p7 |6 v& L$ N, ]- }: Q
19. *    返 回 值: 无
    ! l8 }, Q* y* z; s% {5 Y4 ?5 M
20. *********************************************************************************************************
    2 M: t$ e* Z7 l& p( G6 ^3 o2 P
21. */
    
22. static void InitHardUart(void)
    
23. {
    ( `9 r; L, h* O6 t
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    7 H6 f* S' C3 |4 J: t1 T1 e! |4 A
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    5 v; i+ h; I  {: j: a8 T
26. 
    
27.     /* 时钟初始化省略未写 */
    
28. #if LPUART1_FIFO_EN == 1        
    
29.     /* 使能 GPIO TX/RX 时钟 */
    , ~1 Y0 W6 Q1 Q
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    0 g2 t8 q% G  z7 x$ x6 {7 n4 b
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    
32. 
    ( D: I9 J+ Y! U: H- u* B% }
33.     /* 使能 USARTx 时钟 */
    . G: J5 O% R9 L
34.     LPUART1_CLK_ENABLE();   
    2 k- I2 X5 t  G+ ?* J: U2 d
35. 
    
36.     /* 配置TX引脚 */
    
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    & ^2 w6 g' S) z; ?( Q  t
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    2 B8 H; R( J! ?2 K
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    & f6 @* F1 N% {$ i$ ^& Z
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
41.     GPIO_InitStruct.Alternate = LPUART1_TX_AF;
    
42.     HAL_GPIO_Init(LPUART1_TX_GPIO_PORT, &GPIO_InitStruct);   
    
43. 
    
44.     /* 配置RX引脚 */
    
45.     GPIO_InitStruct.Pin = LPUART1_RX_PIN;
    
46.     GPIO_InitStruct.Alternate = LPUART1_RX_AF;
    
47.     HAL_GPIO_Init(LPUART1_RX_GPIO_PORT, &GPIO_InitStruct);
    $ x5 D) Q- x. k; j1 c) o
48. 
    
49.     /* 配置NVIC the NVIC for UART */   
    
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    6 H+ K/ `, r  n/ X; S" T( s- C
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    6 D4 o+ G* X+ D% b$ z  X
52. 
    
53.     /* 配置波特率、奇偶校验 */
    7 B1 c6 D( a7 ^) J+ o9 g- @
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    # A  g8 K! [4 L# |+ G8 }+ [
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    ' ?. C& y% {1 t+ H. O4 j
59. #endif
    
60. }

复制代码

低功耗定时器的参数配置API如下：
  v' G6 u8 [) |& K6 g- H7 I
* i+ V( H+ d& I; N1 s

1. /*
   : Q( Z6 H% h  o+ {
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_SetLPUartParam
   # K6 d2 ~4 R* A  r9 {  l; _7 }# g
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *    形    参: Instance   USART_TypeDef类型结构体
   4 J, `, Q* i, c8 C
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   5 x0 J( h3 ?  ]
8. *             Mode       发送和接收模式使能
   ! B1 t+ }) Z' {* P% f
9. *    返 回 值: 无
   . F) I0 a: v  G5 W% B7 x/ H
10. *********************************************************************************************************
      h; b3 ~- O+ ^
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    9 e3 \- W) _0 Y* _# F
13. {
    
14.     /*##-1- 配置串口硬件参数 ######################################*/
    7 F$ }" p6 T  ?! G! W
15.     /* 异步串口模式 (UART Mode) */
    ' A  q( \, }3 f( I% w0 y! P& A2 Y
16.     /* 配置如下:
    + `, K# E; l0 c5 @) t$ }0 `
17.       - 字长    = 8 位
    ; I8 F4 _- j2 I1 w
18.       - 停止位  = 1 个停止位
    # A$ a4 t8 \* q& [+ H% @
19.       - 校验    = 参数Parity
    * P1 H% G5 c" j5 b
20.       - 波特率  = 参数BaudRate
    
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    9 K: E7 I" |$ t: v( P" `
22. 
    
23.     UartHandle.Instance        = Instance;
    & {0 R1 t/ `7 M9 {0 z7 B
24.     UartHandle.Init.BaudRate   = BaudRate;
    6 u, ?: U* r' x7 {+ @
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    , m  R7 i0 D  x' M$ D
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    2 ]' q% A4 K" s
27.     UartHandle.Init.Parity     = Parity;
    : g; L4 G9 C5 v1 X
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
29.     UartHandle.Init.Mode       = Mode;
    1 x- V4 N6 N6 C. d5 {7 @) B
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    . p7 T* r4 _# K$ k
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
33. 
    
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
35.     {
    ' |$ I5 C1 h. |
36.         Error_Handler(__FILE__, __LINE__);
    
37.     }
    
38. }

复制代码

2 R( z: l- ^4 B% a# z

* {/ ~, C( t" i! U- u4 @& A66.3.5 低功耗串口中断服务程序工作流程
' c% D) x3 Q+ O( U7 j& g4 F串口中断服务程序是最核心的部分，主要实现如下三个功能

- E4 c. F( {- [  收到新的数据后，会将数据压入RX_FIFO。
8 B5 G5 i( V* k" I4 Q4 Y  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
1 E2 T7 f% G' |6 }5 o4 k! p
9 D2 C+ y, [4 z& [6 h5 I
下面我们分析一下串口中断处理的完整过程。

7 `% D; y! v$ D3 |5 ~, k5 M$ l% b当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
7 }. k* Q  D2 ~" D7 q% P
+ u7 b* t; Q) A! Q( {我们将串口中断服务程序放在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)
   
3. {
   * ]% I, [1 P: c7 y) l
4.     LPUartIRQ(&g_tLPUart1);
   * ?) k9 C% s8 a
5. }
   ( p# v( U% r6 D$ B. e
6. #endif

复制代码

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

  S  ~! l5 m+ S

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: UartIRQ
   9 d! O& F) k3 \" z
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   & J  u* J# |7 a8 j/ z  {6 W
5. *    形    参: _pUart : 串口设备
   0 `, o% Z# t3 y6 S+ b& A1 h
6. *    返 回 值: 无
   0 [8 H1 T- ]+ p5 \
7. *********************************************************************************************************
   
8. */
   ' ~  O( `1 R% J' ^
9. static void UartIRQ(UART_T *_pUart)
   0 s7 j8 v3 e) N5 [' ^
10. {
    
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    3 Q/ y8 ?: n* U6 f
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    * X, V4 r. ]0 r
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14. 
    4 N0 ]0 w( X8 n' q+ f, b! ^
15.     /* 处理接收中断  */
    + ?2 Y  g# t. l: o2 ~7 R
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.     {
    
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
      G4 V0 V9 k3 T# C
20. 
    5 C+ n: }$ O: {1 g) Y
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    8 u- s) _) ^% g
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.         {
    
25.             _pUart->usRxWrite = 0;
    , I& f8 h7 n- \+ d% w
26.         }
    * W/ O2 r2 u9 K  m
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.         {
    4 A) o4 S4 m- q* i- S/ _
29.             _pUart->usRxCount++;
    8 w0 u$ D) h- W7 t0 _
30.         }
    
31. 
    $ i9 I3 [( X# U2 A7 E  V9 ^
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.         //if (_pUart->usRxCount == 1)
    2 s: _( K: b% @5 u
35.         {
    6 g+ F" r" C! A$ m
36.             if (_pUart->ReciveNew)
    - h/ q& n; T2 L; ~: ]
37.             {
    
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    ) J: l( B! P8 B: w6 S
39.             }
    6 f1 k% k3 l% _+ f4 U+ b3 w+ G! Q+ W) V
40.         }
    ; t6 m. j. ?* D0 v
41.     }
    , Z7 d; x( U; U( }9 f4 s% G: e
42. 
    
43.     /* 处理发送缓冲区空中断 */
    
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.     {
    ) a8 r5 @6 g# W  ?( j7 W" j
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    1 X4 A9 t$ v- M( u+ F
52. 
    - k" J3 p( d; v0 l, W2 A. c
53.             /* 使能数据发送完毕中断 */
    ) W/ P2 y' i2 l1 L( }
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.         }
    
57.         Else  /*　还有数据等待发送 */
    7 r1 |; P0 ?2 v8 ^- k
58.         {
    
59.             _pUart->Sending = 1;
    
60. 
    
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    5 T( |# b. \" d$ z: e
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    6 g; m$ q1 E+ o% T# U# g, z
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    ( H/ i! m  e. N9 j: c( T
65.             {
    
66.                 _pUart->usTxRead = 0;
    ; O( J9 Q9 s! t% u& f( [+ m
67.             }
    5 \: l+ T4 X9 m1 \
68.             _pUart->usTxCount--;
    
69.         }
    & i+ e; x" {- i: o( x
70. 
    3 d& E/ c& L* d. m  M
71.     }
    
72.     /* 数据bit位全部发送完毕的中断 */
    ) x, u7 I0 m' Y3 \$ a( h( g: Q* j
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    - S6 W+ U: q/ V& ^
74.     {
    
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.         if (_pUart->usTxCount == 0)
    
77.         {
    
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    & z& D( b9 i3 P) f8 k2 P
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    # X( [4 x, J1 u
81. 
    ! T2 n+ h4 W6 p1 \0 f8 j1 D
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.             if (_pUart->SendOver)
    
84.             {
    
85.                 _pUart->SendOver();
    
86.             }
    
87. 
    ' x$ {# P7 K  b1 S+ k
88.             _pUart->Sending = 0;
    
89.         }
    # o! [8 ?0 t. y- t/ X# F1 q
90.         else
    
91.         {
    
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    2 ^% ]9 I5 ?8 I' Q
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    1 A4 C5 p$ t0 i, Q! x
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.             {
    
99.                 _pUart->usTxRead = 0;
    " R3 n+ }0 a1 b0 o) G
100.             }
     
101.             _pUart->usTxCount--;
     ( R6 ]# n8 X' E4 P) Y% b( C1 y
102.         }
     
103.     }
     1 m8 [1 K+ V& D! f) p. e$ @, p
104. 
     ) V) [& n6 Y$ c( w5 o7 |, `8 R% @( Q: E
105.     /* 清除中断标志 */
     
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     - u: c, H3 b! S% F" f
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);
     
110.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     ! N% ?/ L; v- b. t/ _6 K- b7 \9 b
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     ' m& l* U) Z) ~& a$ ^' P
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     3 b& @/ {% ~% o/ z- A
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     2 Y6 }. V6 P7 [9 ]4 |5 T  G
117. }

复制代码

9 a+ G. h* P3 w/ B# c中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
+ U  C. y% J8 r
  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
6 @( Y. D5 u/ `
9 u( j6 |! R4 K% f' H) a特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

+ H! g0 Z- h( P  发送数据处理
, t6 j% |9 H3 p% T- W6 s发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

/ \" G1 ?4 _) T6 Y66.3.6 低功耗串口数据发送
低功耗串口数据的发送主要涉及到下面三个函数：

6 q) _* k* G2 L3 a( y& K

1. /*
   
2. *********************************************************************************************************
   $ s: W5 c$ v, k$ v! P2 B( ~6 C
3. *    函 数 名: lpcomSendBuf
   
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   2 [9 N9 ]; H5 _7 ?
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *              _ucaBuf: 待发送的数据缓冲区
   . h# G9 O9 W& W& ^
7. *              _usLen : 数据长度
   2 B  w. T* N% M5 _6 i( T+ ~0 c
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    9 |0 u7 L$ Z1 l3 U, b3 t! B. }
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    ; i# P0 u5 G/ s, }2 `7 g$ M! m% `# ?
13.     LPUART_T *pUart;
    " c+ Q+ u: e2 _. c3 x( c
14. 
    
15.     pUart = ComToLPUart(_ucPort);
    & z* ^) i6 G) C6 Z! D
16.     if (pUart == 0)
    
17.     {
    3 T6 Y0 E& g5 X, h) P' O" S
18.         return;
    
19.     }
    7 R- ^" E. v6 E$ N8 Y3 F
20. 
    
21.     if (pUart->SendBefor != 0)
    4 J% W6 Q: a" w2 S( B* Q2 h; [
22.     {
    3 u* E! n# h/ a) O
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.     }
    ! F7 D* _+ \/ v9 M
25. 
    
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    
27. }
    $ z$ n' I; Q& j" n0 e$ a
28. 
    
29. /*
    : ~* {) \) q1 ]! @! y. d
30. *********************************************************************************************************
    
31. *    函 数 名: lpcomSendChar
    
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *    形    参: _ucPort: 端口号(LPCOM1)
      ^  f" H, X& e: r% ~) q; }
34. *              _ucByte: 待发送的数据
    ; i, v6 U; p; J
35. *    返 回 值: 无
    
36. *********************************************************************************************************
    + b, _6 R9 d  H# m- h2 p" o: x- Y
37. */
    4 G9 n0 z; N! w2 j; `3 u
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    : v, S5 s7 c4 ^  N: f
39. {
    
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    ) S& j# d% |5 l  ]+ W
41. }
    " @- ^( o. f5 l
42. 
    ; V( V; T- Z& f" t$ m& {% e
43. /*
    
44. *********************************************************************************************************
    ' s4 V& z+ K$ l0 y7 Y
45. *    函 数 名: LPUartSend
    . k/ n  k1 z( J* ?& q- D
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
47. *    形    参: 无
    
48. *    返 回 值: 无
    
49. *********************************************************************************************************
    . r% S6 [, B& z/ f
50. */
    
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    # c. ~  Q( a0 u  n
52. {
    1 W6 V- ^/ l+ c- M' ?8 _0 A
53.     uint16_t i;
    3 N5 W) A7 {% p6 @0 Z- a: ^
54. 
    
55.     for (i = 0; i < _usLen; i++)
    
56.     {
    
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    & E# f1 R  n8 E. i
58.         while (1)
    8 s0 T# e* i3 _' |8 K
59.         {
    ; A! k% r  w0 b$ _6 d8 Y9 ]+ \
60.             __IO uint16_t usCount;
    + M0 I" d- m, h, Q8 N5 T+ L
61. 
    . w; T3 \/ x# ]0 L
62.             DISABLE_INT();
    
63.             usCount = _pUart->usTxCount;
    
64.             ENABLE_INT();
    
65. 
    8 ^0 e) d* n; Y: e; V- H( C
66.             if (usCount < _pUart->usTxBufSize)
    9 o0 \- M" J6 d0 g$ H
67.             {
    % v/ u! b* |8 \; s7 O) x
68.                 break;
    
69.             }
    ; R- \9 s4 G& k* A0 y& \* D8 C. c
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    # r  ?* H. i! \0 N# k1 I
71.             {
    " ?; d) r3 p- G3 K- k) {3 f% N
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
73.                 {
    
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
75.                 }  
    
76.             }
    % v3 ?* M3 F0 k9 Y4 A% ^: i
77.         }
    1 f' K5 \0 ^# ]8 J; G
78. 
    6 ]/ N, M) l0 G: I6 j5 i: D$ b
79.         /* 将新数据填入发送缓冲区 */
    
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    
81. 
    
82.         DISABLE_INT();
    7 m0 Z* d, L$ `
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    7 D1 b- m2 g& c# H
84.         {
    3 j. w- ~7 O# \6 G8 s' ]2 N
85.             _pUart->usTxWrite = 0;
    
86.         }
    
87.         _pUart->usTxCount++;
    2 W9 e7 b" q/ D5 a( }
88.         ENABLE_INT();
    # ~5 T, h, Q8 v, ^
89.     }
    & f, r- _3 B0 A
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    9 p$ _/ x5 |3 g+ `6 {
92. }

复制代码

" j% h; f4 i! R( w3 J/ @: Y函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。

. g  v3 D( I7 n8 a/ }5 c函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
4 U1 j* q- }) ^8 k! o. e  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。

$ H% ^+ x! ?( A3 Z& x- C函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。
4 R# s& U. b2 u4 e
0 o* d: {  ^5 ~2 z

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: ComToLPUart
   
4. *    功能说明: 将COM端口号转换为LPUART指针
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   ' D! E  T( P9 h, f
6. *    返 回 值: uart指针
   6 s, X8 P+ }. h4 E
7. *********************************************************************************************************
   
8. */
   
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   + H  A3 H; l6 k$ `! v7 l; ]# _/ r
10. {
    3 F8 Q* x$ P1 A4 e! z
11.     if (_ucPort == LPCOM1)
    
12.     {
    $ k: H) d3 n1 w  u. M" \5 j8 i
13.         #if LPUART1_FIFO_EN == 1
    
14.             return &g_tLPUart1;
    
15.         #else
    
16.             return 0;
    9 {1 r1 i7 a& @+ c
17.         #endif
    
18.     }
    7 v) s  F8 O; s; I: i5 \  l) |
19.     else
    
20.     {
    ) a, r: v- w8 E5 Q8 r( Z7 l% e: |
21.         Error_Handler(__FILE__, __LINE__);
    
22.         return 0;
    
23.     }
    4 b; j3 x) p; B2 E
24. }

复制代码

5 b0 V; x; P, \: N/ B

66.3.7 低功耗串口数据接收
下面我们再来看看接收的函数：

1. /*
   + P. [0 w1 U8 b& t6 |
2. *********************************************************************************************************
   
3. *    函 数 名: lpcomGetChar
   
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *              _pByte: 接收到的数据存放在这个地址
   6 |% o+ C6 S+ d( z3 N* w  L) U, }
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   + Y( @) V7 V2 `# ?
8. *********************************************************************************************************
   / C% u$ y! t/ h8 \
9. */
   % i. [! f8 k# t- i0 Q
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    ; J7 }  m0 k# F5 _- M. w& }3 V8 F
11. {
    " |( C1 W5 f3 z3 o; N9 i
12.     LPUART_T *pUart;
    6 m" ^- a- q2 e; O( C
13. 
    6 R" R3 u! w7 \& X" q
14.     pUart = ComToLPUart(_ucPort);
    3 w5 P& [% k; o7 A5 Q5 Y  U
15.     if (pUart == 0)
    # |8 K9 h" Y* q# J5 K( K6 d. Q
16.     {
    # M# e# _! x1 ?- q
17.         return 0;
    
18.     }
    8 X  D3 Z/ M: e. O( [
19. 
    $ L2 H/ R' s0 m2 }6 S  K( g; v
20.     return LPUartGetChar(pUart, _pByte);
    
21. }
    
22. 
    - {* V, F; r# `" }$ x. t' U  A
23. /*
    
24. *********************************************************************************************************
    
25. *    函 数 名: LPUartGetChar
    
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    # W3 N' S+ u, S9 D# r
27. *    形    参: _pUart : 串口设备
    ) q5 m0 V0 d+ ~6 g1 F3 C# P
28. *              _pByte : 存放读取数据的指针
    
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    2 F& r7 P5 T" d3 S
31. */
    
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.     uint16_t usCount;
    6 x6 X9 Y+ c, J' a
35. 
    4 E8 a7 w+ x: O9 Q. o: n8 p2 a
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.     DISABLE_INT();
    
38.     usCount = _pUart->usRxCount;
    
39.     ENABLE_INT();
    
40. 
    6 B+ c5 i, {7 E
41.     /* 如果读和写索引相同，则返回0 */
    
42.     //if (_pUart->usRxRead == usRxWrite)
    % M# J3 p1 R* L6 T) y+ A1 D
43.     if (usCount == 0)    /* 已经没有数据 */
    9 Z2 e8 a5 ]( h' b* i: q+ H4 m
44.     {
    
45.         return 0;
    1 d/ O. \9 z$ ~
46.     }
    9 u7 {: s% ]) [. ?: M) N" H3 J
47.     else
    
48.     {
    
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    ! |6 a& h$ J/ e, G# n( D
50. 
    ( V0 @7 M" W4 E) Q  c+ B! p, V
51.         /* 改写FIFO读索引 */
    
52.         DISABLE_INT();
    ! n1 M  u/ U8 C9 o5 E
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.         {
    6 m* ]9 e7 e; R5 `* }
55.             _pUart->usRxRead = 0;
    
56.         }
    7 e- Y( O" \2 {
57.         _pUart->usRxCount--;
    2 C1 r2 N; H2 p" O5 `/ |
58.         ENABLE_INT();
    3 W! m6 s) O  ^
59.         return 1;
    
60.     }
    
61. }

复制代码

1 v' H% X- m0 x3 ^+ y2 d函数lpcomGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。

$ K3 J. u  o1 M注意：由于函数LPUartGetChar做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。
. w" ]; O, W1 w2 T
+ i' j% b5 A. H# H66.3.8 低功耗串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
# @/ I! g1 W3 S. V
6 C2 v+ a+ y' v# Y# W6 B  B' G4 V为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
# P/ p3 n6 I+ X  s, P6 o  H
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
) L$ m4 a  h; a% D' f
实现printf输出到串口，只需要在工程中添加两个函数：
  a3 q- O% B& r% e

1. /*
   
2. *********************************************************************************************************
   5 N9 o9 \) V; n/ C4 o% l
3. *    函 数 名: fputc
   * q% q+ A* m& Y' L0 ?$ m
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   ' o/ H* O6 Q6 m* \& o
5. *    形    参: 无
   & ~( d$ P. r# p1 p8 S
6. *    返 回 值: 无
   , |+ m* q0 R, V2 S6 J" k# _
7. *********************************************************************************************************
   
8. */
   ( a* [7 ]# T) v# r, C' \
9. int fputc(int ch, FILE *f)
   . I+ ~% z0 h3 _* w7 }7 |( h
10. {
    : x& q. M+ Y, v8 n) J6 J
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.     lpcomSendChar(LPCOM1, ch);
    % X  v, U4 T4 V, W/ O& @- ^
13. 
    
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    4 ?- Q4 E: \, W. e4 o8 D/ D' |: z
16.     /* 写一个字节到USART1 */
    
17.     LPUART1->TDR = ch;
    
18. 
    
19.     /* 等待发送结束 */
    
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    
21.     {}
    
22. 
    6 u( I6 |5 g9 D& N1 q. F- x* S% _
23.     return ch;
    5 `2 v( Z  o2 r: [; N2 v
24. #endif
    % p! j) w' d' T) A- {) s% B' L
25. }
    
26. 
    & b; o2 t2 \2 H" k5 {8 V# P! Y
27. /*
    8 H& I4 C0 C$ u6 {8 H
28. *********************************************************************************************************
    : U1 T' x  ^9 r9 ^) I! Y+ H
29. *    函 数 名: fgetc
    + X$ C7 V' M1 n( e- n, m0 W
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
      ^2 }& |0 E; j# x4 p7 c0 @2 w
31. *    形    参: 无
      |' q( @5 I/ d0 \8 N, I' `2 B
32. *    返 回 值: 无
    $ u0 y! v  O, T8 ]7 S; L6 X: |+ C  u' s
33. *********************************************************************************************************
      Q! i: z. l) T
34. */
    
35. int fgetc(FILE *f)
    9 G" R7 H, N9 G4 [1 ~
36. {
    
37. 
    
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    ' K2 K# @  Z. J' O  o
40. 
    
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    
42. 
    $ ?2 q' g# G! `2 u0 z! Q6 x7 }1 I
43.     return ucData;
    
44. #else
    
45.     /* 等待接收到数据 */
    
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    
47.     {}
    
48. 
    0 o5 m- R( g; b# R4 ]* M) r) V
49.     return (int)LPUART1->RDR;
    , m. O- y! u3 b6 [
50. #endif
    
51. }

复制代码

  V- A3 O9 H* q$ g  p通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
; d  C1 {8 C5 [5 J- `
6 E$ }" |. j3 O  H- L* Z* X7 E66.3.9 低功耗串口停机唤醒方式
0 s; A$ I* U. {& \低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：

  检测到起始位唤醒。
低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。
6 V, C  x$ L+ M9 v: W
6 G* s  P! I0 t% L如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   ' `2 W0 K. I; U9 T
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   0 t( T/ g( W2 O% {
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   
8. /* 接收起始位唤醒 */
   - X4 A. |0 \- j' z
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   ' O; o& a% G. {; T. N: {
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    ) Y5 }# d/ n6 [: u
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    
14. 
    
15. /* 进入停机模式 */
    $ ^; i( d8 a# h. K( Q0 C
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    . ^. H8 L6 Z% u
19. SystemClock_Config();
    
20. 
    " Z' j' I$ J0 [  y
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    , Y. S* w5 T( z# N

复制代码

/ A! M5 E$ Q2 [- k: M) G2 i; c  Y  检测到RXNE标志唤醒，即接收到数据。
低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。

如果想唤醒H7，发一个任意数据即可。

& J6 T1 `, F( h5 J+ o. D7 P

1. /* 使能LPUART的停机唤醒 */
   . i2 [! j0 P, b  g: E/ Q7 H
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   8 c) ?+ T5 G7 Y1 z9 c
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   3 k8 C3 c% g. s3 F1 {8 N2 {5 w
7. 
   + I  G* J5 h3 e. y
8. /* 接收到数据唤醒，即RXNE标志置位 */
     \1 V% S/ s8 L
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   + T* }8 c% O7 ~( V2 W3 v- }
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    . e6 b! e; V: V' v8 _2 U8 V' t
11. {
    5 E, c7 P& T# G9 q
12.     Error_Handler(__FILE__, __LINE__);                        
    ' E% \+ f. l' R% U# n1 i. ~5 n
13. }
    
14. 
    , e$ v7 B9 B+ a1 T4 |& F1 g+ o
15. /* 进入停机模式 */
      z6 ]) k0 }0 D
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    ; h! A( h5 e( p) q/ H
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    + x- F9 L2 C7 O" V& X
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    
23. 
    

复制代码

  检测到匹配地址时唤醒。
( k% y4 [" e/ p: ?低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。

0 b+ g2 h  g: n/ x: U  W如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
2 |$ y' C7 O: p5 c  d

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   8 N% D% V' z; F% C# \. q
4. /* 确保LPUART没有在通信中 */
   
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   7 W5 S2 s: [; g) I$ m$ I$ L
7. 
   
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    $ [' k9 x  H) \
11. WakeUpSelection.Address       = 0x19;
    ; o6 t% N; S- T  s/ w  Z
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
13. {
    6 T2 n+ D- W. A  V* M. `
14.     Error_Handler(__FILE__, __LINE__);                        
    4 ~& `' M1 p" p6 B
15. }
    
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    
18. 
    ' O+ {9 p/ ^. K, Q) j
19. /* 进入停机模式 */
    
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    ) f: v* L+ M- y  Z: x: z- b
21. 
    " ~! H& S- Z3 K2 B1 w% B3 j
22. /* 退出停机模式要重新配置HSE和PLL*/
    
23. SystemClock_Config();
    2 h+ v& {2 A2 _1 _) Y8 `6 t2 ~
24. 
    
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    9 b7 z/ R6 t9 p# t
26. 
    1 w" j' e0 C0 i3 g1 T- f+ M( m9 K
27. /* 关闭LPUART的停机唤醒 */
    ! B5 f9 b( ?# z7 ~  W4 S. u0 _
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    
29. 
    4 q7 N1 t3 a7 |8 q% {- l* f8 }; D

复制代码

; A: Z& c# {3 E' U& R这里有一点要特别注意，程序启动后，调用下面两个函数：

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

  bsp_InitLPUart
  lpcomSendBuf
- z' X* |# t" M* J, U' A% k, ?  lpcomSendChar
  lpcomGetChar
66.4.1 函数bsp_InitLPUart
' u+ A# A- t6 O- N  Q- |) h4 @$ p函数原型：

5 A$ a6 H5 l; [% ]3 u4 Qvoid bsp_InitLPUart(void)
8 l1 g! C1 ^( v/ u# l) C1 R% K
. r. k9 i9 S1 g' z& m函数描述：

此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

使用举例：

" [. G) h! O$ n/ _+ d串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

66.4.2 函数lpcomSendBuf
函数原型：
( \' D* ~' O9 C  a' o
& V, B2 P+ c; Z4 E$ A  E6 `8 j% Dvoid lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

% J! i3 _5 B3 y4 P. @' G  a函数描述：
8 T) Q8 X4 b8 _8 L) B; B
2 s5 Y* B5 H- V; d6 d; n8 e- o: [此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。
, s5 j3 I+ ?7 Z+ u. Y7 r
函数参数：
6 R5 M; M! e  `2 q* k& O
% y  e8 A& H/ ]  第1个参数_ucPort是端口号。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
注意事项：
3 G* K: q: M  q& x. A6 R: y+ L
) ]" _9 f& S$ G3 G! l 此函数的解读在本章66.3.5小节。
发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
8 @8 H5 ]% X- y; Y. d- z* p# J使用举例：
3 v' b1 L5 B1 u4 C1 U) f
3 N0 E0 C& v) s7 ^调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。

: Y) p2 Y; b" }- U2 h' f8 H- k

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

复制代码

# S! S9 r. M) I# X66.4.3 函数lpcomSendChar
9 `' Z( ~, t' B+ }函数原型：

7 \% s! M. v) r8 m) `8 xvoid lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);

+ T! L( S' I' O函数描述：

此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。
4 q$ n' j* {2 x3 y  |
" `4 ?; I7 C' W' F- z% O7 c函数参数：
" m  l: A; s. L9 d  第1个参数_ucPort是端口号。
  第2个参数_ucByte是待发送的数据。
6 Z% M. [* ~6 O& L1 h6 S& P6 J9 X  Z注意事项：
! A' }8 a5 W' ~. \
8 l; ^, P  P, E4 ?  此函数的解读在本章66.3.2小节。
使用举例：
6 c! Q) `9 z; b8 O5 |  z8 v$ E
调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：

& Y+ h& K) n; ]% y  DlpcomSendChar(LPCOM1, 'c')。
$ f6 {+ t$ Y, K& G9 W: ~& F
: w5 E# y1 c: h- F6 M, A+ U66.4.4 函数lpcomGetChar
函数原型：

uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)

- A  e9 R0 n& C. k, c2 L函数描述：
; T6 f9 v) G$ L' f
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

) u( i  k  t( W" B0 g8 D函数参数：
: N- c3 h4 n6 ]3 O5 J
  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
4 s! ~" H# T3 v9 }  返回值，返回0表示无数据, 1 表示读取到有效字节。
注意事项：
8 Z# F) J5 A% D) R
% E6 n. l, T( E" P: ]$ r4 r  ]; X  此函数的解读在本章66.3.6小节。
! m! A6 a+ p2 M* n使用举例：

调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
: L6 Y. v0 [, S/ {
比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。
% Y+ X% \7 ~2 H0 T0 J) D# a8 g
) n( h# F0 L& d66.5 低功耗串口FIFO驱动移植和使用
) f' r8 h4 v& x& ^, V- e) ^5 m串口FIFO移植步骤如下：

; r/ b5 L) |* ]  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
) {, d. A! X9 \3 E3 E7 f  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
9 G" ]1 @' ]/ ?. y$ P7 @

1. #define    LPUART1_FIFO_EN    1
   ( `6 a/ Y' P% ~! g" d) I3 x: o
2. 
   
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   0 @- U3 Q; N6 _' m- _( T! _9 A
4. #if LPUART1_FIFO_EN == 1
   
5.     #define LPUART1_BAUD         115200
   ; P7 ^: e& f' G. f9 b; V; y- U  M
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   0 X  f7 h9 Z* t4 l! ]2 a% J
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   
8. #endif

复制代码

. Z2 }) E3 v* t  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
1 y6 x, t( m  ~) b. n5 D. C& z66.6 实验例程设计框架
0 @9 A, \  ?! E8 A# S/ W2 p通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

/ p' v* p) i; E! c

- u, v8 `( ?: c# s9 C/ ]
% _  p4 z" S# Q/ L  第1阶段，上电启动阶段：
& v& z# A+ Z& R. B' h
这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
: p/ Z/ t6 E# w
第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
0 H( r0 N$ p: o' S! @- }第2部分，应用程序设计部分，实现了三种停机唤醒方法。
1 @1 G" K( S  `" B66.7 实验例程说明（MDK）
配套例子：
3 v# H/ `6 d  c
5 q: {8 p# |2 y6 ^V7-046_低功耗串口的停机唤醒（串口FIFO方式）
5 u# U5 h' M6 d7 |# g2 n. p
实验目的：
8 L0 D  m- ^% N" }0 Q5 Z% i5 U6 H
$ O0 z3 S" J2 p' i学习低功耗串口的停机唤醒。
( w& q1 C( B0 V) a! S0 T0 U实验内容：
2 g! h* j' q" `! _# O0 w
启动一个自动重装软件定时器，每100ms翻转一次LED2。
) g3 k8 P" @8 C5 E$ Z" x+ Q2 |% N3 w当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
# |8 Q/ ]; N5 |( U# j上电启动了一个软件定时器，每100ms翻转一次LED2。
1 W' X3 v, S* X2 C2 `USART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
9 O* q+ W+ _$ M5 j, T( O) t: GLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

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

* o4 F- [# \* ]+ w  _, e% H! jLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：
; a7 a1 a( R* F# C! X+ K* v* A0 Y
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
  R0 B. }1 K7 f' W" h/ J6 @# v: {0 LK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。
* |5 v9 Y/ X2 {# B0 i

, }6 o* b7 P3 V( y
程序设计：
* Y2 G  Q9 [: H
! h& s9 |/ C* I) a" r( v  系统栈大小分配：

- C3 C& j" y' g& a3 g0 y

' I, y7 n. w' a$ U8 e
, ]( u  z/ h8 n9 I& X  f  RAM空间用的DTCM：

# n- s9 C' n. p+ y% ^

3 Y, R& e9 ]: L: g; X( g3 m8 s  硬件外设初始化

9 P& H7 g  W4 ]9 _  t' Q/ N# @硬件外设的初始化是在 bsp.c 文件实现：
' q- u+ H7 M  S" h

1. /*
   7 Z( j3 ]1 e" p! P
2. *********************************************************************************************************
   # B9 E7 K* Z* j  w
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   $ Z! G- \7 @) }! g/ `& t# U$ G
6. *    返 回 值: 无
   . Q: b' O( [3 s/ H5 h. F% U1 z
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   - f" B# M; U0 a& l0 u: W$ n
10. {
    ) _3 r# @2 V1 ~: o* x) ~( Z8 ~
11.     /* 配置MPU */
    . g# @$ M* K; z3 l
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
      c5 Y. `4 j) q7 T/ a( g5 `
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    0 q) a9 w% ~& }
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    3 x, x4 G) p: d( s+ a
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    # X$ f! d% A6 j! f- I
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    - U9 e- p4 E' K8 \
28.     */
      B2 q$ H5 s* b) L  a
29.     SystemClock_Config();
    $ O& \5 ^8 c/ S3 h- x" D4 C
30. 
    $ U7 Z+ _/ ]4 `7 Q
31.     /*
    ) y9 @4 `9 g8 z: z1 q( J- t3 D
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    # N3 @5 k) d9 ~2 j* X8 t7 a+ L3 e0 t, J
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    ' c2 d0 u+ z* ]2 w' v+ a/ _# H7 i
38.     EventRecorderInitialize(EventRecordAll, 1U);
    ' }; F1 k$ l- n7 \% G
39.     EventRecorderStart();
      b) B( s( l* q* u( p2 C* T
40. #endif
    2 y# ~) D2 ~  ?3 h% P
41. 
    8 }! a% ~+ G6 Q. p
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
      o8 x0 _* x5 |" I
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    - i% w* j* Q0 \- V9 e5 D8 Z
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    8 ]2 h4 J# y* g3 P6 n( W, ~
49. }
    $ _: b6 h" s5 ^/ A

复制代码

  MPU配置和Cache配置：
* g- J1 {( e9 n: ]4 M
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
3 o8 q: l, W3 Q* ^
( i6 o3 b# G0 w8 I5 f3 @! _4 j

1. /*
   " g/ @$ L& H7 D
2. *********************************************************************************************************
   / f$ g. b, |9 W
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   5 t* u- Y# H: N  R& A0 K9 S
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    - {8 I' h- \9 q, I
14.     HAL_MPU_Disable();
    
15. 
      Q1 v: o* j9 C- H8 ~3 x& w7 V
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    , q+ C5 Z. y3 T5 P* b& l
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    & Z2 K5 t% Q- x' V+ b$ c* f; B$ Q, t
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    3 b9 ^: ]9 I3 t' l2 P
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    6 T5 @% {5 ^2 g3 B% G
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    / v! b& \/ N/ O, i- ^  V! N  V
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    2 X0 M6 ]; z- C& ~/ [7 J
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    : ^' U, z' h1 P; C/ ^3 J6 v
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 e1 d( |/ R- w3 X+ u
30. 
    , H" R' Y( I: D3 ]8 x1 V* u% n
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    9 y7 L5 z# a1 F% f0 X8 c
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ( U2 b; a1 \( O9 b) o
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : W+ l& d, y& [! b$ G% L
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    ( t: {0 k  S: M% {2 i
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    6 ~8 ^5 @+ o* I. i
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    2 B0 i" \7 A( P' F
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    ) W: ?8 |* o# T  I: V5 x
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + V4 n( F0 h+ l" M" [
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /*使能 MPU */
    4 ^! p0 X, I5 \8 I  E' ]7 K7 b% i, T
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    1 S% ~# `; A+ C; G/ h, Q
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    / {* l, H! ?% }$ h
53. *    函 数 名: CPU_CACHE_Enable
    : C+ H" }5 Z  v) |$ G
54. *    功能说明: 使能L1 Cache
    & H1 P. k4 ?8 ^
55. *    形    参: 无
    - U5 h) R, T; K5 K
56. *    返 回 值: 无
    5 }. p0 \/ r% w3 s5 w3 Y0 _3 B* `
57. *********************************************************************************************************
    # p, c& R* C8 _& U4 c- ^
58. */
    7 v  v& b/ ^7 q8 s9 w& R: H
59. static void CPU_CACHE_Enable(void)
    3 E; @; ^0 K, J/ e$ {7 K8 a; j
60. {
    
61.     /* 使能 I-Cache */
    + `# L) l4 L$ L- Q5 M: W
62.     SCB_EnableICache();
    + [0 O- e  Q/ s5 w9 }, N6 f% G: ]# l
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    7 Y# _" t% h7 D' J
66. }

复制代码

5 ?# C. O/ ]! }( ?  Z2 q2 Y& M  每10ms调用一次蜂鸣器处理：
  z7 F8 s: J; ?1 L! ~7 S8 N9 s
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
, k3 U) A$ W7 z& g# G4 \" ], l

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   0 y1 q6 [! K+ X* B5 d, I
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   ; y/ ^, C, r& P7 P0 D4 w
6. *    形    参: 无
   5 \4 g* ^. x! Z
7. *    返 回 值: 无
   3 c! ]0 \- a$ F. S  G
8. *********************************************************************************************************
   4 G9 \9 {+ `7 h. w2 o9 [' ~/ l+ v
9. */
   
10. void bsp_RunPer10ms(void)
    9 V: m, x0 X; b$ f# ^( U
11. {
    
12.     bsp_KeyScan10ms();
    
13. }
    : E  I* s" x5 [# z0 V

复制代码

# w1 \+ ?7 T$ a" R% l' P5 n& u  主功能：
: H: C0 F! Q" J, Q$ L
6 M$ \. ]1 {, N' s主程序实现如下操作：
6 z* G3 [6 L1 ^1 E, n
启动一个自动重装软件定时器，每100ms翻转一次LED2。
# ~9 `5 Z* G# i6 ?/ K) F  RK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
5 y' O; H0 c  Z8 E7 n/ X1 _K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
  b+ l1 w$ W% r; ~  K0 P

1. /*
     R: a$ S1 r2 Z$ R/ X6 b6 p" T) W
2. *********************************************************************************************************
   
3. *    函 数 名: main
   - p; q2 e7 J3 p4 Y: H0 p) P6 }
4. *    功能说明: c程序入口
   / c- F5 `& N$ g, _, i' l
5. *    形    参: 无
   $ }" D$ R9 c: B7 Y7 W/ ]9 p6 J
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   " t' w/ m# K2 ?( k0 E
9. int main(void)
   
10. {
    0 [* w7 w8 R& p5 r! M4 H" ]8 `
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t ucReceive;
    
13. 
    7 M7 r1 L% S4 G- C" F0 g/ Z
14. 
    5 N2 U1 }: v/ L% \" L; f* e) a' x
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
17.     PrintfHelp();    /* 打印操作提示 */
    - J6 g2 L! L+ h
18. 
    7 p# \# _( t, v( G3 x
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    ' ]4 M  G9 n7 `& [3 S- {0 y
23. 
    , ]4 S! Q3 y9 i8 G
24. 
    ( n! a) X5 q  b: L5 @
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
26. 
    ; t7 S8 N. m3 `3 b+ D6 z
27.     while (1)
    
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    & j; X; S3 m3 G8 K- {
30. 
    % P& Z' C% @0 M5 {9 g$ P' u: t" z
31.         /* 判断定时器超时时间 */
    
32.         if (bsp_CheckTimer(0))   
    & q8 z; b$ V' L$ q# H! a7 `
33.         {
    % S" g  S! M" l3 H' ?0 j* Z
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    
36.         }
    % P# ~4 |9 x2 c6 r/ F
37. 
    
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    2 Y5 Y* N4 l. S
43.             {
    2 f6 K; @. }# C* i0 w5 a
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    # W0 h" J$ V5 n) L. Y
45.                     /* 使能LPUART的停机唤醒 */
    * e# x1 ~( \3 P
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    , g! n$ O6 ~7 |" p
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    8 s* d3 u" p! k& W
51. 
    $ r, ^4 w% I3 B  f! f- u$ G
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    - V1 k- K* ^- p- ]" n# A! [
55.                     {
    6 i$ Z; L+ I, J3 N& U2 f; L
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    
58. 
    ) p# L0 g) ~$ Y
59.                     /* 进入停机模式 */
    ( b6 X4 C# p! n& g/ g/ p
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    ) x2 j/ p9 n& @' m4 i$ a) L
63.                     SystemClock_Config();
    9 U" y' j( I+ ?4 o; z- W. ~& E
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    ) z7 K) X8 \% L; p% ?" d
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    & v/ R% w# |6 Y% k) L) G: A3 W! G
69. 
    0 s5 l# F* [! f! F
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
      C- l: [; `) e, _! M
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
76. 
    
77.                     /* 确保LPUART没有在通信中 */
    6 M/ Q& i/ ]. I" _7 p6 ]# l7 P* }
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    % p1 I6 o  U. [' v, G9 ]# O
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    - `3 T/ c1 r* e  z" M" k
85.                         Error_Handler(__FILE__, __LINE__);                        
    
86.                     }
    2 X! e2 |0 ]( E6 v) h3 ]1 {0 y
87. 
    
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    # [( T4 n+ B/ q/ M% g. }" R: k
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    . _6 V6 j+ a, G
92.                     SystemClock_Config();
    ; o3 H6 v9 Y8 K& [
93. 
    0 e1 R/ g9 H$ n* b# q# i  y* P
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    & H7 i. u+ z/ U6 ~  e: r# H0 x& K
96. 
    3 v4 i, F- f+ @: L$ I8 Q1 A
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    + N9 [) J6 L7 U% b: ?4 Q# M
98. 
    / K% ^; q1 g2 m7 f3 U! t/ m; F
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     4 F6 r0 w! D/ [. n
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     & _# d9 S5 w6 t# |0 Y! a1 W
105. 
     
106.                     /* 确保LPUART没有在通信中 */
     0 g: q% F" G4 `' x" `6 K8 e
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     4 l  n6 H7 {, s) T: |
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     & f2 r7 }' Y1 H6 S% U
109. 
       c( @9 a. S( `, k4 R
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     $ ?; e# w) |6 b
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     ( Y* K; H& s+ L
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     9 L% h7 W6 J: h8 ~! s4 o1 P
113.                     WakeUpSelection.Address       = 0x19;
     5 L+ z& z# u; J6 N
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     
115.                     {
     3 ]- h1 @6 f/ b. M; P9 m) P
116.                         Error_Handler(__FILE__, __LINE__);                        
     ' l. P2 h6 O3 n- a0 Y5 H7 t8 |8 u
117.                     }
     
118. 
     ; X( Q( R$ \7 ^: l
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     : m8 E1 j! f1 R( T# Z' Y3 A
120. 
     
121.                     /* 进入停机模式 */
     " l2 d" a' }) x* g
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     
125.                     SystemClock_Config();
     6 O+ F, _4 v2 [# y1 l1 N
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     
128. 
     3 Z; o) E! C7 m
129.                     /* 关闭LPUART的停机唤醒 */
     * O  @. ~1 |+ L+ z$ g7 p
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     , l: R2 O! f0 t! Q& ^4 e9 x/ y4 S* h
131. 
     
132.                     break;
     8 i# `" r, \- Y5 K  P4 f
133. 
     3 o3 Q1 W7 N+ W' {+ F1 R( U" p! V
134.                 default:
     
135.                     /* 其它的键值不处理 */
     
136.                     break;
     
137.             }
     3 @& N+ Q* g1 X$ M4 u9 _
138.         }
     7 h" S$ U* z! @# w$ I
139.     }
     
140. }

复制代码

7 [9 c$ @& J$ I7 q: ~4 W' w/ ?66.8 实验例程说明（IAR）
$ g/ K7 I( J3 D3 a* s$ Q$ p, C( R/ A配套例子：

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

0 F+ F- A; H' u$ }8 Q6 i实验目的：
9 V6 P* o! a4 @( b
3 t* z- Q% O* U6 o, f  `& y7 `学习低功耗串口的停机唤醒。
. j1 C5 T( }* x" ?实验内容：
( X% ^+ B8 ~0 S. q6 m
/ h7 g' ?. c2 |  u* I& R% _启动一个自动重装软件定时器，每100ms翻转一次LED2。
6 s+ N& o7 Q! r; V+ h当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
" {" S& Q+ ~4 g; k- d& }7 lUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
LPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
# I, Z9 n4 X" `) XLPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
$ N5 N$ w& j2 e! Y
; ?8 @  M' L8 L/ S' I# LLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。

/ O# F  m- J/ Y- @8 N* ~2 eLPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。

实验操作：
9 [* c, ~" I( j& `* D% j/ @0 K
0 {5 @1 ?% j" C: k: q* D4 ?/ \K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
& x  C# ~' M" G2 s+ o6 PK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：

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

  q- M; Y6 N% \9 @. F& k2 E

& F, J5 ^) C5 y# |6 p
2 d3 q+ V0 ^0 ], V6 q% b$ h程序设计：

  系统栈大小分配：

5 q' a3 l' l! W

  RAM空间用的DTCM：
1 z2 N7 n6 [1 f! v! B' `
. H$ C% a' X! a2 [: |

' N& W/ s' a# [% L9 r) v  硬件外设初始化

0 X" R0 J  s2 w* `9 [! R硬件外设的初始化是在 bsp.c 文件实现：

4 Q8 _$ P: s( N8 n

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   / `0 w) J7 A( ^; l7 v7 `
6. *    返 回 值: 无
   ! {& ^) r4 |0 X) ]" n0 r  Z) a
7. *********************************************************************************************************
   : v0 C, b. j$ r' m, @. k$ N4 y
8. */
   
9. void bsp_Init(void)
   0 G1 W" p0 S8 B
10. {
    * }7 A% C! ~3 w0 Z  {: z( n+ G4 s# W( N
11.     /* 配置MPU */
    
12.     MPU_Config();
    0 D6 J( O5 x6 G
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    . z7 ^! L1 N' m
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    8 y1 W$ f3 @  u9 m9 c3 M1 S
21.      */
    
22.     HAL_Init();
    ' ^% }) M$ ?! Z* @+ V; ^% {
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    + {$ _( G7 j: Q% P
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    3 a2 }: e8 b7 m3 b1 I" ?( n
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    % h( n& @  {( P  t
36. #if Enable_EventRecorder == 1  
    8 C& E% j" W) |* u3 ?5 }
37.     /* 初始化EventRecorder并开启 */
    3 r- w/ L( F! S  W9 o
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    1 h0 L' y! q' H' Q, i4 [
41. 
    5 v6 ]1 m, Q. o' b% r9 x: W3 o
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    " X% Z+ A' g1 L. r( m
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    3 q% ^' \' u0 M. F
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
" Z4 i% j( e" z# q8 d
  a7 e' D, t. g5 v: ~: ~

1. /*
   9 t. ?  l  A' }' V6 K
2. *********************************************************************************************************
   ( f# D, |- j5 U: G& L/ Q2 H
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   / [) Q5 v$ C: N8 Y3 s. o3 B3 m" u8 R
7. *********************************************************************************************************
   & B5 j* h5 `. u6 q' I+ Y! x
8. */
   
9. static void MPU_Config( void )
   5 z0 C- i$ `9 j5 g1 o
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    7 Y7 @5 S. X& g3 [; W2 S
12. 
    
13.     /* 禁止 MPU */
    $ @2 `  D" Y1 S1 `: B8 m
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    # q) V- B! @8 _6 W" Z+ R5 Q
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    3 ^* u! V* v: e- n: o
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    8 s7 B$ o8 e! x& _, X3 b- ~4 {9 a
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    + R& g& W# W2 }; G/ F- R' Q' e
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    0 s2 ~: N- M3 z/ c4 y! d
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    1 X1 B8 B6 @) J) s: E
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    3 I% ^. b- I9 [3 R# s  l$ w( `7 D
31. 
    & J$ A4 O7 a1 r+ ?# y. E) E
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    5 L4 K& O+ O' [* V; z- U
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & p' M# E1 @* `5 g! U  v6 V7 z
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    , p1 K% ^# T. X6 `& f
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ' q2 S% M7 r7 y" j: ^3 C0 S
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 e; n5 f2 g, N* U2 i6 \
46. 
    ( `6 \- Z) ?7 g  X/ F6 o
47.     /*使能 MPU */
      N% q6 A7 w9 }# `% S- O3 q
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    ) X( h) F! z9 }! ~  M8 K
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    ; b4 B5 |. R. S; \/ B' g! u
54. *    功能说明: 使能L1 Cache
    + k) R3 ]( ^7 i% t# C' R5 f% `
55. *    形    参: 无
    
56. *    返 回 值: 无
    3 C" x1 J5 Y4 R
57. *********************************************************************************************************
    
58. */
    & s  @9 T9 g: ^# }! L5 r3 m% `
59. static void CPU_CACHE_Enable(void)
    ' A1 T( F' h* r( f
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    7 j* y# P! J+ w( `
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }
    
67. 
    

复制代码

  每10ms调用一次蜂鸣器处理：
3 s' H2 Y$ F! K) z+ O8 A
4 D% @9 c4 p! M* X6 \6 h5 J8 e蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
7 v/ ^  ]; i( M: c% b6 f& Q
3 x' A/ L* I" \7 S

1. /*
   
2. *********************************************************************************************************
   4 ]9 t/ b( Q$ X8 H& S: S1 k( F" N
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   * m. K0 l. @" y. p0 D2 r0 H( M
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   ) _9 f3 z3 t# I
9. */
   & i! f- `) T! {' s7 V0 r$ n
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    $ Y' W3 U' c6 P3 ?1 P( l; N
13. }

复制代码

! g5 x" ?6 J  }) }$ h  主功能：
+ K2 |1 l% ]6 W8 [. T2 g
主程序实现如下操作：
* ]. v+ `) V, `! v( @; S3 n0 b
4 b# \9 d7 C1 {6 g) r9 I: A& X4 i0 q( s 启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。

1. /*
   " T4 _3 U! l/ N/ y0 |. O8 a
2. *********************************************************************************************************
   5 r8 n& |# _! f9 \( p' ~, h# h
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
     Q  K& ?! N/ ~& V0 ]
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   & L/ e% V& s: B5 i1 H
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ) j! C0 E+ K& L' {7 v
12.     uint8_t ucReceive;
    
13. 
    ) H# D; p4 @1 T9 K0 M
14. 
    
15.     bsp_Init();        /* 硬件初始化 */
    " ]7 _1 A2 j4 o; e% m- K1 @! k9 z/ v
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    4 e1 e, m3 s! W& r9 D: C
17.     PrintfHelp();    /* 打印操作提示 */
      s8 e5 q" b% i
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    5 k7 ^" V* i: L( T: @# _1 C* Q# E; Y
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    
23. 
    7 l: H  p- q7 S: n( m
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    & o+ l* `' T, G$ I
26. 
    3 |) x9 C4 [# a0 Z4 c2 l
27.     while (1)
    
28.     {
    4 b9 g6 J& M& N4 }& v. Q
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
30. 
    
31.         /* 判断定时器超时时间 */
    6 F1 \* s& Z" P1 ^! E. K# W
32.         if (bsp_CheckTimer(0))   
    4 e! N$ M# K+ W" x6 J/ ]: P  b
33.         {
    
34.             /* 每隔100ms 进来一次 */  
    
35.             bsp_LedToggle(2);
    ; ^* d7 N$ K3 ^# R. P) o, r
36.         }
    
37. 
    5 m7 G  Z* i! `7 I1 ~8 r
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    4 S7 I; X8 S/ J- R
40.         if (ucKeyCode != KEY_NONE)
    # L: W; G6 R) b% g, z
41.         {
    
42.             switch (ucKeyCode)
    ; k- E$ M, F+ Y0 G* W& j+ d
43.             {
    ) A8 G1 l# V9 _% ?+ x9 w
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    ! N7 L& k* C- V  ?' W
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    / i" M; X% D, |$ K, i
47. 
    7 d: j# h4 m7 R7 K; e
48.                     /* 确保LPUART没有在通信中 */
    
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    : C* X3 |5 e4 ?7 N2 F
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    
57.                     }
    : M' v7 ^2 W! i" S
58. 
    " y+ v" E8 r; [
59.                     /* 进入停机模式 */
    / d) f3 j' y4 L" p
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
61. 
    6 Z2 \2 J: g% t6 S
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    1 {/ W7 b0 _4 d9 D" }& s/ ^
63.                     SystemClock_Config();
    
64. 
    $ Y$ ]: Y. r( v
65.                     /* 关闭LPUART的停机唤醒 */
    6 A/ s, o5 c& B3 B6 z/ H$ h
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    % \* g1 M* J: i# `9 x
67. 
    1 X  I6 g4 P0 N! S9 k, L
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    . t: l* d/ w0 s* q0 t. [( [
72. 
    ) R6 b7 E1 _0 W& |, x5 Y5 k
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    & i# l, b1 q3 s5 X  m
76. 
    # F! m9 w  Z5 P" x9 _+ j8 a8 _
77.                     /* 确保LPUART没有在通信中 */
    ' ?" A! a1 b# C$ r2 K
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    ( D$ w! g7 F: b4 j- `. \
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    ' L' R% `; g/ o
80. 
    1 F% S2 m8 ~# t! u
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    % p; K% q+ C1 A- q( P4 ~9 q' x
84.                     {
    
85.                         Error_Handler(__FILE__, __LINE__);                        
    ( @# f/ i0 U. E% P) Z5 E& c6 M
86.                     }
    ' b: `9 \& I2 i
87. 
    1 c& `" R) i: g, g. F9 K$ l
88.                     /* 进入停机模式 */
    / g! U# X  o7 E) ^2 z6 F6 z$ |( l
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    2 |* y  s: K! w' o
92.                     SystemClock_Config();
    % {, T5 w4 E0 r+ A/ ?
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
96. 
    8 `  b9 i# {* S. V
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    " k, g) ~9 k6 C6 Q
100.                     break;
     ( z6 d( b. p6 d' G- k0 e
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     $ {+ G' I- ~8 A' T. U# h- L- W
103.                     /* 使能LPUART的停机唤醒 */
     ; _4 ~0 d  f  _4 q6 Z
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     
105. 
     / [, Q9 C! d+ y% L- V! n$ }
106.                     /* 确保LPUART没有在通信中 */
     / Z* \1 I- |( ^
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     - B. v3 V1 A2 `* J5 ~
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     4 }4 W0 ^' D, ?: C" |, }( v8 f
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     3 Q& y- `5 u# G( Q
115.                     {
     7 t. Y" c% z3 e3 A2 p, @6 P7 S! w- r
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     
118. 
     % d) t& x! }/ g. u; q
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     8 k9 p7 A1 _3 P1 V& w0 W9 q
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     % [0 r  Z* q' D' U1 E( F: d4 J( }
125.                     SystemClock_Config();
     
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     $ V* S: N, s2 f0 s: @. L9 r
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     - T! `% h) e: I
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     3 B- j5 Q; U( w  b- j: c
131. 
     2 _$ h6 B5 v2 e/ V) N7 n; P
132.                     break;
     
133. 
     9 w* j$ v, t0 I, i) F; @
134.                 default:
     
135.                     /* 其它的键值不处理 */
     ' A1 L, \9 e$ B6 G
136.                     break;
     
137.             }
     8 ~! h0 E. L/ r+ K# e; e
138.         }
     
139.     }
     
140. }
     ) Z* a7 d. a# S

复制代码

6 F% I9 g  t; ?3 v# T# C
( k! k$ _/ L/ Q3 p7 t$ |* o8 v66.9 总结
1 ]/ M$ H! @4 M, I1 k, J$ K+ b: Y本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。


. t/ f. }$ S! b