MCU：stm32L031K6T6

; S& o( R. p- Q; t( A芯片的主要的低功耗特性
( ~/ G: s" Q: O' ?. {$ l4 xFeatures
' r; N% x! P) m- V. S/ O5 K* R$ s• Ultra-low-power platform
) c% ^" S0 |1 x0 B8 a% d+ @– 1.65 V to 3.6 V power supply
5 ]7 p% i6 ~4 H2 w% i– -40 to 125 °C temperature range
) ?) o& q9 e; b& _– 0.23 µA Standby mode (2 wakeup pins)
% l1 B2 i- V) o/ Z0 F– 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)
& g2 x$ K& g8 G– 41 µA 12-bit ADC conversion at 10 ksps
3 k9 Y) |: G% `9 T$ J- e# `. N• Core: Arm® 32-bit Cortex®-M0+
– From 32 kHz up to 32 MHz max.
– 0.95 DMIPS/MHz

功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：
4 E9 S/ L* F" C0 E

" w4 \# j* ]3 E
5 Z  A: P4 W& K: _( R# X1 W( r) l
1 U3 Y0 c* H, D! A9 ?我们选用的当然是最最低功耗的standby模式了：
* Q1 E! j. u$ W" N5 B
standby模式BKP备份寄存器能够使用
standby模式LSI和LSE两个晶振源可以使用
standby模式可以用RTC或Wakeup PIN能够唤醒
  F" W+ |4 N, L. q$ \" y注意 standby模式下RAM里面的数据是不保存的
主程序框架

1. ...
   
2. int main(void){
   * ^  w3 T4 G8 x& y0 C/ h
3.         HAL_Init();
   
4.         
   
5.         SystemClock_Config();
   
6.         
   ; y, e! [, S' B5 L1 R+ b0 l
7.         MX_GPIO_Init();
   + k: v* {; C8 u6 T( J
8.         MX_DMA_Init();
   - W- ]) w6 ?! R, }3 F( j# k- |
9.         MX_ADC_Init();
   % c: q) E' l* Z$ d
10.         MX_IWDG_Init();
    
11.         MX_SPI1_Init();
    " h& l0 c* P2 ?" I6 P7 o
12.         MX_TIM2_Init();
    4 B6 r8 ^  h  d% h
13.         ...
    4 L/ m8 S4 t3 j# A# i
14.         
    * ]4 U; q/ }$ C. `" Y
15.         SystemPower_Config();        //PWR配置
    
16.         
    % H3 D" S$ R( {1 m1 Z! x
17.         BSP_Init();        //板级支持包外设初始化
    / a8 l, y2 f5 ^  P/ e( \
18.         
    
19.         BAK = get_bak_param();        //恢复备份的数据
    
20.         
    ; n& Z1 Z: v# p3 U2 b- ]0 [: s
21.          while（1）{
    ! S8 D! x4 k6 k
22.                 ...        
    
23.                 //主程序体
    1 k, j( {; c  S
24.                
    % [" p6 D- o* W" V
25.         }
    
26. }

复制代码

: O5 D4 o- {# R" k/ z( U重要函数实现
1. PWR配置
3 |% }' U$ ]; p) v$ Z

1. void SystemPower_Config(void){
   
2.         __HAL_RCC_PWR_CLK_ENABLE();
   8 `/ f6 G( l: R9 M6 K' c6 {
3. 
   
4.         HAL_PWREx_EnableUltraLowPower();
   ; v' k6 U- [/ _. y( y
5. 
   4 r$ p- {( ~  X; o# q7 L1 {7 g* W5 A
6.         HAL_PWREx_EnableFastWakeUp();
   4 m& Y+ ^4 w* c6 t% d7 j
7. }

复制代码

2. 进入standby模式
1.先备份数据
set_bak_param(BAK);
2.进入standby模式
- G' a( A2 w' L) i: }( J$ @$ ^5 ?  Ypwr_standby();
# D5 F+ A7 q5 v- y

1. void pwr_standby(void){
   ! C7 e3 M# C% Y3 B+ Y, n# @
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   + \$ ^/ X3 Z8 V/ c: T' W
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   
4.         }
   
5.         
   
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   5 I" \. [2 _, |! m3 {: A
7.         
   : p. a* O4 [6 S
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   - i6 G; n* g& n/ l2 D
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    , ~+ D  g+ L* ^5 T
11.         
    " c: V0 H2 Q0 p9 `1 T
12.         /* Clear all related wakeup flags*/
    
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    : }/ M4 {: _8 E1 \  T1 u2 Z
14. 
    
15.         HAL_PWR_EnterSTANDBYMode();
    
16. }

复制代码

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

. @- Z" J% v) H+ s+ U9 S4. 数据备份和恢复
• Memories
– Up to 32-Kbyte Flash with ECC
– 8-Kbyte RAM
– 1-Kbyte of data EEPROM with ECC
1 O: X" N$ _2 s% \+ [– 20-byte backup register
+ O+ M5 ?, N% x  R: i+ q* _– Sector protection against R/W operation
如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯

1. //**设计结构体用来存储备份的数据**
   
2. typedef struct bak_t{
   
3.         uint32_t        RTC_STA;
   
4.         ...        //根据自己的需要设计结构体吧
   
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   
3.         uint32_t        DR1;
   
4.         uint32_t        DR2;
   " _/ P  x( [* k, L4 v( B9 z+ C
5.         uint32_t        DR3;
   
6.         uint32_t        RTC_STA;        //rtc init sta
   
7. }BKPTypeDef;
   
8. 
   3 V; @1 W  m6 K# z
9. void bkp_init(void){
   
10.         hrtc.Instance = RTC;
    
11.         BKPTypeDef bkp;
    6 h- W- M$ p1 B  Q
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    2 m+ _; v% c0 O* i9 B( W! I/ v
13.                 printf("rtc init\r\n");
    5 u+ O9 v1 A% T3 U6 L) t2 z
14.                 HAL_RTC_Init(&hrtc);
    
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    $ O/ @5 x, D, F$ ]! A- p
16.                 bkp.RTC_STA = 0xaa55aa55;
    
17.                 set_bkp(&bkp);
    3 R  d6 _0 n8 ]
18.         }
      k; a) o1 s. C: _" i- x
19. }
    
20. 
    
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);
    # \: Z; B; w" g% g9 |, V+ X$ H
25.         bkp.DR2= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
    8 B" i# x  I9 V% `
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    : c8 }% F& F7 e6 g0 h# i
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
      T1 O5 L4 D6 U: z- p
28.         return bkp;
    ) |# _5 t8 D$ _9 O9 ^' i
29. }
    
30. 
    6 k3 j5 U& s0 ]+ x7 l, K/ f
31. void set_bkp(BKPTypeDef *bkp){
    
32.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR0, bkp->DR0);
    # A  h+ {+ m" E7 x& Y; n( l
33.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR1, bkp->DR1);
    5 h4 t# w' d4 b4 z9 K1 V* P  H
34.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR2, bkp->DR2);
    % K: z: R3 g0 M& Q8 t
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    ( z& B# z' y. }) t9 H$ x5 U7 b0 S
37. }

复制代码

" F' `) ]( ]& q) O( C4.2 用EEPROM备份和恢复数据
' B" V3 T+ S: I3 M" K

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");
   
4.                 return false;
     m9 B1 w( g: V& r+ ~6 |" D
5.         }
   . D" k) h! W9 S- v4 x# B* {3 L( i7 N
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   ; Y  ?  Z4 U) g" v0 M$ E4 e
7.                 printf("Flash EEPROM Address Error!!!\n");
   7 d  ?6 h5 b# d) N2 l9 O! S! R
8.                 return false;
   
9.         }
   - W1 I  G% C% L( E. Q
10.         
    ; b9 n& M, L- L0 [, {5 ~7 E
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    5 P2 c/ f2 A( V* }9 Q# A* i
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>);
    3 j! J7 g8 \5 Y
14.       </i>  }
    
15. 
    0 [2 G$ r3 v/ h
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    
17.                 printf("Flash EEPROM Lock Failed!!!\n");
      x) L- U5 G. p8 F7 O0 @* @) Z! @
18.                 return false;
    + w% H3 R+ K* n! z  ~
19.         }
    - h1 D) W& j8 U/ Z, Z1 L: p
20.         
    ' @" B( Q1 F( [% i( R! o
21.         return true;
    
22. }
    
23. 
    ) X3 K- H( W, [% M
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    1 N/ ?( l% I; ?9 P8 p7 K# |: F2 a
25.         if(Size > DATAEEPROM_MAX_SIZE){
    1 X: h3 d( M. S# g2 v
26.                 printf("Size is too long!\r\n");
    ; q( I" y# h5 v
27.                 return false;
    & D- A/ z. \0 e% Z6 G7 E
28.         }
    
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    
30.                 printf("Flash EEPROM Address Error!!!\n");
    8 l0 Q, B" h1 t9 ?* t9 J
31.                 return false;
    
32.         }
    3 d- B3 t8 R2 j8 F( ]  M% C
33.         
    " t3 a6 X; {* U4 U' J3 b5 Y* v. c
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    
35.         
    * y" ?+ k& @  D. s( ~2 K$ ]
36.         for(uint16_t i=0;i<Size;i++){
    ) Y7 N% t- d; r
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    
38.         }
    
39. #if 0        
    
40.         for(uint16_t i=0;i<Size;i++){
    4 ?% m7 ~5 _7 p; z8 a
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    
42.         }
    
43. #endif        
    
44.         memcpy(pData, tmp, Size);
    
45.         
    
46.         return true;
    ; k% q; u7 R9 i9 |9 y
47. }

复制代码

1 t0 B7 c" m' Z9 d. a1 ?: b% @! ?$ f5. 区别处理
如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
我们有一个重要的寄存器呀backup register
如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；
: t: g) T. V% i$ |! d. G
1 m, i8 c% Y6 c4 Z) q

1. if(0xaa55aa55 == BKP.RTC_STA){
   ' D0 r8 Q: s0 n( N" ~
2.         ...
   3 T- R1 Q* Q1 {6 E
3.         //显示B画面
   
4. }else{
   9 ^8 l" O4 C& C, M
5.         ...
   
6.         //显示A画面
   
7. }

复制代码

总结
+ U6 J+ L3 P5 N可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
standby模式的程序框架为：

3 |1 ]8 ~4 }, l# a8 s: O

9 }( m  P3 A8 M