66.1 初学者重要提示
: [& Y( A! z+ [+ v& O  学习本章节前，务必优先学习第65章。
  低功耗串口FIFO的实现跟前面章节通用串口FIFO的机制是一样的。
/ D0 H# j; c& l4 d% S  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
0 G( Z9 ^/ E; I4 y66.2 硬件设计
& `$ Q; j+ z5 Q3 ~STM32H743XIH6最多可以支持8个独立的通用串口和一个低功耗串口LPUART1。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

8 H( D- m2 M8 p- ~- K( T! u0 |7 a低功耗串口LPUART TX = PA9，   RX = PA10
. Q9 C4 M+ X6 {8 D" }0 P
- ^. o' B. F8 A0 I! h# h6 H串口USART1  TX = PA9，   RX = PA10 （低功耗串口和USART1用的相同引脚）
  v8 m5 u) z/ t( N: c
串口USART2  TX = PA2，   RX = PA3
% X5 [! ~' |2 S* f' b- O
! Y+ B  T+ ^7 U( o% @串口USART3  TX = PB10，  RX = PB11

串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
$ @" _0 Q# h" G+ C  x: z/ b
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
" d# c* J- V2 F
) f7 q3 V- ^7 R2 |6 U串口USART6  TX = PG14，  RX = PC7  
& ]) Y" `+ K$ w+ W/ O
% M# V* \7 ?; G+ ^1 o# ^* w0 T  j串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

: A& `2 V( W  X' L/ g, Y$ u. B( T串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
0 [' m! I& t4 m& v
STM32-V7开发板使用了4个串口设备。

. @0 r6 c' o/ F7 U) b  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
- ~' q1 M8 Z" f  串口2用于GPS
  串口3用于RS485接口
  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：

; h5 M( ^* x" d% M! w, \) d7 P1 s
关于232的PHY芯片SP3232E要注意以下几个问题：

  SP3232E的作用是TTL电平转RS232电平。
  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
$ H0 H5 q7 I. \  u6 D  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
; C) e) z; @% }5 S" G2 [

" M0 V3 r. z$ m
1 i) v2 V) o3 [. A实际效果如下：
# J' s" o) j5 n1 B* \( X
5 k4 B+ Z0 M% F; c" v$ r. f

- _! S. u$ L0 U
1 E) V8 e! B5 V& _; d通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY

芯片是否有问题。

# G9 R9 h0 ]% [) R+ o  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
6 e: [* w8 Q; I# P5 h7 Y- \6 Q  [66.3 低功耗串口FIFO驱动设计
66.3.1 低功耗串口FIFO框架
为了方便大家理解，先来看下低功耗串口FIFO的实现框图：
+ b$ Y  c( l, i+ }% A) m& \& ~

: J5 D9 J2 ~: Z! X
  第1阶段，初始化：
  V+ l2 i+ `" L& K) y% l! ^
! X5 Z' y2 B9 x通过函数bsp_InitLPUart初始化低功耗串口结构体，低功耗串口硬件参数。
  第2阶段，低功耗串口中断服务程序：
7 H, w1 s) H8 O! L
  接收中断是一直开启的。
3 `: f8 m8 ^& L5 b5 I* |# P  做了发送空中断和发送完成中断的消息处理。
  第3阶段，低功耗串口数据的收发：
* j7 x( V- R( o' r9 b1 x8 x' R" z
低功耗串口发送函数会开启发送空中断。
低功耗串口接收中断接收到函数后，可以使用函数lpcomGetChar获取数据。
66.3.2 低功耗串口时钟选择
我们这里实现了三种时钟选择：
( D& q. ^* y' ~7 `6 y0 ^
LPUART时钟选择LSE(32768Hz)
2 K# u8 k1 j3 v0 f7 e) ~最高速度是10922bps，最低8bps（计算方法3x < 32768 < 4096x，x表示波特率）。

2 X: e7 q' D& g9 cLPUART时钟选择HSI(64MHz)
最高值是21MHz，最小值15625bps（计算方法3x < 64MHz < 4096x，x表示波特率）。

0 n7 e# f* ]+ w+ lLPUART时钟选择D3PCLK1(100MHz)
最大值33Mbps，最小值24414bps（计算方法3x < 100MHz < 4096x，x表示波特率）。
; ?+ |, o' I* n4 Y
6 A  o' ~  v7 P- N3 k$ A0 A如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，程序代码如下，用户可以根据需要，使能相应的宏定义：
( }. E" W4 C! [8 N# W

1. //#define LPUART_CLOCK_SOURCE_LSE      
   
2. #define LPUART_CLOCK_SOURCE_HSI   
   
3. //#define LPUART_CLOCK_SOURCE_D3PCLK1   
   
4. 
   
5. /*
   
6. *********************************************************************************************************
   ( R$ J% T- _9 m' d/ p) b7 ?
7. *    函 数 名: InitHardLPUart
   
8. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开发板
   " Z' d- ^& I3 f
9. *    形    参: 无
   5 p( P! F7 A) x, q2 E' O5 B
10. *    返 回 值: 无
    0 p! X; i( @0 h' r6 w; ~
11. *********************************************************************************************************
    
12. */
    
13. static void InitHardLPUart(void)
    9 n7 c; J* @' t( ?2 H4 I+ s7 y
14. {
    & m1 ?7 [) _2 C: B8 _1 d* Q" F2 M
15.     GPIO_InitTypeDef  GPIO_InitStruct;
    
16.     RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
    
17. 
    
18. /* 使用LSE(32768Hz)，最高速度是10922bps，最低8bps */   
    
19. #if defined (LPUART_CLOCK_SOURCE_LSE)
    
20.     {
    ! t* i) m" a/ h
21.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    0 K1 w2 v  r; \6 [! P% Q' S5 p
22. 
      B) e- m0 ?- M4 l* R% x
23.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    $ @% q; f# u2 Y
24.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    + U5 e& f" i' v- a* V( t6 j
25.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    
26. 
    
27.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    / k# H9 {9 c8 Y  ?5 q. Z3 E
28.         {
    $ h5 M5 J) |- d- X( b% E1 E. [
29.             Error_Handler(__FILE__, __LINE__);        
    
30.         }
    0 E6 r  M5 w( W- F) S/ A/ b( o
31. 
    1 x& Q# R9 y! ^  J
32.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    ' w0 F- j9 z. [7 C
33.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_LSE;
    # K; @2 D/ ~" J1 S
34.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
35.     }   
    
36. /* LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps */   
    
37. #elif defined (LPUART_CLOCK_SOURCE_HSI)
    & J9 o/ O# B( R. Y' ?
38.     {
    + @9 j  W1 t2 s, \
39. 
    ! g( Q; ~! y+ E; ^$ h) M- C# S$ l
40.         RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    ' U0 L6 ]1 h9 N8 b! o  M
41. 
    
42.           RCC_OscInitStruct.OscillatorType      = RCC_OSCILLATORTYPE_HSI;
    7 e& R: E8 P+ n% h
43.           RCC_OscInitStruct.HSIState            = RCC_HSI_ON;
    
44.           RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    4 N! g* ?- Y8 {7 H. c+ h
45.           RCC_OscInitStruct.PLL.PLLState        = RCC_PLL_NONE;
    
46. 
    
47.         if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    
48.         {
    
49.             Error_Handler(__FILE__, __LINE__);        
    
50.         }
    ! j9 s1 S# |$ y( ^( |
51. 
    
52.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    
53.         RCC_PeriphCLKInitStruct.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_HSI;
    
54.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
55.     }
    
56. /* LPUART时钟选择D3PCLK1（100MHz），最大值33Mbps，最小值24414bps */   
    
57. #elif defined (LPUART_CLOCK_SOURCE_D3PCLK1)
    3 C7 S# K7 |* E+ b/ n, i% k4 }
58. 
    
59.     RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPUART1;
    % p) E% q& C9 K7 y9 q% s
60.     RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPUART1CLKSOURCE_D3PCLK1;
    1 |6 C4 ~5 a0 l% B# O# L" z
61.     HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
62. #else
    3 z4 O% ?& i9 G0 w
63.     #error Please select the LPTIM Clock source inside the bsp_lpuart_fifo.c file
    
64. #endif
    ' m6 `3 G% n6 J. y, e3 e
65. 
    # A. r5 ~- Q# s: R* O
66. #if LPUART1_FIFO_EN ==
    2 t" V* p& f; N! x
67.     /* 其它省略未写 */
    
68. #endif
    / a1 V9 T1 S# T/ n* _
69. }

复制代码

# q, k3 j) A0 h. y: b66.3.3 低功耗串口FIFO之相关的变量定义
9 G) D1 P1 a# s& C0 Z- v6 ~4 f低功耗串口驱动的核心文件为：bsp_lpuart_fifo.c, bsp_lpuart_fifo.h。
' C& p4 l/ w8 m2 i2 y. ^* Q/ M
* |+ U( ?8 V% I7 ?4 Z这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有printf函数的实现。
0 h1 `3 A* H/ r% B* o! O
/ b0 _, |" n. _每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
7 l* _2 u3 z" O+ G4 @2 |
  }# @) b, F2 `' I) I$ N1 ^9 I我们来看下这个FIFO的定义，在bsp_lpuart_fifo.h文件。

# ^4 Z! ?- |7 }7 M

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   $ Y, a& t- T6 z' y- n
2. #if LPUART1_FIFO_EN == 1
   
3.     #define LPUART1_BAUD         115200
   * s! \  T# Q+ t
4.     #define LPUART1_TX_BUF_SIZE     1*1024
   / C5 Q# q- P  D
5.     #define LPUART1_RX_BUF_SIZE     1*1024
   
6. #endif
   & T* \/ v2 Q0 U. H: H8 C1 K  u7 [
7. 
   
8. /* 串口设备结构体 */
   , h' `" ?3 }; W: N# ~
9. typedef struct
   2 Q; |# T8 d) U
10. {
    
11.     USART_TypeDef *uart;        /* STM32内部串口设备指针 */
    / z" h. f0 L- z3 ]
12.     uint8_t *pTxBuf;            /* 发送缓冲区 */
    ' y4 b2 {- y7 B
13.     uint8_t *pRxBuf;            /* 接收缓冲区 */
    * m4 \/ u) T- f+ i2 s1 P. r
14.     uint16_t usTxBufSize;        /* 发送缓冲区大小 */
    
15.     uint16_t usRxBufSize;        /* 接收缓冲区大小 */
    
16.     __IO uint16_t usTxWrite;    /* 发送缓冲区写指针 */
    # M) [! D! C5 D1 j$ ]; Z8 }* I
17.     __IO uint16_t usTxRead;        /* 发送缓冲区读指针 */
    ' a& c% g8 c) {3 T
18.     __IO uint16_t usTxCount;    /* 等待发送的数据个数 */
    
19. 
    
20.     __IO uint16_t usRxWrite;    /* 接收缓冲区写指针 */
    ( [/ u" Y0 z. u! ~. L# L& U
21.     __IO uint16_t usRxRead;        /* 接收缓冲区读指针 */
    
22.     __IO uint16_t usRxCount;    /* 还未读取的新数据个数 */
    2 A* Y! H( o4 |/ q! H: r' t7 y* P
23. 
    
24.     void (*SendBefor)(void);     /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25.     void (*SendOver)(void);     /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26.     void (*ReciveNew)(uint8_t _byte);    /* 串口收到数据的回调函数指针 */
    
27.     uint8_t Sending;            /* 正在发送中 */
    . j3 Y  K/ q" j4 `# q* s
28. }UART_T;
    
29. 
    & ^8 i" w1 }) ?! h5 O
30. 
    
31. bsp_lpuart_fifo.c文件定义变量。
    
32. 
    7 d* ^& T$ e/ [3 h/ f0 {
33. /* 定义低功耗串口结构体变量 */
    
34. #if LPUART1_FIFO_EN == 1
    
35.     static LPUART_T g_tLPUart1;
    
36.     static uint8_t g_TxBuf1[LPUART1_TX_BUF_SIZE];        /* 发送缓冲区 */
    , y6 Y  {3 h! t  h
37.     static uint8_t g_RxBuf1[LPUART1_RX_BUF_SIZE];        /* 接收缓冲区 */
    % J  K+ P* g+ J, J: ?" n
38. #endif
    

复制代码

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

5 S# w$ Z& [) f2 [1 d7 l7 J4 s66.3.4 低功耗串口FIFO初始化
低功耗串口的初始化代码如下；

) a9 b. {3 n' L% N; D. Z4 Z/*
*********************************************************************************************************
*    函 数 名: bsp_InitLPUart
& r9 C2 J2 J+ q$ f* E*    功能说明: 初始化串口硬件，并对全局变量赋初值.
*    形    参: 无
*    返 回 值: 无
2 r; M- @- l. M6 T. r+ F*********************************************************************************************************
*/
" L" g( u0 P- \. Z8 F0 gvoid bsp_InitLPUart(void)
- y  P( r' c8 e1 i+ F* p6 b" u{
5 Y2 E+ A9 m' Z8 R! y! u$ p7 G6 {    LPUartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    InitHardLPUart();        /* 配置串口的硬件参数(波特率等) */
' R, h3 l$ A# ?6 B$ @}
# |! i5 g$ x1 j2 }3 M2 ~3 U* h& F
8 X# _. F5 S. L
下面将初始化代码实现的功能依次为大家做个说明。
% ~! |1 l' K  O# C8 T% A* c+ i
! }' T1 J0 J4 q+ u* ^5 S  函数LPUartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
- U! N" W2 b# D7 k8 R5 A

1. /*
   * `; m8 Y# J4 n' ^' t2 Y
2. *********************************************************************************************************
   0 C! X2 s6 n; \& k2 A
3. *    函 数 名: LPUartVarInit
   . [; l2 [; e* B/ a
4. *    功能说明: 初始化串口相关的变量
   
5. *    形    参: 无
   7 s0 M# ]" b1 a; A. L& F
6. *    返 回 值: 无
   / X1 e) `! C9 `# @0 o2 h4 t
7. *********************************************************************************************************
   
8. */
   6 M+ p* ]$ T! O5 }  V6 c! n
9. static void LPUartVarInit(void)
   " _' h7 c+ `9 V
10. {
    ! ~2 q3 `  W" v
11. #if LPUART1_FIFO_EN == 1
    5 E2 q4 Q% U) M8 h( J+ d
12.     g_tLPUart1.uart = LPUART1;                        /* STM32 串口设备 */
    1 Y( K  p4 U$ b; U
13.     g_tLPUart1.pTxBuf = g_TxBuf1;                    /* 发送缓冲区指针 */
    
14.     g_tLPUart1.pRxBuf = g_RxBuf1;                    /* 接收缓冲区指针 */
    
15.     g_tLPUart1.usTxBufSize = LPUART1_TX_BUF_SIZE;         /* 发送缓冲区大小 */
    
16.     g_tLPUart1.usRxBufSize = LPUART1_RX_BUF_SIZE;         /* 接收缓冲区大小 */
    
17.     g_tLPUart1.usTxWrite = 0;                        /* 发送FIFO写索引 */
    
18.     g_tLPUart1.usTxRead = 0;                        /* 发送FIFO读索引 */
    5 V; x4 d" _8 S' ?3 W. \$ A1 c
19.     g_tLPUart1.usRxWrite = 0;                        /* 接收FIFO写索引 */
    
20.     g_tLPUart1.usRxRead = 0;                        /* 接收FIFO读索引 */
    
21.     g_tLPUart1.usRxCount = 0;                        /* 接收到的新数据个数 */
    
22.     g_tLPUart1.usTxCount = 0;                        /* 待发送的数据个数 */
    1 M4 a( C. f. i4 r/ A5 d
23.     g_tLPUart1.SendBefor = 0;                        /* 发送数据前的回调函数 */
    - v* d3 {7 R! D- e1 R6 ?8 z/ U
24.     g_tLPUart1.SendOver = 0;                        /* 发送完毕后的回调函数 */
    
25.     g_tLPUart1.ReciveNew = 0;                        /* 接收到新数据后的回调函数 */
    
26.     g_tLPUart1.Sending = 0;                             /* 正在发送中标志 */
    5 ?" k- }! W& z, o5 O. t
27. #endif
    ! a. F1 L4 t) u  T# h) E
28. }

复制代码

% T- z+ ~% h, u7 L  l

  函数InitHardLPUart
4 r8 {  B2 w# e此函数主要用于串口的GPIO，中断和相关参数的配置。

1. /* LPUART1的GPIO  PA9, PA10 */
   
2. #define LPUART1_CLK_ENABLE()              __HAL_RCC_LPUART1_CLK_ENABLE()
   
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
   
7. #define LPUART1_TX_AF                     GPIO_AF3_LPUART
   
8. 
   
9. #define LPUART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   & |1 ~  C8 I- ], k8 s0 V
10. #define LPUART1_RX_GPIO_PORT              GPIOA
    
11. #define LPUART1_RX_PIN                    GPIO_PIN_10
    ; I. _" Z+ r# E6 m1 _+ H& c! Y
12. #define LPUART1_RX_AF                     GPIO_AF3_LPUART
    
13. 
    . L! c1 t" J" [: R
14. /*
    / B! P1 i. O' }/ f  b/ \
15. *********************************************************************************************************
    0 D( k  m4 A* D/ w
16. *    函 数 名: InitHardUart
    
17. *    功能说明: 配置串口的硬件参数和底层
    
18. *    形    参: 无
    : e7 Z  _" t- P8 B5 t% O
19. *    返 回 值: 无
    " T' E- S1 L/ q5 T  x9 [! o6 R
20. *********************************************************************************************************
    
21. */
    
22. static void InitHardUart(void)
    5 Q5 _5 d; }* y9 `2 e
23. {
    + j. o. a) z0 D: w* z  M3 G
24.     GPIO_InitTypeDef  GPIO_InitStruct;
    
25.     RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
26. 
    
27.     /* 时钟初始化省略未写 */
    
28. #if LPUART1_FIFO_EN == 1        
    
29.     /* 使能 GPIO TX/RX 时钟 */
    
30.     LPUART1_TX_GPIO_CLK_ENABLE();
    1 i+ `: r( j/ u+ S0 C
31.     LPUART1_RX_GPIO_CLK_ENABLE();
    % `3 m- ~7 M0 Q
32. 
    
33.     /* 使能 USARTx 时钟 */
    
34.     LPUART1_CLK_ENABLE();   
    
35. 
    # K# V" |2 `) v/ v$ [& J( u  ]. O
36.     /* 配置TX引脚 */
    
37.     GPIO_InitStruct.Pin       = LPUART1_TX_PIN;
    
38.     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    , c0 S' `7 s6 k' o- p: i
39.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
40.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    - ]+ }" ~% l4 P, S- V+ h
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);
    # @( g/ B0 E* o$ A9 a) _
48. 
    ' [! r& i/ {3 _& o# u3 F4 D/ n
49.     /* 配置NVIC the NVIC for UART */   
    / r0 s7 q% O  T3 e6 `, p
50.     HAL_NVIC_SetPriority(LPUART1_IRQn, 0, 1);
    
51.     HAL_NVIC_EnableIRQ(LPUART1_IRQn);
    4 H  S* z( B' P0 k! ]8 u8 ]; W
52. 
    
53.     /* 配置波特率、奇偶校验 */
    
54.     bsp_SetLPUartParam(LPUART1,  LPUART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    1 E% g4 A" E# r% |1 q
55. 
    
56.     SET_BIT(LPUART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
57.     SET_BIT(LPUART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    
58.     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
59. #endif
    9 ?; N* a) L! D
60. }

复制代码

" i. }. e: S  T9 f低功耗定时器的参数配置API如下：
1 ]6 A7 o9 x, h9 Z
5 f, C; w) s& s8 k! T9 W

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_SetLPUartParam
   
4. *    功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *    形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   2 X4 X# s! ]- a% m/ ]8 C) P6 z
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   
9. *    返 回 值: 无
   ; \+ ?$ ~" y( B/ G1 c2 Q
10. *********************************************************************************************************
    / Y& T  J# y3 c0 i! b5 ~( v+ |
11. */   
    
12. void bsp_SetLPUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    
14.     /*##-1- 配置串口硬件参数 ######################################*/
    ! [% q/ k5 W$ ^2 G
15.     /* 异步串口模式 (UART Mode) */
    
16.     /* 配置如下:
    6 y  x8 F( n( L6 f! _1 m& @
17.       - 字长    = 8 位
    5 }7 r, n) X* A; Q- [4 t! ~
18.       - 停止位  = 1 个停止位
    $ R9 p! ^3 l! s, a( Z
19.       - 校验    = 参数Parity
    ; {# N/ p+ e& r: T. X
20.       - 波特率  = 参数BaudRate
    + `, j* d$ s5 N; N3 p$ K/ E
21.       - 硬件流控制关闭 (RTS and CTS signals) */
    
22. 
    5 A$ C  z  [- d' F% z
23.     UartHandle.Instance        = Instance;
    , `( f$ `$ g! J8 y. b/ I: I
24.     UartHandle.Init.BaudRate   = BaudRate;
    
25.     UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
26.     UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
27.     UartHandle.Init.Parity     = Parity;
    8 Q5 I6 S% w0 {' q, f7 ^+ Q
28.     UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
29.     UartHandle.Init.Mode       = Mode;
    5 j% ]" A% Q4 J6 \: h8 K, c3 p4 }
30.     UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
31.     UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    7 F  C# B0 Z& l$ O/ d/ }
32.     UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    : M2 V8 r* Y: c; ]- f$ B. p
33. 
    
34.     if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
35.     {
    ! p; {1 J% b. m3 \" F2 V; _
36.         Error_Handler(__FILE__, __LINE__);
    # B: w) W# M/ U5 I
37.     }
    ' Q' C* R& g( t3 B6 X
38. }

复制代码

5 C' T% L" K. l) t) y+ f. T  Z66.3.5 低功耗串口中断服务程序工作流程
* D( |9 e1 }- L2 x+ s% A( I串口中断服务程序是最核心的部分，主要实现如下三个功能

, x2 \: D! Y5 w& S+ W0 m  收到新的数据后，会将数据压入RX_FIFO。
# Y4 a* \) M6 u* C5 j2 W2 p  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
" N4 ^1 h4 k& r
. @8 V# S3 B* d) }9 I/ d, q
下面我们分析一下串口中断处理的完整过程。

# n/ Y9 j9 U0 D# ]+ M8 d当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为LPUART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
3 _( O$ Y# o" t4 @0 {" a
我们将串口中断服务程序放在bsp_lpuart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_lpuart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是低功耗串口的中断服务程序：

1. #if LPUART1_FIFO_EN == 1
   % c! ?# n9 S" t8 S+ [
2. void LPUART1_IRQHandler(void)
   
3. {
   
4.     LPUartIRQ(&g_tLPUart1);
   
5. }
   
6. #endif

复制代码

下面，我们来看看UartIRQ函数的实现代码。
( [" L/ l1 L  z3 v$ ]

1. /*
   8 K$ h$ S, r! ~" v
2. *********************************************************************************************************
   9 K% z7 |. n, I
3. *    函 数 名: UartIRQ
   
4. *    功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *    形    参: _pUart : 串口设备
   ) E# L) \. r; N6 {7 v
6. *    返 回 值: 无
   4 i' D% t+ r: w* y# h; W+ j  s
7. *********************************************************************************************************
   
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    
11.     uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.     uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    " n4 X  u$ Q, n3 _& p  U; H
13.     uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14. 
    
15.     /* 处理接收中断  */
    
16.     if ((isrflags & USART_ISR_RXNE) != RESET)
    4 [  g; [# E- t4 K  I1 @2 Q4 \
17.     {
    
18.         /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.         uint8_t ch;
    % D# N5 B- \; w8 O9 S/ q& ?, W
20. 
    
21.         ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    ; R7 @  M% [6 U, E2 @9 f+ g
22.         _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.         if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.         {
    
25.             _pUart->usRxWrite = 0;
    
26.         }
    
27.         if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.         {
    7 B( f9 c: s0 [* ]" j' k7 Q$ R! x
29.             _pUart->usRxCount++;
    
30.         }
    , o- [4 Q4 A$ g+ v+ O8 K
31. 
    
32.         /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.         //if (_pUart->usRxWrite == _pUart->usRxRead)
    8 r6 D( U5 @2 e( n9 F
34.         //if (_pUart->usRxCount == 1)
    
35.         {
    : F2 d# b4 z2 E; q/ u, I0 S
36.             if (_pUart->ReciveNew)
    
37.             {
    + Z# Z: j1 r0 ?
38.                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    ; {, v, E/ n: j& C; b
39.             }
    9 ?' S8 x# q; ~5 e& m5 x4 J
40.         }
    
41.     }
    5 w8 A3 P4 q# ^1 `
42. 
    # B$ C! \/ ?/ }/ s, d9 q* N
43.     /* 处理发送缓冲区空中断 */
    
44.     if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.     {
    : {3 R" b( O  ?$ h
46.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.         if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    3 C. K: T' f6 {# X( C2 T
48.         {
    
49.         /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.             //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    ( e) V: n- T; {. N
53.             /* 使能数据发送完毕中断 */
    
54.             //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    1 d/ X5 G2 M$ r- x6 D* X/ ]$ ]
55.             SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.         }
    6 [! y% W/ ?" F
57.         Else  /*　还有数据等待发送 */
    
58.         {
    ' K3 G) h' S: ?( i6 ]9 f
59.             _pUart->Sending = 1;
    
60. 
    7 [5 A5 H) o# e' X9 n
61.             /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    # J" y& V8 e, o0 C0 l" t
62.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
      Y4 t" a+ w! x
63.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    4 Q6 ~9 b9 i% L5 k
64.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.             {
    
66.                 _pUart->usTxRead = 0;
    ) v7 e5 U7 [: Q5 ?2 Y1 N9 V
67.             }
    1 o5 O! [( f. u6 a/ A$ ~
68.             _pUart->usTxCount--;
    
69.         }
    
70. 
    
71.     }
    ; R' k/ l4 q$ A% \8 S+ P8 e% t- M
72.     /* 数据bit位全部发送完毕的中断 */
    $ l$ @) _9 `, F/ n
73.     if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    / m/ V+ ]9 o: l: G3 F! i. N, L
74.     {
    
75.         //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.         if (_pUart->usTxCount == 0)
    & F( m  [1 n# o' H
77.         {
    1 p' X6 S* p5 ]! C, k4 G
78.             /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.             //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.             CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    
82.             /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.             if (_pUart->SendOver)
    ) I) x2 [; a1 [2 f! ]4 J/ T
84.             {
    
85.                 _pUart->SendOver();
    + g5 E- k$ F0 A, F2 Z* m5 U  w
86.             }
    5 y9 d5 K, T1 ^4 t. ^
87. 
    9 `* L+ v. d" N, J4 y
88.             _pUart->Sending = 0;
    
89.         }
    " Z* f) o9 H: Q$ }; r( {
90.         else
    ( u* o- F  h5 t0 j4 x1 a
91.         {
    & w7 H. z1 X. @* l2 S1 {) D
92.             /* 正常情况下，不会进入此分支 */
    
93. 
    0 y6 \5 }: f( T" I0 E+ y
94.             /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.             //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    2 X- P" e% |$ G' y
96.             _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
      @9 g& m. |8 W0 ~# A3 z% e3 i# E
97.             if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.             {
    
99.                 _pUart->usTxRead = 0;
    , e8 l+ L& C/ p% B4 T$ `
100.             }
     
101.             _pUart->usTxCount--;
     
102.         }
     $ P! A/ A. P/ ?: @  E- F
103.     }
     8 K# d2 B0 @% J7 U8 x0 B
104. 
     - L6 F& e0 U( q+ v5 l. h
105.     /* 清除中断标志 */
     
106.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     : u5 f+ X  B0 K3 _8 y$ e/ x" X: K
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);
     : o3 n! @& e5 B/ W+ f, t1 h8 Q# @
111.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     
114.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.     SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);   
     - ]: B6 Z9 d7 W3 |# K: d- |9 Y
117. }

复制代码

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

2 s: C1 n' O* E2 G' c: P  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。

8 y, L* Q) A- D4 N特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
2 e# }' S( j% A* R" P9 F* d" p
  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

66.3.6 低功耗串口数据发送
低功耗串口数据的发送主要涉及到下面三个函数：
1 B8 u# o. O" E: h
4 y% h, ?1 `* A1 |9 F2 X

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: lpcomSendBuf
   * c3 V; l% o' Y1 f3 ~: I+ \
4. *    功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *              _ucaBuf: 待发送的数据缓冲区
   
7. *              _usLen : 数据长度
   2 w! m$ _# Z! B4 C3 n" ?- B# Q
8. *    返 回 值: 无
   : @/ a3 b1 y2 z: S* v$ H6 [$ U
9. *********************************************************************************************************
   
10. */
    
11. void lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    
13.     LPUART_T *pUart;
    
14. 
    
15.     pUart = ComToLPUart(_ucPort);
    
16.     if (pUart == 0)
    
17.     {
    6 u0 M: \6 H  l$ W( P5 C
18.         return;
    1 J. G  e5 |0 b
19.     }
    # H, O, ^* {: G9 A$ A  c
20. 
    
21.     if (pUart->SendBefor != 0)
    / u0 P9 D# p9 d
22.     {
    & Z+ k7 y0 f; D" A2 q# r. |
23.         pUart->SendBefor();        /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.     }
    
25. 
    6 [. C( M# h- [# e0 e: M3 }
26.     LPUartSend(pUart, _ucaBuf, _usLen);
    
27. }
    
28. 
    
29. /*
    ' p/ [9 L( J3 m8 I6 j& o! p
30. *********************************************************************************************************
    
31. *    函 数 名: lpcomSendChar
    ; A& u; y. \# w& Y- e: C- Y2 P
32. *    功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    5 {- @4 }' A/ q% e. k) m
33. *    形    参: _ucPort: 端口号(LPCOM1)
    # r$ ]: }# \: G
34. *              _ucByte: 待发送的数据
    7 k" h' C/ {' ?  }- x# H
35. *    返 回 值: 无
    
36. *********************************************************************************************************
    . s  b& I3 B8 V
37. */
    % q) p* d& t& a1 u2 U( A* ?+ R) f
38. void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte)
    8 Y: q: O2 B: r- K' ~
39. {
    
40.     lpcomSendBuf(_ucPort, &_ucByte, 1);
    2 y' x, o" i5 o
41. }
    ; R; S5 l& p+ n; }: j
42. 
    / O# G" y/ i( \  W9 n% b8 @+ D1 ~
43. /*
    
44. *********************************************************************************************************
    5 i3 y  Q) c8 F6 s( y  K
45. *    函 数 名: LPUartSend
    
46. *    功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    / l% \' \1 y) b4 z7 ?3 J( K! n
47. *    形    参: 无
    
48. *    返 回 值: 无
    # I+ i1 K6 D* H: b" J# K3 j
49. *********************************************************************************************************
    + T3 {- W' W7 b: |) m
50. */
    
51. static void LPUartSend(LPUART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    . R$ ?' C+ m, k% M% |! J' |2 u
52. {
    2 y; N6 M4 x) X: |
53.     uint16_t i;
    : v" J+ V# P7 X5 |/ B
54. 
    + P& b4 K, L0 J& y8 e5 R
55.     for (i = 0; i < _usLen; i++)
    
56.     {
    
57.         /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    9 h' r' ~. f) j' d1 v- U% P
58.         while (1)
    
59.         {
    6 P" _4 r7 X) \# y. e
60.             __IO uint16_t usCount;
    2 l1 u; H+ V2 Q9 q% O
61. 
    4 \" {8 m# ^5 U! Y; T" R' j1 M
62.             DISABLE_INT();
    $ d- R$ N- ^5 l  `* h  q3 \, Z4 y
63.             usCount = _pUart->usTxCount;
    
64.             ENABLE_INT();
    5 T2 w' p  Z" V9 s
65. 
    ( G8 L- x' u2 t( L- `
66.             if (usCount < _pUart->usTxBufSize)
    
67.             {
    
68.                 break;
    + \6 m. x, u. f0 ?+ Q
69.             }
    
70.             else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
71.             {
    . p7 g# q. i! s% z
72.                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
73.                 {
    7 ?% K+ m# X+ i/ G
74.                     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    - V2 @4 y' s$ ~
75.                 }  
    & v$ n5 R  S# y9 {
76.             }
    
77.         }
    
78. 
    
79.         /* 将新数据填入发送缓冲区 */
    
80.         _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;</i>
    " x& R( C  w( J, h, y1 f' o
81. 
    
82.         DISABLE_INT();
    2 y. l5 q1 n) K- i' {" f
83.         if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    7 m1 D: L7 d" m3 v8 r7 J5 ~2 m
84.         {
    
85.             _pUart->usTxWrite = 0;
    % J& i5 G3 ^" |+ T/ |7 `
86.         }
    
87.         _pUart->usTxCount++;
    
88.         ENABLE_INT();
    3 s' p* D7 Q; @" G# Z- l
89.     }
    * S& R. ^; A2 C6 Y7 Y8 \8 w
90. 
    
91.     SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);    /* 使能发送中断（缓冲区空） */
    4 W# F6 S! z6 K; _
92. }

复制代码

+ `( |3 g  {, f% T5 x( O, u函数lpcomSendChar是发送一个字节，通过调用函数lpcomSendBuf实现，而函数lpcomSendBuf又是通过调用函数LPUartSend实现，这个函数是重点。

函数LPUartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
, O6 G0 m' f8 T
  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
! R* O4 n7 L1 I+ U  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
, W9 Y$ @( |0 u* m5 a
注意：由于函数LPUartSend做了static作用域限制，仅可在bsp_lpuart_fifo.c文件中调用。函数lpcomSendChar和lpcomSendBuf是供用户调用的。
/ [4 F) [* B" i# n* [/ \1 H' c
/ `! z, P* Q) r  b/ d' G3 x函数lpcomSendBuf中调用了一个函数pUart = ComToLPUart(_ucPort)，这个函数是将整数的COM端口号转换为LPUART结构体指针。
3 C8 }3 U- L$ f4 ]! s9 `

1. /*
   ! X% P! s- c1 |) i! M+ W/ o" r* B
2. *********************************************************************************************************
   
3. *    函 数 名: ComToLPUart
   
4. *    功能说明: 将COM端口号转换为LPUART指针
   & U" L8 [9 `" B6 s6 X
5. *    形    参: _ucPort: 端口号(LPCOM1)
   
6. *    返 回 值: uart指针
   
7. *********************************************************************************************************
   
8. */
   9 U% ~+ i+ o; A3 \
9. LPUART_T *ComToLPUart(LPCOM_PORT_E _ucPort)
   
10. {
    
11.     if (_ucPort == LPCOM1)
    5 @  w; Z! t% c- i* W" V. S
12.     {
    
13.         #if LPUART1_FIFO_EN == 1
    . {% @: ~6 j- i/ C! o3 e2 l, ~
14.             return &g_tLPUart1;
    
15.         #else
    
16.             return 0;
    
17.         #endif
    
18.     }
    3 m3 e7 ~3 n6 |$ e9 y1 d
19.     else
    
20.     {
    3 [7 z: @2 K7 {* X( a( ^! {
21.         Error_Handler(__FILE__, __LINE__);
    # h4 a2 {9 x0 S. `9 r
22.         return 0;
    
23.     }
    4 c  \6 ]5 V' V
24. }

复制代码

/ a* H. E7 Y+ L

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

3 N+ i+ t; u* e) `' j

1. /*
   
2. *********************************************************************************************************
   2 d1 d" Z' B/ L! t& A2 D
3. *    函 数 名: lpcomGetChar
   
4. *    功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *    形    参: _ucPort: 端口号(LPCOM1)
   $ o" V" E% ^& M" C+ A
6. *              _pByte: 接收到的数据存放在这个地址
   3 o9 Y' D; T: x4 Q* K
7. *    返 回 值: 0 表示无数据, 1 表示读取到有效字节
   . ]* @2 ], R+ W7 G3 z
8. *********************************************************************************************************
   ( N: Y3 t. R2 l8 P* c; s$ e$ m
9. */
   ! I3 o5 ]; r! d+ H5 O
10. uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    
12.     LPUART_T *pUart;
    ( M5 _0 e4 h; D  E1 L5 B- F+ f9 t
13. 
    
14.     pUart = ComToLPUart(_ucPort);
    
15.     if (pUart == 0)
    + g4 {5 i+ {$ k; C3 U# L
16.     {
    
17.         return 0;
    
18.     }
    
19. 
    ( m3 J" X- c% J
20.     return LPUartGetChar(pUart, _pByte);
    , a8 l2 T/ I! L
21. }
    + a" `0 r+ n! j( Z
22. 
    
23. /*
    0 N* q1 x* L! E0 m
24. *********************************************************************************************************
      l; D0 x- R! z* O( _2 u" c
25. *    函 数 名: LPUartGetChar
    
26. *    功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *    形    参: _pUart : 串口设备
    2 w* ?0 F8 j% t- H& |' e
28. *              _pByte : 存放读取数据的指针
    1 e8 P( P1 C' ]; j* H, x
29. *    返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    
31. */
    4 n) i# `0 ]0 O2 V" u$ J0 g8 K
32. static uint8_t LPUartGetChar(LPUART_T *_pUart, uint8_t *_pByte)
    
33. {
    # s! q3 K6 k/ G
34.     uint16_t usCount;
    ) q9 Y" i" ~% ^+ g
35. 
    / A7 y/ G, Q$ U  k" a9 W
36.     /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    " ^2 m5 L0 D7 o! `
37.     DISABLE_INT();
    / R2 E; s! t# i
38.     usCount = _pUart->usRxCount;
      P: _' y& R, P% N  n
39.     ENABLE_INT();
    
40. 
    
41.     /* 如果读和写索引相同，则返回0 */
    
42.     //if (_pUart->usRxRead == usRxWrite)
    3 b& c5 S/ c- }. g" U5 T! N
43.     if (usCount == 0)    /* 已经没有数据 */
    # ~' l5 w3 h# i' t, |4 K6 W
44.     {
    
45.         return 0;
    2 E* f6 F8 U% v  F
46.     }
    1 }* _* k  a( y
47.     else
    1 V, F( u4 y7 ]8 n8 _3 s
48.     {
    ) ?; ^% @- l2 U8 \" q
49.         *_pByte = _pUart->pRxBuf[_pUart->usRxRead];        /* 从串口接收FIFO取1个数据 */
    
50. 
    
51.         /* 改写FIFO读索引 */
    ! Y( U; U9 G2 l# l: K: N
52.         DISABLE_INT();
    $ W: N+ J3 y* z. m$ c/ B
53.         if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.         {
    
55.             _pUart->usRxRead = 0;
    
56.         }
    4 h3 w8 C5 B, N( @3 d! G
57.         _pUart->usRxCount--;
    
58.         ENABLE_INT();
    
59.         return 1;
    
60.     }
    
61. }

复制代码

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

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

, y% c9 b; h& \5 a; T6 B& N66.3.8 低功耗串口printf实现
' }0 z- e& L! c: @7 fprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
, {* f* u; r$ v7 g9 ^- e
实现printf输出到串口，只需要在工程中添加两个函数：
( e+ F" [( L' j' Q- C6 s

1. /*
   6 A/ [, B3 n; L) C5 D
2. *********************************************************************************************************
   
3. *    函 数 名: fputc
   4 y0 q( A3 Q0 C1 B" V
4. *    功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   # ]/ G* k% W5 P1 v" O' s# S% {! M* b$ r
5. *    形    参: 无
   
6. *    返 回 值: 无
   . \, S8 e, W2 F/ L) N5 Z/ x
7. *********************************************************************************************************
   
8. */
   ' C* l$ X! F" I- Z1 }* z* _( y; y
9. int fputc(int ch, FILE *f)
   
10. {
    " _% y) t* T) I3 C5 y( l- C" i
11. #if 0    /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    $ S; u/ r8 M- E* r( O
12.     lpcomSendChar(LPCOM1, ch);
    * A5 a5 ~# {! b+ S  a8 l2 m
13. 
    % Q0 a) \1 ~3 y9 l1 {
14.     return ch;
    
15. #else    /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.     /* 写一个字节到USART1 */
    ( I7 b, V5 F, q' o
17.     LPUART1->TDR = ch;
    
18. 
    
19.     /* 等待发送结束 */
    8 C) {3 ?1 Z; U% J* G
20.     while((LPUART1->ISR & USART_ISR_TC) == 0)
    
21.     {}
    % R0 X/ y/ `$ r1 F
22. 
    ) r3 z# ?4 H* y0 Y9 J" A0 D
23.     return ch;
    . N( |) ^' R8 [7 r; u
24. #endif
    ) |  ^( R, w% @+ a/ W
25. }
    $ c* Q2 I: u, Q" j$ b
26. 
    
27. /*
    ; c( A* V/ {% P8 M
28. *********************************************************************************************************
    7 G$ C, E1 A& G
29. *    函 数 名: fgetc
    
30. *    功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    6 I- S: f7 o$ k% O7 G; l# ]' @
31. *    形    参: 无
    
32. *    返 回 值: 无
    
33. *********************************************************************************************************
    % m! ~  ^3 N# `& i
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    3 N( R# y1 q+ z+ t
38. #if 1    /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.     uint8_t ucData;
    
40. 
    
41.     while(lpcomGetChar(LPCOM1, &ucData) == 0);
    9 N1 O2 b4 ^# g7 [- G, Q
42. 
    
43.     return ucData;
    4 a0 E7 z5 S( j3 K5 k
44. #else
      j6 m; K! P; ^" H* J; t' L' z' H8 }
45.     /* 等待接收到数据 */
    + ^2 r: u) D- a9 u/ ?1 X. [+ r5 ?, S
46.     while((LPUART1->ISR & USART_ISR_RXNE) == 0)
    - O5 ?+ ~& c- x/ b
47.     {}
    & Q( f4 o, J" F/ c8 q0 ?) U* r
48. 
    9 Z; I' |4 R! R; Q
49.     return (int)LPUART1->RDR;
    
50. #endif
    . b7 u4 o8 }0 J$ p, m6 p! O
51. }

复制代码

. c! p3 i# G& d# D通过上面代码中的条件编译，可以设置printf函数阻塞和非阻塞方式，如果采用非阻塞方式，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
: l* B5 U' v* P, n3 S
66.3.9 低功耗串口停机唤醒方式
# P/ {, j7 S1 ^+ Z低功耗串口的唤醒主要是通过接收数据来唤醒，具体唤醒的方如下：

* D: v( u# v/ E% c0 q" d7 O* w5 s  检测到起始位唤醒。
低功耗串口设置为起始位检测方式如下，并且设置进入停机模式。
6 o# C% M. {2 Y6 g7 {+ o/ W9 r
1 S& h7 L# m- n+ q; ^0 [如果想唤醒H7，发一个起始位即可，简单些也可以任意发送一个数据：

8 a1 a; a1 s2 \. p; j7 s/ x) m

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   7 q5 j' D5 T0 [" l
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. 
   
8. /* 接收起始位唤醒 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
11. {
    
12.     Error_Handler(__FILE__, __LINE__);                        
    ( o( h4 W, F6 a5 k; V
13. }
    ( t7 k8 j* _$ p" A
14. 
    
15. /* 进入停机模式 */
    7 x5 i% `( Z. O* n3 Z" E1 l
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    $ p. v3 \; X% E+ b
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    " s0 m$ J2 _0 H- J- R0 S
19. SystemClock_Config();
    
20. 
    # |: [2 v) _' a4 c% a( ^  `. W
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    

复制代码

  检测到RXNE标志唤醒，即接收到数据。
低功耗串口设置为RXNE检测方式如下，并且设置进入停机模式。
  \3 s8 u4 J; {2 I/ Q) j  W3 v% p
如果想唤醒H7，发一个任意数据即可。

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   
3. 
   
4. /* 确保LPUART没有在通信中 */
   6 C% p% k, F' H: U# Y* T; e; @6 G- ]
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   
8. /* 接收到数据唤醒，即RXNE标志置位 */
   
9. WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
   
10. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    7 D: u9 i2 M; G( A% ?' C! Y* ~
11. {
    " _) d+ Z. p& b/ M$ Z* f% v1 {
12.     Error_Handler(__FILE__, __LINE__);                        
    
13. }
    
14. 
    ! i% X( M; C! P7 z& A; h: f
15. /* 进入停机模式 */
    
16. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    ! V0 G. X8 |) d% @$ L/ I
17. 
    
18. /* 退出停机模式要重新配置HSE和PLL*/
    
19. SystemClock_Config();
    / k% Q; E4 R9 E3 {1 l' J0 W
20. 
    
21. /* 关闭LPUART的停机唤醒 */
    
22. HAL_UARTEx_DisableStopMode(&UartHandle);
    / \& B9 I9 ~! ]) z$ ]
23. 
      t  N" g3 r( h0 ~  {" z

复制代码

% A% }6 {  q1 [% ~9 G9 H  检测到匹配地址时唤醒。
+ k% h9 {( o( A1 u低功耗串口设置为地址匹配检测方式如下，并且设置进入停机模式。
, ~4 f& l4 \; h0 W# g2 v
' l' Q# ^) I( F- r9 r& l如果想唤醒H7，必须发送指定的匹配地址。匹配地址支持7bit和4bit匹配两种方式，比如我们采用7bit匹配，设置地址是0x19，那么用户唤醒的时候要将最高bit设置为1，即发生地址0x99（0b1001 1001）才可以唤醒。
' [0 k2 S" Q5 ^5 d2 F1 F

1. /* 使能LPUART的停机唤醒 */
   
2. HAL_UARTEx_EnableStopMode(&UartHandle);
   * b& x7 d& D! j- X$ l7 b
3. 
   
4. /* 确保LPUART没有在通信中 */
   - b# |, q; ~8 v
5. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
   + S( ]1 j% h3 f* c
6. while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
   
7. 
   
8. /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
   
9. WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
   0 z! d$ Y' j4 d* o/ U
10. WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
    2 G8 y9 b' Y' ^; A  |. O* x+ t
11. WakeUpSelection.Address       = 0x19;
    ' i4 `- I3 z9 q
12. if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
13. {
    
14.     Error_Handler(__FILE__, __LINE__);                        
    
15. }
    
16. 
    
17. CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
    % L9 L1 }3 g( ^9 g
18. 
    
19. /* 进入停机模式 */
    1 r: q% M. E% L) A, }
20. HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
21. 
    6 r( Y  r  E0 N$ Z( a% q
22. /* 退出停机模式要重新配置HSE和PLL*/
    % r1 R6 y2 u8 }% D! r4 s7 Z
23. SystemClock_Config();
    1 H- K8 a4 L2 ?  p& O/ [
24. 
      O! T$ E  H) A* V- `& E
25. SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
    ' s% g( L- F* J, k
26. 
    9 r0 m/ V, p% K1 J# i, B
27. /* 关闭LPUART的停机唤醒 */
    6 J3 L% y; v7 z2 N) A& Z' e
28. HAL_UARTEx_DisableStopMode(&UartHandle);
    . z* x; h( E1 @1 U6 D5 M8 G; p( k7 q
29. 
      u; {" e8 c" M& K' {% ~& C5 E: @+ y

复制代码

/ Z- \8 i/ S$ r" Q$ f# U* v这里有一点要特别注意，程序启动后，调用下面两个函数：
. u- @/ [4 x1 {/ m) s

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

复制代码

) y$ @- p: x$ t' K66.4 低功耗串口FIFO板级支持包（bsp_lpuart_fifo.c）
串口驱动文件bsp_lpuart_fifo.c主要实现了如下几个API供用户调用：

  bsp_InitLPUart
  lpcomSendBuf
9 j1 L# N. U, f  lpcomSendChar
5 h; {; v# r6 L  lpcomGetChar
66.4.1 函数bsp_InitLPUart
函数原型：
1 J  q8 f. k/ n2 {8 o; J- K: I
* o& l+ b  h; z; q: fvoid bsp_InitLPUart(void)

函数描述：

+ @( I/ Z0 r) l- X, Y8 [& T此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
8 D0 S) M+ _. R; G( L
使用举例：
: Q% a3 T, z' `6 M; D/ Y
5 q/ y: L" G: ~& x( R/ C串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
! o: {4 R+ [! B, y! e8 O
66.4.2 函数lpcomSendBuf
函数原型：

0 U. Q. p; }) avoid lpcomSendBuf(LPCOM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
6 ^. J+ M% E( q
- \# B- L1 V$ ]函数描述：
& ^4 R/ M) A  e* {/ q
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：

  第1个参数_ucPort是端口号。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
. Z) Y: V( [5 W  第3个参数_usLen是要发送数据的字节数。
注意事项：
8 |/ O. q# M8 o- C) V$ W
* n5 J( V! B$ e  Q6 K: T* p6 C/ } 此函数的解读在本章66.3.5小节。
发送的数据最好不要超过bsp_lpuart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
使用举例：

调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
1 i+ v  l  F$ A2 D$ f
! l8 u6 B0 i( G

1. const char buf1[] = "接收到串口命令1\r\n";
   8 [" v' K9 Z; l# o2 W
2. lpcomSendBuf(LPCOM1, (uint8_t *)buf1, strlen(buf1));

复制代码

66.4.3 函数lpcomSendChar
函数原型：
2 I- V# n4 V( l( U  P
void lpcomSendChar(LPCOM_PORT_E _ucPort, uint8_t _ucByte);
, B/ T1 b# C  y1 q: H- ]  q
函数描述：
1 J7 P0 B/ @/ C3 o$ Y( o
此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数lpcomSendBuf实现的。
; S+ N5 D0 C' h' {
/ ?% K) `+ t& w5 b函数参数：
4 F! I( a& R: I2 v  L% p: s  第1个参数_ucPort是端口号。
  第2个参数_ucByte是待发送的数据。
注意事项：

  此函数的解读在本章66.3.2小节。
  y4 z" e8 p, ]3 H# A/ v8 k( v使用举例：

5 B" }- [# v) Y; L3 v& W7 Q调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。比如通过串口1发送一个字符c：
/ r( o+ Z! p! D: W
% b5 w0 p. \! ~) @" a2 N. jlpcomSendChar(LPCOM1, 'c')。
& @8 `& l  m7 d
. h  a, c) s3 U+ m8 _66.4.4 函数lpcomGetChar
函数原型：

# t1 S+ u7 Z8 \! K+ O" m9 ?uint8_t lpcomGetChar(LPCOM_PORT_E _ucPort, uint8_t *_pByte)

" }& X. G; W. F" i9 f函数描述：
: H) d& v: K- k0 g
1 V+ U* a3 R) P# ~) D; j/ S% ~此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：

  第1个参数_ucPort是端口号。
  第2个参数_pByte用于存放接收到的数据。
* J% E6 S) S9 t8 B  返回值，返回0表示无数据, 1 表示读取到有效字节。
/ ~/ J: v0 Q; C注意事项：

; v: v6 Q# Z) b/ p1 e  此函数的解读在本章66.3.6小节。
, Z; B1 D# `' {2 }1 v使用举例：

# M+ O+ c. `( w调用此函数前，务必优先调用函数bsp_InitLPUart进行初始化。
$ d" r% \" Z1 ~
- d* H4 n" k& v% `0 E比如从串口1读取一个字符就是：lpcomGetChar(LPCOM1, &read)。
1 j& ^2 E, r  Q6 E- x# M
) n+ |, `& b& Y) V66.5 低功耗串口FIFO驱动移植和使用
7 {3 q4 K$ U3 W0 ?  e6 q串口FIFO移植步骤如下：
4 t4 Q* H3 c$ g% \
# P/ V4 i! H, z  O  第1步：复制bsp_lpuart_fifo.h和bsp_lpuart_fifo.c到自己的工程目录，并添加到工程里面。
/ e9 X8 j7 `: M0 T; E; Q  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
7 L1 {1 ~* I: Z/ ^9 u7 m" E5 R

1. #define    LPUART1_FIFO_EN    1
   $ Q" x( |$ c0 G0 F1 }2 F1 h8 B
2. 
   , ]+ h+ ?$ X/ h; u/ q
3. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   8 k7 G# I" v9 }, A4 t
4. #if LPUART1_FIFO_EN == 1
   ! W( F! p) G4 L  c
5.     #define LPUART1_BAUD         115200
   
6.     #define LPUART1_TX_BUF_SIZE     1*1024
   6 |  u  ?; Y$ D& G2 P% z% I6 s
7.     #define LPUART1_RX_BUF_SIZE     1*1024
   & d7 b1 Q) H: W2 C( M+ V
8. #endif

复制代码

4 ~! J. \# ?7 V- t# K# G/ ^  N2 O  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
; |) H% {, X& N& _# C, P# }6 ~5 m7 S66.6 实验例程设计框架
: i5 u" s0 ^  M% }5 |6 u  H9 r通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

. `3 d6 H7 C! l
  第1阶段，上电启动阶段：

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

$ F$ t$ d. p0 y4 v6 ~第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
* M, `* _7 V" F2 _+ X4 K6 t) n0 r6 Q% n第2部分，应用程序设计部分，实现了三种停机唤醒方法。
, x4 d1 Z/ y3 z0 I66.7 实验例程说明（MDK）
配套例子：
8 z" l7 q5 b* i* J4 F
V7-046_低功耗串口的停机唤醒（串口FIFO方式）

实验目的：

学习低功耗串口的停机唤醒。
实验内容：

8 A% y2 ^- o1 ~% J) m6 V% z启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
( D0 q7 A9 F; H- w+ HUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
4 b; n3 }1 ]9 ]( t' L  LLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
LPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。
" ]) w% n- u- f& W/ H
LPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。
) A2 W5 ?/ o6 V
LPUART时钟选择D3PCLK1(100MHz)，最大值33Mbps，最小值24414bps。
% R5 n4 @3 N8 Q: W0 g
实验操作：
$ b+ m6 v" ?8 e6 L8 z4 x9 Q
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
上电后串口打印的信息：
8 S4 p5 Z" k( c- g2 Y
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

$ {5 e8 b4 k: B" ]
* i( ^, W. h4 J程序设计：

  系统栈大小分配：

  RAM空间用的DTCM：

. ~% x, a* `9 G9 X# |
  硬件外设初始化
3 `5 F6 `  V0 W; d/ j: G9 c
硬件外设的初始化是在 bsp.c 文件实现：
& v0 [5 L9 P% L6 z8 B

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   4 [5 i& J6 }. {. k" Y* H
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   * n+ ?3 B/ W# }  T7 N( p
5. *    形    参：无
   ' v, |$ M" Z; U$ C
6. *    返 回 值: 无
   7 `0 s- M5 _8 i7 F6 \4 Q: O, I
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   # [( B; i2 q9 q! m/ T, b
10. {
    % ~$ x1 t! ~# N& o* s  P3 S
11.     /* 配置MPU */
    5 ^/ ?' w1 _2 U
12.     MPU_Config();
    
13. 
    - H  r* t$ G# U2 z
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    3 p0 C7 {' D# O! W6 z
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    5 G' N5 {1 @+ P% c
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    5 k( m# y% q% q+ b* G
23. 
    * I* C( B5 D! e1 r: \8 R
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    / w* u  K/ Q3 v$ n4 N" ^4 r! _
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    3 m  j" d6 |& a3 f
29.     SystemClock_Config();
    
30. 
    5 E7 x4 s5 ^& \; y; b6 Z
31.     /*
    
32.        Event Recorder：
    # f' S+ ~, V! U9 M, L
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    & d6 {) l7 f; A5 j, x# }
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    , l- K4 I: ~2 j  n4 ~
39.     EventRecorderStart();
    
40. #endif
    ' o: L2 F) f, e. o
41. 
    2 J6 t5 H& {2 A. c
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    6 x7 V. m4 U) a3 f3 I" Q; M, E
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
      Y3 w; f2 G% f9 i$ V6 ?
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    , J/ n. t  J( W+ J) D# _: J$ x+ D
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ; x* x( ~( `1 j4 u% p" d
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    

复制代码

( D& m7 E$ }8 [
  MPU配置和Cache配置：

- f% U7 N4 y; @. G& W$ G数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
; N) V" f: q& ]+ ~5 Y
& y' E( l. D& P/ [5 |* m4 z

1. /*
   % [- f! W* [: o# s2 m0 Y, }' [' q
2. *********************************************************************************************************
   : k8 H; ?' \& e. n* C* a# P
3. *    函 数 名: MPU_Config
   " N8 c1 k& N9 `4 L
4. *    功能说明: 配置MPU
   2 o9 k( M% F+ A7 c% Z$ g! k- E
5. *    形    参: 无
   * _# u( p% M& A. ]$ Y9 v% j2 `
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ' K! l) ^9 ^2 j
8. */
   
9. static void MPU_Config( void )
   7 L2 B! r2 Z* ]
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    ) e/ \8 l# s5 r; N
13.     /* 禁止 MPU */
    # P: B5 o& {: M; V  t6 u
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ( Y' E5 j  c$ k: ^
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    2 x" z, ^% ], q
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    . [( c8 [3 O8 G4 W- u1 @8 U# d
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 }6 z5 W- k" B0 Q( |* N
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    3 k5 X: C* c8 Z6 q0 S! n1 L) o4 V% v( ?
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 N6 O( n- M. Y9 A8 G
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    ' e& H) N& o  Z  K% b, \7 e
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    # L7 L3 D- f  {/ r/ d
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 v5 B3 N; }6 z9 ^4 g
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    " j5 o, U3 L7 G& ]+ t8 {
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    " M4 b5 l" y6 ?( i( H0 ]7 S- }) h6 [
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , p+ V* O' V. n) T7 z& M- }" t! O
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ! O8 R/ G& @! \6 ]7 m5 r
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
      O) s- @; M# B$ c% y
44. 
    9 e: K' G+ K7 Q
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    % f- D' O' j& J' u( X/ ^
46. 
    
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    4 d3 C$ [* x6 ~  K( O$ e3 \9 T9 t
51. /*
    
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    2 l, X! N5 F; G) [
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    % r, U7 c, D% |
60. {
    
61.     /* 使能 I-Cache */
    ( J. c# ^' l3 v# x! ?) @
62.     SCB_EnableICache();
    ( Q3 y6 v/ b2 J, f5 Z
63. 
    ' \0 j0 C1 @! d& Y
64.     /* 使能 D-Cache */
    & D, n- @  b) z, G1 g
65.     SCB_EnableDCache();
    
66. }

复制代码

! A% t# z+ f9 S# T0 c8 J  U  每10ms调用一次蜂鸣器处理：

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
4 u* @5 T  e% \
+ R/ {( b& Y9 [: l/ [

1. /*
   2 a2 M# P# {: u5 N, L( V
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
     e. ], o3 D  h4 y3 [8 V, K+ Q
6. *    形    参: 无
   $ o4 _2 ?/ ^3 m% O& E/ B
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    9 ]6 }, m6 C5 T! W3 E& M! B
11. {
    0 ?/ M. t/ h1 ^" l) w7 F
12.     bsp_KeyScan10ms();
    
13. }
    0 z: }$ M; b& A  `

复制代码

* s+ r& T. T% H0 u; x  主功能：

主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
% V" j* n8 l) l+ }K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
6 T# W6 p: E$ y( O# b/ R. GK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
6 W) ~) `% U( z6 O5 ?

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   9 a- D: {  x( n7 o/ j3 M7 i8 c  c
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   ( _. K# {  w( Y6 I9 `
10. {
    ( j# u9 T; s) T$ g; X! A; F% g
11.     uint8_t ucKeyCode;    /* 按键代码 */
    % @1 E1 A# q' [, r& x5 e
12.     uint8_t ucReceive;
    
13. 
    : W6 l5 f% ?5 @
14. 
    5 [) @( P, H( g; h5 K8 i! ~& i! _
15.     bsp_Init();        /* 硬件初始化 */
    
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
17.     PrintfHelp();    /* 打印操作提示 */
    
18. 
    
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    3 U% M. @3 B6 q* c) U0 z+ D  S- c
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    ; y3 Y6 w4 X0 G' v9 `3 X7 s
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    & R8 F) [* V6 M4 p+ s. V
23. 
    
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    . f4 I+ G( D1 b# M# _* J7 V& U
26. 
    ' I; x% G% O( o( ^) I: h
27.     while (1)
    
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    8 D- \# H$ c1 F1 p6 _9 O. _6 A
30. 
    
31.         /* 判断定时器超时时间 */
    - o8 i: a# W# F. }& ]* q6 u4 p
32.         if (bsp_CheckTimer(0))   
    
33.         {
    4 b1 t% R6 S6 p. `: W; \2 r& @* U
34.             /* 每隔100ms 进来一次 */  
    1 L8 }; X- ]" ]7 y8 }8 l1 v' n
35.             bsp_LedToggle(2);
    
36.         }
    ) K# _1 R8 t# k# L9 J) E8 t
37. 
    8 n) i% ^3 U9 A& Y
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
      X2 M& c& \% V! c/ a9 v
41.         {
    , E- I; w3 P: S  G' `8 h
42.             switch (ucKeyCode)
    ' S; \+ S! |9 F7 a* V& w
43.             {
    
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    ) f0 D* g& G: b/ m$ z
47. 
    
48.                     /* 确保LPUART没有在通信中 */
    / b! @2 F% T- \% A1 X  H) }# c/ Q
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    / w  F0 S: ?' L3 ^# R% s" E9 q% W
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    
56.                         Error_Handler(__FILE__, __LINE__);                        
    + b8 ?9 x8 k3 Y
57.                     }
    
58. 
    0 M# J% q) r  @
59.                     /* 进入停机模式 */
    * z" h2 u# I7 C5 o" [1 `; D
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    & M: z# I$ J- h' ~/ P* k3 ~0 |
61. 
    2 U; M4 y0 X7 d) q6 @  R
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    * M. z3 u3 a+ o+ E- n
63.                     SystemClock_Config();
    , D$ J  m1 C, n, D/ ?- C. R8 l/ q
64. 
    1 m3 J' s# q7 L' ~9 F: I
65.                     /* 关闭LPUART的停机唤醒 */
    
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    4 t! f! J' S. G
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    
72. 
    
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    ) ]) v7 L, g4 Q% |
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    + E# N5 {0 \% P2 }1 n1 O7 R4 Y
76. 
    : k) p# \8 j1 t9 e$ J4 ^
77.                     /* 确保LPUART没有在通信中 */
    * ~  r  I  U3 N# ~4 ]/ I( I
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    ; d% ^0 e3 S! V# K2 V5 P2 x; b; Y
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    , C/ D2 B2 f2 \7 _+ b
80. 
    
81.                     /* 接收起始位唤醒 */
    
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
84.                     {
    . E8 a% a5 V! W9 B+ N0 D& T* c- i- e
85.                         Error_Handler(__FILE__, __LINE__);                        
    ' ^: ?2 z: I, r! h
86.                     }
    5 Z7 S  O- K- j6 h9 I# r: R
87. 
    
88.                     /* 进入停机模式 */
    7 n- v  W. d5 D
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    7 w) V# \5 E1 W2 ?
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    , \2 e% J0 O( {4 P! @3 Y) x
92.                     SystemClock_Config();
    
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    - h- m/ p: Z% v3 t* l) |' V
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    ' @  F, s& Q# F6 q2 M
96. 
    
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     5 P$ c* D+ x( K5 e5 G
103.                     /* 使能LPUART的停机唤醒 */
     % X7 x. d9 U( f, l. K0 o) F
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     ) f+ T5 Q5 {6 ?8 Q
105. 
     ' z; N; {9 ~* |. z* |. w  t$ y
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     
109. 
     
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     8 |' B6 O" {, Q: E. T1 {
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     9 X* x( ~. T$ J, `
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     3 [. ]$ q/ E, q3 q# X  K8 A
115.                     {
     ! I: A, b' A8 q/ m
116.                         Error_Handler(__FILE__, __LINE__);                        
     
117.                     }
     " T2 C' E' y8 {/ [8 D  f  Y. \
118. 
     0 o- @8 i# B/ ]; q& ]# j
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     
123. 
     $ _6 R0 F4 }- l9 u
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     ) h% z, M, W3 V* q
125.                     SystemClock_Config();
     - t8 o1 L3 W* \, s8 I" {
126. 
     0 j- z( Y: r: |  U" o$ a
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     ! C) b$ B% J6 D. W( \' t
128. 
     
129.                     /* 关闭LPUART的停机唤醒 */
     # e9 h+ u6 X( O& h
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     3 ~- z  C( |$ g
132.                     break;
     
133. 
     
134.                 default:
     9 \" y- h. @7 h  A: m
135.                     /* 其它的键值不处理 */
     . f# C3 G/ l7 S5 v8 ^
136.                     break;
     
137.             }
     
138.         }
     " Y. h, ^0 P7 V% p" L  T$ L/ O
139.     }
     
140. }

复制代码

- V: L; M+ [6 ~  |; ^! _) Q66.8 实验例程说明（IAR）
配套例子：
. P, ?# @/ ~$ p* Z) c
V7-046_低功耗串口的停机唤醒（串口FIFO方式）
# n; b  g$ |1 a7 ~& H5 \
* u" ~! Z# C6 Z) C) @实验目的：

学习低功耗串口的停机唤醒。
实验内容：
6 b: B; ^) f! @$ p* i
# R# }/ i& N: M% T! H启动一个自动重装软件定时器，每100ms翻转一次LED2。
当前程序使用的串口打印就是用的低功耗串口，即USART1和LPUART1都可以使用PA9和PA10。
上电启动了一个软件定时器，每100ms翻转一次LED2。
+ v# E  R8 _6 G7 xUSART1和LPUART都可以使用PA9和PA10引脚做串口打印功能，本例子是用的LPUART做开发板串口打印。
! k& \; z4 Y1 b" F( I& yLPUART可以选择HSI时钟，LSE时钟和D3PCLK1时钟，在bsp_lpuart_fifo.c文件开头可以配置。如果需要低功耗模式唤醒，必须使用LSE或者HSI时钟，波特率在bsp_lpuart_fifo.h定义，本例子是用的HSI时钟。
6 g+ b7 l% |# T' T8 p5 I$ gLPUART时钟选择LSE(32768Hz)，最高速度是10922bps，最低8bps。

* C5 k' F' n3 ^3 oLPUART时钟选择HSI(64MHz)，最高值是21MHz，最小值15625bps。

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

实验操作：
; O3 T" f& l1 O6 @" B  t- r
) s. H- b% R4 v9 P6 O( CK1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
* }! c, ?8 \0 k/ B% ]3 TK3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
% L4 j6 _8 t, R2 H0 b8 q9 x6 j. M上电后串口打印的信息：

4 U2 J( j6 [" R8 V9 T波特率 115200，数据位 8，奇偶校验位无，停止位 1
" ]8 f5 \0 o- L  e

/ d# ~3 D3 t# b4 Z% q* X程序设计：
& N+ j* J% `+ V! e3 e
  系统栈大小分配：

, L& s& U* i3 P, p
  RAM空间用的DTCM：

, x0 |7 w' a9 l$ a3 _1 ~

# S/ J$ _. Y  D/ R; x  硬件外设初始化
4 g# s( l$ q, F2 I: A: @- `/ h
硬件外设的初始化是在 bsp.c 文件实现：
* o0 y7 n: J, ^) q: f8 U( `2 l

1. /*
   ! w/ K. \& ]% w& i9 [7 R
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   ! w- k" x' b& \2 {! H
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   3 e% C6 d6 d# {# n9 T
9. void bsp_Init(void)
   
10. {
    5 P, H: K. l0 ~
11.     /* 配置MPU */
    1 j$ a# S# d1 P& r* K- u
12.     MPU_Config();
    : _- w$ v! [- t% S' Z! G) F, O
13. 
    
14.     /* 使能L1 Cache */
    ) B4 A5 k4 V" _% {; \+ j
15.     CPU_CACHE_Enable();
    
16. 
    " u6 c7 K: W( f8 {
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    . n' t$ U  \0 x1 b4 V, N
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    + q$ \4 ]+ i6 y  g% {$ D" q
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    6 ?. I0 G1 v+ T9 y5 V
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    - M- z  D! x7 Y8 [0 p
28.     */
    + [. l. I& \: q8 c
29.     SystemClock_Config();
    
30. 
    
31.     /*
    4 p  X1 k2 M$ }4 O4 \4 E
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    - H* F/ E$ X* `
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    , ]8 F' J" T- W8 n9 P% D. |
35.     */   
    8 T) p( k3 P( c
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    . W) D# d+ t! c) B3 C9 b+ B( m
40. #endif
    
41. 
    . u3 f$ l+ w1 P% F3 H! W8 [
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    - K# A" O1 M3 p- h! s8 {7 o0 V
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    # N1 n3 Q7 f; l  \8 |
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    * @( I" M6 R. X- O$ X$ [" |
49. }

复制代码

  MPU配置和Cache配置：

& {6 C% ^, P! a# h$ U- w数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   3 A: j5 n! M! L" ~# u
2. *********************************************************************************************************
   % K1 `$ U$ X2 J, @$ C2 L7 Q) m
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   3 s& Q' A, U; @. P2 |3 v" M
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   1 E7 q1 L2 `3 E0 m
8. */
   / i; d) J+ O! e  l' \* M. I* B% F
9. static void MPU_Config( void )
   1 ]- e0 t1 t0 r8 k* v
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    / M0 ?! g+ d& r
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    & U: l% o5 B& X! b
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    / {* k/ A' }* t% C4 p& @
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    $ \5 p5 O0 b! O6 n1 T" k
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    % V9 d; R( N$ P2 d; H' n
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ' ]% m/ t& L' b- ^% g7 |; c
28. 
    1 w% O: H/ O# I) `1 m8 @; M
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    ' [. [- W' M! R+ F6 c" @. D* j
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    2 X: ]2 W, y8 B5 }6 d% o  b# i
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    " k. i0 Y; t. Q7 o# Z0 E
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ! {+ U# w$ e' Z6 M2 T) w6 I
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    3 ~6 J* x2 W. n* y
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    3 O8 C' a/ b1 ?+ O' `& {
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    ( T+ o" o% {2 T
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # P' L" Z5 H" B% D4 g
46. 
      G/ e7 Q" g6 G! H+ f+ z0 V9 e
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    # |, u8 `2 N& O& \
49. }
    
50. 
    # C+ q4 X: @1 z6 e$ k4 [% b+ S
51. /*
    1 b$ c3 p" r, C
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    & ~# b6 c$ w: U
55. *    形    参: 无
    ) \, f+ h% Y$ f% N7 ~4 L
56. *    返 回 值: 无
    , Z- q* S; O, I7 n! w
57. *********************************************************************************************************
    
58. */
    : w/ `( M7 @) p+ y( i
59. static void CPU_CACHE_Enable(void)
    ! B# }2 p3 B+ ]5 F
60. {
    
61.     /* 使能 I-Cache */
    # `- A) G) |) k5 f
62.     SCB_EnableICache();
    
63. 
    & w" ~9 Q) q  p/ z# K  r
64.     /* 使能 D-Cache */
    ! x1 ^! w$ L/ ^3 A* F& }+ S9 n
65.     SCB_EnableDCache();
    " i5 i7 J' j# v# |3 q
66. }
    
67. 
    

复制代码

  每10ms调用一次蜂鸣器处理：
  s6 ^$ _$ `# x
7 d* V7 k) m0 i  A2 ^蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

5 u- |/ u& l6 C# X

1. /*
   
2. *********************************************************************************************************
   & k' V: ?+ V5 }& I; A8 I
3. *    函 数 名: bsp_RunPer10ms
   ' ^) l! K) v' E6 m7 t* l  p
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
     M' ~5 r0 R9 N, I( u4 o
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   6 L1 T! e$ [# Z: U5 Q
7. *    返 回 值: 无
   9 E1 u+ l* y6 A8 g3 ?& y
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    ! K4 q' ~; x* c: P
11. {
    5 @: M9 R0 e: `; R" |
12.     bsp_KeyScan10ms();
    % t: G4 c- d. s; K& V9 V" R8 O
13. }

复制代码

! E# d$ n. s! A/ w  主功能：

4 _& D- C, P* _$ r; n5 \主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒。
% X/ r4 g% O! ^, u4 _) B. X K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒。
+ ^+ ]; m6 Z0 f# }; { K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒。
( o/ b0 {/ B/ I9 a

1. /*
   9 B, I( b3 t  F
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   9 P' A* A7 ]) V/ ]5 F
5. *    形    参: 无
   4 g' b1 c, G4 \, H9 M
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   4 ~. G" A" _- ?" U8 r" ^; H
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ( Z! c, U" b9 s6 ~* f
12.     uint8_t ucReceive;
    
13. 
    
14. 
    : Z. x# U% }5 J" ^7 |
15.     bsp_Init();        /* 硬件初始化 */
    0 w9 X9 \5 W* `8 e* X/ |% Q
16.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
17.     PrintfHelp();    /* 打印操作提示 */
    : u2 G0 A& ^* k0 E$ l+ W8 |  q: r
18. 
    5 `/ t. D; B8 j6 K  ]* k
19.     HAL_EnableDBGStopMode(); /* 使能停机模式下，LPUART工程可以继续调试 */
    
20.     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI); /* 从停机模式唤醒后使用HSI时钟 */
    
21.     __HAL_RCC_LPUART1_CLKAM_ENABLE();     /* 激活LPUART的自主模式，即停机状态下可以继续接收消息 */
    , `3 A+ G7 c  o7 T& U6 H
22.     __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_WUF);/* 使能唤醒中断 */
    , d  `  ?% c  _0 a: X: z/ X+ d/ \
23. 
    
24. 
    
25.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    7 a/ O  a" C6 q9 V% ?
26. 
    
27.     while (1)
    
28.     {
    
29.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ; {3 J7 ^2 a6 I2 c
30. 
    5 N/ h  M' e, m, l. z) j7 L0 y9 I) Z; {
31.         /* 判断定时器超时时间 */
    $ G! r- I7 k' T/ _/ Y$ p+ X; r
32.         if (bsp_CheckTimer(0))   
    
33.         {
    0 z! @* l$ C' U0 M* E# z' a9 c
34.             /* 每隔100ms 进来一次 */  
    7 t* h6 r0 _( ]: ~0 `9 E2 _$ x
35.             bsp_LedToggle(2);
    ( N3 ^4 J# y1 p# L' a& t! z
36.         }
    ; P! y4 R3 K  ~  r/ m3 U- @
37. 
    3 \$ |$ X! q8 ^
38.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    5 y! P' _1 }) W  k
39.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
40.         if (ucKeyCode != KEY_NONE)
    
41.         {
    
42.             switch (ucKeyCode)
    
43.             {
    # B; m: P/ L4 P' {
44.                 case KEY_DOWN_K1:    /* K1键按下，进入停机模式，低功耗串口接收任意字节数据可以唤醒 */
    ! |" c7 V  `5 E4 o* l. T
45.                     /* 使能LPUART的停机唤醒 */
    
46.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    
47. 
    ) W' G1 a. p  p" N- r& z
48.                     /* 确保LPUART没有在通信中 */
    
49.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    2 Q# I: E, N: q+ N
50.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    4 K& I* w* R( Q, d" x
51. 
    
52.                     /* 接收到数据唤醒，即RXNE标志置位 */
    
53.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_READDATA_NONEMPTY;
    * r; W$ [" a* y
54.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    
55.                     {
    2 W$ M$ ~9 n9 Z) S
56.                         Error_Handler(__FILE__, __LINE__);                        
    8 E5 i; M+ A# g# c
57.                     }
    : j& |& a6 `- ~0 o7 P  a$ y
58. 
    0 L4 ?- B  i5 p6 ?8 O
59.                     /* 进入停机模式 */
    6 {' h! r: P: b5 u+ A% ~% ^. T5 c
60.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    6 A- I7 c) l! u2 m) d( i5 Q
61. 
    $ h) V- f; X2 ?* k( i' Y' i$ ~
62.                     /* 退出停机模式要重新配置HSE和PLL*/
    
63.                     SystemClock_Config();
    
64. 
    
65.                     /* 关闭LPUART的停机唤醒 */
    & E. Z) X5 ~' J+ K
66.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    
67. 
    
68.                     lpcomGetChar(LPCOM1, &ucReceive);
    
69. 
    
70.                     printf("低功耗串口接收到数据 %x 后唤醒\r\n", ucReceive);
    
71.                     break;
    
72. 
    $ c2 p; d, E: C1 o* u4 Q
73.                 case KEY_DOWN_K2:     /* K2键按下，进入停机模式，低功耗串口检测到起始位可以唤醒 */
    0 h4 x8 s: l' N
74.                     /* 使能LPUART的停机唤醒 */
    
75.                     HAL_UARTEx_EnableStopMode(&UartHandle);
    ! T2 W# `" K$ F
76. 
    ! v% F) c& I5 j& Z0 V8 W& E
77.                     /* 确保LPUART没有在通信中 */
      I7 x( U; }. f% w+ A: D
78.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
    ' v# s. r7 r, q4 w1 \
79.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
    
80. 
    
81.                     /* 接收起始位唤醒 */
    ; e& F- O- g' E0 d8 C
82.                     WakeUpSelection.WakeUpEvent = UART_WAKEUP_ON_STARTBIT;
    
83.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
    : W% f$ a. O) g2 y* F  l' F% S+ |
84.                     {
    : b% e+ c0 X% u& V6 w
85.                         Error_Handler(__FILE__, __LINE__);                        
    
86.                     }
    * e5 R( k$ Q+ F8 Q% B/ C$ ~
87. 
    
88.                     /* 进入停机模式 */
    
89.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    
90. 
    
91.                     /* 退出停机模式要重新配置HSE和PLL*/
    
92.                     SystemClock_Config();
    3 v: d3 f: t$ l0 V: J
93. 
    
94.                     /* 关闭LPUART的停机唤醒 */
    % W$ B- v1 ~2 I# M: @
95.                     HAL_UARTEx_DisableStopMode(&UartHandle);
    ) u6 L  x( g3 \; n
96. 
    " P6 Y. `# K7 Z' r
97.                     lpcomGetChar(LPCOM1, &ucReceive);
    9 _5 d5 {# `: t! A- C2 |& q
98. 
    
99.                     printf("低功耗串口检测到起始位（数据） %x 后唤醒\r\n", ucReceive);
    
100.                     break;
     
101. 
     . t4 N1 Y+ }3 U( ?2 y$ c, K
102.                 case KEY_DOWN_K3:    /* K3键按下，进入停机模式，低功耗串口检测到地址0x99可以唤醒 */
     
103.                     /* 使能LPUART的停机唤醒 */
     " @& A4 A6 T" Z: @" [# V
104.                     HAL_UARTEx_EnableStopMode(&UartHandle);
     ' d# i7 |  t8 K! s
105. 
     & F0 i- Y3 P7 j0 s9 `
106.                     /* 确保LPUART没有在通信中 */
     
107.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_BUSY) == SET){}
     
108.                     while(__HAL_UART_GET_FLAG(&UartHandle, USART_ISR_REACK) == RESET){}
     : M/ K9 t) Y; U) Y5 R
109. 
     ( T& k( V4 S2 a* H
110.                     /* 接收地址0x99（发送的数据MSB位要为1），可以唤醒 */
     , W! L$ |2 Z! P8 g1 [. z0 b4 \  n
111.                     WakeUpSelection.WakeUpEvent   = UART_WAKEUP_ON_ADDRESS;
     9 O. A6 B0 h3 p8 r& w* [) @; C9 f! }; o
112.                     WakeUpSelection.AddressLength = UART_ADDRESS_DETECT_7B;
     
113.                     WakeUpSelection.Address       = 0x19;
     
114.                     if (HAL_UARTEx_StopModeWakeUpSourceConfig(&UartHandle, WakeUpSelection)!= HAL_OK)
     
115.                     {
     
116.                         Error_Handler(__FILE__, __LINE__);                        
     6 r* _! N7 a; |* n. i- N
117.                     }
     
118. 
     0 n) O, y  y% R0 D
119.                     CLEAR_BIT(LPUART1->CR1, USART_CR1_RXNEIE); /* 关闭串口接收中断 */
     
120. 
     
121.                     /* 进入停机模式 */
     
122.                     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     1 \9 ]+ n0 H0 k) X/ R8 @2 Q  C
123. 
     
124.                     /* 退出停机模式要重新配置HSE和PLL*/
     9 q7 G* ?. l8 T' A
125.                     SystemClock_Config();
     : r2 T* r* y! b9 Q3 d
126. 
     
127.                     SET_BIT(LPUART1->CR1, USART_CR1_RXNEIE);  /* 使能串口接收中断 */
     " g: f/ H: s/ G
128. 
     1 o( T' W+ J9 v& E) N
129.                     /* 关闭LPUART的停机唤醒 */
     
130.                     HAL_UARTEx_DisableStopMode(&UartHandle);
     
131. 
     " I9 u' o; R) Q# X% u5 k3 M
132.                     break;
     
133. 
     - n2 R- Y" g: `* t
134.                 default:
     
135.                     /* 其它的键值不处理 */
     
136.                     break;
     $ N0 N4 D. |; C! U$ Q
137.             }
     . o3 n. m) M5 d4 d7 \0 x% [' R
138.         }
     + r0 z. L3 a4 K% h1 c) z, s) r/ @
139.     }
     
140. }
     ) }& c' w3 \! J7 d5 ~) ^

复制代码

1 l9 V7 Z$ L4 B$ F- T. N" w
' Y  `6 e8 }3 k) |66.9 总结
本章节就为大家讲解这么多， 重点是低功耗串口的三种唤醒方式。
& g" P  ^3 ]0 v% _


/ G: \& t* @$ J5 F: |7 W