MCU：stm32L031K6T6

4 W# T3 B" t/ o+ h! A芯片的主要的低功耗特性
Features
• Ultra-low-power platform
– 1.65 V to 3.6 V power supply
6 J0 d" V; E' K: p+ W' i– -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+
- }2 _: s* y4 X) T& \% @– From 32 kHz up to 32 MHz max.
7 ^; u7 o+ [& L0 G  |– 0.95 DMIPS/MHz

功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：
" j0 `6 N1 Z8 v1 e3 d0 C9 @

5 y7 [- G/ H$ c' V7 x+ f- F2 t

9 L9 \. m( P9 s7 U6 n3 ]/ |
5 u' {7 `( X/ U+ Y
1 l, g5 `/ N0 Q: E+ t( a& K1 _我们选用的当然是最最低功耗的standby模式了：

! f6 D& j7 m. r$ A' v" a1 Sstandby模式BKP备份寄存器能够使用
/ }, w# N' R4 H3 s% f% k8 N# Cstandby模式LSI和LSE两个晶振源可以使用
+ [5 i7 W) P8 @- f6 ]* N! r  astandby模式可以用RTC或Wakeup PIN能够唤醒
注意 standby模式下RAM里面的数据是不保存的
主程序框架
' j) ]. X7 y' b& R0 o/ S( n

1. ...
   0 r+ P) `1 a- i* @0 V
2. int main(void){
   
3.         HAL_Init();
   
4.         
   
5.         SystemClock_Config();
   . P( u1 B* T# c+ M
6.         
   ; R& R7 d( N9 b* M1 _6 a# K* q6 r
7.         MX_GPIO_Init();
   
8.         MX_DMA_Init();
   ! q" ], J1 |* r9 e" U. P- b
9.         MX_ADC_Init();
   1 I& U2 e- f  d/ i) }8 i! O" q
10.         MX_IWDG_Init();
    7 s/ u8 E( @' H9 v' ]8 z
11.         MX_SPI1_Init();
    ( {! i) T1 \4 m$ Q
12.         MX_TIM2_Init();
    4 P9 }& T; G; B% o4 J, z
13.         ...
    
14.         
    
15.         SystemPower_Config();        //PWR配置
    - m# ?! |5 n2 U. n) p* m
16.         
    
17.         BSP_Init();        //板级支持包外设初始化
    9 q; S- A0 y# l" }
18.         
    ( Y% p& c8 S0 f1 C% e% h- y
19.         BAK = get_bak_param();        //恢复备份的数据
    
20.         
    
21.          while（1）{
    
22.                 ...        
    
23.                 //主程序体
    
24.                
    * q0 @2 v; p; a
25.         }
    
26. }

复制代码

重要函数实现
5 E' s9 i$ @6 I( V; Y) Y1. PWR配置

1. void SystemPower_Config(void){
   + C; Z5 Q$ H2 P
2.         __HAL_RCC_PWR_CLK_ENABLE();
   9 Q4 ^# c7 M. i# X
3. 
   4 A) x* \+ |  [6 c( q
4.         HAL_PWREx_EnableUltraLowPower();
   7 t- ^  K3 ^( l& y' r, @- G& r7 h
5. 
   
6.         HAL_PWREx_EnableFastWakeUp();
   
7. }

复制代码

2. 进入standby模式
* K6 M. i* z. g$ T! I1.先备份数据
: N- c5 k9 g' U2 Cset_bak_param(BAK);
. G9 H" j% q: P4 i4 z2.进入standby模式
. `" q% B! F! v# M: r- Spwr_standby();

1. void pwr_standby(void){
   ; H  D& t) e' j6 ]
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   ' t! m. ]; Q# u8 Y# U1 R) e$ o
4.         }
   3 ?1 O+ u  X& W2 Y9 w
5.         
   $ w; e0 t3 w+ k7 t8 J- L0 j, g
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   $ @/ o2 P3 ^& {# B5 U- w
7.         
   
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   1 }/ F% o6 n+ j/ ]4 B$ U
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   4 j$ _" z: l$ b8 t/ r6 W# g
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    
11.         
    
12.         /* Clear all related wakeup flags*/
    * ^0 f$ v6 h- o! O3 L$ d# R/ s
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
      L2 @6 |8 v7 S, ~4 L/ A
14. 
    
15.         HAL_PWR_EnterSTANDBYMode();
    
16. }

复制代码

9 a. c; N" c! X3. 唤醒
唤醒没什么好说的，standby模式下唤醒，程序跟上电复位没什么区别，RAM里面数据都没了，但是BKP中的数据仍然存在；
这里暂时就把唤醒当做是重新上电吧，后面说到BKP的时候再区别处理；

' N4 w7 o: s8 ?) `2 ?/ l2 F4. 数据备份和恢复
. e& H# d, g' ^( C) q" K• Memories
5 S$ s0 ]) J, i" n– Up to 32-Kbyte Flash with ECC
– 8-Kbyte RAM
– 1-Kbyte of data EEPROM with ECC
– 20-byte backup register
$ s% O' \$ W2 T– Sector protection against R/W operation
5 d0 M7 @* b: K$ b" U* s3 N. t如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯
6 Z0 L0 N7 r/ X- m' o1 h4 ?3 l

1. //**设计结构体用来存储备份的数据**
   8 ]& L* m! s+ m) Z! y
2. typedef struct bak_t{
   
3.         uint32_t        RTC_STA;
   , [1 _# l. p$ P! k8 y
4.         ...        //根据自己的需要设计结构体吧
   
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   4 l2 J9 {; ^8 O( @) K: |
2.         uint32_t        DR0;        
   
3.         uint32_t        DR1;
   2 o( s: \+ a1 K9 F
4.         uint32_t        DR2;
   
5.         uint32_t        DR3;
   
6.         uint32_t        RTC_STA;        //rtc init sta
   / w4 `2 Z3 L, t. l# Y- D
7. }BKPTypeDef;
   
8. 
   
9. void bkp_init(void){
   
10.         hrtc.Instance = RTC;
    3 ]- R) x3 b1 k" k
11.         BKPTypeDef bkp;
    
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    
13.                 printf("rtc init\r\n");
    
14.                 HAL_RTC_Init(&hrtc);
    * L6 ^' W( M0 q# J: b9 O+ Q! J
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    
16.                 bkp.RTC_STA = 0xaa55aa55;
    * F9 C5 L( w+ L/ M& c
17.                 set_bkp(&bkp);
    
18.         }
    $ {' w6 ?7 b; B8 ^9 I
19. }
    5 p) q1 b- _8 p8 c/ v8 Q' U3 h! W
20. 
    - t2 q* [/ Y6 R
21. BKPTypeDef get_bkp(void){
    
22.         BKPTypeDef bkp;
    
23.         bkp.DR0= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0);
    . r; g5 I) t# E+ L( G
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);
    ) F/ Q3 q8 J9 t
28.         return bkp;
    
29. }
    ; o& T2 ^0 \. w; h; R- F
30. 
    
31. void set_bkp(BKPTypeDef *bkp){
    
32.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR0, bkp->DR0);
    8 v1 Y! M2 q+ Q  M6 z6 `; H
33.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR1, bkp->DR1);
    
34.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR2, bkp->DR2);
    4 w# c) X6 `. q$ l
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    ) Y" V# N- T" s/ z0 e6 ~- k
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    
37. }

复制代码

* s! ]1 p1 }! {' D4.2 用EEPROM备份和恢复数据

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
   1 t6 g" p8 g1 _' e: V; i
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   
4.                 return false;
   " j- J: H7 h1 S7 s# h
5.         }
   ; p3 b0 h) q+ r. _) \
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   
7.                 printf("Flash EEPROM Address Error!!!\n");
   5 x' w: k7 d, g2 g' G0 J/ s
8.                 return false;
   - y& k+ M) ^# J: p
9.         }
   3 x$ C. X4 i) s& k1 S/ @
10.         
    
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    8 u" R0 C" _% Y, v' Z$ ]! 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>);
      l9 i& o* p7 R
14.       </i>  }
    
15. 
    
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    ' {8 K0 R& O$ Q" j1 W* z$ @" j) C  J3 }, _
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    9 H2 C2 k" u( Q, B7 G% j9 l
18.                 return false;
    - ^6 e( u8 p+ V3 [
19.         }
    
20.         
    
21.         return true;
    8 P/ g: w( }2 v+ X* }
22. }
    
23. 
    
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    : A$ [% h* j$ [9 E" H
25.         if(Size > DATAEEPROM_MAX_SIZE){
    
26.                 printf("Size is too long!\r\n");
    
27.                 return false;
    
28.         }
    
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    % k  n. X0 w$ |
30.                 printf("Flash EEPROM Address Error!!!\n");
    0 |7 U1 A5 m& o/ M% y/ n
31.                 return false;
    
32.         }
    + P7 \) Y6 U% ]; U$ y( M; L
33.         
    ! K  ^2 Z, T8 j" w" I
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    
35.         
    
36.         for(uint16_t i=0;i<Size;i++){
    # b  {) e) h: B
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    
38.         }
    
39. #if 0        
    
40.         for(uint16_t i=0;i<Size;i++){
    
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    
42.         }
    4 H7 a( p; C! A( O7 q
43. #endif        
      u6 W8 m5 N$ R( ^8 `! C
44.         memcpy(pData, tmp, Size);
    
45.         
    
46.         return true;
    
47. }

复制代码

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

0 f8 ?6 G' l" d2 s! ]6 y3 S

1. if(0xaa55aa55 == BKP.RTC_STA){
   
2.         ...
   
3.         //显示B画面
   
4. }else{
   / O) O  v- l2 y2 j5 L
5.         ...
   
6.         //显示A画面
   
7. }

复制代码

/ @* e* j1 m4 Y2 t+ q& m  N) j总结
可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
standby模式的程序框架为：

' d' t/ A4 f+ `5 c" x