MCU：stm32L031K6T6

$ l7 K' ?4 ?& }$ P* g芯片的主要的低功耗特性
0 T3 \" z% ~- L8 PFeatures
2 q( ~) G: P# ?# j• Ultra-low-power platform
– 1.65 V to 3.6 V power supply
– -40 to 125 °C temperature range
– 0.23 µA Standby mode (2 wakeup pins)
4 p' Q2 X# }7 A$ _– 0.35 µA Stop mode (16 wakeup lines)
3 V! d1 I4 Q2 {0 c' {9 _  \– 0.6 µA Stop mode + RTC + 8 KB RAM retention
9 }7 B, G& C& b" R– Down to 76 µA/MHz in Run mode
( ~/ ]4 g. l3 G– 5 µs wakeup time (from Flash memory)
* N- M7 {+ B( E9 l1 I– 41 µA 12-bit ADC conversion at 10 ksps
• Core: Arm® 32-bit Cortex®-M0+
– From 32 kHz up to 32 MHz max.
) ^3 h' c3 ]6 F– 0.95 DMIPS/MHz

功耗当然越低越好咯，但是低功耗是要付出代价的，看下各种功耗下的时钟、RAM、IO、寄存器等的运行情况，如下：
6 h8 h6 ^' H6 d& h& L, p

* O) ^9 ~+ y# p) ]' P

我们选用的当然是最最低功耗的standby模式了：

standby模式BKP备份寄存器能够使用
1 w+ J$ g& U4 _- tstandby模式LSI和LSE两个晶振源可以使用
1 T& c' w9 q& J. R5 C; `( fstandby模式可以用RTC或Wakeup PIN能够唤醒
0 q5 @' c' _3 G5 k1 B7 `1 j3 U7 Q注意 standby模式下RAM里面的数据是不保存的
主程序框架
& ~7 T; ]' P2 `$ W( u! l% y

1. ...
   
2. int main(void){
   ) B1 p% B' P% b
3.         HAL_Init();
   
4.         
   # h6 n5 h3 G2 E( M6 n
5.         SystemClock_Config();
   
6.         
   
7.         MX_GPIO_Init();
   
8.         MX_DMA_Init();
     g4 Z. T4 o  g7 y/ e; ^- F
9.         MX_ADC_Init();
   
10.         MX_IWDG_Init();
    
11.         MX_SPI1_Init();
    3 v6 I5 J8 S) C) j
12.         MX_TIM2_Init();
    , u4 q, O: q* W) N/ ?! a+ q! L
13.         ...
    
14.         
    
15.         SystemPower_Config();        //PWR配置
    
16.         
    
17.         BSP_Init();        //板级支持包外设初始化
    & x1 Y( Q* r6 ^# {" B
18.         
    % Y0 T3 Q% x2 ]# z( F7 r
19.         BAK = get_bak_param();        //恢复备份的数据
    
20.         
    
21.          while（1）{
    
22.                 ...        
    3 }$ ?% s9 c" b! r2 T% g0 X( N
23.                 //主程序体
    2 Y) o* Q6 V/ z4 k* C
24.                
    
25.         }
    
26. }

复制代码

重要函数实现
2 r6 r- ~$ v. a6 _: p/ v) p1. PWR配置
: q! s" Y- F+ Z5 X5 R& i' V4 d

1. void SystemPower_Config(void){
   
2.         __HAL_RCC_PWR_CLK_ENABLE();
   8 |! R; Q$ w9 o4 B- n; z1 z
3. 
   
4.         HAL_PWREx_EnableUltraLowPower();
   
5. 
   
6.         HAL_PWREx_EnableFastWakeUp();
   % M; Y8 r* Z, s6 r
7. }

复制代码

" G1 ^1 z- x* {/ {& b: x# s2. 进入standby模式
1.先备份数据
set_bak_param(BAK);
2.进入standby模式
& D6 E; p) e% i& q5 z9 wpwr_standby();

1. void pwr_standby(void){
   
2.         if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET){
   8 n  ?  L* |3 i2 d+ o2 E
3.                 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
   
4.         }
   - u/ r% J. g# j6 z
5.         
   
6.         __HAL_RCC_PWR_CLK_ENABLE();               
   
7.         
   " E2 k/ b! |# Y/ l9 E
8.         //stm32L031K6 的PA0和PA2可以作为唤醒引脚
   
9.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
   ' [5 P- F: `3 u, V5 ?
10.         HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN3);
    4 [( ?0 M/ f& O
11.         
    2 X% ~: w1 f7 B0 y
12.         /* Clear all related wakeup flags*/
    
13.         __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
    - Z9 F) A" l5 \3 A  H- m7 p5 d( X
14. 
    
15.         HAL_PWR_EnterSTANDBYMode();
    
16. }

复制代码

3. 唤醒
唤醒没什么好说的，standby模式下唤醒，程序跟上电复位没什么区别，RAM里面数据都没了，但是BKP中的数据仍然存在；
( v$ P+ {- t- f8 u  }, A& r这里暂时就把唤醒当做是重新上电吧，后面说到BKP的时候再区别处理；

' Q+ S( T$ Z7 x- H, d9 r; Z4. 数据备份和恢复
( W; ?  o& m. A' P- ~. y$ x1 {• Memories
3 ]0 @6 t! j! J4 A/ ~– Up to 32-Kbyte Flash with ECC
+ ~+ {5 a: B$ R5 J– 8-Kbyte RAM
– 1-Kbyte of data EEPROM with ECC
2 }* U; D0 W  s– 20-byte backup register
– Sector protection against R/W operation
如果需要备份的数据比较少，不超过20byte，那么可以使用backup寄存器备份数据；如果大于20byte但是不超过1Kbytes可以用MCU内部的EEPROM备份数据；超过1Kbytes可以选用别的功耗模式，或者可以选用外部flash或EEPROM等介质存储数据咯

1. //**设计结构体用来存储备份的数据**
   " b- `8 e* r- h  ?# O5 X
2. typedef struct bak_t{
   3 ]# u2 M1 a& V+ n
3.         uint32_t        RTC_STA;
   
4.         ...        //根据自己的需要设计结构体吧
   0 n8 J  k7 t1 d4 _; K) ^2 G
5. }BAKTypeDef;

复制代码

4.1 用BKP备份和恢复数据

1. typedef struct bkp_t{
   
2.         uint32_t        DR0;        
   
3.         uint32_t        DR1;
   
4.         uint32_t        DR2;
   
5.         uint32_t        DR3;
   
6.         uint32_t        RTC_STA;        //rtc init sta
   
7. }BKPTypeDef;
   
8. 
   + K" ?" c& W! W3 J0 x
9. void bkp_init(void){
   & O# |7 J( M, O/ w
10.         hrtc.Instance = RTC;
      `, N* x/ j0 I1 Q
11.         BKPTypeDef bkp;
    
12.         if(0xaa55aa55 != get_bkp().RTC_STA){        //判断初始化RTC
    
13.                 printf("rtc init\r\n");
    
14.                 HAL_RTC_Init(&hrtc);
    7 p5 N: z1 R3 E. Y/ _
15.                 bkp.DR0= bkp.DR1= bkp.DR2= bkp.DR3 = 0;
    
16.                 bkp.RTC_STA = 0xaa55aa55;
    4 y7 }  m+ F1 _4 ]: \2 y! y$ L
17.                 set_bkp(&bkp);
    ; m( `' H- C( W; t: z
18.         }
    
19. }
    : f  ?" s" L2 O7 n
20. 
    
21. BKPTypeDef get_bkp(void){
    
22.         BKPTypeDef bkp;
    1 A/ A6 U+ _/ r, a" t
23.         bkp.DR0= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0);
    
24.         bkp.DR1= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR1);
    . G) ]4 [6 P# w; `' s. B) T/ Y
25.         bkp.DR2= HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR2);
    
26.         bkp.DR3 = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3);
    8 o: c. S; t+ s/ i5 I5 E" L
27.         bkp.RTC_STA = HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR4);
    
28.         return bkp;
    
29. }
    8 Z9 \2 U  u% k7 [" R8 P
30. 
    6 z6 F) f) ^/ D; l5 H" B
31. void set_bkp(BKPTypeDef *bkp){
    
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);
    
35.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, bkp->DR3);
    
36.         HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR4, bkp->RTC_STA);
    2 D$ `% k2 M2 {& V8 D
37. }

复制代码

4 `6 U! ]! e4 y( J7 l3 j4.2 用EEPROM备份和恢复数据

1. bool DATAEEPROM_write(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
   : r' n1 G% M2 s/ q* @: A
2.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Unlock()){
     W1 Z4 @6 C: {
3.                 printf("Flash EEPROM Unlock failed!!!\n");
   
4.                 return false;
   ( g% s6 F) Z7 Z& A6 l
5.         }
   
6.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
   7 f4 w9 m/ Z. T# ]
7.                 printf("Flash EEPROM Address Error!!!\n");
   
8.                 return false;
   
9.         }
   ' }, ~% a" U3 G, c7 F' V
10.         
    
11. //        HAL_FLASHEx_DATAEEPROM_Erase(DATA_EEPROM_BASE);
    ) Z$ |2 t0 y/ W2 c8 `% O2 l
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>);
    
14.       </i>  }
    7 A2 ^  \4 j2 L* g. l$ I
15. 
    & ?& {" [+ S3 Y! ~4 }/ s+ F
16.         if(HAL_ERROR == HAL_FLASHEx_DATAEEPROM_Lock()){
    - N/ L# [, g( g: Y: o
17.                 printf("Flash EEPROM Lock Failed!!!\n");
    $ Q  @, A# U1 q* `/ c1 e9 Y' u" w
18.                 return false;
    3 p, p0 V& j: i
19.         }
    
20.         
    7 o! N9 f. L, ~4 H, U) ]# [
21.         return true;
    # C4 c! h3 G& X  v
22. }
    ' N7 T" O1 \. b8 {. X9 k. x- c
23. 
    % Y1 R) f" w# K6 M' s
24. bool DATAEEPROM_read(uint16_t addr_offset, uint8_t *pData, uint16_t Size){
    , e- ~/ A8 ]4 M
25.         if(Size > DATAEEPROM_MAX_SIZE){
    
26.                 printf("Size is too long!\r\n");
    
27.                 return false;
    + ~6 K+ `4 K$ U$ W$ p! K
28.         }
    
29.         if(DATA_EEPROM_BASE+addr_offset > DATA_EEPROM_END){
    - X0 e* H0 l3 p
30.                 printf("Flash EEPROM Address Error!!!\n");
    
31.                 return false;
    2 i7 R2 }, x( Z9 F
32.         }
    0 ?' I2 m% z: L- k
33.         
    2 d# b2 d) t, g* R
34.         uint8_t tmp[DATAEEPROM_MAX_SIZE] = {0};
    
35.         
    / E3 ^& c2 V! v) U* `7 q8 R" L
36.         for(uint16_t i=0;i<Size;i++){
    - _* z- P; K' n9 {5 S6 ^! F! m
37.                 tmp = *(uint32_t*)(DATA_EEPROM_BASE+addr_offset+32*i);
    
38.         }
    8 V4 T# S, q7 _% Z
39. #if 0        
    7 Y& M1 B/ x( Q2 y6 n* T. t# ?1 c
40.         for(uint16_t i=0;i<Size;i++){
    1 O4 E0 O& ?2 U6 _9 R" N
41.                 printf("tmp[%d]:%x\r\n",i,tmp);
    , V3 @5 ~  C3 X( k1 x
42.         }
    
43. #endif        
    
44.         memcpy(pData, tmp, Size);
    
45.         
    % M+ P5 Y! J( c/ M( s
46.         return true;
    
47. }

复制代码

6 Q0 n- a* D8 O9 @! S1 k: o8 G5. 区别处理
如果上电复位的时候你要让屏幕显示A画面，而唤醒之后你要让屏幕显示B画面，那该怎么区分MCU是上电复位还是wakeup的呢？
5 b- o1 M/ z; u5 F我们有一个重要的寄存器呀backup register
4 c  C/ `9 D2 A) p$ d6 E" S7 z9 _如果是上电复位那backup register里面的数据全部都是乱数据；
如果是wakeup那读取进入standby模式之前备份的特定的数据，如果数据对上了就是wakeup，如果没有对上，那就是上电复位了；上面的程序中我们用BKP.RTC_STA==0xaa55aa55 来判断是那种模式启动的MCU；

- F( P7 Z" y2 i5 q! Y# M: B

1. if(0xaa55aa55 == BKP.RTC_STA){
   
2.         ...
   1 e" a! h& e; d8 C4 g* [2 o
3.         //显示B画面
   
4. }else{
   
5.         ...
   
6.         //显示A画面
   
7. }

复制代码

( [; W5 s9 `! y' m/ R总结
; n5 v. ~8 k- Y7 G0 ~/ F, y可以选用多种低功耗模式，sleep模式、stop模式、standby模式，其中standby模式功耗最低。
选用standby模式，进入低功耗之后RAM中没有数据了，且只能用特定的且已经配置了的PIN脚来唤醒MCU；
; z# s7 ~1 P7 x+ f" Qstandby模式的程序框架为：

: N+ R6 P/ J& K: F: V