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


+ v' C& B* \1 |7 q9 I
1 [- a" K: [) |  B        作为一个技术狗，我直接跳过ST关于产品线的介绍，直接杀入主题--基于STM32L476的低功耗设计，当然在这之前先介绍几个ST发布发布的非常好用的工具。
* Z& @0 O5 [' ^4 K5 y9 _/ |) T
3 t' R4 l3 |* H" G" W- L3 ?        一、ST MCU Finder
             这个软件我最早是在苹果软件商店发现的，下载下来觉得挺好用，所以还推荐给我群里的人了，后来又发布了安卓版本和PC桌面版（包含WINDOWS\LINUX\MAC OS）作为一个ST的忠实粉丝，我也是第一时间下载使用并推荐给群里的人。也在摩尔吧开过一次直播，和大家探讨基于ST MCU Finder 和cube MX以及keil进行产品快捷开发的课题，链接为：https://www.moore8.com/courses/1444。当然，啰嗦了这么多，还是没有给大家说说这个软件是干嘛的，我直接上图
3 C9 U7 C1 X+ S% v& _& M
上面的是图标，下面是软件打开后界面：
0 L; n0 t5 a. Q: H) g' o+ q$ b" X1 e
% O0 n" D5 u( j' j! W
            这简直就是一个选型利器啊，我们可以根据自己的需求，选择合适的检索方式，然后可以快速找到适合自己的芯片了啦。找到芯片之后还可以快速下载数据手册和其他的文档。再也不用网上到处找文档了。

       二、STM32CubeMX
            这又是一件利器，它可以方便的查看芯片的IO管脚图，时钟树等，不只是可以看，而且可以配合，是一款很好的IO分配，时钟树配置软件，而且它可以进行电源功耗计算。其实最厉害的应该是代码自动生成。

上面是STM32CubeMX的图标，下面是使用的详图：
6 p8 X7 w8 V4 g. ^# e5 x
以STM32L476 nucleo板子为例，创建一个项目

; M# w! O7 c  l5 m7 L/ m3 R
& R7 \- {& ?% F3 B$ X0 m' Z/ y具体功能大家看图，下载软件使用一下就爽翻了，我就不详细描述了。
- A5 p2 J- w& p4 P( G& c' M' ?
4 y) U$ a. ~& p; A& u        三：常用的网站及公众号：
0 O8 g7 X; ^. F& N7 d9 u, \               STM32社区：https://www.stmcu.org.cn/
               STM32中文官网：http://www.stmcu.com.cn
               STM32四轴飞行器教程：https://www.moore8.com/courses/course/1308
               公众号：STM32单片机



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

1. /* Includes ------------------------------------------------------------------*/
   8 p: ~; O: w1 @
2. #include "main.h"
   8 R! ^& y; c2 B3 H; @
3. #include "stm32l4xx_hal.h"
   2 Q7 G8 F0 _& E- N8 f+ U+ m4 \
4. 
   $ }1 W0 [$ ]+ {
5. /* USER CODE BEGIN Includes */
   
6. #include <stdio.h>
   , Z" @  e) n1 B6 _+ l* F
7. #include "string.h"
   
8. 
   
9. #ifdef __GNUC__
   # Q+ B1 I+ Z. M' g$ y/ t
10.   /* With GCC, small printf (option LD Linker->Libraries->Small printf
    2 T9 Y" {0 g; j1 D
11.      set to 'Yes') calls __io_putchar() */
    3 \2 Q/ s  Y) u. s. A
12.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    - ]" B! H- Z' P/ g! E( x
13. #else
    
14.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    
15. #endif /* __GNUC__ */
    
16. 
    # b  O1 u6 w. l; R7 p" d7 _+ z
17. /* USER CODE END Includes */
    
18. 
    
19. /* Private variables ---------------------------------------------------------*/
    9 I5 ~: L1 ~" r# w
20. UART_HandleTypeDef huart2;
    
21. 
    
22. /* USER CODE BEGIN PV */
    / f6 O. n; z- g! I% k( C
23. /* Private variables ---------------------------------------------------------*/
    
24. __IO uint8_t ReceiveStatus = 0;
    ! n3 ^: w9 n& ?# o( z
25. __IO uint16_t RxCmdCounter = 0;
    
26. __IO uint8_t ReadyToReception = 0;
    
27. __IO uint8_t CmdEnteredOk  = 0;
    ' R+ k. X/ _" y* e4 w
28. 
    
29. #define LR_ASCII_VALUE ((uint8_t)0x0A)
    / `. h1 R! Y  G
30. #define CR_ASCII_VALUE ((uint8_t)0x0D)
    & w: {* f! q" ^4 k* Q$ J
31. #define RXCOMMANDSIZE   0x20
    
32. #define RXBUFFERSIZE   0x01
    
33. 
    . q/ v8 y8 E; z! g- e! y  d
34. 
    ) n9 k6 Y& k; }# ~1 X
35. char RxCommand[RXCOMMANDSIZE];
    ; m/ o! t( W8 u5 b1 p# V3 ]
36. uint8_t RxBuffer[RXBUFFERSIZE] = {0}; //transmitting byte per byte
    
37. 
    / v$ m0 w) Z3 e& E1 f
38. char temp; //initialisation character
    
39. char * s;
    - n& q+ i4 q, \# h6 \  w4 N5 @
40. 
    
41. /* USER CODE END PV */
    
42. 
    
43. /* Private function prototypes -----------------------------------------------*/
    
44. void SystemClock_Config(void);
    
45. void Error_Handler(void);
    
46. static void MX_GPIO_Init(void);
    
47. static void MX_USART2_UART_Init(void);
    
48. 
    
49. /* USER CODE BEGIN PFP */
    
50. /* Private function prototypes -----------------------------------------------*/
    
51. void DecodeReception(void);
    
52. void LSE_OFF_Config(void);
    , k* k1 d6 T. Y9 Y: A
53. extern void test_shutdown(void);  
    $ C/ M& u$ e' G" l( o7 g6 a
54. extern void test_standby(void);
    * U& A$ \* L4 W& F7 b. e& P$ q
55. extern void test_lpsleep_2mhz(void);
    
56. extern void test_stop2(void);
    
57. /* USER CODE END PFP */
    & u; }3 u( z6 q$ h& J, R5 Z2 ^4 z
58. 
    $ y& l3 J  f) G
59. /* USER CODE BEGIN 0 */
    
60. 
    
61. /* USER CODE END 0 */
    2 L5 }! I  A8 S/ T
62. 
    1 i, O5 W; L% H# z7 R
63. int main(void)
    0 p# B2 l0 r+ f) O5 F) H  W9 e6 |
64. {
    ) r: m4 |8 ?! G  {0 h3 L" T- e
65. 
    9 i4 i! l: T0 S$ L7 Z
66.   /* USER CODE BEGIN 1 */
    
67. 
    
68.   /* USER CODE END 1 */
    ; l* ]; Q( }; _3 R( P4 v5 P
69. 
    
70.   /* MCU Configuration----------------------------------------------------------*/
    . j& o- e1 W' |) N' Z$ _) Q
71. 
      i3 W3 |) J; u9 E
72.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    : X- {4 Q: K$ U! w3 i
73.   HAL_Init();
    2 c7 z! M1 D  \4 x
74. 
    * s  i0 I! E* D% y/ g2 M6 B0 F; d: K
75.   /* Configure the system clock */
    . P( b1 D1 g3 O- n
76.   SystemClock_Config();
    ( u- |2 M- w2 z) @0 B. k
77. 
    
78.   /* Initialize all configured peripherals */
    : h$ p% _; c' U' o" q
79.   MX_GPIO_Init();
    ' l8 a' j( N- v; G5 j
80.   MX_USART2_UART_Init();
    
81. 
    # F) Z7 X. \! G( H# f
82.   /* USER CODE BEGIN 2 */
    
83. 
    
84.   HAL_Delay(1000);//delay 1s
    2 v* ^: k: ^! z, f7 ^/ F' z4 r
85. 
    
86. /* Output a message on Hyperterminal using printf function */
    $ a# M4 _$ v$ J! k5 Z$ t
87.   printf("\n\rREADY\n\r");
    
88.   printf("Please enter the test number according below options\n\r");
    
89.   printf("      0       (SHUTDOWN) \n\r");
    
90.   printf("      1       (STANDBY) \n\r");
    
91.   printf("      2       (STOP2) \n\r");
    8 k1 q; h7 D3 _) ?! }1 t9 w! D
92.   printf("      3       (LPSLEEP 2MHz         - FLASH OFF) \n\r");
    , O4 E' k3 {# l
93.   
    / a5 Q) h8 P: A  _% S
94.   printf(" --> \n\r");
    
95.   
    
96.     while (CmdEnteredOk != 0x1) {
    
97.     ReceiveStatus = 0;
    . }" r) t* O! D1 F
98.     while (ReceiveStatus != 0x1){
    7 e# I# ?" @+ z; l# y
99.       /* Start the USART2 Receive process to receive the RxBuffer */
    
100.       if(HAL_UART_Receive_IT(&huart2, RxBuffer, RXBUFFERSIZE) != HAL_OK)
     1 c; k* U' i/ a( u, b" X0 I8 @, i
101.         {
     5 N! b$ |: q& F% n
102.           Error_Handler();
     6 o& e3 F- v. j+ D+ i$ d/ G0 R
103.         }
     2 `( U& h) B8 R: a- r8 h* u* ]
104.       while (!ReadyToReception);
     7 C3 M2 l& d0 H5 _
105.       ReadyToReception = 0;
     & h! R/ ~4 n3 t0 P) ^
106.       DecodeReception();
     8 G: X* `( g/ B5 U7 ?, ]' D
107.     }
     - e1 \4 [& w2 w/ ]
108.       CmdEnteredOk = 1;
     / X8 i6 x$ f4 t$ b/ {6 V8 M
109. 
     4 k7 O2 `5 a/ @, l
110.       s = RxCommand;
     
111.    
     9 q# G" S3 Q/ {+ l+ N) B1 W8 [
112. // __EFF_NENW1NW2   __ATTRIBUTES int        strcmp(const char *, const char *);
     & @% H0 e+ p+ e% m; Y
113. // strcmp(s, "x\r") ==0, input char is x\r, it is true
     - c( I3 B4 h7 f" D
114.          
     - s* R3 F" T  l2 e) e" g2 h
115. // TODO 5: If receive char "0", enter into Shutdown mode   
     6 l5 E! i- H& C+ v' P5 T3 ~4 W
116.       
     
117.       
     
118. // TODO 6: If receive char "1", enter into Standby mode      
     ; r; R: B  f4 w, [6 q
119.       
     3 r, D& _- S/ L3 ~% f7 A
120.       
     
121. // TODO 7: If receive char "2", enter into Stop2 mode
     4 x- w  X% G; k
122.      
     # X1 N* P) u/ b1 x" D. W
123.       
     
124. // TODO 8: If receive char "3", enter into Low Power Sleep
     
125.       
     ( j" j3 S2 Y' J0 n7 r( l
126.          
     
127.       else {
     
128.          printf("Invalid test number.. Please enter again\n\r");
     
129.          CmdEnteredOk = 0;
     5 s3 ]+ C0 e2 y- S, ^" t
130.          /* Reset received test number array */
     
131.          memset(RxCommand, 0, RXCOMMANDSIZE);
     9 w% T1 ?: U8 o6 C
132.        }
     3 J# y" u0 |  e6 D4 }. R6 I; b
133.       
     
134.     }
     1 T8 d) l7 q1 W' |/ f
135.   
     ! V1 b6 {5 v; ?' F  ~" Z5 x
136.   /* USER CODE END 2 */
     
137. 
     
138.   /* Infinite loop */
     
139.   /* USER CODE BEGIN WHILE */
     
140.   while (1)
     ) K* Q1 [6 H3 C4 J7 @/ O4 Z
141.   {
     6 P5 v: o' o7 t3 c5 ^" l
142.   /* USER CODE END WHILE */
     1 [6 D2 j3 E8 h
143. 
     ! h1 B0 L  n2 [. h
144.   /* USER CODE BEGIN 3 */
     ) ]: }1 z- O! v0 _; m
145. 
     ( {9 S# g: z/ U/ W
146.   }
     
147.   /* USER CODE END 3 */
     . U1 `% L) v, u' g
148. 
     ) n2 b' _# ?: H$ g
149. }
     7 e0 o) X. }( }0 ?
150. 
     
151. /** System Clock Configuration
     ( m! C; ]& a% B0 ^( x
152. */
     
153. void SystemClock_Config(void)
     
154. {
     . Y' \1 y7 [$ g5 |: Y# ~
155. 
     
156.   RCC_OscInitTypeDef RCC_OscInitStruct;
     
157.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
     
158.   RCC_PeriphCLKInitTypeDef PeriphClkInit;
     
159. 
     
160.     /**Initializes the CPU, AHB and APB busses clocks
     / L3 _( m4 y( F, Y
161.     */
     
162.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
     * K. z& `% [# n2 b; \: ]6 s
163.   RCC_OscInitStruct.MSIState = RCC_MSI_ON;
     
164.   RCC_OscInitStruct.MSICalibrationValue = 0;
     
165.   RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6;
     
166.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     
167.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     $ w: z$ q; r9 g
168.   {
     : u4 Y5 L- A+ @
169.     Error_Handler();
     
170.   }
     
171. 
     / X* Y! J8 U9 y4 ~/ V
172.     /**Initializes the CPU, AHB and APB busses clocks
     % v# G5 c: K( I: O1 ^' [
173.     */
     
174.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
     
175.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
     # P' R9 E8 E+ ~
176.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
     $ \. c" S6 z( r6 A
177.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
178.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     : \  m* O; b/ [5 a
179.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     
180. 
     
181.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     
182.   {
     0 z( g2 S7 i; N7 i% y, ~0 r
183.     Error_Handler();
       {6 _" h9 t& N) G9 m
184.   }
     6 M0 o& f; O& U" K, _8 T
185. 
     
186.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
     % @4 y: v/ ], w8 t  w3 O) l
187.   PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
       [  Z( i+ u; x8 I5 B
188.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
     
189.   {
     
190.     Error_Handler();
     6 m; c# [$ \. {7 m  k1 Y
191.   }
     / j1 v; q9 w9 }0 Q% ?3 F
192. 
     
193.     /**Configure the main internal regulator output voltage
     
194.     */
     7 \; I/ o# k" S* U5 X
195.   if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
     
196.   {
     " F3 X7 [$ \( o$ t9 m9 G
197.     Error_Handler();
     
198.   }
     4 \( m, M. h( i0 b& P6 ~+ t8 @
199. 
     % ]  a4 ]" M0 [( k( m% c% W2 @
200.     /**Configure the Systick interrupt time
     
201.     */
     6 y4 ]: d* k% Q/ b; f
202.   HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
     6 r, i' }( z: y. }; @% x6 O; T
203. 
     
204.     /**Configure the Systick
     
205.     */
     
206.   HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     
207. 
     ) ^, ]  n' f% f1 M
208.   /* SysTick_IRQn interrupt configuration */
     / R7 Q; N+ _; o8 t7 l
209.   HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
     + k4 m/ {) \$ `
210. }
     
211. 
     3 v0 p: h, F7 O. ~
212. /* USART2 init function */
     8 J: H7 s5 z$ `6 ?" Z3 p
213. static void MX_USART2_UART_Init(void)
     
214. {
     - @2 f  r0 ?: U' d; F
215. 
     # o: q9 I" T2 A+ _3 R8 r
216.   huart2.Instance = USART2;
     
217.   huart2.Init.BaudRate = 9600;
     7 d5 ]! L$ Z: y9 S# l0 V4 d
218.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
     ' a8 \* ]0 _- K
219.   huart2.Init.StopBits = UART_STOPBITS_1;
     , |2 C& z: U: @; q
220.   huart2.Init.Parity = UART_PARITY_NONE;
     
221.   huart2.Init.Mode = UART_MODE_TX_RX;
     ' \; n1 B$ d0 {
222.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     
223.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
     
224.   huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
     1 A1 J( h+ k1 P) D) N
225.   huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
     
226.   if (HAL_UART_Init(&huart2) != HAL_OK)
     ; f; w5 s. F: r0 A' Q4 b
227.   {
     
228.     Error_Handler();
     
229.   }
     9 x* d! l6 O9 U$ l
230. 
     $ G) w' b$ f- x* }
231. }
     
232. 
     
233. /** Configure pins as
     ' H8 Q; d* |9 M4 X9 E/ J1 B
234.         * Analog
     
235.         * Input
     
236.         * Output
     
237.         * EVENT_OUT
     
238.         * EXTI
     8 }9 A) d6 {% p  S  T* W$ ?" V
239. */
     
240. static void MX_GPIO_Init(void)
     
241. {
     7 G. i% I& a. k" L3 p( ~
242. 
     
243.   GPIO_InitTypeDef GPIO_InitStruct;
     
244. 
     
245.   /* GPIO Ports Clock Enable */
     
246.   __HAL_RCC_GPIOC_CLK_ENABLE();
     8 E" \  N( ^- e; A8 x. ?0 o  G( t+ ]
247.   __HAL_RCC_GPIOH_CLK_ENABLE();
     5 F" {! t1 z! P* v7 U
248.   __HAL_RCC_GPIOA_CLK_ENABLE();
     
249.   __HAL_RCC_GPIOB_CLK_ENABLE();
     
250. 
     
251.   /*Configure GPIO pin : PC13 */
     ' ?4 w) z! Q- h$ p' e
252.   GPIO_InitStruct.Pin = GPIO_PIN_13;
       W. s- D  W% Q9 e
253.   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
     $ X8 s  n( ^+ @0 U# G
254.   GPIO_InitStruct.Pull = GPIO_NOPULL;
     . X  T& ]1 n( `8 p$ X/ I0 u3 V: w
255.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     
256. 
     ; v4 i7 O8 U( b
257. }
     / w8 v; V  [) ?5 {$ k
258. 
     
259. /* USER CODE BEGIN 4 */
     8 P2 l, q: V" ~% w, b0 l( D/ x
260. 
     
261. PUTCHAR_PROTOTYPE
     5 ^/ n) T5 D* Q7 |
262. {
     / ]) @: E& ?6 c% [
263.   /* Place your implementation of fputc here */
     * r% H6 C% y! s/ g3 j+ U% ~9 b
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);
     ! ?6 [; x2 u- w0 G: E
266. 
     , X% A) Y+ M( B, d
267.   return ch;
     ' z. S. @' w! R  `- g6 K% I
268. }
     
269. 
     
270. void DecodeReception(void)
     & |' h$ A" H) |% G
271. {
     
272.   /* Read one byte from the receive data register */
     * G6 `- Z: S, D- A
273.   temp = (char) RxBuffer[0];
     ) b8 o3 _: A8 O
274.   RxCommand[RxCmdCounter++] = temp;
     
275. 
     ) f( V- l; [$ N& f- {  p* X
276.   /* Check if is an LR/CR character */
     2 _( @% h7 ?- m- e7 z
277.   if ((temp == CR_ASCII_VALUE) || (temp == LR_ASCII_VALUE))
     " |3 x6 p# B0 K! [  j9 X
278.   {
     ) L7 P  X! L7 a
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;
     * Q- y$ a7 H' R- L  F
285.      
     
286.     ReceiveStatus = 1;
     # x5 r0 v* K9 l1 U/ s9 k, `! `
287.   }
     ' v, q7 g% Q& R1 y2 D) q
288. }
     / b0 d. x9 \- r) r8 J8 X, V8 [
289. 
     
290. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     
291. {
     & s& x4 [8 z5 b6 \
292.      ReadyToReception = 1;
     # C1 `& c3 e) u6 L
293. }
     
294. 
     0 K- M) a* I6 i
295. void SystemClock_2MHz(void)
     
296. {
     
297.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
     
298.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     2 {/ T) Q& h' X. I' l! ]
299. 
     
300.   /* MSI is enabled after System reset, update MSI to 2Mhz (RCC_MSIRANGE_5) */
     + w. W- }" T* @# d: _1 N. H
301.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
     2 G" ^; R; p; H1 t4 P1 s
302.   RCC_OscInitStruct.MSIState = RCC_MSI_ON;
     6 `# S7 Y& v$ k0 }
303.   RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_5;
     
304.   RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
     
305.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     6 W8 ^) g- o& u3 k: n' @
306.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     ( x  b' o, {3 Z" d2 W8 `
307.   {
     5 A1 y& `. J  @& c
308.     /* Initialization Error */
     
309.     Error_Handler();
     
310.   }
     % _8 q& U2 A  |) z! z
311.   
     3 b, @8 K, \/ e/ K
312.   /* Select MSI as system clock source and configure the HCLK, PCLK1 and PCLK2
     
313.      clocks dividers */
     
314.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;
     
315.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
     
316.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
317.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;  
     - H( t- R- P6 x" _4 z
318.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     
319.   if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     
320.   {
     
321.     /* Initialization Error */
     / v/ u5 E' f" s3 `
322.     Error_Handler();
     9 h, X2 \+ \: e8 |
323.   }
     
324.   
     
325. }
     7 V3 E% l5 d6 N4 ]* t
326. 
     
327. void GPIO_AnalogState_Config(void)
     ( t8 s7 {( S+ \* D
328. {
     
329.   GPIO_InitTypeDef GPIO_InitStruct;
     " r9 r" Z0 s* u( Q$ _$ k# E
330.   
     ) l! p8 f7 a+ x6 I7 ~4 C7 s
331.   /* Set all GPIO in analog state to reduce power consumption, */
     ' ^4 A  O, D' ?% m, [
332.         
     4 [& t. y% F' @5 c6 n$ j; E1 e
333.     __HAL_RCC_GPIOA_CLK_ENABLE();
     
334.     __HAL_RCC_GPIOB_CLK_ENABLE();
     3 `2 }6 c! b+ d- Z
335.     __HAL_RCC_GPIOC_CLK_ENABLE();
     : h' A2 }& I0 w
336.     __HAL_RCC_GPIOD_CLK_ENABLE();
     ; r0 h2 |8 b8 r4 V, u  ?
337.     __HAL_RCC_GPIOE_CLK_ENABLE();
     ( C, x/ U+ U8 P- |! `. Z  \
338.     __HAL_RCC_GPIOF_CLK_ENABLE();
     ) Q, ]3 w+ B  \( E" t8 L
339.     __HAL_RCC_GPIOG_CLK_ENABLE();
     + [5 J7 Q1 K" O% T* G3 t
340.     __HAL_RCC_GPIOH_CLK_ENABLE();   
     1 ]5 J$ y- U2 N' B9 a+ [: R  s1 v
341. 
     
342.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     
343.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     
344.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     ( Z+ h! l5 L3 @( e0 ]
345.     GPIO_InitStruct.Pin = GPIO_PIN_All;
     + I2 _& ~- A: ^; U3 l2 T. d1 y& v
346. 
     * {8 P8 D! f5 z) w5 x2 p4 N
347.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
348.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
     
349.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     * p' U4 O8 ^" R
350.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
     
351.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
     
352.     HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
     
353.     HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
     1 t( U( `! ^' x$ s
354.     HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);  
     
355. 
     
356.     __HAL_RCC_GPIOA_CLK_DISABLE();
     8 }) ]/ E/ r' ~( B" a/ {' v% ?
357.     __HAL_RCC_GPIOB_CLK_DISABLE();
     0 d: Q3 T" K( ~$ O4 T9 D* s- z" _: W
358.     __HAL_RCC_GPIOC_CLK_DISABLE();
     % ^: v8 s1 j. P. i2 ?$ z1 X1 }
359.     __HAL_RCC_GPIOD_CLK_DISABLE();
     
360.     __HAL_RCC_GPIOE_CLK_DISABLE();
     
361.     __HAL_RCC_GPIOF_CLK_DISABLE();
     
362.     __HAL_RCC_GPIOG_CLK_DISABLE();
     
363.     __HAL_RCC_GPIOH_CLK_DISABLE();
     & c) r: [! G# r1 p. }
364. 
     
365. }
     
366. 
     
367. void LSE_OFF_Config(void)
     
368. {
       a) j5 m3 p; ?9 K
369.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     
370. 
     
371.   /* set LSE OFF */
     5 ?7 ^% z0 r% o1 f& e) Q
372.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
     6 i+ y2 F% A* ~' t9 r% V
373.   RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
     ( x% m+ x; n8 R/ h, O5 N2 f! t% _
374.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
375.   {
     " O5 a2 U( J" J! q6 R
376.     /* Initialization Error */
     
377.     Error_Handler();
     3 ], u( Q7 X4 @3 y5 a
378.   }
     ) P4 c$ e% [0 g) C( w) J7 Q
379. 
     / J9 _& g6 t2 W
380. }
     
381. 
     
382. 
     " B+ P. j8 F4 u5 Z* c9 P
383. // TODO 1: Enter into Shutdown mode
     
384. 
       p* K# o' J+ H* ]
385. 
     
386. // TODO 2: Enter into Standby mode
     
387. 
     
388. 
     
389. // TODO 3: Enter into Stop2 mode
     / v/ C$ a+ m0 M1 Z  @
390. 
     & k8 i/ F0 N" B  N- H, A  g) K
391. 
     9 {0 U( b5 D- e8 w7 l( M) _2 ~
392. // TODO 4: Enter into Low Power Sleep mode
     . }. o9 c3 v7 L! ]3 C2 C- U
393. 
     * s2 ]' n) d' {" ^
394. 
     
395. 
     
396. /* USER CODE END 4 */
     
397. 
     2 F+ L& c; u4 A+ R8 n
398. /**
     . O( _+ G. p# |( r! {
399.   * @brief  This function is executed in case of error occurrence.
     
400.   * @param  None
     % i. ?% t4 w* ~" y( ?
401.   * @retval None
     
402.   */
     ; Z* U' ?4 `0 {
403. void Error_Handler(void)
     9 L' e+ E6 }0 F7 M3 b
404. {
     
405.   /* USER CODE BEGIN Error_Handler */
     3 D- ^6 ^, k" n8 B2 f, C
406.   /* User can add his own implementation to report the HAL error return state */
     
407.   while(1)
     7 R! l$ U  ~# I; G$ i
408.   {
     3 d' t* |/ ]8 @: E! S; x5 C
409.   }
     * ?  w  m% T0 [7 _
410.   /* USER CODE END Error_Handler */
     
411. }
     4 G7 X/ w3 o+ H' j
412. 
     ( B6 z4 i- i/ q5 g3 [0 S% K
413. #ifdef USE_FULL_ASSERT
     
414. 
     ; G  @0 ^0 j! k, V3 X$ O5 V
415. /**
     . H9 V2 r% J  S
416.    * @brief Reports the name of the source file and the source line number
     
417.    * where the assert_param error has occurred.
     . x6 {. P& Z8 u6 Y( ?0 X/ Q2 v
418.    * @param file: pointer to the source file name
     5 ]7 Y% U7 T3 U- S+ g
419.    * @param line: assert_param error line source number
     
420.    * @retval None
     
421.    */
     " w* @( T- _  Q+ T
422. void assert_failed(uint8_t* file, uint32_t line)
     
423. {
     
424.   /* USER CODE BEGIN 6 */
     
425.   /* User can add his own implementation to report the file name and line number,
     3 w- w3 s! y' a3 T" r& a$ v
426.     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
427.   /* USER CODE END 6 */
     8 T( U( d7 A  z5 B3 z9 ^
428. 
     
429. }
     / f) k. n% c& a
430. 
     & y3 x& u/ g' i5 }. m5 u
431. #endif
     
432. 
     / f' a9 c" [9 ~% K1 |; ^
433. /**
     # b0 q9 [# s( L% d4 ?6 _' l
434.   * @}
     
435.   */
     
436. 
     3 b( j! H  {+ T; G# e
437. /**
     7 ~( W' B7 B9 x, {- p4 n0 j: j0 Q
438.   * @}
     
439. */
     
440. 
     8 A5 |1 \& Y& |+ L) a5 C
441. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
     5 t( g' v# {% [! P+ h, d( m+ B5 W

复制代码

上面是修改之前的代码。
% j5 k" h# j+ y; g* G9 ?' y1 x我自己测试的结果是（图上红色的数字是我的测试结果，与理论值基本吻合）：
6 I% d  L+ i( j2 q

大家也可以根据帖子里共享的ppt思考一下补全代码。

总之昨天学到了以下东西：
1、知道了设计低功耗产品时，硬件层面和软件层面各应该注意什么
2、能够使用CUBE MX配置工程并生成项目代码
$ w2 B3 R% ]$ J; k: `: s! O3、计算理论功耗，测量实际功耗并对比

收获满满的一天，下面把学习的资料分享给大家：



4 n% f' D3 A8 t 00_Part0_20170516_Xi'an_MassMarket_Begin.pdf (1.22 MB, 下载次数: 193)

2017-5-17 21:15 上传

点击文件名下载附件
. P8 D( e0 d) J4 Z; @4 p: }
( x; [! A6 ~7 C, c0 S
, L. Y+ L8 |6 P# n1 d( Z 01_Part1_STM32L高性能低功耗实战设计.pdf (5.34 MB, 下载次数: 345)

2017-5-17 21:16 上传

点击文件名下载附件
, ?5 ^: @" k) h; {# T8 T
5 u* M5 P- `/ t- Q 02_Part2_STM32L实战案例分析_update.pdf (1.07 MB, 下载次数: 271)

2017-5-17 21:16 上传

点击文件名下载附件
# v) }  ~, p" t- j& ]. Y3 j
0 B- ~, V: E  t6 y( P 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 上传

点击文件名下载附件

Ecosystem.pdf (11.27 MB, 下载次数: 376)

2017-5-17 21:17 上传

点击文件名下载附件
, ]6 u; y- h% C+ s
0 D! @& p$ X2 n: |( p2 j STM32_2017_Roadmap_ext.pdf (4.11 MB, 下载次数: 245)

2017-5-17 21:17 上传

点击文件名下载附件

HandsOnPart_Low Power Doc.pdf (2.93 MB, 下载次数: 309)

2017-5-17 21:17 上传

点击文件名下载附件

9 t% T% v- R7 Z) t) s% z0 H


# \  b! L# L/ X9 B  e. T

+ @: Z, x* \* B" F. b
0 T) J3 ]& f9 {# [

; Y, `8 x6 M8 j8 Q8 k$ c
8 ?& @; j7 Y1 P( A0 \
4 \3 e$ v7 ?" w; p+ F
4 C& G0 ]/ |- Z1 J6 Y, C. B  Y
7 }/ L* ?" j4 {' g
( a" R5 y6 q0 o& Z; z
% ?2 T8 t# L) ]- r

$ `3 u, D* g4 x; ^, X

xjtu2013 发表于 2018-1-9 11:04
, v# y) E4 f' Q小马哥好啊，STM32L476低功耗培训的培训工程包能不能共享一下 啊，初学者，很需要详细的资料，谢谢 ...

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

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

支持下                  

谢谢小马哥的支持

谢谢分享

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

wofei1314 发表于 2017-5-19 10:51
$ {* p  Y6 [. t& r: O' Q  N原来楼主是小马哥啊，谢谢分享~

您是哪位？

jiuwangbujiu 发表于 2017-5-19 11:06
% |; D5 s. m# u您是哪位？

我是你的一份粉丝

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

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

感谢分享！

好资料

顶马哥

select326 发表于 2017-5-24 15:23
& D' s! I+ i! b0 |2 ~顶马哥

谢谢支持，以后多多交流

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

5 y+ k: T9 I3 g1 ]; v3群的网友哦！

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