MCU：stm32L031K6T6

芯片的主要的低功耗特性
Features
• Ultra-low-power platform
– 1.65 V to 3.6 V power supply
" c; Y, j6 B9 c& O1 ?, c  y– -40 to 125 °C temperature range
– 0.23 µA Standby mode (2 wakeup pins)
3 Q5 J( @' Q1 |- D  i$ z– 0.35 µA Stop mode (16 wakeup lines)
3 }; u# O- t2 b: H# Q% w– 0.6 µA Stop mode + RTC + 8 KB RAM retention
* e+ H# L* `5 m6 k– Down to 76 µA/MHz in Run mode
– 5 µs wakeup time (from Flash memory)
" h7 \5 @4 {0 @9 K0 c  Y( n; S& _( J– 41 µA 12-bit ADC conversion at 10 ksps
• Core: Arm® 32-bit Cortex®-M0+
% s: x; a( z1 d& E– From 32 kHz up to 32 MHz max.
– 0.95 DMIPS/MHz

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

5 ~' v" i2 f+ R" K( n, r- n# v

6 V3 @- Q" D: \% V) O7 X

$ z3 Q& @9 t; [6 M5 \

我们选用的当然是最最低功耗的standby模式了：
  p: \8 C3 d" l+ o
standby模式BKP备份寄存器能够使用
" O$ o, e" R' v/ Y$ H$ \standby模式LSI和LSE两个晶振源可以使用
standby模式可以用RTC或Wakeup PIN能够唤醒
$ O% a; v! V( ^, \2 F注意 standby模式下RAM里面的数据是不保存的
) \) F6 j; f+ u( l主程序框架
7 m4 T! f0 M4 c/ v

1. ...
   & R2 g, L& Z( @3 l$ v. {7 z2 L
2. int main(void){
   6 L9 ?  y$ n! r- L+ j! H
3.         HAL_Init();
   ! ^4 K& g& d2 j
4.         
   1 L% ?6 P7 {  U& a: B# U
5.         SystemClock_Config();
   
6.         
   
7.         MX_GPIO_Init();
   % P! ~) A! T; h) g* ]. r8 L/ M/ X
8.         MX_DMA_Init();
   ' f0 i5 ^! F4 X. T) `
9.         MX_ADC_Init();
   2 j5 b  S2 c% A; \
10.         MX_IWDG_Init();
    % {6 x1 z$ _& ^& I+ U
11.         MX_SPI1_Init();
    
12.         MX_TIM2_Init();
    
13.         ...
    
14.         
    
15.         SystemPower_Config();        //PWR配置
    
16.         
    
17.         BSP_Init();        //板级支持包外设初始化
    
18.         
    . ~; c, L' \) c, `; B
19.         BAK = get_bak_param();        //恢复备份的数据
    
20.         
    
21.          while（1）{
    
22.                 ...        
    0 y4 l3 c: q0 Y  M/ c' |- @1 ^' Z
23.                 //主程序体
    
24.                
    ( p5 y3 F& ~. j  V6 E
25.         }
    5 i( J1 z2 M, ?" D
26. }

复制代码

重要函数实现
1 I4 I  ^0 l& ~( ]- Y  M4 S1. PWR配置

1. void SystemPower_Config(void){
   8 |3 F9 I/ ]* `( s+ N. Y
2.         __HAL_RCC_PWR_CLK_ENABLE();
   4 g4 g) y1 v+ M, A% Z. U7 U7 m
3. 
   
4.         HAL_PWREx_EnableUltraLowPower();
   - ?0 G8 e" [4 |( F3 E* E0 k
5. 
   
6.         HAL_PWREx_EnableFastWakeUp();
   ( R! e' T5 R  y0 I' ]0 W
7. }

复制代码

2. 进入standby模式
* c9 M4 ?# Y* I" H1.先备份数据
set_bak_param(BAK);
2.进入standby模式
pwr_standby();

1. void pwr_standby(void){
   
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   : \5 k7 f: u8 i; b
4.         }
   
5.         
   
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   & G" {! S; F8 n1 x1 v0 J
7.         
   
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   + i+ X* r0 l* N( ^
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    
11.         
    
12.         /* Clear all related wakeup flags*/
    
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    7 O& ]. L* H4 E1 \  T$ S0 j
14. 
    
15.         HAL_PWR_EnterSTANDBYMode();
    
16. }

复制代码

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

( J9 Q! y5 e' Y7 W) ?4. 数据备份和恢复
6 U. U2 K2 U0 x5 R9 |• Memories
– Up to 32-Kbyte Flash with ECC
4 f( i  C& j: g& I5 s8 U– 8-Kbyte RAM
– 1-Kbyte of data EEPROM with ECC
– 20-byte backup register
– Sector protection against R/W operation
- u2 G4 ^0 ^" I: D& b: I如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯
0 Q7 |. Q3 m$ G
. m3 k4 U) P6 ?2 k1 a% q

1. //**设计结构体用来存储备份的数据**
   6 |8 R) w9 x% O. O- z( f
2. typedef struct bak_t{
   
3.         uint32_t        RTC_STA;
   0 O, N# D7 o: {- E
4.         ...        //根据自己的需要设计结构体吧
   
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   8 ?! D% A: m1 Z  [  i+ B
3.         uint32_t        DR1;
   
4.         uint32_t        DR2;
   0 S* f, j7 L% C& L6 G5 H0 H, _4 r- G
5.         uint32_t        DR3;
   9 x; Z+ N  E3 V4 r8 c
6.         uint32_t        RTC_STA;        //rtc init sta
   1 W+ T& X- `; f0 H- N. c" O
7. }BKPTypeDef;
   ' f1 g" I9 A1 C' p
8. 
   4 C  _# I; O4 b& p
9. void bkp_init(void){
   
10.         hrtc.Instance = RTC;
    
11.         BKPTypeDef bkp;
    
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    * t: n4 |" l5 l
13.                 printf("rtc init\r\n");
    ( G/ B, T7 ]+ b; C
14.                 HAL_RTC_Init(&hrtc);
    1 N8 f# D' s4 r( t9 T! B, z
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    
16.                 bkp.RTC_STA = 0xaa55aa55;
    
17.                 set_bkp(&bkp);
    
18.         }
    4 A; Q- z% D& p# j
19. }
    4 P& t3 }: A3 e7 ], Z( }$ y, [9 [- q7 {
20. 
    
21. BKPTypeDef get_bkp(void){
    + N: V* }6 m5 {  O6 w# @& A, a
22.         BKPTypeDef bkp;
    : H" i" D. F, M, {" R
23.         bkp.DR0= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0);
    
24.         bkp.DR1= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR1);
    ! ]8 m7 \0 k1 v2 I$ S
25.         bkp.DR2= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
    % w$ j6 l: Z3 g" G* h% B
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    4 }& _$ [4 A$ C( ^/ e
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    . W5 V8 O- w% X: }5 B
28.         return bkp;
    2 T/ O4 P# S: Z4 J
29. }
    5 C8 |+ O! G  o$ {# ?! j- N3 @7 ^/ V
30. 
    ; V, |& X' T5 O* ?! x3 v0 B
31. void set_bkp(BKPTypeDef *bkp){
    5 q& U$ Q! `0 v  \2 b
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);
    7 i: y3 Z( L& k) j" W; j, F) G
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    8 i4 d0 S: [9 W; S8 h
37. }

复制代码

) T/ `; y" {- }/ O4.2 用EEPROM备份和恢复数据

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   ( J8 ^. a8 ~  [' ^* N$ |7 ?+ G
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
   
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   
4.                 return false;
   4 f, y1 t, v& w. i' C. h2 J
5.         }
   8 d/ H  G  }3 J7 k7 u
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   
7.                 printf("Flash EEPROM Address Error!!!\n");
   # X& u; Y; A' u# D) U
8.                 return false;
   
9.         }
   
10.         
    
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    
12.         for(uint16_t i=0;i<Size;i++){
    ' z, Y7 a5 T: ]( h% [! P
13.                 HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, DATA_EEPROM_BASE+addr_offset+32*i, pData<i>);
    
14.       </i>  }
    8 f& {" L, h) Y2 ?! q* Y" g
15. 
    ) c1 {( U+ d. w9 u2 f
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    
18.                 return false;
    
19.         }
    
20.         
    ( C( `/ R* v3 |( ]
21.         return true;
    , {: d7 l# t& q6 Y* f
22. }
    
23. 
    
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    
25.         if(Size > DATAEEPROM_MAX_SIZE){
    ) g) Y9 [, L/ c1 ?5 d* G, m* j
26.                 printf("Size is too long!\r\n");
    ) c& D; |: g) G* O
27.                 return false;
    
28.         }
    ) k5 I8 R6 f, E
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    1 j# c* w& ^) [  l, b: Y
30.                 printf("Flash EEPROM Address Error!!!\n");
    
31.                 return false;
    2 Q$ O, v) ?" N( @2 _
32.         }
    ! f; I; R* D$ J( U3 M: f
33.         
    
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    4 t. X# s) E; N2 f
35.         
    
36.         for(uint16_t i=0;i<Size;i++){
    1 E! V) W& w0 s' {8 O
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    
38.         }
    , S, ]2 M- m- f1 e
39. #if 0        
    
40.         for(uint16_t i=0;i<Size;i++){
    
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    3 q1 E+ g& i9 I* K5 L9 {( o" \( J
42.         }
    
43. #endif        
    4 S( H. N) Y# U8 n! R5 Z
44.         memcpy(pData, tmp, Size);
    $ H6 P1 q/ {5 V! P* c# `0 x7 U
45.         
    / k% M2 i  Z$ C( R5 s4 a
46.         return true;
    0 o! o5 @, _, V5 h2 Y, c, B9 g# }
47. }

复制代码

+ D7 |' j4 @( Q2 V, |) }5. 区别处理
* I  V$ ^7 T9 L  @如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
我们有一个重要的寄存器呀backup register
- o2 g+ C3 x, K! K' p& T如果是上电复位那backup register里面的数据全部都是乱数据；
/ z0 ]6 t7 g! q+ G如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；
8 \# R2 b6 j' e( ~) u9 k
4 y" x4 ~' I$ a( O: X; F

1. if(0xaa55aa55 == BKP.RTC_STA){
   
2.         ...
   
3.         //显示B画面
   ) g) S2 }: d: J( _5 r: t) b
4. }else{
   
5.         ...
   
6.         //显示A画面
   
7. }

复制代码

- ~" O, q+ @1 S* p* @总结
可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
6 }7 x/ z! M  p( {选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
; b/ C3 x8 b" ~7 w& n1 p* qstandby模式的程序框架为：
1 p, @- p' ?1 q0 D9 Y