STM32通用低功耗组件——PM

电源管理组件

嵌入式系统低功耗管理的目的在于满足用户对性能需求的前提下，尽可能降低系统能耗以延长设备待机时间。高性能与有限的电池能量在嵌入式系统中矛盾最为突出，硬件低功耗设计与软件低功耗管理的联合应用成为解决矛盾的有效手段。现在的各种 MCU 都或多或少的在低功耗方面提供了管理接口。比如对主控时钟频率的调整、工作电压的改变、总线频率的调整甚至关闭、外围设备工作时钟的关闭等。有了硬件上的支持，合理的软件设计就成为节能的关键，一般可以把低功耗管理分为三个类别：

u  处理器电源管理主要实现方式：对 CPU 频率的动态管理，以及系统空闲时对工作模式的调整。

u  设备电源管理主要实现方式：关闭个别闲置设备

u  系统平台电源管理主要实现方式：针对特定系统平台的非常见设备具体定制。

随着物联网 (IoT) 的兴起，产品对功耗的需求越来越强烈。作为数据采集的传感器节点通常需要在电池供电时长期工作，而作为联网的 SOC 也需要有快速的响应功能和较低的功耗。

在产品开发的起始阶段，首先考虑是尽快完成产品的功能开发。在产品功能逐步完善之后，就需要加入电源管理 (Power Management，以下简称 PM) 功能。为了适应 IoT 的这种需求，RT-Thread 提供了电源管理组件。电源管理组件的理念是尽量透明，使得产品加入低功耗功能更加轻松。

PM 组件介绍

RT-Thread 的 PM 组件采用分层设计思想，分离架构和芯片相关的部分，提取公共部分作为核心。在对上层提供通用的接口同时，也让底层驱动对组件的适配变得更加简单。

主要特点

RT-Thread PM 组件主要特点如下所示:

u  基于模式来管理功耗，空闲时动态调整工作模式，支持多个等级的休眠。

u  对应用透明，组件在底层自动完成电源管理。

u  支持运行模式下动态变频，根据模式自动更新设备的频率配置，确保在不同的运行模式都可以正常工作。

u  支持设备电源管理，根据模式自动管理设备的挂起和恢复，确保在不同的休眠模式下可以正确的挂起和恢复。

u  支持可选的休眠时间补偿，让依赖 OS Tick 的应用可以透明使用。

u  向上层提供设备接口，如果打开了 devfs 组件，那么也可以通过文件系统接口访问。

工作原理

低功耗的本质是系统空闲时 CPU 停止工作，中断或事件唤醒后继续工作。在 RTOS 中，通常包含一个 IDLE 任务，该任务的优先级最低且一直保持就绪状态，当高优先级任务未就绪时，OS 执行 IDLE 任务。一般地，未进行低功耗处理时，CPU 在 IDLE 任务中循环执行空指令。RT-Thread 的电源管理组件在 IDLE 任务中，通过对 CPU 、时钟和设备等进行管理，从而有效降低系统的功耗。

( _, P8 \% g8 k0 b- _

在上图所示，当高优先级任务运行结束或被挂起时，系统将进入 IDLE 任务中。在 IDLE 任务执行后，它将判断系统是否可以进入到休眠状态（以节省功耗）。如果可以进入休眠， 将根据芯片情况关闭部分硬件模块，OS Tick 也非常有可能进入暂停状态。此时电源管理框架会根据系统定时器情况，计算出下一个超时时间点，并设置低功耗定时器，让设备能够在这个时刻点唤醒，并进行后续的工作。当系统被（低功耗定时器中断或其他唤醒中断源）唤醒后，系统也需要知道睡眠时间长度是多少，并对OS Tick 进行补偿，让系统的OS tick值调整为一个正确的值。

低功耗状态和模式

RT-Thread PM 组件将系统划分为两种状态:运行状态(RUN)和休眠状态(Sleep)。运行状态控制 CPU 的频率，适用于变频场景；休眠状态根据 SOC 特性实现休眠 CPU，以降低功耗。两种状态分别使用不同的 API 接口，独立控制。

u  休眠状态休眠状态也就是通常意义上的低功耗状态，通过关闭外设、执行 SOC 电源管理接口，降低系统功耗。休眠状态又分为六个模式，呈现为金字塔的形式。随着模式增加，功耗逐级递减的特点。下面是休眠状态下模式的定义，开发者可根据具体的 SOC 实现相应的模式，但需要遵循功耗逐级降低的特点。

u  运行状态运行状态通常用于改变 CPU 的运行频率，独立于休眠模式。当前运行状态划分了四个等级：高速、正常、中速、低速，如下：

PM组件的实现接口

在 RT-Thrad PM 组件中，外设或应用通过投票机制对所需的功耗模式进行投票，当系统空闲时，根据投票数决策出合适的功耗模式，调用抽象接口，控制芯片进入低功耗状态，从而降低系统功耗。当未进行进行任何投票时，会以默认模式进入(通常为空闲模式)。

pm组件的控制块：

1. static struct rt_pm _pm;

复制代码

API接口：

1.请求休眠模式

1. void rt_pm_request(uint8_t sleep_mode);

复制代码

sleep_mode 取以下枚举值：

1. enum
   
2. 
   
3. {
   
4. 
   4 F: h; E3 h7 t8 `6 H
5.    /* sleep modes */
   
6. 
   
7.    PM_SLEEP_MODE_NONE = 0,    /* 活跃状态 */
   
8. 
   # D) w* g4 o% a
9.    PM_SLEEP_MODE_IDLE,        /* 空闲模式（默认） */
   
10. 
    
11.    PM_SLEEP_MODE_LIGHT,       /* 轻度睡眠模式 */
    
12. 
    % `% A( L# N; p$ n5 `8 s$ U
13.    PM_SLEEP_MODE_DEEP,        /* 深度睡眠模式 */
    
14. 
    
15.    PM_SLEEP_MODE_STANDBY,     /* 待机模式 */
    ' m6 R1 }, ?0 r& \
16. 
    
17.    PM_SLEEP_MODE_SHUTDOWN,    /* 关断模式 */
    
18. 
    0 Y* h- d- o4 h- M9 L6 b& M4 g9 U! Q
19.    PM_SLEEP_MODE_MAX,
    " ~4 m( V; j1 M5 y9 |
20. 
    
21. };

复制代码

调用该函数会将对应的模式计数加1，并锁住该模式。此时如果请求更低级别的功耗模式，将无法进入，只有释放（解锁）先前请求的模式后，系统才能进入更低的模式；向更高的功耗模式请求则不受此影响。该函数需要和 rt_pm_release 配合使用，用于对某一阶段或过程进行保护。下面是具体代码实现：

1. void rt_pm_request(rt_uint8_t mode)
   
2. 
   3 f( \  S7 H/ _" V: s
3. {
   
4. 
   
5.    rt_base_t level;
   
6. 
   
7.    struct rt_pm *pm;
   $ u/ p$ _3 D) ?# s. Y/ I% M
8. 
   
9. 
   
10. 
    9 R9 E( Q+ J# Y# D2 R- m/ ~2 m
11.    if (_pm_init_flag == 0)
    
12. 
    % Q- d0 K& C8 S! y' L  s
13.        return;
    
14. 
    2 X# ]* ^" i- \& ?
15. 
    6 C+ G2 x# [- R' M6 R
16. 
    
17.    if (mode > (PM_SLEEP_MODE_MAX – 1))
    
18. 
    
19.        return;
    - G4 w& T/ n! e# b4 ]
20. 
    
21. 
    
22. 
    
23.    level = rt_hw_interrupt_disable();
    % d7 H0 u( w6 B
24. 
    
25.    pm = &_pm;
    * m5 u' A- R! x% a  U
26. 
      n- r% O9 L! N/ O+ k  V. x
27.    if (pm->modes[mode] < 255)
    - b6 @0 ]7 S1 [& y
28. 
    0 a$ {" Q4 A; _
29.        pm->modes[mode] ++;//将对应的模式计数加1
    
30. 
    
31.    rt_hw_interrupt_enable(level);
    
32. 
    
33. }

复制代码

3 e8 N, \& Z8 a1 f! p2 M0 ]

2.释放休眠模式

1. void rt_pm_release(uint8_t sleep_mode);

复制代码

调用该函数会将对应的模式计数减1，配合rt_pm_request 使用，释放先前请求的模式。下面是具体代码实现：

1. void rt_pm_release(rt_uint8_t mode)
   : Y- j4 s% D% B; Z+ p, L1 J+ Q
2. 
   9 @7 d6 |9 _$ U& \: C1 C" ~
3. {
   
4. 
   & _) o9 S5 q+ E6 K/ S
5.    rt_ubase_t level;
   $ _2 R3 O# N6 ]: J/ w: ?' ]4 s$ H
6. 
   
7.    struct rt_pm *pm;
   $ \3 g4 K4 i" Q# Z
8. 
   ! ^0 I5 h- L/ y6 s: p) J
9. 
   7 V% g, [; H& {9 t0 @, m
10. 
    & r1 t: }; P$ y2 Z
11.    if (_pm_init_flag == 0)
    
12. 
    5 r( \- M- c8 G5 k, Z' U- R
13.        return;
    ( ^/ Q+ K; ]4 `" M9 p+ i
14. 
    6 O* m( h7 J0 Z  W- }
15. 
    
16. 
    
17.    if (mode > (PM_SLEEP_MODE_MAX - 1))
    , c+ }8 K6 G) L" `9 V0 n( L
18. 
    9 K6 T" }( M) J7 N# H$ K, X) G
19.        return;
    
20. 
    ) J# O8 F/ y! w+ a
21. 
    ! [: T* q1 z" a5 E7 g. L
22. 
    0 l6 t1 }4 A' L( Y
23.    level = rt_hw_interrupt_disable();
    
24. 
    
25.    pm = &_pm;
    
26. 
    
27.    if (pm->modes[mode] > 0)
    2 y, i0 ]/ l' M! d; L- D% W
28. 
    
29.        pm->modes[mode] --;//将对应的模式计数减1
    
30. 
    
31.    rt_hw_interrupt_enable(level);
    # v; o. n1 V! \; W
32. 
    
33. }

复制代码

+ U, j5 S- E* L8 S) [$ j

特殊情况下，比如某个阶段并不允许系统进入更低的功耗模式，此时可以通过rt_pm_request 和 rt_pm_release 对该过程进行保护。如 I2C 读取数据期间，不允许进入深度睡眠模式(可能会导致外设停止工作)，因此可以做如下处理:

1. /* 请求轻度睡眠模式(I2C外设该模式下正常工作) */
   3 f4 O& v; s" w% T3 \% ^
2. 
   
3. rt_pm_request(PM_SLEEP_MODE_LIGHT);
   $ y1 G/ ~# @: j% J7 U
4. 
   2 t% \/ A! L- X# N# H9 U
5. 
   
6. 
   
7. /* 读取数据过程 */
   
8. 
   
9. 
   ) F% `: n- {; N  ?8 f+ I% O
10. 
    . Q, m& A" A8 t2 q& @
11. /* 释放该模式 */
    4 L! a. G" J% U) N
12. 
    , p( y# g, T6 |) H! m! ^
13. rt_pm_release(PM_SLEEP_MODE_LIGHT);

复制代码

4 G7 f* [' a9 W

3.设置运行模式

1. int rt_pm_run_enter(uint8_t run_mode);

复制代码

' t1 g5 y# t5 b. w
6 Z# t& T, {' @

run_mode 可以取以下枚举值：

1. enum
   
2. 
   0 j; C/ E' B! O4 v: N0 d! e) N$ ^
3. {
   , ~: B' `! N! Q& |$ }2 ]3 E! R( Z
4. 
   
5.    /* run modes*/
     I2 M2 t+ X2 ]2 M( _) J
6. 
   ; u' ?) g) z3 i, d& p7 [- g
7.    PM_RUN_MODE_HIGH_SPEED = 0,    /* 高速 */
   ' d4 B& x, x, k+ D/ h9 N  `& J1 k
8. 
   
9.    PM_RUN_MODE_NORMAL_SPEED,      /* 正常（默认） */
   
10. 
    
11.    PM_RUN_MODE_MEDIUM_SPEED,      /* 中速 */
    
12. 
    ; `- v- _. X: E+ ?: |; i2 r1 w
13.    PM_RUN_MODE_LOW_SPEED,         /* 低速 */
    
14. 
    
15.    PM_RUN_MODE_MAX,
    
16. 
    
17. };

复制代码

调用该函数改变 CPU 的运行频率，从而降低运行时的功耗。此函数只提供级别，具体的 CPU 频率应在移植阶段视实际情况而定。

下面是具体代码实现：

1. int rt_pm_run_enter(rt_uint8_t mode)
   
2. 
   
3. {
   / R/ C% {+ l2 I/ e1 k7 @
4. 
   
5.    rt_base_t level;
   5 g5 ^: S+ u6 c# \/ W0 O
6. 
   # p, j3 b5 j4 s: f* [+ w! P+ B6 p
7.    struct rt_pm *pm;
   & J8 _# y, Y. [9 c  b$ s( Z# a  u
8. 
   4 G, M8 b' F) d; q3 q8 L
9. 
   
10. 
    
11.    if (_pm_init_flag == 0)
    / u. R$ p- g; g  m8 [' n
12. 
    
13.        return -RT_EIO;
    
14. 
    & ]  E7 j$ h7 b5 X" I* U
15. 
    
16. 
    
17.    if (mode > PM_RUN_MODE_MAX)
    8 d& d" X) F$ K# z2 @+ _
18. 
    
19.        return -RT_EINVAL;
    
20. 
    $ a6 H7 j0 |5 L% ~! [+ P6 U3 v8 n( |
21. 
    , h1 }9 k  R, x2 W% m8 H( e0 ~
22. 
    9 f2 d/ C3 W8 ^) p
23.    level = rt_hw_interrupt_disable();
      w5 a! b3 O3 s
24. 
    
25.    pm = &_pm;
    
26. 
    
27.    if (mode < pm->run_mode)
    6 }5 J# @0 m6 K: I: f- |
28. 
    
29.   {
    
30. 
    
31.        /* change system runing mode */
    
32. 
    
33.        pm->ops->run(pm, mode);
    
34. 
    ) ^- B1 {$ S/ w7 c7 E
35.        /* changer device frequency */
    
36. 
    8 N3 ~+ P& K9 \/ m* Y  c) |# E
37.        _pm_device_frequency_change(mode);
    ( ^* R  k" ?6 f8 a$ y
38. 
    / g4 m) a: |. C; n0 O/ d' U5 Y
39.   }
    
40. 
    
41.    else
    / H! M& [6 h3 V9 P( ^. a- a" f+ P; \8 t
42. 
    
43.   {
    
44. 
    
45.        pm->flags |= RT_PM_FREQUENCY_PENDING;
    4 E( T# ~* }/ ?) H: |  J
46. 
    
47.   }
    ( U, h9 V& J! A$ G6 g
48. 
    
49.    pm->run_mode = mode;
    
50. 
    8 ~' h6 ~6 V3 m, m# A- L
51.    rt_hw_interrupt_enable(level);
    ! b0 U! _, s/ _) t* a$ G
52. 
    
53. 
    " L# V) D& H" A9 Q# D1 A: _# O
54. 
    ; X' q! T. x8 R& G8 j1 A
55.    return RT_EOK;
    
56. 
    * r+ ?+ G0 ?  a6 f: @1 d" d9 A
57. }

复制代码

# I' a  u9 w$ L% i
+ r) I+ o7 g# A* V

4.设置进入/退出休眠模式的回调通知

1. void rt_pm_notify_set(void (*notify)(uint8_t event, uint8_t mode, void *data), void *data);

复制代码

event 为以下两个枚举值，分别标识进入/退出休眠模式。

1. enum
   7 U$ \* f0 a$ q* k2 o
2. 
   
3. {
   9 E* ~- n2 R" S. x/ `5 U0 z0 q7 n0 p
4. 
   
5.    RT_PM_ENTER_SLEEP = 0,    /* 进入休眠模式 */
   - b: }( J, y% u. S, W3 z) e% ^" K
6. 
   , g) R# M1 \1 q3 k0 ]
7.    RT_PM_EXIT_SLEEP,         /* 退出休眠模式 */
   , D  n* \5 a+ `, o; W9 d0 n
8. 
   
9. };

复制代码

在应用进入/退出休眠模式会触发回调通知。下面是具体代码实现：

1. void rt_pm_notify_set(void (*notify)(rt_uint8_t event, rt_uint8_t mode, void *data), void *data)
   
2. 
   
3. {
   
4. 
   
5.    _pm_notify.notify = notify;
   7 ]+ N  i6 N; U9 }4 J; @. N
6. 
   9 ~4 E$ ?$ w0 R$ r9 M" u; j5 `& O
7.    _pm_notify.data = data;
   0 t3 ]% b, I1 X0 O7 m7 N
8. 
   
9. }

复制代码

$ ?1 ^7 ~. |/ o" O. b
8 V, n4 y9 j) G. ~( j

5.注册PM设备

1. void rt_pm_device_register(struct rt_device *device, const struct rt_device_pm_ops *ops)

复制代码

8 W! e( c% ?' D

与应用不同，某些外设可能在进入低功耗状态时执行特定操作，退出低功耗时采取措施恢复，此时可以通过注册PM设备来实现。通过注册 PM 设备，在进入低功耗状态之前，会触发注册设备的 suspend 回调，开发者可在回调里执行自己的操作；类似地，从低功耗状态退出时，也会触发 resume 回调。运行模式下的频率改变同样会触发设备的frequency_change 回调。下面是具体代码实现：

1. void rt_pm_device_register(struct rt_device *device, const struct rt_device_pm_ops *ops)
   ; A4 o# L" P+ v5 \
2. 
   
3. {
   
4. 
   
5.    rt_base_t level;
   
6. 
   
7.    struct rt_device_pm *device_pm;
   
8. 
   
9. 
   
10. 
    ( a: s2 h% J+ |/ u
11.    RT_DEBUG_NOT_IN_INTERRUPT;
    
12. 
    2 C; W- D+ z, |
13. 
    9 C" S6 k& E0 L% g( X$ H9 {) Q
14. 
    
15.    level = rt_hw_interrupt_disable();
    / ~0 }" Y/ u) |! P9 R& U
16. 
    
17. 
    6 v# m  n3 k% D8 ?
18. 
    
19.    device_pm = (struct rt_device_pm *)RT_KERNEL_REALLOC(_pm.device_pm,
    
20. 
      P7 o' x) F! a! A- `: L* F
21.               (_pm.device_pm_number + 1) * sizeof(struct rt_device_pm));
    - ^5 B" K. u& l7 n- H0 e" h
22. 
    1 Q2 [' A% p- L, N1 p
23.    if (device_pm != RT_NULL)
    , M. H: ~+ S9 i. I
24. 
    ' ^( z! ?: w, _1 w, x8 J. |  H0 `! V- y. N
25.   {
    
26. 
    ( e  t4 \: P. V. m7 x
27.        _pm.device_pm = device_pm;
    % n" O( D# j2 @8 e; [
28. 
    7 O! e4 l. @; v9 @' _
29.        _pm.device_pm[_pm.device_pm_number].device = device;
    
30. 
    ; M: y+ c7 {2 V
31.        _pm.device_pm[_pm.device_pm_number].ops    = ops;
    # u8 G) D1 |3 I! G0 P' v6 h1 ?# J
32. 
    4 [% f2 W( n$ s: Q
33.        _pm.device_pm_number += 1;
    0 S8 ^% k7 c1 P- i: T
34. 
    
35.   }
    
36. 
    
37. 
    
38. 
    
39.    rt_hw_interrupt_enable(level);
    
40. 
    
41. }

复制代码

设置进入/退出休眠模式的回调通知和注册为设备的回调通知流程：

首先应用设置进出休眠状态的回调函数，然后调用 rt_pm_request 请求休眠模式，触发休眠操作；PM 组件在系统空闲时检查休眠模式计数，根据投票数给出推荐的模式；接着 PM 组件调用 notfiy 通知应用，告知即将进入休眠模式；然后对注册的 PM 设备执行挂起操作，返回 OK 后执行 SOC 实现的的休眠模式，系统进入休眠状态（如果使能时间补偿，休眠之前会先启动低功耗定时器）。此时 CPU 停止工作，等待事件或者中断唤醒。当系统被唤醒后，由于全局中断为关闭状态，系统继续从该处执行，获取睡眠时间补偿系统的心跳，依次唤醒设备，通知应用从休眠模式退出。如此一个周期执行完毕，退出，等待系统下次空闲。

模式的切换代码实现：当任务进入到空闲线程，最终是调用此函数进入低功耗和唤醒的

1. static void _pm_change_sleep_mode(struct rt_pm *pm, rt_uint8_t mode)
   ( R+ [0 d$ y& W* b( V
2. 
   
3. {
   
4. 
   ! X/ @0 T0 q- }4 u
5.    rt_tick_t timeout_tick, delta_tick;
   
6. 
   
7.    rt_base_t level;
   3 E0 N% X* b: B9 D) ^5 V
8. 
   
9.    int ret = RT_EOK;
   ' m' t& U5 ^4 ~
10. 
    0 z' }% W  R. \9 ]- ?1 \
11. 
    
12. 
    
13.    if (mode == PM_SLEEP_MODE_NONE)
    
14. 
    1 U8 O$ b# C9 B$ l; L( }
15.   {
    / g& q6 y* e) C4 n& m7 P
16. 
    & _9 k5 Z8 W' N) D' F
17.        pm->sleep_mode = mode;
    
18. 
    
19.        pm->ops->sleep(pm, PM_SLEEP_MODE_NONE);
    3 V& _/ o# t7 y" N, T3 G
20. 
    4 [/ ?& q& h, B" A" b
21.   }
    + q* R% x9 T& S1 r1 P6 X: @; f: i
22. 
    9 u5 ?/ \) ^, u
23.    else
    / F4 K5 E" @% W$ g. Z1 [0 P$ w
24. 
    
25.   {
    
26. 
    ! R6 W; T) v0 L' ~- H- y" C) Y
27.        level = rt_pm_enter_critical(mode);
    
28. 
    9 ~, i9 G6 q( y( a6 |
29. 
    
30. 
    
31.        /* Notify app will enter sleep mode */
    
32. 
    ! ^8 W' {  ~+ c; s- u( N1 ?; @
33.        if (_pm_notify.notify)
    5 Z- R) q7 t  w2 _2 U6 r
34. 
    
35.            _pm_notify.notify(RT_PM_ENTER_SLEEP, mode, _pm_notify.data);
    
36. 
    
37. 
    " K4 ?$ w5 r6 M+ n3 h; m( g
38. 
    : {5 z! B- A! H$ L0 G: g
39.        /* Suspend all peripheral device */
    
40. 
    " A  e3 W2 i  C; g
41.        ret = _pm_device_suspend(mode);
    0 y, b, V( R* n) O: [5 B9 C; I
42. 
    ; A6 A7 M1 \& G. J
43.        if (ret != RT_EOK)
    
44. 
    2 Z! |! c2 R) o3 K% m- V
45.       {
    
46. 
    
47.            _pm_device_resume(mode);
    
48. 
    $ l# r8 C3 |$ }! f8 Y8 N9 L: i
49.            if (_pm_notify.notify)
    ) n2 ~( \+ }$ Z3 U# `0 \8 d7 t* \
50. 
    
51.                _pm_notify.notify(RT_PM_EXIT_SLEEP, mode, _pm_notify.data);
    8 W7 ?) g( R5 W8 S+ s
52. 
    : D) e; Q" a" R$ U7 H6 Y! A
53.            rt_pm_exit_critical(level, mode);
    
54. 
    
55. 
    7 j, ]& P0 @0 A5 W
56. 
    6 b+ V. I7 A4 }# h" o
57.            return;
    
58. 
    
59.       }
    ' b! Q/ v+ g$ ~
60. 
    * e& J; P6 C: Y3 V) O) f# ]3 K
61. 
    
62. 
    
63.        /* Tickless*/
    
64. 
    - p  e- K- Z7 x
65.        if (pm->timer_mask & (0x01 << mode))
    
66. 
    
67.       {
    0 x* l3 j" d" v+ H
68. 
    
69.            timeout_tick = rt_timer_next_timeout_tick();
    
70. 
    
71.            if (timeout_tick == RT_TICK_MAX)
    
72. 
    8 i3 E5 v1 L9 E( h
73.           {
    6 N( d! V2 p3 T" Q# @
74. 
    
75.                if (pm->ops->timer_start)
    
76. 
    ! _0 u& x5 u8 X. m3 Q
77.               {
    
78. 
    
79.                    pm->ops->timer_start(pm, RT_TICK_MAX);
    
80. 
    
81.               }
    
82. 
    
83.           }
    ( ?. t& }( Q: n3 A
84. 
    
85.            else
    
86. 
    
87.           {
    
88. 
    8 q+ x$ u% r( t5 a* G
89.                timeout_tick = timeout_tick - rt_tick_get();
    : m9 X$ W8 H0 K% f
90. 
    % W( o' i, \) i8 E$ M) x7 h4 K
91.                if (timeout_tick < RT_PM_TICKLESS_THRESH)
    4 d) i. A" ]: F8 o
92. 
    
93.               {
    * ^& _  r% E" i. B2 I
94. 
    ! m) d. u; \9 _
95.                    mode = PM_SLEEP_MODE_IDLE;
    
96. 
    3 z  o" B5 W$ S# O4 K3 ~% \
97.               }
    0 m. h/ g0 D) _; `: j( f7 W" P
98. 
    ! j- H& N' Z! C" E. d; _0 g
99.                else
    
100. 
     0 v( y/ ?  c- `+ _0 m& N/ A& q
101.               {
     
102. 
     
103.                    pm->ops->timer_start(pm, timeout_tick);
     5 q- o) Y. n' g2 f" r$ \
104. 
     
105.               }
     
106. 
     
107.           }
     7 n8 t9 \# o$ q' T  b0 b2 t
108. 
       p( c4 F5 ~; C) c! O, {
109.       }
     
110. 
     # ?# K( ~1 F& p" F* k
111. 
     ) R. m  ~  \+ b9 r+ e7 ^
112. 
     
113.        /* enter lower power state */
     
114. 
     , c) q0 q- o' O
115.        pm->ops->sleep(pm, mode);
       l1 v/ Y8 ~; `; A8 o- I, M# \
116. 
     4 f% a2 v' @' {, B
117. 
     
118. 
     , Q7 B' i* \# j5 a+ X7 J
119.        /* wake up from lower power state*/
     - h7 \/ m7 {4 s: E" L0 @
120. 
     4 z8 j, }2 E. e& j4 ?' q
121.        if (pm->timer_mask & (0x01 << mode))
     
122. 
     + n9 E% ^3 g  x7 v' `: d0 _
123.       {
     3 N9 c% H  L: `" I! Y! D
124. 
     
125.            delta_tick = pm->ops->timer_get_tick(pm);
     ' K) `3 o$ `7 |
126. 
     0 Y( m, h" _9 j" F& o
127.            pm->ops->timer_stop(pm);
     0 i9 ?, v; _4 l( \
128. 
     
129.            if (delta_tick)
     
130. 
     
131.           {
     
132. 
     
133.                rt_tick_set(rt_tick_get() + delta_tick);
     ; Q2 O! _" C; g3 @' m
134. 
     # e" F1 @. ?4 n& k# f4 n" L7 F
135.                rt_timer_check();
     + N; ~) C' W% P. W& E& E1 ~
136. 
     5 o, M/ D6 n; d! Y( W- _& Q
137.           }
     * e/ c( C6 J7 {7 `% ^
138. 
     
139.       }
     ) O, Z+ n  ?& ]. x
140. 
     ) g$ k) k" a" l( Y5 o
141. 
     
142. 
     
143.        /* resume all device */
     
144. 
     
145.        _pm_device_resume(pm->sleep_mode);
     
146. 
     6 \1 }% q. N# E) f" a( j" G( v
147. 
     : G# T( H+ n9 B7 L! Q7 Z: J) r3 V, e
148. 
       N$ F4 T# ^  g1 p2 m! o
149.        if (_pm_notify.notify)
     
150. 
     3 x; G0 K, f2 O" P* _
151.            _pm_notify.notify(RT_PM_EXIT_SLEEP, mode, _pm_notify.data);
     
152. 
     
153. 
     
154. 
     
155.        rt_pm_exit_critical(level, mode);
     
156. 
     ) _$ k; a# O- E* M8 ^! w
157.   }
     
158. 
     
159. }

复制代码

! b" X5 b9 ]/ |7 {

移植的实现原理

RT-Thread 低功耗管理系统从设计上分离运行模式和休眠模式，独立管理，运行模式用于变频和变电压，休眠调用芯片的休眠特性。对于多数芯片和开发来说，可能并不需要考虑变频和变电压，仅需关注休眠模式。底层功能的实现已经有Sunwancn大神对STM32做了全系列的适配，以下是底层实现原理，用户也可以自行根据自身情况对底层进行裁剪或增强。

（注意： 驱动可能有更新，移植请到gitee下载最新pm驱动。地址在pm-ports-stm32-new 分支：https://gitee.com/sunwancn/rt-thread/tree/pm-ports-stm32-new）

PM 组件的底层功能都是通过structrt_pm_ops结构体里的函数完成：

1. /**
   " R# S. N& d* d; T6 w+ H7 m
2. 
     |% X2 g3 Q4 r+ [+ V3 u5 T
3. * low power mode operations
   
4. 
   
5. */
   0 W  V& V( D$ ]/ X3 b
6. 
   
7. struct rt_pm_ops
   
8. 
   & n6 R" w$ ^2 y+ D/ ]  |7 m( Q
9. {
   
10. 
    
11.    void (*sleep)(struct rt_pm *pm, uint8_t mode);
    
12. 
    
13.    void (*run)(struct rt_pm *pm, uint8_t mode);
    
14. 
    
15.    void (*timer_start)(struct rt_pm *pm, rt_uint32_t timeout);
    
16. 
    
17.    void (*timer_stop)(struct rt_pm *pm);
    ( P; T1 O6 O7 ~  F
18. 
    
19.    rt_tick_t (*timer_get_tick)(struct rt_pm *pm);
    1 G% F$ m2 j; y# H5 K# u3 _
20. 
    
21. };

复制代码

u  移植休眠模式移植休眠模式仅需关注 sleep 接口，下面是具体的实现:

1. void stm32_sleep(struct rt_pm *pm, rt_uint8_t mode)
   % r9 k9 e2 g8 ~4 y9 a2 b' q
2. 
   
3. {
   . f! [* J' F  T
4. 
   
5.    switch (mode)
   
6. 
   + ]. N* u( X: F7 O  O
7.   {
   
8. 
   ( S8 I" ?2 W3 W2 s9 a
9.    case PM_SLEEP_MODE_NONE:
   
10. 
    9 V8 d9 X( d# K
11.        break;
    # P( W& O( Y, h( U. f/ H
12. 
    . R$ l% W% }7 l& G
13. 
    & H4 |  @$ u. L- v% F! M6 Q- D! N
14. 
    + A( X+ ?. z# B2 g& C, \
15.    case PM_SLEEP_MODE_IDLE:
    . v+ V! q4 i8 m, P; W
16. 
    - g! L& J: d$ U( }$ u7 G8 a3 l, v
17.        if (pm->run_mode == PM_RUN_MODE_LOW_SPEED)
    1 ~! l7 d' T/ ^) R% u0 d9 o
18. 
    / S/ T+ ?  i' B3 `9 G6 Z) m
19.       {
    
20. 
    & l  h! k' p3 l. R  Z
21.            /* Enter LP SLEEP Mode, Enable low-power regulator */
    : _1 O$ q9 E3 ?: ^4 Z+ h: {, r, M7 W
22. 
    1 |2 y- _  X& F3 B; r, _
23.            HAL_PWR_EnterSLEEPMode(PWR_LOWPOWERREGULATOR_ON, PWR_SLEEPENTRY_WFI);
    1 V) U6 z" X1 B: ^7 z& Y
24. 
    
25.       }
    . T2 U5 X- T, ~% E. ?) n6 b' t$ z1 f1 J
26. 
    
27.        else
    . z# }, n- e3 F; J3 P
28. 
    9 {5 R0 v9 H" ^* f& w. Q, n
29.       {
    1 }! [% H' D. v2 X
30. 
    
31.            /* Enter SLEEP Mode, Main regulator is ON */
    
32. 
    1 `* k) u% F- H/ t
33.            HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
    ' ?9 r$ E" w4 w, g4 x
34. 
    
35.       }
    
36. 
    ! J: A8 M: w* E5 u' b0 l
37.        break;
    4 K; d, X8 G4 L5 H5 h  |! o
38. 
    6 Y$ g) D  w4 K8 e. ~; k# a/ j3 `
39. 
    
40. 
    
41.    case PM_SLEEP_MODE_LIGHT:
    6 [  y0 [3 Y1 L# S
42. 
    
43.        if (pm->run_mode == PM_RUN_MODE_LOW_SPEED)
    # }( M/ y+ O( N
44. 
    
45.       {
    
46. 
    
47.            __HAL_FLASH_SLEEP_POWERDOWN_ENABLE();
    6 ~" r8 d6 M" N: |1 p
48. 
    
49.            /* Enter LP SLEEP Mode, Enable low-power regulator */
    ) u* P+ N: a6 `1 j3 L! H' y6 E" h' B+ H
50. 
    
51.            HAL_PWR_EnterSLEEPMode(PWR_LOWPOWERREGULATOR_ON, PWR_SLEEPENTRY_WFI);
    
52. 
    ' S/ a, b6 f* z- P# _$ u) T8 C8 z" Z
53.            __HAL_FLASH_SLEEP_POWERDOWN_DISABLE();
    5 A( p- j* |" w9 y* V% p& Q3 d
54. 
    ) z7 }2 M6 f2 Q
55.       }
    
56. 
    ( T' b. e  n3 M8 U# X+ }: K
57.        else
    
58. 
    / g7 F  |" g5 t3 L2 s& k
59.       {
    
60. 
    
61.            /* Enter SLEEP Mode, Main regulator is ON */
    1 j( O2 v" ]/ M9 ]
62. 
    ) j* i& E' t/ Y% s- b& O* {
63.            HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
    
64. 
    
65.       }
    # G) U! o7 }  F- V1 w. F
66. 
    1 r% L) L8 L& d: m
67.        break;
    
68. 
    
69. 
    2 m/ M9 r5 S3 I2 B+ t$ Q
70. 
    ) C# |; X9 @9 Q0 ]! F# X: W: @
71.    case PM_SLEEP_MODE_DEEP:
    # u- i9 g, G5 j$ p" A
72. 
    1 a5 ?4 n& u5 q. r  k9 G
73.        /* Disable SysTick interrupt */
    
74. 
    
75.        CLEAR_BIT(SysTick->CTRL, (rt_uint32_t)SysTick_CTRL_TICKINT_Msk);
    
76. 
    ( A* t' r* L' ^# Q
77. 
    
78. 
    
79.        if (pm->run_mode == PM_RUN_MODE_LOW_SPEED)
    
80. 
    + N9 A- t3 C% v) _9 R, `
81.       {
    7 F6 q6 ~, `; x6 K/ A
82. 
    5 m* P1 l3 K# S7 M* `
83.            /* Clear LPR bit to back the normal run mode */
    / H. o/ ^" x7 f# d
84. 
    - _" e8 w! f2 \7 _4 j& l2 v6 Q, E
85.            CLEAR_BIT(PWR->CR1, PWR_CR1_LPR);
    
86. 
    ' [) K8 I4 |% C; E# I  |
87.            /* Enter STOP 2 mode */
    % p( J2 o; s. ^+ T
88. 
    
89.            HAL_PWREx_EnterSTOP2Mode(PWR_STOPENTRY_WFI);
    
90. 
    
91.            /* Set Regulator parameter to lowpower run mode */
    # X& P( Y8 A& o, f$ F3 L. w1 \
92. 
    ; @+ y8 @, H! Y1 T9 {1 P
93.            SET_BIT(PWR->CR1, PWR_CR1_LPR);
    
94. 
    : c- Q7 d: o* w
95.       }
    
96. 
    
97.        else
    $ u  \1 f+ x3 z5 `8 J4 r3 x
98. 
    
99.       {
    " j! O% y6 a7 o5 ~2 i. i
100. 
     
101.            /* Enter STOP 2 mode */
     
102. 
     
103.            HAL_PWREx_EnterSTOP2Mode(PWR_STOPENTRY_WFI);
     
104. 
     
105.       }
     
106. 
     1 |) r' j% O1 O1 }5 w
107. 
     7 f" j1 r5 t% z& B) F
108. 
     
109.        /* Enable SysTick interrupt */
     
110. 
     ; V! m. v9 z6 `
111.        SET_BIT(SysTick->CTRL, (rt_uint32_t)SysTick_CTRL_TICKINT_Msk);
     ( V  ~/ D. p+ t3 X! A5 V
112. 
     : I! c! \+ a. ^% l9 A
113.        /* Re-configure the system clock */
     $ S; j+ q8 h5 K" @
114. 
     
115.        systemclock_reconfig(pm->run_mode);
     5 Y6 a5 j- u9 F; ~7 w' \
116. 
     
117.        break;
     & @1 b: {' \! t6 h& I# ]
118. 
     9 N- C0 q  F# O  T) a% V: x% c
119. 
     
120. 
     
121.    case PM_SLEEP_MODE_STANDBY:
     
122. 
     
123.        __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
     0 A1 {  ~" g/ Q- p
124. 
     
125.        /* Enter STANDBY mode */
     
126. 
     : x$ J9 E( a, Q: ^7 q. g) F, t
127.        HAL_PWR_EnterSTANDBYMode();
     
128. 
     7 C! U) M- T( J( F( T
129.        break;
     ) t, U* x* a( n0 M# }
130. 
     5 M0 ?9 X' ~1 e
131. 
     % D4 ?; V& q9 [$ `6 O
132. 
     - l$ {" ]4 w- [& A* @) l2 F* h/ q2 r/ l
133.    case PM_SLEEP_MODE_SHUTDOWN:
     9 _9 @/ w2 P7 X2 T- O- F3 Y3 j
134. 
     7 Z7 D: G3 z" f# ?# Q
135.        __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
     0 n* a( M' l% U- E; U3 V# x
136. 
     
137.        /* Enter SHUTDOWNN mode */
     ! K* p4 j  ?0 {" O2 x
138. 
     
139.        HAL_PWREx_EnterSHUTDOWNMode();
       M3 H' L/ C7 `( h+ _* g1 O
140. 
     , H6 h# _, p, z# {
141.        break;
     8 a1 ?0 u3 ?; \) i2 ]2 Q8 `
142. 
     
143. 
     
144. 
     / m( D' d7 g0 H4 ^$ ]4 a0 U) q* }
145.    default:
     8 e% X2 s9 s  L+ O( v
146. 
     
147.        RT_ASSERT(0);
     / i$ G7 w  [' F' e+ S: l
148. 
     
149.        break;
     6 l0 J0 Q' Q, n0 n$ @. O' R
150. 
     2 {# E1 L) u4 a8 g, q
151.   }
     
152. 
     
153. }

复制代码

) p7 Z  i; A8 q6 r0 Y8 G5 E+ _

移植时间补偿接口某些情况下，我们可能需要系统在空闲时进入 Stop 模式，以达到更低的降功耗效果。根据手册可知，Stop 2 模式会关闭系统时钟，当前的 OS Tick 基于内核的 Systick 定时器。那么在系统时钟停止后，OS Tick 也会停止，对于某些依赖 OS Tick 的应用，在进入 Stop 2 模式，又被中断唤醒后，就会出现问题，因此需要在系统唤醒后，对 OS Tick 进行补偿。Stop 2 模式下，绝大多数外设都停止工作，仅低功耗定时器 1（LP_TIM1）和RTC，选择 LSI 作为时钟源后，仍然能正常运行，所以可以选择 LP_TIM1 或者RTC 作为 Stop 2 模式的时间补偿定时器。

休眠的时间补偿需要实现三个接口，分别用于启动低功耗定时器、停止定时器、唤醒后获取休眠的Tick，下面是具体的实现：

1. static void stm32_pm_timer_start(struct rt_pm *pm, rt_uint32_t timeout)
   % I5 A9 |; p* j, x' S3 ~3 b
2. 
   1 j2 D+ b) N7 \' ^' T! o) m$ Q
3. {
   % s: V) b$ |6 }# y. {
4. 
   
5.    RT_ASSERT(pm != RT_NULL);
   
6. 
   
7.    RT_ASSERT(timeout > 0);
   
8. 
   
9. 
   
10. 
    
11.    if (timeout != RT_TICK_MAX)
    
12. 
    ( \- g% {6 d, h0 U- U7 R' h
13.   {
    / B# f; G9 ^$ J% o; y
14. 
    
15.        /* Convert OS Tick to PM timer timeout value */
    
16. 
    0 p  ^$ b* T/ \' E& ?# u
17.        timeout = stm32_pm_tick_from_os_tick(timeout);
    & C/ q& H5 K* B4 W5 t
18. 
    4 y/ Z2 D9 R& s+ Q; z( ~$ M; U" M' m
19.        if (timeout > stm32_pmtim_get_tick_max())
    1 h% K& p! V+ Q/ @: c0 }' N
20. 
    4 ^- n' r* y4 C9 q+ A0 P
21.       {
    
22. 
    
23.            timeout = stm32_pmtim_get_tick_max();
    
24. 
    * [  G7 Y3 Y& N2 @% d. w
25.       }
    3 J) m& ~) w, u( f1 C3 D
26. 
    % q* ]  m/ u% P- d1 s
27. 
    8 K% h) Q8 j8 D
28. 
    
29.        /* Enter PM_TIMER_MODE */
    
30. 
    / X% K, d1 t3 q5 o
31.        stm32_pmtim_start(timeout);
    0 H2 L; V2 L6 i) Y0 k" b, d9 b8 i
32. 
    
33.   }
    
34. 
    - r" r2 U' ?5 l7 B/ W% l8 e% g
35. }
    
36. 
    8 ?) Y8 k& \" j2 O( f/ V8 H
37. 
    9 x' m( Z- {" O0 t. x5 N
38. 
      [* B9 J. p: ]  v
39. static void stm32_pm_timer_stop(struct rt_pm *pm)
    ( a6 @' `% A% ]
40. 
    
41. {
    
42. 
    
43.    RT_ASSERT(pm != RT_NULL);
    
44. 
    7 A: w2 L6 {  ~: y
45. 
    
46. 
    
47.    /* Reset PM timer status */
    
48. 
    
49.    stm32_pmtim_stop();
    ) l  n8 X! {2 V' D* {8 W/ q0 [
50. 
    2 `* A2 Y" T3 ^' L: q6 i
51. }
    1 d4 ?2 `/ ~- j1 i4 O+ ^8 M
52. 
    + K' C! b" l2 C# F. |- Q
53. 
    $ i$ P5 m4 H5 I6 x+ v" g
54. 
    / [& Z0 \: p  J4 d' ^- n
55. static rt_tick_t stm32_pm_timer_get_tick(struct rt_pm *pm)
    
56. 
    5 T7 i0 z* I& l. u+ D" ?
57. {
    6 q, P5 _, A. \5 m8 O
58. 
    
59.    rt_uint32_t timer_tick;
    % p& K& n1 _, L% |5 D
60. 
    
61. 
    5 d5 i) ]$ }+ L: w5 P1 |( N. T
62. 
    
63.    RT_ASSERT(pm != RT_NULL);
    
64. 
    
65. 
    
66. 
    ! b3 x8 e0 [( L$ U5 B. }
67.    timer_tick = stm32_pmtim_get_current_tick();
    
68. 
    : P$ V  S0 b) l' W0 {/ {" u7 K
69. 
    
70. 
    
71.    return stm32_os_tick_from_pm_tick(timer_tick);
    ) R2 N: d0 u) ~# X7 Y
72. 
    5 c7 Y9 i4 x$ r& v& D1 X& \6 ^
73. }

复制代码

- E5 \# r5 O+ S% F

休眠时间补偿的移植相对并不复杂，根据 Tick 配置低功耗定时器超时，唤醒后获取实际休眠时间并转换为OS Tick，告知 PM 组件即可。

u  移植运行模式移植休眠模式仅需关注 run接口，下面是具体的实现:

1. void stm32_run(struct rt_pm *pm, rt_uint8_t mode)
   % ~' @3 o1 S8 N# }" [  y  Y8 G9 C+ J* T
2. 
   
3. {
   ) A; _) p1 ?$ a( D; A# o0 I: a
4. 
   
5.    static rt_uint32_t last_mode;
   4 Z8 ~0 q2 e# Y* C2 X
6. 
   7 R/ S6 }% \" S/ C) D; D
7.    static char *run_str[] = PM_RUN_MODE_NAMES;
   
8. 
   
9.    struct rcc_conf_struct sconf = _rcc_conf[mode];
   9 M6 i# j; v* \' O& @8 D
10. 
    
11. 
    
12. 
      v% X! I1 Y5 r9 T
13.    if (mode == last_mode)
    0 Y" N& W/ Y$ c% x, `
14. 
    % P0 Y3 z+ ~4 Y* M8 x$ X: l) @) I" [
15.        return;
    
16. 
    
17. 
    , s( f6 }$ B3 d# h- X: n
18. 
    
19.    if (stm32_run_freq[mode][0] != stm32_run_freq[last_mode][0])
    
20. 
    0 Z/ M  I/ V2 ^, k* ~
21.   {
    % S0 P) f* O+ a4 k4 x
22. 
    
23.        if (_rcc_conf[last_mode].low_pow_run_en && !sconf.low_pow_run_en)
    3 {% I* t, y9 W( I
24. 
    6 o; H5 D: c  f  q" n
25.       {
    $ v2 b6 `" R5 A+ S
26. 
    + }& E- d, ]7 t
27.            /* Disable the Low-power Run mode */
    
28. 
    ( X6 Z/ |+ G! [5 G4 R& i/ B& y
29.            HAL_PWREx_DisableLowPowerRunMode();
    * b& a4 ]8 s0 z* W; [
30. 
    3 E" p% n) A9 \1 R+ [* t4 n
31.       }
    / p% o% h; E9 a
32. 
    ) ^. i& b8 d* |! o9 x
33. 
    
34. 
    + c# j% s4 U; J0 Y
35.        systemclock_msi_on(last_mode);
    
36. 
    
37. 
    " W9 O6 d4 S2 [) z' z! C
38. 
    0 E$ S8 x, @) ~5 P) F! f
39.        if (mode < last_mode)
    
40. 
    # ?% g+ u4 X) [( P3 s" W7 n, C+ ]) B
41.       {
    # N6 a4 I) [/ V: R
42. 
    / [5 p, H  Y9 X& D) r! m
43.            /* Frequency increase */
    
44. 
    
45.            HAL_PWREx_ControlVoltageScaling(sconf.volt_scale);
    
46. 
    
47. 
    
48. 
    
49.            _set_sysclock[mode]();
    
50. 
    
51.       }
    7 ~+ l' d% J3 H* S( M' q
52. 
    
53.        else
    2 e5 n; u& G: I0 d9 [. y
54. 
    
55.       {
    5 x9 X: T6 a  X& e+ C
56. 
    ! U6 }" q% U* Y# n
57.            /* Frequency reduce */
      D% _& j- d2 \
58. 
    # y5 S8 n7 B3 i; f
59.            _set_sysclock[mode]();
    / d* r) T7 G" D3 Q+ B
60. 
    8 K4 }  P. h, A0 y. E
61. 
    $ ^# ?- j' I" e
62. 
    ' Z1 {1 E' o/ p1 J4 T
63.            HAL_PWREx_ControlVoltageScaling(sconf.volt_scale);
    
64. 
    & M! C. H' @3 G  `/ p
65.       }
    
66. 
      s0 e% M- E$ B7 P. A9 v, L& d
67. 
    , o9 O9 n" r  L. H$ Y
68. 
    
69.        if (sconf.volt_scale == PWR_REGULATOR_VOLTAGE_SCALE2 || _osc_conf.osc_type == RCC_OSCILLATORTYPE_MSI)
    
70. 
    ; @' J8 W+ F4 A* u3 x
71.       {
    * _6 m) m: M( E# h) h
72. 
    4 T/ a8 C3 `, j
73.            /* Configure the wake up from stop clock to MSI */
    
74. 
    
75.            __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_MSI);
    
76. 
    
77.       }
    2 f) j$ }$ A$ p6 G
78. 
    9 c) `3 f$ z/ b! N  l: r
79.        else
    
80. 
    3 I6 R2 Y6 f9 h
81.       {
    8 v' K% H2 t8 X8 c) f  H6 e) Y
82. 
    
83.            /* Configure the wake up from stop clock to HSI */
    ; i$ t" ^) T. }
84. 
    
85.            __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_HSI);
    
86. 
      h# B  h- A0 d) R# ~
87.       }
    2 O$ [# _/ T# T, K( d+ m: |1 `
88. 
    
89. 
    ! p4 {5 g" p2 q9 }8 o3 R$ M
90. 
    
91.        if (sconf.low_pow_run_en)
    , Y  v) P9 l) l
92. 
    - H8 I; {0 ]% I8 K1 k
93.       {
    1 c% @% C1 E0 B1 _2 `' @& o( i  A
94. 
    
95.            /* Enable the Low-power Run mode */
    # `( R8 {; M; U; J/ m% I( z. g
96. 
    
97.            HAL_PWREx_EnableLowPowerRunMode();
    + q8 `; k  S+ a* X/ g+ E' \
98. 
    
99.       }
    
100. 
     
101. 
     . v3 V* j2 {2 f5 d
102. 
     
103.        systemclock_msi_off(mode);
     2 S: X9 L. k/ C1 k) T) M( i
104. 
     # o3 R1 g7 B+ e& k" P/ C4 V
105. 
     3 {3 ?* l# X- P, T
106. 
     
107. #if defined(RT_USING_SERIAL)
     ) N5 r6 w& g8 J0 L
108. 
     6 `: F: s$ X$ g
109.        /* Re-Configure the UARTs */
     ; Y. }; J& {$ A8 W
110. 
     ' L6 ~  B: A4 \6 X6 A1 Q5 r/ o
111.        uart_console_reconfig();
     
112. 
     / X6 Q) ?; A; x  r; {
113. #endif
     
114. 
     , o8 O% R% X( L' W9 v/ G
115.        /* Re-Configure the Systick time */
     6 w6 B) Q: i  R) p4 t6 J( R
116. 
     
117.        HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / RT_TICK_PER_SECOND);
     
118. 
     " z+ O" V9 I' P# `  @- K7 @" X/ ?! E
119.        /* Re-Configure the Systick */
     
120. 
     
121.        HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     4 Y  a2 g* ]6 R2 z* J9 A
122. 
     + J; q; g5 \9 b6 P  T" ^
123.   }
     , t) p9 \1 U$ y8 {3 j) m, `  n
124. 
     $ G9 G+ p# u7 |4 i0 O8 ~
125. 
     9 O& }3 J9 E5 L! V6 y
126. 
     
127.    last_mode = mode;
     
128. 
     
129.    rt_kprintf("switch to %s mode, frequency = %d %sHz\n",
     & P+ k9 D/ b6 a2 d
130. 
     9 F2 U( O* U( m* ]! A1 d
131.               run_str[mode], stm32_run_freq[mode][0], (stm32_run_freq[mode][1] == 1) ? "M" : "K");
     
132. 
     $ |( U" Y# l- p5 ^5 V7 |
133. 
     - {" A1 g+ a) k$ H
134. 
     
135.    if ((stm32_run_freq[mode][0] / stm32_run_freq[mode][1]) > OSC_CONF_SYS_FREQ_MAX)
       u$ U* ?! g1 h1 {8 C% W" [" ]
136. 
     ' A1 S; M' L( J
137.        rt_kprintf("warning: The frequency has over than %d MHz\n", OSC_CONF_SYS_FREQ_MAX);
     
138. 
     3 @# t1 @/ a& w" x$ a6 r5 M3 {
139. }

复制代码

u  自定义运行级别时钟树配置函数PM 组件驱动在给定运行频率时，已经尽量自动最优化配置时钟树，但有时外设时钟还是没有达到自己想要的频率，这时可以自己配置时钟树，在 board.c 添加以下单个或所有函数，代码可参考SystemClock_Config() 函数：

1. rt_uint16_t stm32_run_freq[PM_RUN_MODE_MAX][2] =
   ( d7 p. ]% P5 W" G, ^8 Q, m4 I
2. 
   
3. {
   
4. 
   
5.    /* The actual frequency is 1/divisor MHz, divisor = {1, 1000} */
   9 |8 _0 l# H! ?! e: @. u; ~) y
6. 
   ! l7 Z) r9 z( s; h/ c" O
7.    /* {sysclk frequency, divisor} */
   
8. 
   
9.   {/* 配置高频运行时的时钟 */, /* 分频系数 */},    /* High speed */
   
10. 
    
11.   {/* 配置普通运行时的时钟 */, /* 分频系数 */},    /* Normal speed */
    % y/ V6 d, i' h& P  p0 e
12. 
    
13.   {/* 配置中低运行时的时钟 */, /* 分频系数 */},    /* Medium speed */
    
14. 
    
15.   {/* 配置低频运行时的时钟 */, /* 分频系数 */},    /* Low speed, MSI clock 2.0 MHz */
    
16. 
    
17. };
    & a( S( G) l8 T1 |, ~
18. 
    
19. void stm32_systemclock_high(void)
    
20. 
    / M( h/ ~. Z1 W- K
21. {
    6 u3 b) e/ f4 L' L7 @! R6 |) ~- m1 A
22. 
    6 }9 e' ^0 w) @( w: H
23.    /* 添加代码，配置高频运行时的时钟树 */
    
24. 
    
25. }
    
26. 
    
27. void stm32_systemclock_normal(void)
    0 H5 K; R/ p8 q. U7 \9 @8 Z
28. 
    # n, D2 L$ ^# G* P8 g
29. {
    
30. 
    7 u: O1 w& C: S: E  R2 f
31.    /* 添加代码，配置普通速度运行时的时钟树 */
    % U# J( p% O% E9 M' Q8 j2 n+ B
32. 
    
33. }
    
34. 
    
35. void stm32_systemclock_medium(void)
    
36. 
    
37. {
    
38. 
    6 r! h0 X8 _& U% a
39.    /* 添加代码，配置中低频运行时的时钟树 */
    
40. 
    
41. }
    ; o$ X5 r! s2 K4 |/ z
42. 
    
43. void stm32_systemclock_low(void)
    
44. 
    
45. {
    
46. 
    
47.    /* 添加代码，配置低频运行时的时钟树 */
    5 |" a8 d% t% }: H5 |/ |
48. 
    4 H) B, Z5 B1 M: f8 L0 }. R
49. }

复制代码

+ @; c0 N0 d2 x: |

当低速的频率小于2MHz时，要注意以下2点：

1.串口波特率如果设置过高，将不能正常通信

2.在时钟频率很低时，要适当减小RT_TICK_PER_SECOND 值，不然由于 OS_tick 过短，某些线程将不能完成任务，从而不能进入低功耗模式

u  初始化PM组件注意：休眠模式的时间补偿需要在初始化阶段通过设置 timer_mask 的对应模式的 bit 控制开启。例如需要开启 Deep Sleep 模式下的时间补偿，在实现 timer 相关的 ops 接口后，初始化时设置相应的bit：

1. int drv_pm_hw_init(void)
   
2. 
   # |# u7 Q6 M; F2 O5 ?
3. {
   
4. 
   
5.    static const struct rt_pm_ops _ops =
   
6. 
   7 w- J! E# X7 p& O4 P# v  H
7.   {
   
8. 
   ! C1 b5 x2 g3 P1 _$ f* t9 R
9.        stm32_sleep,
   0 L: o7 v2 C0 B1 a1 V
10. 
    # J  B4 a! E9 {5 X6 p8 `
11.        stm32_run,
    & n* [- Y2 c5 Y6 A
12. 
    1 q, K" v6 d1 I8 m$ Y8 ]
13.        stm32_pm_timer_start,
    
14. 
    & T- i/ ^. h: T0 w% l
15.        stm32_pm_timer_stop,
    
16. 
    
17.        stm32_pm_timer_get_tick
    % W2 y! b. M7 G$ a
18. 
    
19.   };
    
20. 
    
21. 
    
22. 
    
23.    rt_uint8_t timer_mask = 0;
    ! K5 }% @) P% z' l! x- \" W8 ~$ P
24. 
    ' c1 i! r+ n' P# L
25. 
    7 U7 R# M8 S$ D0 p; q' H
26. 
    3 l3 I% I5 R: o5 ~. g' v7 I
27.    /* Enable Power Clock */
    
28. 
    
29.    __HAL_RCC_PWR_CLK_ENABLE();
    
30. 
    1 Q7 i$ S% i9 W) V2 j
31. 
    
32. 
    
33.    /* initialize timer mask */
    ! m6 C$ Y1 `& C
34. 
    
35.    timer_mask = 1UL << PM_SLEEP_MODE_DEEP;
    
36. 
    , c4 {# Q/ Y8 A! C6 {; }8 R
37. 
    
38. 
    " S% H: Y  A5 X0 ]& P& k
39.    /* initialize system pm module */
    
40. 
    & a* X( `( h; u  d
41.    rt_system_pm_init(&_ops, timer_mask, RT_NULL);
    
42. 
    ( y: i, m1 U0 G0 ?
43. 
    " f3 ?& _4 f' ]
44. 
    
45.    return 0;
    
46. 
    4 X6 Y2 p$ D2 N5 D% R
47. }
    5 D/ n  c& k" R$ d2 S- N) l
48. 
    ( d- E6 J, s  ?. f( B7 ~
49. 
    
50. 
    
51. INIT_BOARD_EXPORT(drv_pm_hw_init);
    1 c6 e' U% |8 c5 t
52. 
    4 J  A% n  u6 m& h; w; {4 ^) `1 t& O
53. void rt_system_pm_init(const struct rt_pm_ops *ops,
    5 r1 l. K" E  A6 c( j5 ~
54. 
    
55.                       rt_uint8_t              timer_mask,
    
56. 
    
57.                       void                   *user_data)
    + B' u5 ~7 c, ]7 |9 w2 r; u
58. 
    
59. {
    
60. 
    
61.    struct rt_device *device;
    
62. 
    * e1 T1 d' @* L
63.    struct rt_pm *pm;
    ' }( i1 W' t7 y$ _) U2 v
64. 
    
65. 
    ) Y: t5 |' B2 t; Y; u8 w
66. 
    
67.    pm = &_pm;
    
68. 
    , `1 q% I; `' S
69.    device = &(_pm.parent);
    
70. 
    - X' m' e1 ]) E$ \! e) A' ~
71. 
    : `! I+ ^8 H+ `: Z+ p; \& D
72. 
    ' f' j, P3 D, d! w7 F4 F; ]* @
73.    device->type        = RT_Device_Class_PM;
    
74. 
    ; N# V6 v* C4 x; \
75.    device->rx_indicate = RT_NULL;
    
76. 
    0 j5 e: D8 `) t" \* W
77.    device->tx_complete = RT_NULL;
    
78. 
    2 H7 h1 g1 f+ r. A: R8 A8 x. J
79. 
    2 H! l1 V, ^2 T/ ^$ R6 Z& }/ Q$ X
80. 
    & m% j% }  d6 @" {& g9 n; w
81. #ifdef RT_USING_DEVICE_OPS
    
82. 
    + Y8 q2 q2 c; k) p0 @4 ?% Q
83.    device->ops = &pm_ops;
    
84. 
    
85. #else
    
86. 
    
87.    device->init        = RT_NULL;
    
88. 
    
89.    device->open        = RT_NULL;
    7 p4 G8 j1 T' y8 q9 y+ ]
90. 
    
91.    device->close       = RT_NULL;
    % E0 ?0 x+ R' `. o8 {& @/ q9 L8 Z
92. 
    
93.    device->read        = _rt_pm_device_read;
    & p/ i3 t% C1 C
94. 
    
95.    device->write       = _rt_pm_device_write;
    
96. 
    3 y; S( V8 p/ N( v0 G% F% k  y4 t
97.    device->control     = _rt_pm_device_control;
    5 r6 h% }8 f! o  }3 Q
98. 
    
99. #endif
    
100. 
     + k- X& I# c3 h
101.    device->user_data   = user_data;
     % T3 M8 u" R' E/ N9 _2 H  A# F
102. 
     1 Y- N* a5 Y& y
103. 
     ; ]0 V; `2 n" Y. n+ T9 j
104. 
     
105.    /* register PM device to the system */
     0 c# U. r% i/ g. s
106. 
     ) O2 s. U5 H" s* o
107.    rt_device_register(device, "pm", RT_DEVICE_FLAG_RDWR);
     
108. 
     ! b, ]- h7 i4 f: v3 M9 n! K
109. 
     
110. 
     
111.    rt_memset(pm->modes, 0, sizeof(pm->modes));
     ( X: y: ]7 b, O8 }/ c( O1 k' H; R
112. 
     
113.    pm->sleep_mode = _pm_default_sleep;
     9 ]: s2 i$ s, L9 w
114. 
     
115.    pm->run_mode   = RT_PM_DEFAULT_RUN_MODE;
     ' s* A4 ?" s9 k2 V0 E. F. ^* h
116. 
     # ~4 Y" |+ o7 M4 `, E
117.    pm->timer_mask = timer_mask;
     
118. 
     
119. 
     
120. 
     
121.    pm->ops = ops;
     
122. 
     2 Z8 h$ F& k2 g) u6 `3 S1 t! I4 B
123. 
     : X1 j1 m- Z7 N( a  U4 \
124. 
     3 Y" I' H9 Y1 u1 U; Y
125.    pm->device_pm = RT_NULL;
     
126. 
     
127.    pm->device_pm_number = 0;
     
128. 
     " ^! k4 \8 G: S) l7 C0 b, S
129. 
     
130. 
     
131.    _pm_init_flag = 1;
     " N) ^: u& C/ R; n# b: o5 L5 m( X
132. 
     1 B, o9 e8 J7 L, P- r9 j
133. }

复制代码

STM32L4 移植 PM

STM32L4 的低功耗模式简介：

STM32L4系列 是 ST 公司推出的一款超低功耗的 Crotex-M4 内核的 MCU，支持多个电源管理模式，其中最低功耗 Shutdown 模式下，待机电流仅 30 nA。ST 公司 把 L4系列 的电管管理分为很多种，但各个模式的并非功耗逐级递减的特点，下面是各个模式之间的状态转换图：

尽管 STM32L4系列 的低功耗模式很多，但本质上并不复杂，理解它的原理有助于我们移植驱动，同时更好的在产品中选择合适的模式。最终决定 STM32L4系列 系统功耗的主要是三个因素：稳压器（voltageregulator）、CPU 工作频率、芯片自身低功耗的处理，下面分别对三个因素进行阐述。

u  稳压器L4 使用两个嵌入式线性稳压器为所有数字电路、待机电路以及备份时钟域供电，分别是主稳压器（main regulator，下文简称 MR）和低功耗稳压器（low-power regulator，下文简称 LPR）。稳压器在复位后处于使能状态，根据应用模式，选择不同的稳压器对 Vcore 域供电。其中，MR 的输出电压可以由软件配置为不同的范围（Range 1 和 Rnage 2）。稳压器应用场合

u  CPU 工作频率通过降低 CPU 的主频达到降低功耗的目的：MR 工作在 Range 1 正常模式时，SYSCLK 最高可以工作在 80M；MR工作在 Range 2 时，SYSCLK 最高不能超过 26 M；低功耗运行模式和低功耗休眠模式，即 Vcore 域由 LPR 供电，SYSCLK 必须小于2M。

u  芯片本身的低功耗处理芯片本身定义了一系列的休眠模式，如 Sleeep、Stop、Standby和 Shutdown，前面的四种模式功耗逐渐降低，实质是芯片内部通过关闭外设和时钟来实现。

配置工程

配置 PM 组件：

配置内核选项：使用 PM 组件需要更大的 IDLE 线程的栈，这里使用了1024 字节

在空闲线程中

会调用rt_system_power_manager接口来进入低功耗模式：

1. /**
   
2. 
   
3. * This function will enter corresponding power mode.
   
4. 
   
5. */
   
6. 
   
7. void rt_system_power_manager(void)
   
8. 
   " B  n" ?: ]  r5 q
9. {
   
10. 
    " a" @& k8 b" K% A, P: u9 J
11.    rt_uint8_t mode;
    
12. 
    
13. 
    * v; r2 f' O! j6 r/ q5 R" ~2 |
14. 
    
15.    if (_pm_init_flag == 0)
    9 a& V9 H1 X& R9 b' J  u4 E
16. 
    
17.        return;
    ! n( P8 B  Z7 d
18. 
    
19. 
    
20. 
    " n5 o/ J. \, a. ~, q9 O, S
21.    /* CPU frequency scaling according to the runing mode settings */
    7 h3 t* H5 F* t; d
22. 
    
23.    _pm_frequency_scaling(&_pm);
    
24. 
    1 v% W' D: X, e5 ^0 `
25. 
    
26. 
    
27.    /* Low Power Mode Processing */
    - F1 r0 [3 Z  A  G* t
28. 
    " ~8 j; G0 q9 {' U
29.    mode = _pm_select_sleep_mode(&_pm);
    
30. 
    
31.    _pm_change_sleep_mode(&_pm, mode);
    6 W7 L- d0 R+ @- n/ Y
32. 
    
33. }

复制代码

2 U9 r, j$ R7 Y2 x

保存后，可以看到pm.c已经被添加到了工程：

然后添加PM组件的设备驱动，驱动的最新地址：pm-ports-stm32-new 分支：https://gitee.com/sunwancn/rt-thread/tree/pm-ports-stm32-new

注意： 目前所使用的驱动不是最新版本，移植请到gitee下载最新pm驱动。

从\rt-thread\bsp\stm32\libraries\HAL_Drivers，拷贝如下四个文件到工程的drivers文件夹下：

本项目选择的是使用RTC作为STOP后的时间补偿，所以需要打开rtc设备和所使用的宏：

注： 如果没有使用RTT的自身的RTC函数的话，前面2个宏可以不要。

应用示例：此程序主要实现开机后经过10秒后进入 STOP 模式，然后每经过5秒SLEEP 模式和 STOP 模式互相切换，如此循环往复，同时经过一个循环后，切换 MCU 的运行频率，验证运行的稳定性。并且打开了回调和中断唤醒，在进入睡眠和唤醒后会分别熄灭和点亮LED灯，在睡眠时间可以通过外部中断唤醒：

1. /*
   
2. 
   / v* E/ T1 y3 \+ V2 ]  J8 G
3. * Copyright (c) 2006-2018, RT-Thread Development Team
   
4. 
   
5. *
   
6. 
   
7. * SPDX-License-Identifier: Apache-2.0
   
8. 
   : j# R+ o5 |" |( Q! }& k
9. *
   ! |$ }4 Z  ~9 w* t$ x  }
10. 
    , Y/ [8 V1 ]& R+ v, @
11. * Change Logs:
    
12. 
    
13. * Date           Author       Notes
    6 f# {1 P" d$ L- a$ |
14. 
    
15. * 2018-11-06     SummerGift   first version
    
16. 
    ( r( o' r+ h6 P, c  j1 {3 ~; A
17. */
    : U- `+ l) ^, [1 e$ P' B9 Q; c9 \
18. 
      i  _7 ]0 e0 l8 F+ k
19. 
    
20. 
    
21. #include <rtthread.h>
    ) {6 Q0 o; W8 r+ G0 }/ Q
22. 
    9 O6 r  P6 c; b
23. #include <rtdevice.h>
      Y7 G0 K8 p/ P. N; o+ e' [* y
24. 
      O( L- O: Y! o
25. #include <board.h>
    
26. 
    3 ?' S- Y2 O# w9 ^5 {! X8 u
27. #include <drivers/pm.h>
      V- L- ]( R+ K: x! \$ r8 d
28. 
    
29. #define LOG_TAG             "PM.test"
    
30. 
    & V  o) e3 O8 L2 J; z( f$ W
31. #define LOG_LVL             LOG_LVL_DBG
    " K' A2 R( L9 Q) T7 Y/ c# Q' `4 T' f
32. 
    3 @6 r/ G8 z2 s0 v
33. #include <ulog.h>
    
34. 
    9 c6 H" k, Q) e" p# h2 u/ o
35. /* defined the LED0 pin: PB13 */
    
36. 
    
37. #define LED0_PIN   GET_PIN(C, 6)
    4 L4 f9 b; Z' @- e* t, W
38. 
    6 I! w0 e% C% m! _. m
39. #define MCU_IRQ_WAKE_PIN   GET_PIN(C, 9)
    
40. 
    $ V! v1 l5 v  n) T
41. static RTC_HandleTypeDef hrtc;
    
42. 
      X; h3 ^& v- z/ ?+ e6 V
43. static RTC_TimeTypeDef curtime = {0};
    ) D3 k" {/ _" T( g/ V! P0 [8 M1 E; R
44. 
    
45. static RTC_TimeTypeDef alarmtime = {0};
    
46. 
    
47. static RTC_AlarmTypeDef alarm = {0};
    
48. 
    5 ]' \0 U$ O" X& i( ]7 Q9 d4 P0 `
49. static struct rt_semaphore  wake_sem;
    
50. 
    
51. static rt_uint8_t sleep_mode = PM_SLEEP_MODE_DEEP; /* STOP 模式 */
    6 v. l: D+ b. h# U/ {/ d7 e
52. 
    % w, z4 O: f8 N* O4 T
53. 
    ) T5 S1 _! ~- x0 J- U, p
54. 
    . L: _9 k: O) V- K7 I0 Q; l8 @
55. static rt_uint8_t run_mode = PM_RUN_MODE_NORMAL_SPEED;
    
56. 
    2 |$ X: R' T! ]' a* q$ A& p1 Y
57. 
    1 h2 G7 c2 Z* `( p
58. 
    
59. static rt_uint32_t get_interval(void);
    
60. 
      V1 W& T( g( _% l. _2 y& v3 J2 W
61. static void get_rtc_time(RTC_TimeTypeDef *time);
    
62. 
    
63. static rt_uint8_t mode_loop(void);
    
64. 
    % b6 o1 c9 Z$ i4 D" G$ Z
65. static rt_uint8_t issleep = 0;
    5 H* N8 I' m" }9 V' F
66. 
    
67. /* 中断回调函数 */
    / m8 X( o& l- v# c1 s, o7 _
68. 
    1 x) o0 \9 z7 d: f' A
69. static void MCU_IRQ_WAKE(void *args)
    
70. 
    
71. {
    - [8 P& ]# ]7 [5 h0 h
72. 
    0 K- C1 I: [( I
73. 
    ! H8 X  h9 y2 z) N0 f1 s1 M
74. 
    1 `0 L3 V2 I( F+ q! A. a* W0 R
75.    if(issleep)
    
76. 
    
77.   {
    / C: I8 W' ^6 W" t1 o/ D* u  O
78. 
    
79.        rt_kprintf("MCU_IRQ_WAKE!\n");
    
80. 
    
81.        rt_sem_release(&wake_sem);
    , V, B% a- A; N. K4 X
82. 
    
83.        issleep = 0;
    
84. 
    $ L8 s4 i* \; v# M( M
85.   }
    5 y" o* h( Z& ^4 ?! N
86. 
    # ?" ]2 ]' E4 n* x: ]  L. O" `' U$ w
87. 
    
88. 
    7 C, b% w5 c; v: D- f
89. }
    
90. 
    
91. static void pm_botify(uint8_t event, uint8_t mode, void *data)
    / P; r5 O: x0 S: ?: w
92. 
    $ x; q- l5 h- _$ b
93. {
    
94. 
    " _4 b9 b6 G1 l' J" b
95. 
    
96. 
    
97.    if(event == RT_PM_ENTER_SLEEP && mode == PM_SLEEP_MODE_DEEP)
    
98. 
    
99.   {
    * r& s+ r9 u8 P2 E
100. 
     
101.        rt_pin_write(LED0_PIN, PIN_HIGH);
     
102. 
     
103.        issleep = 1;
     
104. 
     
105.   }
     % G2 m  \1 w4 L; t4 N
106. 
     4 l+ H( S( W# S+ }% m4 C
107.    else if (event == RT_PM_EXIT_SLEEP && mode == PM_SLEEP_MODE_DEEP )
     
108. 
     
109.   {
     
110. 
     8 |! L5 \$ K; }( o$ |* D
111.        rt_pin_write(LED0_PIN, PIN_LOW);
     
112. 
     
113.   }
     * Z& V5 e- d" e/ V% F+ |  z
114. 
     
115. }
     
116. 
     , f: R: X, H# y8 |
117. 
     
118. 
     6 U5 L2 E9 ~+ z
119. int pm_test(void)
     9 s" O1 E) L8 l# _$ L( N0 J& V/ r
120. 
       t. w) F# i) r9 a$ q  s9 w
121. {
     % p6 {! Z/ A" g5 l' q/ Z
122. 
     
123.    hrtc.Instance = RTC;
     
124. 
     1 J3 ^3 Z2 B* j, X
125. 
     / T- s0 ^: S; v3 ~1 P8 T
126. 
     6 N6 e3 @. {! O' X+ e. X
127.    rt_sem_init(&wake_sem, "wake_sem", 0, RT_IPC_FLAG_FIFO);
     0 C! Y+ ^; @. F9 D
128. 
     
129.    rt_pm_notify_set(pm_botify,0);
     
130. 
     
131.    /* 按键0引脚为输入模式 */
     
132. 
     , }0 L8 w7 F- v
133.    rt_pin_mode(MCU_IRQ_WAKE_PIN, PIN_MODE_INPUT_PULLDOWN);
     
134. 
     3 X5 Q% P" P  g+ b6 I$ k
135.    /* 绑定中断，上升沿模式，回调函数名为beep_on */
     4 u0 S0 D$ n; Y; K
136. 
     
137.    rt_pin_attach_irq(MCU_IRQ_WAKE_PIN, PIN_IRQ_MODE_RISING, MCU_IRQ_WAKE, RT_NULL);
     
138. 
     $ K7 B3 H3 z: ^+ I
139.    /* 使能中断 */
     
140. 
     
141.    rt_pin_irq_enable(MCU_IRQ_WAKE_PIN, PIN_IRQ_ENABLE);
     1 z) p! i5 `/ @
142. 
     1 T' Z, H6 j3 i4 t& s
143. 
     & S1 ^8 N/ B5 z1 c: E5 Z$ e
144. 
     
145.    rt_thread_mdelay(10000);
     4 p4 j% M$ z3 C
146. 
     ( J; U5 p: R. F) G) f
147. 
     % }: O  r3 f; L1 }7 ?/ Z1 q
148. 
     
149. 
     
150. 
     
151. #ifdef RT_USING_PM
     $ e9 H( A  E% {, f' h( z( ]
152. 
     
153.    /* 申请低功耗模式 */
     6 e3 K) ^0 W3 q* `& u$ d" X
154. 
     
155.    rt_pm_request(sleep_mode);
     
156. 
     
157. #endif
     
158. 
     
159. 
     
160. 
     8 N) P6 E2 f4 i9 G
161.    get_rtc_time(&curtime);
     
162. 
     1 v& ?% ?  R( o. ?- U4 @' F
163. 
     
164. 
     
165.    if (sleep_mode == PM_SLEEP_MODE_STANDBY)
     0 ~' }' x' T, d- L- [7 t4 S
166. 
     
167.   {
     * Z1 H- Y5 Y3 _
168. 
     . ~1 S; ]  B& _6 ]
169.        /* 设置休眠，闹钟 20 秒后唤醒，简化版闹钟，只支持 1分钟内有效 */
       `) o' _4 P% ]  X& q  @, j
170. 
     
171.        alarmtime.Hours = curtime.Hours;
     4 S% m1 i; j( z  F; ^4 j; V( Y# C
172. 
     6 }6 T2 j) l; \+ w; C% G
173.        alarmtime.Minutes = curtime.Minutes;
       L0 }3 x4 V' z0 h) R9 w
174. 
     
175.        alarmtime.SubSeconds = curtime.SubSeconds;
     6 t+ \' F8 Y$ d
176. 
     
177.        alarmtime.Seconds = curtime.Seconds + 20;
     ( `% ~" `% t5 Z
178. 
     
179.        if (alarmtime.Seconds >= 60)
     : P6 _7 G* T, k* p7 A
180. 
     , f' k7 f! \6 K5 H$ O
181.       {
     * z6 R; d9 n; g( f! P3 a
182. 
     - i. S# [4 O: D$ C! a; G
183.            alarmtime.Seconds -= 60;
     % q) P5 ]# J/ L( B4 j
184. 
     ! Y( N1 P/ ~; P7 Y
185.            alarmtime.Minutes ++;
     9 k1 L1 P, Z) @  Y4 j$ ?
186. 
     
187.            if (alarmtime.Minutes >= 60)
     
188. 
     
189.                alarmtime.Minutes -= 60;
     ' H( D( t2 v) i* M, N2 |! m: W' Y$ Y
190. 
     % @; ?. r* n9 g5 J9 j% A
191.       }
     
192. 
     ' t( I  p9 h) D
193. 
     
194. 
     
195.        alarm.Alarm = RTC_ALARM_A;
     
196. 
     
197.        alarm.AlarmTime = alarmtime;
     5 D1 b3 E' w/ Y4 l. c+ x+ D* e
198. 
     
199.        alarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
     3 L! O% }( ~  Z4 F+ L1 ]% e
200. 
     
201.        alarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;
     
202. 
     
203.        alarm.AlarmMask = RTC_ALARMMASK_DATEWEEKDAY | RTC_ALARMMASK_HOURS;
     
204. 
     ( O: {# |0 \& _+ g, t4 o2 L
205.        alarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_NONE;
     
206. 
     * V) i6 ^$ w7 M; G
207.        alarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
     
208. 
     * i0 g- z8 O* b3 g& Z
209.        alarm.AlarmDateWeekDay = 0x1;
     
210. 
     4 |% i9 y" I' n2 Q7 M
211. 
     8 p. G2 ^* j# O" u" y8 s: D2 }
212. 
     / H8 B) p( Y* d) G( ]
213.        /* 开启闹钟 */
     
214. 
     
215.        HAL_RTC_SetAlarm_IT(&hrtc, &alarm, RTC_FORMAT_BIN);
     % X7 p4 a' V! v+ p. i! x
216. 
     
217.   }
     / q: ]1 T, T3 X! Y' Z
218. 
     
219. 
     ! L) Z0 m5 t+ r
220. 
     
221.    while (1)
     : E8 Z: \; |, O. _6 L7 n
222. 
     - ?7 N# q. |7 p
223.   {
     
224. 
     5 c* _  r* W! ]/ H- l8 z2 \
225.        /* 开始进入低功耗模式 */
     ) h, s. o  P1 k9 I7 j: G
226. 
     ; |- p* f+ w! s0 v. v
227.        rt_sem_take(&wake_sem, rt_tick_from_millisecond(5000));
     8 V" r+ h# B; _6 m; E& n
228. 
     
229. 
     ! f3 Z0 i4 t( |8 g+ l5 B
230. 
     # o5 r( _! t( p* a" J
231.        /* 退出低功耗模式 */
     
232. 
     + |4 k2 I! |/ |+ K
233.        rt_kprintf("Sleep %d ms\n", get_interval());
     , a' L: d( E. _
234. 
     1 m+ a& J! R5 s3 f  ^* d/ q
235. 
     6 |0 t7 q8 y6 S% o0 ?6 z
236. 
     
237. #ifdef RT_USING_PM
     
238. 
     
239.        /* 申请正常模式 */
     
240. 
     % z' G! A* Z* X% v" ^* m
241.        rt_pm_request(PM_SLEEP_MODE_NONE);
     1 I' D# V( g5 r$ W5 J9 f
242. 
       n' u7 l% N, m
243. #endif
     
244. 
     
245. 
     
246. 
     
247.        rt_thread_mdelay(5000);
     
248. 
     2 v* P: N" e* x" l' ?9 R
249. 
     
250. 
     1 [; T% r4 h2 k, x2 E
251.        rt_kprintf("Wakeup %d ms\n", get_interval());
     8 ]$ m* ~* F0 N8 f; U
252. 
     1 M6 u+ H+ m/ a! C3 w
253. 
     
254. 
     9 S& S- e4 b1 h" U* }, e/ M( E7 ^1 `' z
255.        /* 运行模式切换 */
     
256. 
     
257.        rt_pm_run_enter(mode_loop());
     
258. 
     / o/ G0 K. X4 E- L3 J) J: q
259. 
     
260. 
     # j2 P- M  ^) Q) u0 h* h) j/ D7 B
261. #ifdef RT_USING_PM
     
262. 
     
263.        rt_pm_release(PM_SLEEP_MODE_NONE);
     
264. 
     
265. #endif
     
266. 
     
267.   }
     ! |7 [; {+ B, V  L, \/ D  d/ Q
268. 
     ( z; f3 Z5 b+ N' \
269. 
     / x% R1 j1 H* f+ s) U
270. 
     
271.    return RT_EOK;
     
272. 
     2 |: ^% b& I& w
273. }
     
274. 
     
275. //MSH_CMD_EXPORT(pm_test, PM TEST);
     9 f9 e4 v4 A+ c* B- b
276. 
     
277. 
     8 f! c: B, d6 o# w0 _9 _( q, I
278. 
     
279. static rt_uint32_t get_interval(void)
     : }# c3 J( Q( _9 l) C6 a
280. 
     * O+ o2 [4 ^" W
281. {
     9 x  ?* C* t# k0 j0 W  M
282. 
     , [4 O. w% G3 e% A$ o$ f$ n! F$ d
283.    rt_uint32_t seconds;
     
284. 
     
285. 
     
286. 
     
287.    rt_uint32_t last_seconds = curtime.Seconds;
     
288. 
     
289.    rt_uint32_t last_subseconds = curtime.SubSeconds;
     - c/ D# r6 d- `# @* [' z3 X0 u  P
290. 
     
291. 
     " F) ^5 q7 f- z* K
292. 
     
293.    get_rtc_time(&curtime);
     
294. 
     
295. 
     
296. 
     " c) S+ V: z6 q/ }4 }7 G# K9 m
297.    if (curtime.Seconds < last_seconds)
     
298. 
     
299.        seconds = 60 + curtime.Seconds - last_seconds;
     4 A" S+ s6 s3 r
300. 
     1 G( V# i" F( N. K3 \. B; \
301.    else
     , R0 y5 _4 ?& p: O
302. 
     
303.        seconds = curtime.Seconds - last_seconds;
     6 X1 L6 |5 f' p3 S) w
304. 
     / n& i8 V* n9 r, L: h
305. 
       B# _) t) V- n) [7 B8 u5 A
306. 
     ) D  W- e0 u+ m
307.    return (rt_uint32_t)(seconds * 1000 + ((int32_t)last_subseconds - (int32_t)curtime.SubSeconds) * 1000 \
     1 g# R' J: c1 t: {- O& h4 P
308. 
     
309.                         / (int32_t)(((RTC->PRER & RTC_PRER_PREDIV_S) >> RTC_PRER_PREDIV_S_Pos) + 1U));
     " ~$ ^1 h: d: X. \; W
310. 
     ' f% v: h4 n; H7 Z9 z
311. }
     - p/ _0 p/ x  S  z
312. 
     3 |5 B& Y$ i1 _; M
313. 
     
314. 
     ' R: N) T3 \0 s! G( Q3 p0 V
315. static void get_rtc_time(RTC_TimeTypeDef *time)
     
316. 
     % E: u& o. O+ S4 I2 c: ]
317. {
     , J. K" B9 _5 e- j  @
318. 
     ; i$ R3 b9 v7 @+ V  k
319.    rt_uint32_t st, datetmpreg;
     
320. 
     
321. 
     2 M! z4 V  S( V: \: k5 h5 k- U) Y7 m
322. 
     
323.    HAL_RTC_GetTime(&hrtc, time, RTC_FORMAT_BIN);
     6 Q. C9 @) f2 i, K' O* ]
324. 
     / W" c' q+ k) R# u
325.    datetmpreg = RTC->DR;
     
326. 
     
327.    if (HAL_RCC_GetPCLK1Freq() < 32000U * 7U)
     
328. 
     2 K8 U! n/ X) H1 X
329.   {
     : i# i3 Q: m$ N4 ^- A
330. 
     & X6 S) [0 I7 G2 B& p
331.        st = time->SubSeconds;
     % X- N) P" N9 X; B! D) I/ t
332. 
     
333.        HAL_RTC_GetTime(&hrtc, time, RTC_FORMAT_BIN);
     
334. 
     
335.        datetmpreg = RTC->DR;
     
336. 
     
337. 
     
338. 
     8 c5 A. k2 g& q3 z9 \9 M! ~( y$ U
339.        if (st != time->SubSeconds)
     
340. 
     8 r3 U2 v  @+ y% Z
341.       {
     
342. 
     
343.            HAL_RTC_GetTime(&hrtc, time, RTC_FORMAT_BIN);
     
344. 
     
345.            datetmpreg = RTC->DR;
     
346. 
     
347.       }
     
348. 
     
349.   }
     
350. 
     
351.   (void)datetmpreg;
     
352. 
     3 N- w( w" S$ {5 n  V
353. }
     ! _7 `) K$ J( [4 k7 ]
354. 
     
355. 
     " x  h2 _5 i  R, B0 B
356. 
     
357. rt_uint8_t mode_loop(void)
     / U' c5 p' n2 k' u; c) q9 z
358. 
     
359. {
     
360. 
     
361.    rt_uint8_t mode = 1;
       {( l9 n0 \. m- N( i1 \
362. 
     
363. 
     
364. 
     
365.    run_mode++;
     
366. 
     
367.    switch (run_mode)
     
368. 
     
369.   {
     % M2 K) E: n8 G8 n: q
370. 
     
371.    case 0:
     ; }  }. Q0 R7 x0 B
372. 
     5 O. v4 C2 L5 ~
373.    case 1:
     
374. 
     
375.    case 2:
     
376. 
     2 L0 Q  ]: @: x# k' @$ U$ x
377.    case 3:
     6 P/ F( i3 f, z5 ?7 \' c
378. 
     
379.        mode = run_mode;
     
380. 
     ' t; Z- S/ j. w% Q7 ]) P8 n
381.        break;
     0 k5 t9 G' o& H7 a
382. 
     
383.    case 4:
     
384. 
     
385.        mode = 2;
     9 U3 d. \2 X* @" U2 i: H% y
386. 
     
387.        break;
     + E( A3 v1 u, B' g- E
388. 
       {8 v( C6 a4 }, F1 T  r
389.    case 5:
     7 }" l/ Y9 q$ y6 q) I+ A
390. 
     
391.        mode = 1;
     
392. 
     : R5 C3 f+ r+ V! l* U  v
393.        break;
     
394. 
     
395.    case 6:
     ! N; M' |7 z2 ?. \( Y
396. 
     
397.        mode = run_mode = 0;
     " b8 X: X/ _- t& {; ]; Y6 I
398. 
     
399.        break;
     0 {9 X) ~' o" G, c- u( P
400. 
     7 s) F1 G3 V, N" ]6 l8 B2 O
401.   }
     / g0 a% S+ D0 i' o: {
402. 
     
403. 
     
404. 
     
405.    return mode;
     
406. 
     
407. }

复制代码

运行效果：

目前PM组件的STM32驱动还需要更多人的测试，需要加入STM32低功耗测试小组的，加我微信：17630350805 请备注低功耗。

-END-

文章出处： RTThread物联网操作系统