MCU：stm32L031K6T6
2 I7 E+ g! V3 {
芯片的主要的低功耗特性
Features
• Ultra-low-power platform
! w9 {8 h2 ~8 m9 \' x7 [1 B– 1.65 V to 3.6 V power supply
/ @" J0 `+ F& |2 p9 \  d– -40 to 125 °C temperature range
– 0.23 µA Standby mode (2 wakeup pins)
– 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)
– 41 µA 12-bit ADC conversion at 10 ksps
  l. O* }3 c- H# H- _, O• Core: Arm® 32-bit Cortex®-M0+
# O$ O7 q7 N4 L" G+ W0 b4 O# {– From 32 kHz up to 32 MHz max.
– 0.95 DMIPS/MHz

$ ^4 r. ]+ D  s, B功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：

  o& R# Y2 Y+ ]( l" c' d  Q9 ?

! o; O# ]* y% `0 _! w: c) `我们选用的当然是最最低功耗的standby模式了：
+ R  a+ B8 Y3 ^5 n0 ^) F$ `
standby模式BKP备份寄存器能够使用
$ H) I  E/ g+ X! Sstandby模式LSI和LSE两个晶振源可以使用
standby模式可以用RTC或Wakeup PIN能够唤醒
注意 standby模式下RAM里面的数据是不保存的
主程序框架
8 B# \# B: {) A4 R5 V) b

1. ...
   
2. int main(void){
   , o& `; u' M/ _4 j
3.         HAL_Init();
   4 J+ w: ~: D( C9 K
4.         
   
5.         SystemClock_Config();
   
6.         
   " F/ _3 J' l* f2 h
7.         MX_GPIO_Init();
   
8.         MX_DMA_Init();
   1 `; S! q" [9 N
9.         MX_ADC_Init();
   % E( Y' P+ h6 M6 S, K3 T
10.         MX_IWDG_Init();
    
11.         MX_SPI1_Init();
    
12.         MX_TIM2_Init();
    ( \7 N2 D5 S. F5 w
13.         ...
    
14.         
      u, m5 I% g! s6 m
15.         SystemPower_Config();        //PWR配置
    
16.         
    
17.         BSP_Init();        //板级支持包外设初始化
    & D  P' n. l" `" L# d
18.         
    ' l9 L' p! N3 X8 ]5 x  A
19.         BAK = get_bak_param();        //恢复备份的数据
    8 _, u2 M( ^& q4 e- V
20.         
    
21.          while（1）{
    9 D9 _! c* S  O7 `& h$ v
22.                 ...        
    1 C# ^1 P- {* i2 u' N
23.                 //主程序体
    
24.                
    
25.         }
    
26. }

复制代码

重要函数实现
1. PWR配置

1. void SystemPower_Config(void){
   3 _+ u' H4 m0 _( ^4 V/ a+ T
2.         __HAL_RCC_PWR_CLK_ENABLE();
   0 @$ Z. u3 \9 \. e* `' @: |! l
3. 
     w/ F& \& W  U  U" |1 w; V7 A
4.         HAL_PWREx_EnableUltraLowPower();
   
5. 
   7 B* R4 D* Q4 B9 a7 J
6.         HAL_PWREx_EnableFastWakeUp();
   
7. }

复制代码

. P8 b; h* f4 P$ v& V3 R2. 进入standby模式
1.先备份数据
( c9 ], x8 D+ J" ?% \set_bak_param(BAK);
1 f  a9 y5 o2 Z1 U. J  Z* A0 W0 N, x2.进入standby模式
. `  F7 H0 Y& Y2 C% \0 `$ J, jpwr_standby();

1. void pwr_standby(void){
   1 h1 Q5 s" ?- g& y% N3 e
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   * {7 k9 {, n; `8 Y+ V) T' [1 _/ a
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   
4.         }
   8 W" @0 \9 ?: `
5.         
   ; Q9 q! y- `! b: a  e% n8 y; ~! z  n
6.         __HAL_RCC_PWR_CLK_ENABLE();               
     J' `8 ]* a" W5 v
7.         
   
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   $ p; s4 o6 m+ H% [2 F0 t3 x; O% K
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   ) R$ c6 d; u6 q5 x
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    ) l7 L4 m9 G; e# R$ D
11.         
    
12.         /* Clear all related wakeup flags*/
    4 @1 u  G( Z+ {* n. S" [
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    
14. 
    
15.         HAL_PWR_EnterSTANDBYMode();
    - n" ^5 y0 O( C$ v
16. }

复制代码

# A1 }9 K; }' C1 w/ S. w3. 唤醒
* r, _' o  ~7 d& t  m' A( R7 E唤醒没什么好说的，standby模式下唤醒，程序跟上电复位没什么区别，RAM里面数据都没了，但是BKP中的数据仍然存在；
这里暂时就把唤醒当做是重新上电吧，后面说到BKP的时候再区别处理；

) ]& Q7 }1 ~3 W+ H& o4. 数据备份和恢复
- e4 Y, ^. ~. Y8 C* L$ p• Memories
– Up to 32-Kbyte Flash with ECC
– 8-Kbyte RAM
" s4 H+ r" H+ Q$ o– 1-Kbyte of data EEPROM with ECC
9 ?7 |9 n% K$ i* g– 20-byte backup register
+ L# |2 \7 W5 T2 h2 O– Sector protection against R/W operation
2 y  Z: S- g& n( v+ _6 G如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯
; s( z4 I4 w4 i6 y7 H
. ~6 c' R& o& \% n0 u3 B

1. //**设计结构体用来存储备份的数据**
   
2. typedef struct bak_t{
   , g$ b* }+ r, v: c- v# `2 M
3.         uint32_t        RTC_STA;
   - k* s5 L' j* X+ i, ]- T$ [
4.         ...        //根据自己的需要设计结构体吧
   # u' ~" L- v( r# T- r. f( D
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   
3.         uint32_t        DR1;
   
4.         uint32_t        DR2;
   3 g$ Q; O+ t0 Q, e6 @) F9 G! h
5.         uint32_t        DR3;
   
6.         uint32_t        RTC_STA;        //rtc init sta
   , R* Y- t" w/ k6 n/ a- O
7. }BKPTypeDef;
   4 D" B+ b1 Y6 ]7 D# G! l
8. 
   
9. void bkp_init(void){
   % ~3 _; r/ Z% y: [* X9 F
10.         hrtc.Instance = RTC;
    
11.         BKPTypeDef bkp;
    
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    
13.                 printf("rtc init\r\n");
    
14.                 HAL_RTC_Init(&hrtc);
    
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    
16.                 bkp.RTC_STA = 0xaa55aa55;
    
17.                 set_bkp(&bkp);
    % e* ?) A9 b8 a6 P
18.         }
    : w5 R, A7 R8 H4 r# s  D* x
19. }
    6 w+ ]! x6 N6 i' q/ f! s
20. 
    
21. BKPTypeDef get_bkp(void){
    
22.         BKPTypeDef bkp;
    + j' z0 L2 L8 R  M
23.         bkp.DR0= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0);
    4 Z/ Q, c2 b2 \
24.         bkp.DR1= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR1);
    
25.         bkp.DR2= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
    
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    ' M" t, W4 v3 l1 s# @( s' T0 O
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    - E% Q5 B2 K8 \( G8 \% k- X) x: p
28.         return bkp;
    
29. }
    $ @1 @1 x7 V9 T3 O
30. 
    # G5 g, e- i- \* D
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);
    # y; k6 n) T0 f$ k
34.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR2, bkp->DR2);
    ( j5 Q# [3 c, ^( r* x9 g
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    0 Z7 J' t, V+ r* J" R: j4 W
37. }

复制代码

- ^/ A9 M* `' b3 v/ E4.2 用EEPROM备份和恢复数据

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   : E+ c* m, q5 m
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
   
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   
4.                 return false;
   
5.         }
   
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   " k" o, f5 W  Y" q% T( A
7.                 printf("Flash EEPROM Address Error!!!\n");
   
8.                 return false;
   $ U* V0 Q6 u+ y$ q- Y4 Q4 t
9.         }
   " T3 J1 v& m( I) D4 v
10.         
    
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    2 P# e+ u  E8 q6 D
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>);
    ; B7 f! [8 D; d
14.       </i>  }
    
15. 
    % @/ D' z0 ~4 ~, L
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    
18.                 return false;
    
19.         }
    
20.         
    
21.         return true;
    " P4 ?* K9 u3 ]1 g+ \
22. }
    
23. 
    , F/ b6 c' }3 U! p% J  i% U
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    9 `8 b& s6 a* a
25.         if(Size > DATAEEPROM_MAX_SIZE){
    / T% T6 A. ]. i# a& B6 E
26.                 printf("Size is too long!\r\n");
    
27.                 return false;
    
28.         }
    ) w% F7 }0 G; s
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    
30.                 printf("Flash EEPROM Address Error!!!\n");
    
31.                 return false;
    
32.         }
      A$ o& Q, ~& L& L  e7 j# @
33.         
    
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    
35.         
    
36.         for(uint16_t i=0;i<Size;i++){
    
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    
38.         }
    
39. #if 0        
    9 H, L+ l' A+ E& @1 m
40.         for(uint16_t i=0;i<Size;i++){
    " [; _# L4 F( }' ^/ M2 G
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    
42.         }
    + r3 T+ `+ b' F! @, h
43. #endif        
    ' H1 ~6 l) T* r- \, k  Y& e
44.         memcpy(pData, tmp, Size);
    % M' |, f4 D6 T  q& N) p! S
45.         
    
46.         return true;
    
47. }

复制代码

+ Q8 _8 J6 L( j+ L# i5. 区别处理
( m2 T$ j& t( L2 |$ u7 w如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
* w7 U4 `+ O7 c5 a我们有一个重要的寄存器呀backup register
4 y. T  f' Q, O如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；

1. if(0xaa55aa55 == BKP.RTC_STA){
   ( q7 b& c+ e# f/ |3 }4 h! G; I& x
2.         ...
   , F% [2 f  P1 ~! a! B: K& S
3.         //显示B画面
   # v6 o* U8 u7 }& ?1 H
4. }else{
   
5.         ...
   - I) M& z) c- d+ Q! ?1 p
6.         //显示A画面
   
7. }

复制代码

; s4 j/ ^& X2 E" D9 h总结
可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
2 S5 p2 V, R9 q- q7 F3 A选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
standby模式的程序框架为：

, V$ a$ U& ~% @- o