MCU：stm32L031K6T6

芯片的主要的低功耗特性
Features
• Ultra-low-power platform
( ?5 v" r% M7 \4 O– 1.65 V to 3.6 V power supply
) L$ \0 `: I, @3 h/ y0 t% i& e– -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

* n* s! v% o( S( u3 {3 k功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：
2 g' J- b5 k, \9 A$ j  z

  W6 R8 h- J2 q* y- ?4 ]3 l' K

我们选用的当然是最最低功耗的standby模式了：
! {5 O9 H0 A1 q
$ I0 t1 \! I1 N& ?" X9 R, Lstandby模式BKP备份寄存器能够使用
standby模式LSI和LSE两个晶振源可以使用
3 H# q5 g+ {$ j' Vstandby模式可以用RTC或Wakeup PIN能够唤醒
注意 standby模式下RAM里面的数据是不保存的
# [: P2 a% [- T* _主程序框架
: P) l' d4 ]6 G

1. ...
   
2. int main(void){
   
3.         HAL_Init();
   
4.         
   ' k7 v) ?1 I( ]" t' d0 m0 w
5.         SystemClock_Config();
   . ]7 G) {" y( ?. Q5 _  v& h
6.         
   
7.         MX_GPIO_Init();
   
8.         MX_DMA_Init();
   0 _) M9 n# K$ A0 k$ ?
9.         MX_ADC_Init();
   
10.         MX_IWDG_Init();
    6 T2 E5 S) l8 P! @! J6 U' C
11.         MX_SPI1_Init();
    7 w6 W+ v& ^  e# N9 m
12.         MX_TIM2_Init();
    
13.         ...
    * {" `  R0 ^6 i1 M1 r  S4 Q0 E; F
14.         
    6 T+ q" `/ |) z- C4 }4 j" C$ P
15.         SystemPower_Config();        //PWR配置
    
16.         
    : j) f+ I) ^2 g- N7 R0 f" l+ i
17.         BSP_Init();        //板级支持包外设初始化
    1 `# P/ X8 }! f; M8 l- t+ s) v3 [" f
18.         
    . L# K! G) ?6 V9 H( [! k. o
19.         BAK = get_bak_param();        //恢复备份的数据
    
20.         
    
21.          while（1）{
    
22.                 ...        
    1 J& \, ~& f1 f! _
23.                 //主程序体
    
24.                
    
25.         }
    3 r1 ]' w0 _$ M# Q! q( c
26. }

复制代码

" `5 q, ~0 Q) b9 ?  ]8 H7 T重要函数实现
1. PWR配置

1. void SystemPower_Config(void){
   - d3 s' a0 }+ Y* O- F- E: N
2.         __HAL_RCC_PWR_CLK_ENABLE();
   + Z# y8 M3 a# ~9 Z
3. 
   2 T& A, K; _. w/ N% w- P. j
4.         HAL_PWREx_EnableUltraLowPower();
   - o% S2 |/ n2 b$ k! {
5. 
   
6.         HAL_PWREx_EnableFastWakeUp();
   ; t0 K% J& T! i, Q8 j
7. }

复制代码

/ d/ l6 }: B: [0 R2 e6 R2. 进入standby模式
1.先备份数据
set_bak_param(BAK);
! G# g* H) b4 x: l2.进入standby模式
, q* c. i. `8 B' }2 \5 z0 h# tpwr_standby();

1. void pwr_standby(void){
   , V" n9 J5 k$ c+ ^
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();               
   " c* h: P* k( n$ s$ _
7.         
   . F9 X/ I4 d* C, R) i- C$ t7 E7 ]
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   " R" n4 Q+ t; e, L( K  c
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   1 A# e% k3 I$ Z3 `  H
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    0 g6 g1 k- p/ M& j+ D! e  d
11.         
    % g  c% A: X$ d/ t
12.         /* Clear all related wakeup flags*/
    
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    
14. 
    ! a- R  y, o7 v' O
15.         HAL_PWR_EnterSTANDBYMode();
    ( C( h3 U- q( h) T9 p& R
16. }

复制代码

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

4. 数据备份和恢复
9 n9 g' k: U$ q3 r  w" W8 ?• Memories
– Up to 32-Kbyte Flash with ECC
– 8-Kbyte RAM
8 d# n$ _% e; |' G– 1-Kbyte of data EEPROM with ECC
– 20-byte backup register
– Sector protection against R/W operation
* y( N% C- @! ?; Z1 b1 n5 A如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯

& j0 O/ n) x; F, E, v  @6 }, Q

1. //**设计结构体用来存储备份的数据**
   , `6 S! i; R3 H) b+ d
2. typedef struct bak_t{
   
3.         uint32_t        RTC_STA;
   ) ^" Z: _1 ~  l" \; m
4.         ...        //根据自己的需要设计结构体吧
   
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   
3.         uint32_t        DR1;
   7 k  g' v, F* Z# v& T3 L1 r* Z
4.         uint32_t        DR2;
   3 o, @) k0 `5 n+ `( h: A5 C
5.         uint32_t        DR3;
   
6.         uint32_t        RTC_STA;        //rtc init sta
   " L2 w- Z7 q& q
7. }BKPTypeDef;
   
8. 
   
9. void bkp_init(void){
   " m  j/ h6 {# g
10.         hrtc.Instance = RTC;
    
11.         BKPTypeDef bkp;
    $ Z- o: P( `" {7 l9 [. s" |
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    9 V+ r$ E6 ~: Z1 F8 m) k
13.                 printf("rtc init\r\n");
    " d- X# z( l$ n* q* K3 Q" ~# G
14.                 HAL_RTC_Init(&hrtc);
    ; |" I+ D& @0 i) B
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    
16.                 bkp.RTC_STA = 0xaa55aa55;
    
17.                 set_bkp(&bkp);
    / H! i" i* t1 g7 O$ z& w
18.         }
    
19. }
    
20. 
    
21. BKPTypeDef get_bkp(void){
    0 ^1 Z3 `( h) h2 E- N9 l0 T
22.         BKPTypeDef bkp;
    
23.         bkp.DR0= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0);
    ' B& r2 \9 p2 [" [6 y) k
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);
    
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    ; z- U( }% k/ x
28.         return bkp;
    ) ~7 k$ O7 d( O5 T* k
29. }
    
30. 
    % [4 j. }# l( Q: X
31. void set_bkp(BKPTypeDef *bkp){
    8 a9 o& R0 |& ]' V  H( t
32.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR0, bkp->DR0);
    1 n7 V; I% H6 e0 N8 r
33.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR1, bkp->DR1);
    . T2 K7 s& g# w/ A, n* F$ N+ C
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);
    6 L- j, {& \' f0 l& T
37. }

复制代码

4.2 用EEPROM备份和恢复数据

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
   6 Q9 u4 [# z( `- |
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   1 ?- ~9 o" P2 ]5 G% \
4.                 return false;
   
5.         }
   
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   & m! o: w) ?6 K5 v- q
7.                 printf("Flash EEPROM Address Error!!!\n");
   
8.                 return false;
   
9.         }
   
10.         
    
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    
12.         for(uint16_t i=0;i<Size;i++){
    & I4 l( p2 _/ n1 c) c* ]. \
13.                 HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, DATA_EEPROM_BASE+addr_offset+32*i, pData<i>);
    . i& E( O! q: E$ B
14.       </i>  }
    ; ?$ `6 o" v# f6 f% V
15. 
    3 q2 E9 I0 l# z
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    1 ^* I8 F/ u1 y2 z4 D
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    
18.                 return false;
    ! x: ]# P5 }% n
19.         }
    
20.         
    
21.         return true;
    7 p4 y' Y8 s; f6 ^' Y
22. }
    
23. 
    : Q0 ^  e4 F. C  j
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    
25.         if(Size > DATAEEPROM_MAX_SIZE){
    ( }3 f' ~( O7 p4 A8 O
26.                 printf("Size is too long!\r\n");
    
27.                 return false;
    
28.         }
    
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    
30.                 printf("Flash EEPROM Address Error!!!\n");
    + [  U' F9 C; g3 _$ _/ Q- H
31.                 return false;
    
32.         }
    
33.         
      K: O8 m: V( I5 W
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    
35.         
    ) t% N8 ]3 h: D% j) ?% z5 B
36.         for(uint16_t i=0;i<Size;i++){
    
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    / t  t6 d) _, j
38.         }
    
39. #if 0        
    - o1 R2 ~- i, K( `% N2 ]& a
40.         for(uint16_t i=0;i<Size;i++){
    
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    9 C- W& X& H: o( c" r
42.         }
    
43. #endif        
    
44.         memcpy(pData, tmp, Size);
    
45.         
    % v) S3 P2 X) a/ b
46.         return true;
    1 a; o0 R1 A. \5 b5 i
47. }

复制代码

: F1 Q# D6 \$ E7 y6 g* v! Y5. 区别处理
如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
我们有一个重要的寄存器呀backup register
  F: {7 {6 J) q+ E4 u7 m( @6 p, E" m如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；
1 t% Q5 S! _. j5 y

1. if(0xaa55aa55 == BKP.RTC_STA){
   
2.         ...
   7 U; Y2 m% T+ q/ O% J8 u/ B  J% I
3.         //显示B画面
   3 Q: o  |! a# V# E9 v6 {
4. }else{
   
5.         ...
   
6.         //显示A画面
   ' U0 ]7 Q# }  e9 |
7. }

复制代码

" p+ G$ T4 d, m3 N总结
$ j4 s- L* v( c可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
5 K4 }- x) e; v% U% u0 L选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
1 T" X0 H! c" }) w- j6 |  R( b, Cstandby模式的程序框架为：