MCU：stm32L031K6T6

芯片的主要的低功耗特性
$ ?, `- q( m6 U4 L; P% E' DFeatures
• Ultra-low-power platform
– 1.65 V to 3.6 V power supply
9 G5 _5 z$ q9 O6 T  S/ u– -40 to 125 °C temperature range
  b, F$ K, H6 D* i+ O2 ^– 0.23 µA Standby mode (2 wakeup pins)
– 0.35 µA Stop mode (16 wakeup lines)
1 t" X2 f0 y, w4 u; t– 0.6 µA Stop mode + RTC + 8 KB RAM retention
– Down to 76 µA/MHz in Run mode
5 t, a6 M8 c6 s3 y- ~) \3 |* [/ p– 5 µs wakeup time (from Flash memory)
2 P1 v% }2 Y$ c/ Y8 T– 41 µA 12-bit ADC conversion at 10 ksps
• Core: Arm® 32-bit Cortex®-M0+
7 L4 s$ C, E, a! N" W! V– From 32 kHz up to 32 MHz max.
– 0.95 DMIPS/MHz
6 f- J6 @9 M7 C! x; e: U' I
功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：
" R) `3 T% q$ Q( z$ _" s

6 ?# l( o& |2 y. j  y" W# L+ h

: Z' t7 E3 V' \5 k: O+ C7 K; v

我们选用的当然是最最低功耗的standby模式了：
2 n2 n0 ?- s4 b9 Q% j. c" w
standby模式BKP备份寄存器能够使用
+ C, A5 v  z( a/ X! Vstandby模式LSI和LSE两个晶振源可以使用
standby模式可以用RTC或Wakeup PIN能够唤醒
0 I' d3 l. |- E+ ]$ ]* K注意 standby模式下RAM里面的数据是不保存的
主程序框架

1. ...
   ' ]$ `/ }  A' q8 i
2. int main(void){
   4 p$ l2 R# f% \2 j. R/ L9 ^2 P
3.         HAL_Init();
   
4.         
   
5.         SystemClock_Config();
   ! o! p  C- H6 t* [
6.         
   
7.         MX_GPIO_Init();
     J" j* }9 R1 u( Y3 K+ E: w  o
8.         MX_DMA_Init();
   
9.         MX_ADC_Init();
   
10.         MX_IWDG_Init();
    . T: R1 i, D) ]0 `
11.         MX_SPI1_Init();
    & ^5 n/ ?' r& Y1 T& \
12.         MX_TIM2_Init();
    
13.         ...
    
14.         
    & @) V) q& B$ X, h  o! N$ j/ b! ?
15.         SystemPower_Config();        //PWR配置
    
16.         
    2 o/ @% r- P5 n
17.         BSP_Init();        //板级支持包外设初始化
    
18.         
    % U1 V/ N4 C4 M- I( z: x" A
19.         BAK = get_bak_param();        //恢复备份的数据
    # Y' V5 H4 M: j& s/ X$ U
20.         
    
21.          while（1）{
    6 ~+ m6 O9 n! r8 w3 a  s& {
22.                 ...        
    + @' T" P% K( [  z
23.                 //主程序体
    ) t3 q1 ~0 R7 |: T9 N4 {- ]* s) ?( Z4 O
24.                
    ( @' W, V7 K+ V' T/ ~$ G9 ^
25.         }
    
26. }

复制代码

$ p9 J: z# ^2 ~重要函数实现
" i) D4 a, k4 q" @1. PWR配置

1. void SystemPower_Config(void){
   
2.         __HAL_RCC_PWR_CLK_ENABLE();
   
3. 
   
4.         HAL_PWREx_EnableUltraLowPower();
   * j( T# c3 n  U2 a# }1 w
5. 
   , h+ p7 r; f& [  h0 @+ e3 l8 f
6.         HAL_PWREx_EnableFastWakeUp();
   
7. }

复制代码

2. 进入standby模式
1.先备份数据
set_bak_param(BAK);
8 P7 y; s9 ?' \. U2.进入standby模式
1 u- c3 {+ Y0 z0 y; w0 apwr_standby();
5 i. _- S* ?2 G! b% c

1. void pwr_standby(void){
   % a# ~( c$ o/ Y
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   4 i+ P0 v* F6 R) R# M1 [# Y
4.         }
   
5.         
   
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   9 T% n" r& D3 N! _( w8 R' x
7.         
   . d" k( M# [9 n2 x1 r3 r: v# s
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   2 H; g2 v4 G  O! R
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    
11.         
    / P& s9 }7 D7 J) v
12.         /* Clear all related wakeup flags*/
    
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    1 R, A+ z- G. l0 f  E
14. 
    
15.         HAL_PWR_EnterSTANDBYMode();
    
16. }

复制代码

$ j2 R- s+ x" E$ O5 q, \( m; _3. 唤醒
唤醒没什么好说的，standby模式下唤醒，程序跟上电复位没什么区别，RAM里面数据都没了，但是BKP中的数据仍然存在；
这里暂时就把唤醒当做是重新上电吧，后面说到BKP的时候再区别处理；
- r1 V3 v# F, H
4. 数据备份和恢复
• Memories
; G8 r( V5 T& p% i/ W– Up to 32-Kbyte Flash with ECC
– 8-Kbyte RAM
– 1-Kbyte of data EEPROM with ECC
4 Z" H0 O$ v9 [5 K$ F– 20-byte backup register
– Sector protection against R/W operation
& ?. s5 r+ o4 h* G1 d. u如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯
3 R. {1 C4 W+ R9 a

1. //**设计结构体用来存储备份的数据**
   + N/ {( D, ?* I
2. typedef struct bak_t{
   $ M$ k8 U. P' T2 e
3.         uint32_t        RTC_STA;
   
4.         ...        //根据自己的需要设计结构体吧
   
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   2 R! B% g; g$ B9 {3 c3 f
3.         uint32_t        DR1;
   & d. j  I0 d" b, ]+ p' X
4.         uint32_t        DR2;
   
5.         uint32_t        DR3;
   
6.         uint32_t        RTC_STA;        //rtc init sta
   5 X( k6 G& R* r
7. }BKPTypeDef;
   
8. 
   
9. void bkp_init(void){
   ) Z- S6 y  S+ q# Q; i8 z* {
10.         hrtc.Instance = RTC;
    
11.         BKPTypeDef bkp;
    & w; w2 E" a) j! d  b" D
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    
13.                 printf("rtc init\r\n");
    
14.                 HAL_RTC_Init(&hrtc);
    4 r6 X, [. P& b. Z; z
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    
16.                 bkp.RTC_STA = 0xaa55aa55;
    7 f; ~8 `2 h" t) d( ^# h! D1 T
17.                 set_bkp(&bkp);
    
18.         }
    
19. }
    
20. 
    
21. BKPTypeDef get_bkp(void){
    
22.         BKPTypeDef bkp;
    ) R6 l8 x+ ]" X, @8 Y: ^; S- @, j
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);
    + m8 K6 r- f1 N7 R
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    
28.         return bkp;
    * u8 I5 Z5 i' @# _# Y6 ^( Z: J
29. }
    ' g, S! S, m9 l/ A. Q) u9 O: j; B
30. 
    8 M! Z/ _; T5 \  ^" {4 J/ E, x
31. void set_bkp(BKPTypeDef *bkp){
    
32.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR0, bkp->DR0);
    5 ?9 q; f5 U( Q7 z
33.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR1, bkp->DR1);
    
34.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR2, bkp->DR2);
    $ F3 q9 L0 d7 V0 {$ d
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    
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()){
   
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   . E2 K5 y* _+ r5 m/ v7 o& G' l" R
4.                 return false;
   9 \4 l  {/ ^  b6 M3 B
5.         }
   
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   ' d9 C: I/ h. u8 H5 r
7.                 printf("Flash EEPROM Address Error!!!\n");
   
8.                 return false;
   ) J; `4 C; `# W8 o0 x& t, x
9.         }
   8 ^' \6 p6 `- M
10.         
    , ~9 h. M0 F5 p& D& ~+ Q
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    7 x; S! }  @' D. V+ o/ F2 w
12.         for(uint16_t i=0;i<Size;i++){
    & J1 Z: z9 |+ z
13.                 HAL_FLASHEx_DATAEEPROM_Program(FLASH_TYPEPROGRAMDATA_BYTE, DATA_EEPROM_BASE+addr_offset+32*i, pData<i>);
    
14.       </i>  }
    / I& |. |3 a0 |% E
15. 
    
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    9 F+ l/ [6 |( L0 H( U6 M6 F7 m
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    
18.                 return false;
    
19.         }
    
20.         
    
21.         return true;
    ( }, \; Q5 y+ t
22. }
    
23. 
    
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    4 s; O. h* [& R+ P# f6 |! d/ _3 o
25.         if(Size > DATAEEPROM_MAX_SIZE){
    , G" A$ Y  F- a# G3 t5 r& Y
26.                 printf("Size is too long!\r\n");
    $ ~, p6 b0 |( ~
27.                 return false;
    
28.         }
    
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    
30.                 printf("Flash EEPROM Address Error!!!\n");
    9 a3 H* c# V6 M8 L- p2 I, r
31.                 return false;
    
32.         }
    
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);
    0 }+ I5 j8 {9 k+ x1 g) ]
38.         }
    
39. #if 0        
    
40.         for(uint16_t i=0;i<Size;i++){
    & E, ^- j; R7 ~4 J' x3 ~8 F
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    
42.         }
    
43. #endif        
    
44.         memcpy(pData, tmp, Size);
    ' K2 `- u# _+ u
45.         
      |5 [0 [, D# h
46.         return true;
    
47. }

复制代码

5. 区别处理
3 X) r! v5 v, g3 g; v* S如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
我们有一个重要的寄存器呀backup register
如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；

1. if(0xaa55aa55 == BKP.RTC_STA){
   ) E+ O  M) |7 l* y: R8 A3 f
2.         ...
   . V2 _. b  o- a5 R- Z' D
3.         //显示B画面
   % M) I' U, o, B9 I6 e# K
4. }else{
   
5.         ...
   1 f* Q' {3 H. R/ f
6.         //显示A画面
   3 C+ O" G' q8 I  h
7. }

复制代码

总结
可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
$ p2 ~" K; H. @$ n% I& p; B8 \standby模式的程序框架为：
: s9 V* u& D& x) [" ?
: k+ o4 c. T' z