MCU：stm32L031K6T6

芯片的主要的低功耗特性
+ d5 t" i1 x! g0 k3 H5 b" p2 aFeatures
. n) ?& u8 z% O, Z: Q" Z. p• Ultra-low-power platform
– 1.65 V to 3.6 V power supply
– -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
• Core: Arm® 32-bit Cortex®-M0+
– From 32 kHz up to 32 MHz max.
– 0.95 DMIPS/MHz

功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：
* b7 f  X7 l, A; w+ s. H
1 @* q8 Y  j& u* z6 S

3 r/ U8 _4 C- ^+ P" q2 k9 J# E; t

3 O( P6 J5 c5 _, N1 G6 g# k9 g我们选用的当然是最最低功耗的standby模式了：
+ \; S; s% c. I
standby模式BKP备份寄存器能够使用
standby模式LSI和LSE两个晶振源可以使用
4 D' d9 ?; A# nstandby模式可以用RTC或Wakeup PIN能够唤醒
注意 standby模式下RAM里面的数据是不保存的
. s  |5 x# _, Z- k! a1 S主程序框架
2 C7 d% X2 |4 p5 p" P5 K5 `

1. ...
   
2. int main(void){
   2 y, n/ K( N: c' C
3.         HAL_Init();
   % I' {3 [3 E3 [3 _: a: W
4.         
   
5.         SystemClock_Config();
   
6.         
   1 n* c; z/ U- W: |; _( t3 D
7.         MX_GPIO_Init();
   * W- \" J* U+ F( w3 ^+ U+ Q1 O
8.         MX_DMA_Init();
   
9.         MX_ADC_Init();
   5 \( l5 J7 L1 H) m
10.         MX_IWDG_Init();
    4 n- ?- H" p- V8 J% B
11.         MX_SPI1_Init();
    
12.         MX_TIM2_Init();
    
13.         ...
    " |$ X' l* t# q
14.         
    
15.         SystemPower_Config();        //PWR配置
    
16.         
    
17.         BSP_Init();        //板级支持包外设初始化
    
18.         
    
19.         BAK = get_bak_param();        //恢复备份的数据
    ! z; a3 ^5 ^$ D+ M4 v2 ?: U
20.         
    * S$ x/ v( @- J& X" V0 S7 D
21.          while（1）{
    0 a+ L" \; F: I7 A
22.                 ...        
      I0 M% a9 y& ^
23.                 //主程序体
    . b  p" y" v) V& U$ u# b
24.                
    $ C! J$ T9 E! ^+ \
25.         }
    
26. }

复制代码

9 Q; t5 A6 `( _. t) U: u" _7 H重要函数实现
1. PWR配置
0 `$ }& F( o& F7 I; w

1. void SystemPower_Config(void){
   ' `- m% P" ]5 W3 V: Z
2.         __HAL_RCC_PWR_CLK_ENABLE();
   ! y. N; B, w3 P6 Y
3. 
   
4.         HAL_PWREx_EnableUltraLowPower();
   
5. 
   # y" k; C! ^3 q/ e
6.         HAL_PWREx_EnableFastWakeUp();
   $ p4 A& Z7 K/ \. d
7. }

复制代码

0 V' p. ]  x/ I) ^2. 进入standby模式
* b% R5 O: d- f% ?. k! I1.先备份数据
. x# J7 a& d" k0 Z+ vset_bak_param(BAK);
2.进入standby模式
7 g. B3 u9 c. _0 Q. x6 @pwr_standby();
/ E8 Z( B3 g) ^8 n" L/ w8 x4 W
7 M- ^" ]6 e6 C

1. void pwr_standby(void){
   & j0 \  J& u% t$ _9 x
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   1 ]4 q% V& {0 x$ c
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   
4.         }
   
5.         
   
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   5 V- L) H3 U) W, S" d4 l  P/ e
7.         
   
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   ; E* j6 E7 g% y+ m
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   * ~# X4 k7 `! e
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    - M. q8 H" ~% J7 e* ?4 g( M2 W4 U
11.         
    
12.         /* Clear all related wakeup flags*/
    . z, z. p8 X9 r" X9 G" K
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
      k5 O9 Y* y3 v' G: Y
14. 
    " @9 C4 N/ ?4 o9 |- s5 e! U
15.         HAL_PWR_EnterSTANDBYMode();
    . f, [- U8 [3 l  K( F: P7 D% \. {
16. }

复制代码

6 h2 f3 P( c" J8 Y8 J. q3. 唤醒
唤醒没什么好说的，standby模式下唤醒，程序跟上电复位没什么区别，RAM里面数据都没了，但是BKP中的数据仍然存在；
# R, J; W. v- O这里暂时就把唤醒当做是重新上电吧，后面说到BKP的时候再区别处理；
6 P8 h# w( C% E. C" L1 S* }
4. 数据备份和恢复
9 a5 ?+ S. P# o  U* _: p• Memories
3 ^( [1 ~* u1 h% |$ U9 Q! P7 @1 S, W– Up to 32-Kbyte Flash with ECC
– 8-Kbyte RAM
3 B% c0 t% X" Y& ]0 {4 S– 1-Kbyte of data EEPROM with ECC
8 j5 g$ W  A) R- c, d3 o– 20-byte backup register
5 s+ }, p1 A4 L' r– Sector protection against R/W operation
如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯

1. //**设计结构体用来存储备份的数据**
   , ~' m! D9 e8 `; J2 R9 U9 ~* ?
2. typedef struct bak_t{
   
3.         uint32_t        RTC_STA;
   
4.         ...        //根据自己的需要设计结构体吧
   % o/ n2 p* a% W' ~1 `% R
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   
3.         uint32_t        DR1;
   
4.         uint32_t        DR2;
   
5.         uint32_t        DR3;
   8 v5 M4 J. @; J6 C2 T% q
6.         uint32_t        RTC_STA;        //rtc init sta
   
7. }BKPTypeDef;
   
8. 
   
9. void bkp_init(void){
   
10.         hrtc.Instance = RTC;
    ) |! Q/ F3 u5 C3 U& p( h
11.         BKPTypeDef bkp;
    
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    
13.                 printf("rtc init\r\n");
    
14.                 HAL_RTC_Init(&hrtc);
    # P! _! c- [' a8 M. i0 `
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    / t" h' q. e& F3 A+ O* S! h
16.                 bkp.RTC_STA = 0xaa55aa55;
    
17.                 set_bkp(&bkp);
    : Q; i6 I/ \0 k( F' P0 t7 }, o3 _
18.         }
    ! p9 b* [- R8 |' D% T& K% e- C5 j
19. }
    . I4 ?+ {$ b% B" ^- w
20. 
    # A6 A7 ?' B+ D- e" I
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);
    
25.         bkp.DR2= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
    0 C& g# e! O. Y. ~% I
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    : o4 h/ X' m2 z. A* |! r
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    2 G: `2 U! H( l; W4 x
28.         return bkp;
    * `6 T* {( E( ]6 M: T& @# b$ A
29. }
    ' |' r  ?. O! Y) C! P5 J7 b7 g
30. 
    7 _  V4 G. s" C6 _) i& b
31. void set_bkp(BKPTypeDef *bkp){
    
32.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR0, bkp->DR0);
    / L# N* O! w/ B
33.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR1, bkp->DR1);
    4 E' v% o. {+ }% k; Y$ r$ M
34.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR2, bkp->DR2);
    ( a3 g1 W3 E8 g# h; v0 }! q
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    
37. }

复制代码

- @/ A- q8 Z  T4 d+ G4.2 用EEPROM备份和恢复数据
( _+ t7 [9 n3 Y1 Y+ C

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   3 j  U* \8 x% v! R  {
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
   
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   ( e& k! t& ?% z; j; H+ U
4.                 return false;
   
5.         }
   
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   9 }) C$ n2 W8 B
7.                 printf("Flash EEPROM Address Error!!!\n");
   
8.                 return false;
   " ~* j. \9 f+ P) S. P- @
9.         }
   6 f' i! s$ |+ m' v" L; ]; }
10.         
    
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    & ~* |. M  y3 e6 E
12.         for(uint16_t i=0;i<Size;i++){
    3 f% B' m) l; C" c1 }, X9 |/ }) k5 m
13.                 HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, DATA_EEPROM_BASE+addr_offset+32*i, pData<i>);
      ?/ P; t0 I6 s7 f" `2 d: z3 _& y- x4 F
14.       </i>  }
    
15. 
    0 S+ Q- {' Q+ H
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    9 |( A1 v: \: e
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    
18.                 return false;
    # ~! O! \- J9 h, A
19.         }
    # y8 Z2 n1 w, e+ I
20.         
    3 ^, t8 K2 p' ^( d* e3 |1 p
21.         return true;
    
22. }
    
23. 
    
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    
25.         if(Size > DATAEEPROM_MAX_SIZE){
    8 J4 I1 n0 ^8 @2 F8 A  n* m' ]
26.                 printf("Size is too long!\r\n");
    1 ?8 U% g& G/ E; i* K% W7 G
27.                 return false;
    % [; I: ^9 L" v8 t% ~* |
28.         }
    9 ]% A7 K* \; ?4 M, j
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    ( N+ v. @% T2 k6 k2 V; z  i
30.                 printf("Flash EEPROM Address Error!!!\n");
    2 |: o! E# d. [- F' s
31.                 return false;
    
32.         }
    
33.         
    8 k: i6 k, @; e: _5 |8 |
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    / g& R- I5 o: @; ~
35.         
    
36.         for(uint16_t i=0;i<Size;i++){
    
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    6 @/ X7 O% {$ b
38.         }
    ' b" b; Q; o1 y2 k" V$ Z
39. #if 0        
    
40.         for(uint16_t i=0;i<Size;i++){
    3 ~- n2 \8 M7 `; y$ w, `* g
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    + A% S+ N! A2 g
42.         }
    & x0 A' J) O! I. m
43. #endif        
    
44.         memcpy(pData, tmp, Size);
    
45.         
    
46.         return true;
    8 E; z: H- h) L/ U2 O9 S" d- I
47. }

复制代码

+ Q; C$ Z" ?( @2 T5. 区别处理
9 d: y9 g  N2 B% g/ f如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
我们有一个重要的寄存器呀backup register
如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；

! y; y5 g6 v3 I7 D

1. if(0xaa55aa55 == BKP.RTC_STA){
   
2.         ...
   ) A! d: C0 @6 J
3.         //显示B画面
   . g# o. R3 ]1 i( F4 y
4. }else{
   
5.         ...
   
6.         //显示A画面
   
7. }

复制代码

) D' n' m9 d! G. |总结
可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
! R/ u% ~, M8 M选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
9 e$ Z: x3 M: B+ u; Tstandby模式的程序框架为：
: U5 Q5 b9 e2 [/ n% |2 q# x1 I3 i
4 r, [& ^8 o/ j6 [