期待了好久，ST昨天（2017年5月16日）终于在西安举办了第一届线下培训，这次培训的主题是“STM32低功耗设计应用Workshop”。
        用ST的芯片已经有好几年的历史了，但是我之前一直用的是STM32F1和STM32F4,STM8S系列的产品，对于低功耗的产品之前还真没有怎么太多的接触，有幸能参与此次培训，感觉一整天收获颇丰，感觉花了一天时间把低功耗设计的一些大概的东西掌握了，这个学习效率还是蛮高的。所以将自己学习到的东西总结分享给大家，如果有理解不到位的地方，还望各位大神指点一二，以促进我们共同成长。
7 |8 N3 b+ p; O) d- p6 _- z        全天培训是在咖啡厅进行的，课堂上时时飘来可口的饭香味，整体氛围很好。

4 r& Z' o2 ?( `2 m9 e" e; R; W

( s1 l. i. A! H# s* ]+ p
+ Y0 J* @  i" Z- M$ ~- d        作为一个技术狗，我直接跳过ST关于产品线的介绍，直接杀入主题--基于STM32L476的低功耗设计，当然在这之前先介绍几个ST发布发布的非常好用的工具。
, t( `- d6 P" F/ _6 |
        一、ST MCU Finder
3 ~8 L% L) s" L             这个软件我最早是在苹果软件商店发现的，下载下来觉得挺好用，所以还推荐给我群里的人了，后来又发布了安卓版本和PC桌面版（包含WINDOWS\LINUX\MAC OS）作为一个ST的忠实粉丝，我也是第一时间下载使用并推荐给群里的人。也在摩尔吧开过一次直播，和大家探讨基于ST MCU Finder 和cube MX以及keil进行产品快捷开发的课题，链接为：https://www.moore8.com/courses/1444。当然，啰嗦了这么多，还是没有给大家说说这个软件是干嘛的，我直接上图
6 `* E; \' F) B. N- J' {
上面的是图标，下面是软件打开后界面：
' l: F7 X8 N4 x

            这简直就是一个选型利器啊，我们可以根据自己的需求，选择合适的检索方式，然后可以快速找到适合自己的芯片了啦。找到芯片之后还可以快速下载数据手册和其他的文档。再也不用网上到处找文档了。

7 a# I. o2 E2 T! l* w  l0 x       二、STM32CubeMX
! k' K# E) I  E            这又是一件利器，它可以方便的查看芯片的IO管脚图，时钟树等，不只是可以看，而且可以配合，是一款很好的IO分配，时钟树配置软件，而且它可以进行电源功耗计算。其实最厉害的应该是代码自动生成。

0 F# S' |1 T7 C' P+ M2 N上面是STM32CubeMX的图标，下面是使用的详图：

以STM32L476 nucleo板子为例，创建一个项目


具体功能大家看图，下载软件使用一下就爽翻了，我就不详细描述了。

7 z, r- y: X/ g, M        三：常用的网站及公众号：
. ~  _' R# M  ~( J- m               STM32社区：https://www.stmcu.org.cn/
# T' w+ |- K- d4 M4 {* b; D               STM32中文官网：http://www.stmcu.com.cn
               STM32四轴飞行器教程：https://www.moore8.com/courses/course/1308
               公众号：STM32单片机

! b# ~3 \0 S6 y+ C# ?

  d/ H$ t: K8 X/ L! s* ~        安利完上面两个软件，开始正式总结回忆低功耗课程的内容：
        1、在低功耗案例分享中学习到的东西有以下几点：
              #、影响低功耗设计的几个因素：
1 H( s: _  Y: M: [1 R) P$ D: u# }                      *芯片的工艺和制程：不同的制程芯片内部晶体管的开关功耗不同，导致整个芯片功耗不同
9 N5 }! n7 a# y6 i                      *晶体管数量不同：这个是显而易见的一个因素
+ t' d( A$ o& j+ Q' v$ k) b                      *模拟外设的使用：模拟外设相对耗电量比较大
                      *RAM与Falsh大小：不同的存储容量耗电也不一样，存储功耗近似和存储空间大小成正比
$ V0 A& H! t8 Q                      *MCU供电特性：提供的电压越低，功耗也就越低，但是此时频率也越低，和电脑超频耗电量大一个道理
9 j# T, ]9 g& H( d' L( I9 F9 z                      *时钟频率：时钟频率越高，耗电量越大
. L1 n2 m% Z3 v5 \                      *工作模式：不同的工作模式耗电量不同，这个是显而易见的
              #、功耗分为静态功耗和动态功耗，动态功耗与电压、频率、负载等关系相关
              #、L4系列独有的电压转换器，可调时钟源，SMPS等.
0 M. V8 m5 R; [! P1 v. Y- ^6 O              #、外设和GPIO连接的时候，如果两端电压不一致，就会导致电流产生，从而消耗功耗，所以要仔细阅读外设手册并进行合理配置
: v+ w: h4 c  A3 V+ C$ U              #、IIC等外设的管脚必须外加强上拉，在进入低功耗之前把IIC的管脚设置为上拉输入模式
              #、中断标识未清除也可能导致功耗上升
& ?0 L9 M" s! U1 |. A6 O: P; C              #、虚焊等其他情况也可能导致功耗异常
              #、在数据传输未结束的时候，尽量不要切换到低功耗模式，可能会失败
              #、使用低功耗串口唤醒系统的时候，如果串口波特率太高可能导致前面的数据丢失
              #、一些特殊场景可以考虑把代码优先级修改为速度优先，用空间换时间
        2、HandsOn环节的实验学习（具体实验安排我就不说了，请参考ppt）：
8 L; Y: [6 N) I              代码如下：

1. /* Includes ------------------------------------------------------------------*/
   # R0 ], {* ]5 p$ ^9 V
2. #include "main.h"
   
3. #include "stm32l4xx_hal.h"
   / j/ S$ w5 Q& n4 H/ @
4. 
   8 K, R! z7 ~8 e, Q7 |1 c
5. /* USER CODE BEGIN Includes */
     }# k( W  G/ n9 z: L9 Q+ S- \# O
6. #include <stdio.h>
   , l" }4 }& i$ Q# s4 y- N1 q
7. #include "string.h"
   
8. 
   
9. #ifdef __GNUC__
   9 e% S& y+ f$ _4 @# ]6 v
10.   /* With GCC, small printf (option LD Linker->Libraries->Small printf
    + i! e3 U  }- f/ n
11.      set to 'Yes') calls __io_putchar() */
    1 E$ q) x# p# m
12.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    - ]$ W, Z$ l2 n6 W9 q4 F1 N
13. #else
    / b  a6 S2 }; q# L  J
14.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    
15. #endif /* __GNUC__ */
    
16. 
    
17. /* USER CODE END Includes */
    
18. 
    
19. /* Private variables ---------------------------------------------------------*/
    
20. UART_HandleTypeDef huart2;
    9 ?0 E4 M9 I1 H& y' m' m
21. 
    4 f; K9 T( {# @: \- G
22. /* USER CODE BEGIN PV */
    
23. /* Private variables ---------------------------------------------------------*/
    
24. __IO uint8_t ReceiveStatus = 0;
    
25. __IO uint16_t RxCmdCounter = 0;
    
26. __IO uint8_t ReadyToReception = 0;
    
27. __IO uint8_t CmdEnteredOk  = 0;
    
28. 
    
29. #define LR_ASCII_VALUE ((uint8_t)0x0A)
    * D! C; {+ q6 o
30. #define CR_ASCII_VALUE ((uint8_t)0x0D)
      C" z; S# u  X# J- N" i
31. #define RXCOMMANDSIZE   0x20
    % Y; [! ~- t  t* t$ }
32. #define RXBUFFERSIZE   0x01
    5 M" }* z& q* X% X
33. 
    " n! T! \6 i! ]# V0 J) [, L
34. 
    
35. char RxCommand[RXCOMMANDSIZE];
    
36. uint8_t RxBuffer[RXBUFFERSIZE] = {0}; //transmitting byte per byte
    
37. 
    
38. char temp; //initialisation character
    9 q+ v+ {% ~% {% |  F2 P( J
39. char * s;
    & R# ]+ z1 a- r1 R* T. w
40. 
    ; y: U% a7 G% ?2 M7 }3 A
41. /* USER CODE END PV */
    + i' y# z1 ~+ z$ Q
42. 
    ; h/ L$ a+ @9 D( t
43. /* Private function prototypes -----------------------------------------------*/
    
44. void SystemClock_Config(void);
    4 B& {7 l6 o6 B8 N6 T
45. void Error_Handler(void);
    , `/ t: f) l8 z4 `
46. static void MX_GPIO_Init(void);
    - o4 \4 P% Q& n
47. static void MX_USART2_UART_Init(void);
    
48. 
    
49. /* USER CODE BEGIN PFP */
    " e; y7 v  K# j4 u, r! {
50. /* Private function prototypes -----------------------------------------------*/
    
51. void DecodeReception(void);
    ' o: H0 P0 |$ B0 T7 u
52. void LSE_OFF_Config(void);
    ' ^0 k- v7 y) ^+ _* d+ \( i4 k- q
53. extern void test_shutdown(void);  
    
54. extern void test_standby(void);
    3 {* x9 E8 Y4 Z1 U
55. extern void test_lpsleep_2mhz(void);
    # N6 P  |6 l( t" v$ W" D6 V
56. extern void test_stop2(void);
    3 O' t* g) ?4 {: K/ Q
57. /* USER CODE END PFP */
    
58. 
    
59. /* USER CODE BEGIN 0 */
    . c! t& r0 a% A( d  {: u4 V
60. 
    
61. /* USER CODE END 0 */
    
62. 
    1 M3 M9 _1 h# @( t' X: I
63. int main(void)
    
64. {
    
65. 
    2 ?; ]( R; W1 W
66.   /* USER CODE BEGIN 1 */
    + I7 B5 N3 Z( N0 m
67. 
    $ ?+ c2 K7 P, G  x& @
68.   /* USER CODE END 1 */
    7 q0 ~% T# M) x/ l( c/ {% h# H5 x
69. 
    & }7 X6 A5 J- A7 _! C5 D) U
70.   /* MCU Configuration----------------------------------------------------------*/
    
71. 
    
72.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
73.   HAL_Init();
    + p8 u9 N# L/ u# k* v# g# G! l
74. 
    ; X# N7 ~7 y; g' V" C) B
75.   /* Configure the system clock */
    6 ]6 F0 p7 j$ f; ~
76.   SystemClock_Config();
    
77. 
    
78.   /* Initialize all configured peripherals */
    9 _0 V) I% s" x9 O
79.   MX_GPIO_Init();
    
80.   MX_USART2_UART_Init();
    ! C6 W- |- e1 c0 ?6 G$ D5 ?
81. 
    
82.   /* USER CODE BEGIN 2 */
    
83. 
    
84.   HAL_Delay(1000);//delay 1s
    $ O0 k7 [8 u2 ?4 u( S* y/ D
85. 
    & z* [5 o2 u# U% N
86. /* Output a message on Hyperterminal using printf function */
    6 u! K5 M7 ]/ s
87.   printf("\n\rREADY\n\r");
    3 O$ }1 q3 e$ `! E3 F3 }- u
88.   printf("Please enter the test number according below options\n\r");
    
89.   printf("      0       (SHUTDOWN) \n\r");
    * G; ~+ E5 N* A
90.   printf("      1       (STANDBY) \n\r");
    6 A+ `# {: ?1 g
91.   printf("      2       (STOP2) \n\r");
    
92.   printf("      3       (LPSLEEP 2MHz         - FLASH OFF) \n\r");
    9 [( p1 \3 S6 ?1 F7 ?, a
93.   
    
94.   printf(" --> \n\r");
    9 v4 v9 r% I( Z6 x: \9 G
95.   
    
96.     while (CmdEnteredOk != 0x1) {
    
97.     ReceiveStatus = 0;
    " _/ y( s, Y9 k; n% m
98.     while (ReceiveStatus != 0x1){
    
99.       /* Start the USART2 Receive process to receive the RxBuffer */
    ; _' |% M% f: }0 A" P3 ]: U' \6 n
100.       if(HAL_UART_Receive_IT(&huart2, RxBuffer, RXBUFFERSIZE) != HAL_OK)
     
101.         {
     5 ^9 W( x6 l# b: y4 V
102.           Error_Handler();
     ! G$ }8 J& b; o4 l2 I* Y5 K
103.         }
     - M/ C" h$ l# |! d0 ?3 o
104.       while (!ReadyToReception);
     
105.       ReadyToReception = 0;
     
106.       DecodeReception();
     
107.     }
     
108.       CmdEnteredOk = 1;
     $ }# f4 w) [5 I( b
109. 
     
110.       s = RxCommand;
     1 K! U& j* h2 P" w# z
111.    
     2 A/ x7 x* j( a' V
112. // __EFF_NENW1NW2   __ATTRIBUTES int        strcmp(const char *, const char *);
     
113. // strcmp(s, "x\r") ==0, input char is x\r, it is true
     # C4 ]% y0 C; c. l' C. {
114.          
     
115. // TODO 5: If receive char "0", enter into Shutdown mode   
     
116.       
     
117.       
     
118. // TODO 6: If receive char "1", enter into Standby mode      
     
119.       
     * \( P$ O) N' V1 ~. t  i/ Z) g
120.       
     
121. // TODO 7: If receive char "2", enter into Stop2 mode
     
122.      
     / L9 C, G) Q6 g5 |3 L
123.       
     . p  M/ Q  `$ h2 c
124. // TODO 8: If receive char "3", enter into Low Power Sleep
     
125.       
     
126.          
     & s2 W4 D* F% F3 W8 k3 c1 ?. _
127.       else {
     - }6 }1 p- ~1 z7 N
128.          printf("Invalid test number.. Please enter again\n\r");
     
129.          CmdEnteredOk = 0;
     
130.          /* Reset received test number array */
     7 j8 [5 w: e2 m* Y" z/ j' q/ A) R
131.          memset(RxCommand, 0, RXCOMMANDSIZE);
     
132.        }
     . R; C0 R( A& W# Q
133.       
     2 k8 U* v3 \; Z0 T
134.     }
     . r. g3 c+ }( J% Z8 W" h' {
135.   
     , }$ ~6 [, [% G0 o5 q
136.   /* USER CODE END 2 */
     0 R4 ]6 D3 r7 h& ^+ {+ z4 ^
137. 
     
138.   /* Infinite loop */
     * Y2 ?" e, A7 f- r- E* x
139.   /* USER CODE BEGIN WHILE */
     
140.   while (1)
     
141.   {
     0 i3 U& }/ N9 S0 R  S1 N3 b
142.   /* USER CODE END WHILE */
     8 n% _2 f3 Q% X/ J* W! E. s# [1 Y
143. 
     5 r: `* x- T, R0 R, q; i( m' c
144.   /* USER CODE BEGIN 3 */
     ! ~7 w  G' C9 e6 _  M5 P# F
145. 
     ( R+ k. C5 q7 r2 y9 Z) Z# E4 g
146.   }
     / o. z! O5 e; M/ A4 ]; P# c  ]
147.   /* USER CODE END 3 */
     ; i; a4 a. B+ U3 y' m0 B  ^0 S
148. 
     
149. }
     
150. 
     : u4 A" y( B  Z: A
151. /** System Clock Configuration
     2 ~5 U6 W: G9 y8 n* y4 K6 J7 _7 k
152. */
     ' |4 [; f" A+ S  k: {
153. void SystemClock_Config(void)
     
154. {
     9 |4 V& [4 a, p0 Q2 ]
155. 
     
156.   RCC_OscInitTypeDef RCC_OscInitStruct;
     
157.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
     
158.   RCC_PeriphCLKInitTypeDef PeriphClkInit;
     7 Q  j1 {: {' {7 [6 L8 E# j6 a* l& X- Q
159. 
     & f4 t$ Y# ^7 g# v
160.     /**Initializes the CPU, AHB and APB busses clocks
     4 G0 O, Y' V$ z; s, h' H9 b; c
161.     */
     
162.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
     0 u1 x7 m: }. H* w6 w4 k0 ~
163.   RCC_OscInitStruct.MSIState = RCC_MSI_ON;
     1 n4 Y# V% L" [+ P% y
164.   RCC_OscInitStruct.MSICalibrationValue = 0;
     
165.   RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6;
     # a/ p3 I+ i* R4 B
166.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     
167.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
168.   {
     : E$ G/ N$ \. Z
169.     Error_Handler();
     0 s5 i1 F2 S. f( ?7 L
170.   }
     ; U/ a4 F! M) i' U( C6 K
171. 
     $ ~! _% m2 g/ i7 y' z
172.     /**Initializes the CPU, AHB and APB busses clocks
     
173.     */
     ) p5 I: K1 b& ]. |, a' K9 R. \
174.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
     2 o' S1 D+ G, N% C. E& }
175.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
     
176.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
     
177.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
178.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     " R: b& j$ K; E. f5 |5 K; O
179.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     
180. 
     
181.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     1 I5 v9 T& y0 N& k+ I: a
182.   {
     % y  J* g5 E6 N9 t2 r# J
183.     Error_Handler();
     # @9 e' D" `4 f
184.   }
     4 d4 ^. U. Z: S' N9 J( E
185. 
     4 y  P0 N) @6 k0 |! k4 U
186.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
     0 U5 U$ J6 Q% q  T# c: S) Z0 p
187.   PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
     - s& b& f. U$ U
188.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
     ' k# u5 V" X6 H8 v2 \
189.   {
     ( _+ n0 ?0 t. p; Z* P7 J5 K
190.     Error_Handler();
     9 N. K% Q$ I6 A1 v
191.   }
     
192. 
     
193.     /**Configure the main internal regulator output voltage
     ' F! n0 r) q$ ^/ J4 V
194.     */
     
195.   if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
     % B: }7 i: W( X3 {( c( F
196.   {
     
197.     Error_Handler();
     ) `( b% T! s8 m; x) }
198.   }
     
199. 
     2 k& U. h  R. G5 O7 X4 e+ E
200.     /**Configure the Systick interrupt time
     , z! Y) H1 E: I
201.     */
     3 s- G3 P  z7 h7 ~  Q. q
202.   HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
     " o6 ?0 r; ]# T: T1 W' d* g1 B
203. 
     
204.     /**Configure the Systick
     3 z. A9 S8 y" ~+ S2 l4 m: h
205.     */
     
206.   HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     
207. 
     9 P5 m4 ?8 s2 J8 d. G7 E
208.   /* SysTick_IRQn interrupt configuration */
     
209.   HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
       [. N7 z7 H3 H- P& ^! L8 ]
210. }
     
211. 
     
212. /* USART2 init function */
     
213. static void MX_USART2_UART_Init(void)
     " U" N3 `$ L5 b" M7 N
214. {
     
215. 
     
216.   huart2.Instance = USART2;
     - e- q& J* i9 ]7 q3 G1 H- [
217.   huart2.Init.BaudRate = 9600;
     
218.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
     & t4 \  j4 A. }( R( t$ {
219.   huart2.Init.StopBits = UART_STOPBITS_1;
     
220.   huart2.Init.Parity = UART_PARITY_NONE;
     7 [+ T' x) i. t# m! p
221.   huart2.Init.Mode = UART_MODE_TX_RX;
     & }. O7 p# p1 @( e# ^1 o
222.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     
223.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
     2 h, q$ l) ]9 A  N4 q  j
224.   huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
     * ]0 o! w0 F! k* |' E/ v
225.   huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
     
226.   if (HAL_UART_Init(&huart2) != HAL_OK)
     - v- ?4 t+ N7 z+ n' w
227.   {
     - t4 y' P: s# U$ [$ u5 q7 V
228.     Error_Handler();
     
229.   }
     
230. 
     % b/ f+ b) B/ Z
231. }
     
232. 
     
233. /** Configure pins as
     
234.         * Analog
     
235.         * Input
     
236.         * Output
     
237.         * EVENT_OUT
     
238.         * EXTI
     % {0 a% s/ m0 ]/ b6 J( b% X
239. */
     
240. static void MX_GPIO_Init(void)
     ' z3 J: C  Y' K' f  }4 _2 i
241. {
     * g5 F2 P! I- u$ G/ ~: _( \
242. 
     
243.   GPIO_InitTypeDef GPIO_InitStruct;
     
244. 
     
245.   /* GPIO Ports Clock Enable */
     3 Z9 P+ A  \% f0 Z+ q
246.   __HAL_RCC_GPIOC_CLK_ENABLE();
     
247.   __HAL_RCC_GPIOH_CLK_ENABLE();
     , s; x/ W. i) y2 ?( c. I" p$ ?6 W
248.   __HAL_RCC_GPIOA_CLK_ENABLE();
     ( N$ _$ Y1 T/ F8 Y: _( G" V( A
249.   __HAL_RCC_GPIOB_CLK_ENABLE();
     # O; A+ V! O# U* Z8 `- d
250. 
     
251.   /*Configure GPIO pin : PC13 */
     - q1 z& C0 g, _# F- ~
252.   GPIO_InitStruct.Pin = GPIO_PIN_13;
     
253.   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
     / g- ?  P# R8 r% @* J; T  D9 T
254.   GPIO_InitStruct.Pull = GPIO_NOPULL;
     9 [$ O! [/ z  I1 L
255.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     
256. 
     * @2 f, Q% G- A9 v
257. }
     
258. 
     5 [0 s. ^; x# Z2 j+ W; W* R3 g( D
259. /* USER CODE BEGIN 4 */
     & Y+ o; V+ t: i
260. 
     8 A2 V8 y5 a8 v( C; g
261. PUTCHAR_PROTOTYPE
     / j$ f0 |. ]1 Y6 a
262. {
     
263.   /* Place your implementation of fputc here */
     
264.   /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */
     
265.   HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, 0xFFFF);
     
266. 
     
267.   return ch;
     4 ~: A3 }, B9 U8 S  q5 K
268. }
     
269. 
     * k; @2 P& Q3 Z/ l3 |1 g
270. void DecodeReception(void)
     # ]1 R- {) T+ j' x) g* n
271. {
     
272.   /* Read one byte from the receive data register */
     
273.   temp = (char) RxBuffer[0];
     
274.   RxCommand[RxCmdCounter++] = temp;
     
275. 
     
276.   /* Check if is an LR/CR character */
     , b& T3 |2 A+ I6 P4 D
277.   if ((temp == CR_ASCII_VALUE) || (temp == LR_ASCII_VALUE))
     
278.   {
     9 m: f4 r* G  n+ ^' b2 R& c
279.     /* echo entered command on terminal */
     
280.     printf("You entered below test number:\n\r");
     
281.     printf(RxCommand);
     
282.     printf("\n\r");
     
283. 
     
284.     RxCmdCounter = 0;
       S# O) L! R8 _! c( F8 ?# p5 i
285.      
     
286.     ReceiveStatus = 1;
     4 V# q) \5 O3 @4 U% \& \  E
287.   }
     
288. }
     
289. 
     
290. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     
291. {
     
292.      ReadyToReception = 1;
     
293. }
     ' ~. r# L; A4 m
294. 
     & [/ ]) B) E1 }. U$ ^
295. void SystemClock_2MHz(void)
     6 i( ~, e/ v2 ]# k: V: Y5 _
296. {
     
297.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
     
298.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     
299. 
     / t" O) T* E- K& i0 S; ?) o( ^7 p1 E
300.   /* MSI is enabled after System reset, update MSI to 2Mhz (RCC_MSIRANGE_5) */
     
301.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
     
302.   RCC_OscInitStruct.MSIState = RCC_MSI_ON;
     
303.   RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_5;
     ! u! r, y- x) N, H! b& T7 D2 ?# R" }; C
304.   RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
     / Q) ~& ^* G& B- b) O( R
305.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     8 Z  U4 w' u- p- T
306.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     ) E! l/ W  l6 `- t$ Z/ x% Q  M
307.   {
     9 I0 }5 P; S4 H9 B0 t! j7 [8 ^  `
308.     /* Initialization Error */
     8 {8 d6 q3 r) k( z& X
309.     Error_Handler();
     
310.   }
     7 K# r- b+ ]; w; g% B. I
311.   
     
312.   /* Select MSI as system clock source and configure the HCLK, PCLK1 and PCLK2
     
313.      clocks dividers */
     . z, @5 ]1 v" G6 J  Z. W8 H1 b2 L
314.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;
     
315.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
       I8 ]' b4 M: T- Y5 V4 f
316.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     - a5 n, |! w* N. |6 g$ z
317.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;  
     
318.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     
319.   if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     
320.   {
     & M4 v0 r+ w$ q  d
321.     /* Initialization Error */
     
322.     Error_Handler();
       {1 i. X' s) }8 T% {, F- m! ]
323.   }
     ( i* W+ d5 D. E$ N6 _* s; g
324.   
     5 `. r  P( s; q6 }5 N
325. }
     * L' w( F* Y7 i0 c& ?2 c
326. 
     
327. void GPIO_AnalogState_Config(void)
     
328. {
     ( ]* e& i9 b+ o3 h) V" j
329.   GPIO_InitTypeDef GPIO_InitStruct;
     " g, Q" U( ^9 e0 b
330.   
     & _) A! J2 w/ l
331.   /* Set all GPIO in analog state to reduce power consumption, */
     
332.         
     * m, x  E6 }8 S; _: J0 {
333.     __HAL_RCC_GPIOA_CLK_ENABLE();
     . h3 p8 Q3 S9 B# M1 r
334.     __HAL_RCC_GPIOB_CLK_ENABLE();
     
335.     __HAL_RCC_GPIOC_CLK_ENABLE();
     : k. h% I/ \2 u: g- v
336.     __HAL_RCC_GPIOD_CLK_ENABLE();
     4 l$ N5 U; d+ V# U
337.     __HAL_RCC_GPIOE_CLK_ENABLE();
     
338.     __HAL_RCC_GPIOF_CLK_ENABLE();
     
339.     __HAL_RCC_GPIOG_CLK_ENABLE();
     - A2 {: E! ^& X3 j
340.     __HAL_RCC_GPIOH_CLK_ENABLE();   
     ! Y) z* n8 y5 }6 ~8 c6 P
341. 
     
342.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     0 M. ^' s1 D) v" v/ \
343.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     9 M# ~, S% v- ]- y- T
344.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     
345.     GPIO_InitStruct.Pin = GPIO_PIN_All;
     % P* q* V( c; I
346. 
     * m6 D4 f9 q. D& y0 N& _3 n) b
347.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     " `, {5 r/ X8 y4 ?; l
348.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
       B: Y9 ~, ?' H
349.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     / Y' i1 x! N1 R. o# b5 |$ f3 o
350.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
     
351.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
     $ J2 H; {2 j; u6 }
352.     HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
     
353.     HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
     # u8 |( U! B1 [: s+ c7 q6 N) A9 h
354.     HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);  
     
355. 
     1 z$ P) b' {, P. X5 @/ ^- f- U
356.     __HAL_RCC_GPIOA_CLK_DISABLE();
     ; w" @2 X7 p; _% q
357.     __HAL_RCC_GPIOB_CLK_DISABLE();
     
358.     __HAL_RCC_GPIOC_CLK_DISABLE();
     - w5 z  f' G8 n
359.     __HAL_RCC_GPIOD_CLK_DISABLE();
     4 x2 R# t7 d! c; Z6 N; o# n
360.     __HAL_RCC_GPIOE_CLK_DISABLE();
     
361.     __HAL_RCC_GPIOF_CLK_DISABLE();
     
362.     __HAL_RCC_GPIOG_CLK_DISABLE();
     
363.     __HAL_RCC_GPIOH_CLK_DISABLE();
     
364. 
     
365. }
     ! k( u9 ~3 P$ m+ n; p2 s" I
366. 
     
367. void LSE_OFF_Config(void)
     8 r) L" G9 T7 b
368. {
     
369.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     
370. 
     
371.   /* set LSE OFF */
     $ c* d, y) V, x! X% R+ e) a
372.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
     6 {) R; C: r6 O2 z5 A
373.   RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
     * m& m5 ^- ?" x% x7 }
374.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     , c& T# m( a3 J0 {! i  N# \; s
375.   {
     
376.     /* Initialization Error */
     
377.     Error_Handler();
     
378.   }
     
379. 
     . e$ F5 v# N- p& d* u
380. }
     + I& |5 X. T$ k( b$ }/ Z- A5 r: q
381. 
     ( S2 p/ Y8 U9 ]
382. 
     
383. // TODO 1: Enter into Shutdown mode
     0 ~0 o0 z% e. t( B6 q9 C
384. 
     + R! D1 k4 H+ ?* h5 l, g% {
385. 
     
386. // TODO 2: Enter into Standby mode
     
387. 
     ( h$ e4 z) B* X' a& g* j/ U
388. 
     9 K! g" ~8 w/ x8 Z# L; G
389. // TODO 3: Enter into Stop2 mode
     5 K2 R% t$ h% r( Y8 L( ^& e
390. 
     
391. 
     
392. // TODO 4: Enter into Low Power Sleep mode
     4 e: G. f2 g6 H$ ^* D
393. 
     
394. 
     9 p9 p5 W) n. `! |4 S# i" [  X& a
395. 
       r" h% d. m5 ~: P7 L5 X
396. /* USER CODE END 4 */
     $ T+ |. d5 D% E7 x1 A- _
397. 
       [+ s4 ?0 v0 Y
398. /**
     
399.   * @brief  This function is executed in case of error occurrence.
     & v4 M9 ~- G: k5 S0 L* d% P
400.   * @param  None
     ( Q" `, _# b3 `$ E
401.   * @retval None
     
402.   */
     
403. void Error_Handler(void)
     
404. {
     
405.   /* USER CODE BEGIN Error_Handler */
     
406.   /* User can add his own implementation to report the HAL error return state */
     1 t3 u' t5 M% e" M/ V/ q
407.   while(1)
     
408.   {
     
409.   }
     
410.   /* USER CODE END Error_Handler */
     , n! g% O/ g) k$ }8 c# m6 \
411. }
     : E" ?3 j) j$ j' |
412. 
     
413. #ifdef USE_FULL_ASSERT
     
414. 
     - f# `: s/ j( o8 n& F$ e) t
415. /**
     : z( V# k% O) o" Y
416.    * @brief Reports the name of the source file and the source line number
     0 j& a# M* j  p) w7 _1 E& P# [
417.    * where the assert_param error has occurred.
     
418.    * @param file: pointer to the source file name
     
419.    * @param line: assert_param error line source number
     
420.    * @retval None
     
421.    */
     - W% O4 Q, Z) H  P4 h, O! J
422. void assert_failed(uint8_t* file, uint32_t line)
     # d9 _9 H0 F, q# u# c1 a  o
423. {
     
424.   /* USER CODE BEGIN 6 */
     
425.   /* User can add his own implementation to report the file name and line number,
     5 |7 e1 h- X4 Y/ f& T; d* v; |7 T- ?
426.     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
427.   /* USER CODE END 6 */
     
428. 
     3 B- X/ y. Q8 I1 n& {0 J
429. }
     
430. 
     
431. #endif
     
432. 
     
433. /**
     9 D. f! U' P+ E0 A
434.   * @}
     % _, S" C- }# p
435.   */
     " ^5 T. _8 ^5 K7 W: _
436. 
     & c. A* K! d2 }$ f' i
437. /**
     
438.   * @}
     
439. */
     7 a* B& J7 k* I1 g2 ?- |# H0 H
440. 
     : y2 ?( Y! E& C! n" v# y
441. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
     ( S% X' b4 N5 f

复制代码

上面是修改之前的代码。
* F& a7 P7 k" v( P3 f我自己测试的结果是（图上红色的数字是我的测试结果，与理论值基本吻合）：
3 I  H; E+ u5 B0 j- M

大家也可以根据帖子里共享的ppt思考一下补全代码。
& z. C1 A# b2 E! N( M
总之昨天学到了以下东西：
. N# h% s3 u5 K! q# w1、知道了设计低功耗产品时，硬件层面和软件层面各应该注意什么
7 t+ y- T+ Q4 B4 N) S- n( t/ U2、能够使用CUBE MX配置工程并生成项目代码
3、计算理论功耗，测量实际功耗并对比
* `& P9 F" _0 q8 Q& y; H1 A
收获满满的一天，下面把学习的资料分享给大家：
4 ~9 K7 p7 A5 [3 C( m  J# f# e8 w1 T
8 |. s4 q9 r, [" l
: Q7 ~/ T: {) k6 a0 k& K7 ]4 x
( y$ ^! v. q& m3 W9 D4 D 00_Part0_20170516_Xi'an_MassMarket_Begin.pdf (1.22 MB, 下载次数: 193)

2017-5-17 21:15 上传

点击文件名下载附件
  `8 ]& R9 R6 v4 e; h( S

2 R) W$ z" I. x+ O( C# d4 |* E 01_Part1_STM32L高性能低功耗实战设计.pdf (5.34 MB, 下载次数: 345)

2017-5-17 21:16 上传

点击文件名下载附件
6 P6 }' h; @" c
$ ?8 ]# s8 C% H# X$ }4 s# n 02_Part2_STM32L实战案例分析_update.pdf (1.07 MB, 下载次数: 271)

2017-5-17 21:16 上传

点击文件名下载附件
5 b) R" U1 z" P6 h  a; X
1 m& e" p" k7 u+ Z( L- a2 | 03_Part3_Low Power_HandsOn.pdf (2.95 MB, 下载次数: 256)

2017-5-17 21:17 上传

点击文件名下载附件

10_ULPBench Peripheral Demo Setup.pdf (1.06 MB, 下载次数: 141)

2017-5-17 21:17 上传

点击文件名下载附件
4 `1 N6 V# M2 r8 |, D3 v
Ecosystem.pdf (11.27 MB, 下载次数: 376)

2017-5-17 21:17 上传

点击文件名下载附件
- W9 p+ d: N- |, o6 Y& r  p* C3 D
5 v7 k  @2 o7 o' h1 P STM32_2017_Roadmap_ext.pdf (4.11 MB, 下载次数: 245)

2017-5-17 21:17 上传

点击文件名下载附件
. N4 j9 Z$ _5 Q
HandsOnPart_Low Power Doc.pdf (2.93 MB, 下载次数: 309)

2017-5-17 21:17 上传

点击文件名下载附件

2 J1 p) f9 {$ k6 [6 J# t7 W

  J+ n" H' n- ~5 d8 v
% I/ Y6 P4 M: X) w( I0 u
: E) |/ ?& c) ~5 d; ~7 V/ X, e+ w

# B6 q8 F$ Y8 E; G


1 y' r0 D! \! P4 I





4 f5 }8 {) z) G3 f9 I

xjtu2013 发表于 2018-1-9 11:04
2 w+ i2 ]5 q' P小马哥好啊，STM32L476低功耗培训的培训工程包能不能共享一下 啊，初学者，很需要详细的资料，谢谢 ...

哦，刚才终于找到资料了，不用麻烦了

小马哥好啊，STM32L476低功耗培训的培训工程包能不能共享一下 啊，初学者，很需要详细的资料，506956656@qq.com谢谢

支持下                  

谢谢小马哥的支持

谢谢分享

原来楼主是小马哥啊，谢谢分享~

wofei1314 发表于 2017-5-19 10:51
原来楼主是小马哥啊，谢谢分享~

7 [" w$ X) ~0 A& f$ a6 C' r您是哪位？

jiuwangbujiu 发表于 2017-5-19 11:06
您是哪位？

我是你的一份粉丝

wofei1314 发表于 2017-5-19 11:08
我是你的一份粉丝

' d3 F6 c$ s: b

jiuwangbujiu 发表于 2017-5-19 11:16

感谢分享！

好资料

顶马哥

select326 发表于 2017-5-24 15:23
顶马哥

谢谢支持，以后多多交流

jiuwangbujiu 发表于 2017-5-19 11:06
- B7 L. k, h2 r5 z! e  b您是哪位？

3群的网友哦！

这个具体在哪里啊
我之前在上海的时候参加过一次，现在在西安