MCU：stm32L031K6T6
5 ^) J8 o7 ?7 v
, i8 E5 h% X4 d, j  Q芯片的主要的低功耗特性
( I/ s- k; H$ ?" @0 j* a; ZFeatures
• Ultra-low-power platform
+ p4 I* t4 a2 l+ u' E+ ]  d– 1.65 V to 3.6 V power supply
; p" b3 i, q, g" l  z– -40 to 125 °C temperature range
5 V' J8 z3 S8 `- m– 0.23 µA Standby mode (2 wakeup pins)
; D) l/ s# [+ W  H' E2 \; }– 0.35 µA Stop mode (16 wakeup lines)
– 0.6 µA Stop mode + RTC + 8 KB RAM retention
– Down to 76 µA/MHz in Run mode
– 5 µs wakeup time (from Flash memory)
/ q* Z& A9 _  g& F1 ~: Q! @– 41 µA 12-bit ADC conversion at 10 ksps
• Core: Arm® 32-bit Cortex®-M0+
– From 32 kHz up to 32 MHz max.
– 0.95 DMIPS/MHz

功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：

+ R( l: ]+ J: Y2 d$ }- W5 r

# G3 s; Y% \) U- a
我们选用的当然是最最低功耗的standby模式了：

standby模式BKP备份寄存器能够使用
standby模式LSI和LSE两个晶振源可以使用
standby模式可以用RTC或Wakeup PIN能够唤醒
1 ~# N& ~! F- O( \, [$ G  _8 s5 k注意 standby模式下RAM里面的数据是不保存的
$ u! y; B2 n  V: w% }' F主程序框架
7 r8 h$ a3 w- c- H" [$ m

1. ...
   
2. int main(void){
   6 S1 F! T0 o% {; y# u' V
3.         HAL_Init();
   
4.         
   ! P# i9 a8 G8 c$ \* _& F$ r* n
5.         SystemClock_Config();
   
6.         
   & W8 e( F; O* {' A
7.         MX_GPIO_Init();
   
8.         MX_DMA_Init();
   + H3 F; S" }* s9 ^7 |
9.         MX_ADC_Init();
   7 Z, O, G. j% W( w" d9 |  L9 e3 b5 V
10.         MX_IWDG_Init();
    
11.         MX_SPI1_Init();
    1 G# t+ V5 I9 O6 Z
12.         MX_TIM2_Init();
    & o/ B5 R0 Z8 h( A" R  P
13.         ...
    9 S3 X: N5 p1 H2 i8 [) L
14.         
    , U/ _# ?. t2 J' G7 I. `% _
15.         SystemPower_Config();        //PWR配置
    
16.         
    ' x* z+ P, c9 s
17.         BSP_Init();        //板级支持包外设初始化
    
18.         
    
19.         BAK = get_bak_param();        //恢复备份的数据
    3 g9 x1 b% U. u- \/ T
20.         
    / G- T- N# }* C
21.          while（1）{
    
22.                 ...        
    
23.                 //主程序体
    
24.                
    
25.         }
    0 x7 L8 ^3 h4 i+ q4 D
26. }

复制代码

" J8 M' A( A2 G重要函数实现
1. PWR配置

1. void SystemPower_Config(void){
   
2.         __HAL_RCC_PWR_CLK_ENABLE();
   & Z3 r& o$ D4 s8 a5 L' W
3. 
   
4.         HAL_PWREx_EnableUltraLowPower();
   
5. 
   6 {) l5 e! D5 |( e8 T/ a
6.         HAL_PWREx_EnableFastWakeUp();
   % ~+ O+ C9 Q0 M9 m$ M
7. }

复制代码

$ J6 L0 I2 A8 G! V) M2. 进入standby模式
1.先备份数据
set_bak_param(BAK);
2.进入standby模式
pwr_standby();
* J/ O/ q1 K; {9 c/ [
7 e4 _4 b4 Q+ h

1. void pwr_standby(void){
   : p) H5 {& x% ~/ Z4 M& P8 ^: G
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   
4.         }
   
5.         
   
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   
7.         
   3 z) `) D( f- |1 l- N, O
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   ) ^4 D5 ^& q& R2 R+ g
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    4 t( `" [! P+ T5 T. o
11.         
    
12.         /* Clear all related wakeup flags*/
    ; U5 h+ l$ V+ o+ P
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    
14. 
    1 G/ J  L& d2 E0 N  ~6 d# M
15.         HAL_PWR_EnterSTANDBYMode();
      L3 z4 ?1 O6 D! h
16. }

复制代码

" O* D& Z# S( l5 u1 T& s3. 唤醒
唤醒没什么好说的，standby模式下唤醒，程序跟上电复位没什么区别，RAM里面数据都没了，但是BKP中的数据仍然存在；
0 H! j2 s8 D0 U* K* B' _这里暂时就把唤醒当做是重新上电吧，后面说到BKP的时候再区别处理；

% q& p& a$ A* s* ~5 |/ T% u2 f4. 数据备份和恢复
% L& j# M; ?) |1 E• Memories
– Up to 32-Kbyte Flash with ECC
– 8-Kbyte RAM
– 1-Kbyte of data EEPROM with ECC
0 t9 T9 l: E% x% ]9 G5 N– 20-byte backup register
– Sector protection against R/W operation
如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯
& W4 z2 G+ G8 c1 b4 m

1. //**设计结构体用来存储备份的数据**
   
2. typedef struct bak_t{
   
3.         uint32_t        RTC_STA;
   
4.         ...        //根据自己的需要设计结构体吧
   
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据
$ G: x; C& q# w

1. typedef struct bkp_t{
   & X, W7 d  d+ m* O3 y6 w' z
2.         uint32_t        DR0;        
   % u; ^8 y# }/ O& x! k/ M% _+ }9 J8 U
3.         uint32_t        DR1;
   ; b" v& ^( P2 e
4.         uint32_t        DR2;
   ' s/ q' A9 a! a
5.         uint32_t        DR3;
   ) b4 r# |/ l8 [
6.         uint32_t        RTC_STA;        //rtc init sta
   
7. }BKPTypeDef;
   
8. 
   
9. void bkp_init(void){
   
10.         hrtc.Instance = RTC;
    ( J4 m3 Y9 O$ W
11.         BKPTypeDef bkp;
    
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    
13.                 printf("rtc init\r\n");
    ' V1 n3 x5 _. L: N
14.                 HAL_RTC_Init(&hrtc);
    
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    % N% x6 c) F; D: p" c
16.                 bkp.RTC_STA = 0xaa55aa55;
    
17.                 set_bkp(&bkp);
    
18.         }
    
19. }
    6 d5 ~0 ]4 p$ J; d. C5 T
20. 
    
21. BKPTypeDef get_bkp(void){
    
22.         BKPTypeDef bkp;
    * a! |2 y3 T! b6 i0 }0 Q
23.         bkp.DR0= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0);
    % |6 A& |9 X: A! F0 V2 Z9 _: I
24.         bkp.DR1= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR1);
    : ~9 k" o! B4 Z6 \% v
25.         bkp.DR2= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
    6 {' I' g$ s: |* [3 }# O
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    
28.         return bkp;
    
29. }
    
30. 
    : y. a  j5 Q. i# k4 a" a; `
31. void set_bkp(BKPTypeDef *bkp){
    
32.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR0, bkp->DR0);
    
33.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR1, bkp->DR1);
    
34.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR2, bkp->DR2);
    ' Y' Q$ M# c) R8 W0 c0 ^
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    - t8 x9 }' w# Y/ L
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    & ~) \+ Y7 {1 u& {
37. }

复制代码

! w0 N' A) K3 o+ N" E6 A0 ]* J4.2 用EEPROM备份和恢复数据
% u% D3 x" }( r- |. i

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   * X3 h# v$ P6 B5 z
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
   
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   4 p! @8 o* u1 ]3 ^9 N
4.                 return false;
   
5.         }
   
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   
7.                 printf("Flash EEPROM Address Error!!!\n");
   8 D3 _  d1 K" Q3 [: J0 y
8.                 return false;
   7 x' t( j) M; T8 ^/ r' V! C. y9 {2 b
9.         }
   6 L2 t' r' Z7 P# i1 _
10.         
    5 G; t6 d# R: H5 \! g4 H0 Y% O" ^
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    / ]5 j, T: z' D2 c) f$ _
12.         for(uint16_t i=0;i<Size;i++){
    
13.                 HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, DATA_EEPROM_BASE+addr_offset+32*i, pData<i>);
    
14.       </i>  }
    5 Z6 q) J" i7 x: x3 x# R
15. 
    
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    / s) U: D( T( Y
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    
18.                 return false;
    - \* R: s% j; O0 `) }/ J7 Z
19.         }
    
20.         
    0 g* f* I% e) q1 f0 w+ {5 o
21.         return true;
    3 A3 I# G  Y$ N# q" d0 w* r& K. \
22. }
    
23. 
    
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    $ f3 v% l1 P( K3 [4 ]: u
25.         if(Size > DATAEEPROM_MAX_SIZE){
    1 |% Y. D- v2 U: j4 X$ `# T
26.                 printf("Size is too long!\r\n");
    
27.                 return false;
    4 B2 Q6 W, f8 z) P3 b8 n2 \$ x6 Y
28.         }
    
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    
30.                 printf("Flash EEPROM Address Error!!!\n");
    
31.                 return false;
    * f* n% T2 K( \( |
32.         }
    
33.         
    
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    
35.         
    2 Y9 f) X6 t) d/ e+ [. C  \( Q6 Z
36.         for(uint16_t i=0;i<Size;i++){
    
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    
38.         }
    5 n5 N2 J4 l+ {" X' v/ r- }, X
39. #if 0        
    
40.         for(uint16_t i=0;i<Size;i++){
    
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    
42.         }
    
43. #endif        
    
44.         memcpy(pData, tmp, Size);
    
45.         
    
46.         return true;
    0 d: R  h4 }3 i# T+ u( r, x
47. }

复制代码

5. 区别处理
4 K+ ~2 ]2 Y4 ]5 c5 z- i如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
' k' N+ E+ [) j( a. v4 U: T" u# k我们有一个重要的寄存器呀backup register
# k3 Y0 `) S. ^如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；
( l, {' W$ t0 z9 ~8 Y

1. if(0xaa55aa55 == BKP.RTC_STA){
   
2.         ...
   8 K& _' A7 H3 P
3.         //显示B画面
   
4. }else{
   
5.         ...
   & C3 n2 `& s+ k' j) q6 l2 z9 J
6.         //显示A画面
   
7. }

复制代码

  C( i: ~" O& K  \* s/ r5 Q2 }总结
可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
standby模式的程序框架为：
; Q/ p3 b9 Z2 z" @  C, q/ ^
+ k! q4 {; g8 x" H

& u7 v* T% M* a5 j