MCU：stm32L031K6T6
2 L: Z/ S7 `  K, i) O2 \
. X2 {3 l/ c+ a7 w芯片的主要的低功耗特性
1 B) _0 h+ q! L* r; a& ~; IFeatures
( s2 f& n+ p5 a+ d* {• Ultra-low-power platform
– 1.65 V to 3.6 V power supply
– -40 to 125 °C temperature range
" d+ @, H9 ^2 ?! Q( |– 0.23 µA Standby mode (2 wakeup pins)
' x7 z# D' Y! @; P: N% S: P– 0.35 µA Stop mode (16 wakeup lines)
– 0.6 µA Stop mode + RTC + 8 KB RAM retention
9 w8 V6 D+ c5 T4 ~– Down to 76 µA/MHz in Run mode
, M, s$ v2 h# e2 ^2 V0 I– 5 µs wakeup time (from Flash memory)
– 41 µA 12-bit ADC conversion at 10 ksps
9 o# e+ v$ u, @• Core: Arm® 32-bit Cortex®-M0+
9 T* m. }% S5 K  Q# s– From 32 kHz up to 32 MHz max.
. n+ j9 u3 @8 P# L– 0.95 DMIPS/MHz
/ E. m, O" l4 W0 ]0 _/ w
功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：

5 @5 l+ q( {& R; z4 t+ r# p

! e& x- O0 m1 ^" \/ X8 O

我们选用的当然是最最低功耗的standby模式了：
* y3 F7 W6 X4 E& G5 A) ^: C" \
standby模式BKP备份寄存器能够使用
4 K# ~) v  E+ w9 j# Tstandby模式LSI和LSE两个晶振源可以使用
5 ]/ x+ N5 q* k: ?- Y1 istandby模式可以用RTC或Wakeup PIN能够唤醒
注意 standby模式下RAM里面的数据是不保存的
6 ]6 [1 K6 L) t3 S' k1 b) J主程序框架

1. ...
   
2. int main(void){
   
3.         HAL_Init();
   
4.         
   6 n$ [/ z2 Y0 u; P& G! j" i8 [
5.         SystemClock_Config();
   
6.         
   
7.         MX_GPIO_Init();
   
8.         MX_DMA_Init();
   * K! L% H; `" n9 h4 e" P
9.         MX_ADC_Init();
   
10.         MX_IWDG_Init();
    % ^" _8 t9 ]  j: g8 X/ r1 N" V
11.         MX_SPI1_Init();
    
12.         MX_TIM2_Init();
    
13.         ...
    
14.         
    
15.         SystemPower_Config();        //PWR配置
      R6 \4 c' i  f/ {/ Q# U' }
16.         
    
17.         BSP_Init();        //板级支持包外设初始化
    / u7 U, H, ^8 H% ^  J
18.         
    
19.         BAK = get_bak_param();        //恢复备份的数据
    " i5 W) q0 j" T+ o( ?- h
20.         
    
21.          while（1）{
    ( W! f. z; l& P& u! X! e
22.                 ...        
    
23.                 //主程序体
    
24.                
    0 z' E5 U4 \" W1 q1 N& q
25.         }
    
26. }

复制代码

8 t  F% o2 P) S. A重要函数实现
1. PWR配置
6 ]( S* O  ]6 d  T4 \: G( k3 @6 M

1. void SystemPower_Config(void){
   
2.         __HAL_RCC_PWR_CLK_ENABLE();
   
3. 
   3 _4 e/ b! C0 p6 W
4.         HAL_PWREx_EnableUltraLowPower();
   
5. 
   8 V$ r# t3 B2 c& ~* {
6.         HAL_PWREx_EnableFastWakeUp();
   
7. }

复制代码

, C& x5 p- c, s* H. R  ]2. 进入standby模式
% V& L% Z; \5 k' G" K1.先备份数据
set_bak_param(BAK);
2.进入standby模式
0 X) f2 C" A- W5 z; ~9 qpwr_standby();
% _6 B) p8 \- n- c2 r

1. void pwr_standby(void){
   
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   8 P; B3 }* R) s# k& m6 g1 m
4.         }
   ! e' @2 o% |! a% l2 @# b
5.         
   
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   
7.         
   
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   - f3 Y! v0 d/ I1 R+ d; B0 F
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   * X/ N/ Q9 Q3 n2 @; X
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    
11.         
    
12.         /* Clear all related wakeup flags*/
    
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    
14. 
    + e9 M$ g" i1 Z8 y, m
15.         HAL_PWR_EnterSTANDBYMode();
    % a4 i* \& C& a1 z2 M- X
16. }

复制代码

3. 唤醒
唤醒没什么好说的，standby模式下唤醒，程序跟上电复位没什么区别，RAM里面数据都没了，但是BKP中的数据仍然存在；
这里暂时就把唤醒当做是重新上电吧，后面说到BKP的时候再区别处理；

* V, x  E% ~* c' U' Q4. 数据备份和恢复
9 j& C: Q6 t& R% c• Memories
2 ]9 P# T; v+ y, c+ Q0 |– Up to 32-Kbyte Flash with ECC
- L0 {+ w8 `. T0 H9 Q- _2 Z% l– 8-Kbyte RAM
– 1-Kbyte of data EEPROM with ECC
– 20-byte backup register
– Sector protection against R/W operation
- Q! A: Q! D9 B9 E如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯
8 Z( Z* t1 B$ [6 I; h/ y4 E
  ]. Y, y! s+ K  l$ @

1. //**设计结构体用来存储备份的数据**
   
2. typedef struct bak_t{
   5 V4 y+ n' k* f$ s: `+ h3 W
3.         uint32_t        RTC_STA;
   
4.         ...        //根据自己的需要设计结构体吧
   : {( R1 w" w8 `' z1 R. f. x
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   
3.         uint32_t        DR1;
   ! S! Q" M% b$ L5 x+ p
4.         uint32_t        DR2;
   
5.         uint32_t        DR3;
   : {, K$ @4 R1 I% F9 x" o, _
6.         uint32_t        RTC_STA;        //rtc init sta
   - p- E+ `& Y+ K% b8 t4 n- `2 |; Y
7. }BKPTypeDef;
   
8. 
   5 ?0 ?4 i. t# l" H! A) |, c3 N( J
9. void bkp_init(void){
   
10.         hrtc.Instance = RTC;
    % D) N& ]4 j9 z$ W" c. H
11.         BKPTypeDef bkp;
    6 F5 ^7 U% ~1 Z
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    
13.                 printf("rtc init\r\n");
    . k0 O/ L3 w9 ~4 c
14.                 HAL_RTC_Init(&hrtc);
    
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    
16.                 bkp.RTC_STA = 0xaa55aa55;
    
17.                 set_bkp(&bkp);
    3 I1 B0 o6 s. `% p$ _) [6 g& G
18.         }
    
19. }
    
20. 
    
21. BKPTypeDef get_bkp(void){
    
22.         BKPTypeDef bkp;
    
23.         bkp.DR0= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0);
    
24.         bkp.DR1= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR1);
    0 d$ [3 _1 L- Z  }1 ?4 W
25.         bkp.DR2= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
    . @- p4 K& r/ f, _
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    9 I0 Q1 o. K) K8 N8 w; m
28.         return bkp;
    
29. }
    
30. 
    
31. void set_bkp(BKPTypeDef *bkp){
    ( b& V0 ]/ E7 W1 [3 ~# w
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);
    
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    7 o+ K$ q$ |) T" j/ l) y8 x8 [
37. }

复制代码

' L) Q: B# `* X9 K+ r  q4.2 用EEPROM备份和恢复数据
, p$ A# [2 k( R, R: k$ P

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   5 R. H5 Z  }& @
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
   
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   + [. I4 {% O# j
4.                 return false;
   
5.         }
   , c$ b/ p  K) _! v0 \! g( t
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   
7.                 printf("Flash EEPROM Address Error!!!\n");
   
8.                 return false;
   . S5 g8 S! G' D0 i' G6 n& E
9.         }
   
10.         
    
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    & t) }: P, R7 m- d* N+ I
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>);
    8 r" b# n" @/ s& g+ a0 v
14.       </i>  }
    
15. 
    3 t7 @: N  T, {* p
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    ( t+ E2 U3 S9 O' D% F
18.                 return false;
    & S9 o3 M7 e! e+ J
19.         }
    5 G2 v, @- Y$ v& [- J/ I8 D( }- t
20.         
    
21.         return true;
    
22. }
    5 N; E2 y' P9 ^; a$ Q: G$ x& \
23. 
    
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    . T. q4 Z7 ~% W2 P3 V, b) ]5 I
25.         if(Size > DATAEEPROM_MAX_SIZE){
    
26.                 printf("Size is too long!\r\n");
    
27.                 return false;
    
28.         }
    4 {  |) M& k' E3 w' ~( I! }
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    
30.                 printf("Flash EEPROM Address Error!!!\n");
    
31.                 return false;
    
32.         }
    . a2 `3 n6 g- I2 ?6 T
33.         
    2 F( B7 k( V1 M) H; }; j' S+ X/ R
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    1 ^3 k: B1 V% h- i! ?3 z( q) i6 o
35.         
    2 _" z& V! m: ^" j* c6 g, Q) N- k
36.         for(uint16_t i=0;i<Size;i++){
    
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    * F& ]2 |1 w7 Q9 p, F
38.         }
    
39. #if 0        
    $ Z+ n2 m2 n1 M4 i2 _5 Z; V
40.         for(uint16_t i=0;i<Size;i++){
    
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    + y! m* @4 w" V* w
42.         }
    
43. #endif        
    ) x+ T% W& U2 N  M: D/ `9 o) V
44.         memcpy(pData, tmp, Size);
    3 a8 `( ?! ?  U- m2 d" B
45.         
    
46.         return true;
    5 z. m" o; J! N# U" Y' F
47. }

复制代码

5. 区别处理
( U) |( V) R0 }# y7 C如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
我们有一个重要的寄存器呀backup register
如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；
: e1 r( p" l+ \7 p

1. if(0xaa55aa55 == BKP.RTC_STA){
   # {% e* e0 \; w! p
2.         ...
   % J. j: T$ }3 ^" `' {4 S
3.         //显示B画面
   & e# v* b  T5 Q) W9 O. s% D
4. }else{
   . M1 A0 \6 N7 M- _$ f* B& t
5.         ...
   # W, c3 n$ B3 \
6.         //显示A画面
   + f0 ?! p6 D1 }2 x
7. }

复制代码

总结
可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
3 c7 Y. h# m3 O6 a, Q选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
! ?" N0 S, f7 b$ |3 l. w/ ]standby模式的程序框架为：
8 R3 Z, G. `) j0 M' J. R5 x