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




        作为一个技术狗，我直接跳过ST关于产品线的介绍，直接杀入主题--基于STM32L476的低功耗设计，当然在这之前先介绍几个ST发布发布的非常好用的工具。

        一、ST MCU Finder
' K; k" A: T1 {  Y2 }) r             这个软件我最早是在苹果软件商店发现的，下载下来觉得挺好用，所以还推荐给我群里的人了，后来又发布了安卓版本和PC桌面版（包含WINDOWS\LINUX\MAC OS）作为一个ST的忠实粉丝，我也是第一时间下载使用并推荐给群里的人。也在摩尔吧开过一次直播，和大家探讨基于ST MCU Finder 和cube MX以及keil进行产品快捷开发的课题，链接为：https://www.moore8.com/courses/1444。当然，啰嗦了这么多，还是没有给大家说说这个软件是干嘛的，我直接上图

1 F2 J( M( u" a6 t. o5 w- t上面的是图标，下面是软件打开后界面：

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

       二、STM32CubeMX
0 ^8 |9 X$ z! _% n& }            这又是一件利器，它可以方便的查看芯片的IO管脚图，时钟树等，不只是可以看，而且可以配合，是一款很好的IO分配，时钟树配置软件，而且它可以进行电源功耗计算。其实最厉害的应该是代码自动生成。
7 U. S- T  t) n0 E
上面是STM32CubeMX的图标，下面是使用的详图：
; O4 T6 D: q  n5 g) p  s$ `
以STM32L476 nucleo板子为例，创建一个项目

8 e% N$ B% U- A8 N
具体功能大家看图，下载软件使用一下就爽翻了，我就不详细描述了。
/ E0 W) {: u' ?3 A9 ~
        三：常用的网站及公众号：
               STM32社区：https://www.stmcu.org.cn/
               STM32中文官网：http://www.stmcu.com.cn
               STM32四轴飞行器教程：https://www.moore8.com/courses/course/1308
8 t& u1 q  S9 k( s4 J0 D& d               公众号：STM32单片机

# w) G7 P: d+ F) }7 t

        安利完上面两个软件，开始正式总结回忆低功耗课程的内容：
        1、在低功耗案例分享中学习到的东西有以下几点：
              #、影响低功耗设计的几个因素：
: Y* z$ y7 }1 P% y/ b5 G                      *芯片的工艺和制程：不同的制程芯片内部晶体管的开关功耗不同，导致整个芯片功耗不同
                      *晶体管数量不同：这个是显而易见的一个因素
6 c9 y" c' T9 ]                      *模拟外设的使用：模拟外设相对耗电量比较大
                      *RAM与Falsh大小：不同的存储容量耗电也不一样，存储功耗近似和存储空间大小成正比
9 H4 B: }7 I) G                      *MCU供电特性：提供的电压越低，功耗也就越低，但是此时频率也越低，和电脑超频耗电量大一个道理
5 |6 H7 R, g4 R* q! c% \0 r$ x                      *时钟频率：时钟频率越高，耗电量越大
                      *工作模式：不同的工作模式耗电量不同，这个是显而易见的
              #、功耗分为静态功耗和动态功耗，动态功耗与电压、频率、负载等关系相关
$ I2 r* G2 ^: ^( P8 E; q              #、L4系列独有的电压转换器，可调时钟源，SMPS等.
& v9 y  d; Y1 U' l+ t              #、外设和GPIO连接的时候，如果两端电压不一致，就会导致电流产生，从而消耗功耗，所以要仔细阅读外设手册并进行合理配置
              #、IIC等外设的管脚必须外加强上拉，在进入低功耗之前把IIC的管脚设置为上拉输入模式
, W- `5 q9 t! x2 J0 W* |              #、中断标识未清除也可能导致功耗上升
              #、虚焊等其他情况也可能导致功耗异常
              #、在数据传输未结束的时候，尽量不要切换到低功耗模式，可能会失败
" _9 V8 w; [  }- P) T% g* D! \0 o              #、使用低功耗串口唤醒系统的时候，如果串口波特率太高可能导致前面的数据丢失
              #、一些特殊场景可以考虑把代码优先级修改为速度优先，用空间换时间
, k+ D" t! n4 l: L% o8 C        2、HandsOn环节的实验学习（具体实验安排我就不说了，请参考ppt）：
              代码如下：
5 S1 a9 E: K" \2 D. I* R

1. /* Includes ------------------------------------------------------------------*/
   
2. #include "main.h"
   2 P1 V8 {9 Y) w* b! i
3. #include "stm32l4xx_hal.h"
   
4. 
   0 I2 p& A7 U1 ?& x( A4 ]5 g1 B$ ?6 A
5. /* USER CODE BEGIN Includes */
   
6. #include <stdio.h>
   2 t. C# I6 Y* f5 \/ B' N0 S
7. #include "string.h"
   " O8 J9 |: i* B4 `* _
8. 
   
9. #ifdef __GNUC__
   3 U6 ]# e3 r7 l3 p6 ~6 w( w
10.   /* With GCC, small printf (option LD Linker->Libraries->Small printf
    
11.      set to 'Yes') calls __io_putchar() */
    9 s# i7 U( u3 F6 b( E, B( X
12.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    4 v# J1 A; m0 c9 ~4 B
13. #else
    ' t4 d8 N' d  U/ e
14.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    
15. #endif /* __GNUC__ */
    
16. 
    / o( w" s# ~! ?; P9 s! p+ n
17. /* USER CODE END Includes */
    
18. 
    * l! d8 C  t0 g2 Q# l
19. /* Private variables ---------------------------------------------------------*/
    
20. UART_HandleTypeDef huart2;
    
21. 
    
22. /* USER CODE BEGIN PV */
    3 Q( c. ]! d8 L
23. /* Private variables ---------------------------------------------------------*/
    
24. __IO uint8_t ReceiveStatus = 0;
    
25. __IO uint16_t RxCmdCounter = 0;
    6 w, T  ^( Q8 P  V( h
26. __IO uint8_t ReadyToReception = 0;
    
27. __IO uint8_t CmdEnteredOk  = 0;
    
28. 
      \! g8 K# N* O/ x
29. #define LR_ASCII_VALUE ((uint8_t)0x0A)
    
30. #define CR_ASCII_VALUE ((uint8_t)0x0D)
    
31. #define RXCOMMANDSIZE   0x20
    6 s8 S7 X3 a) }  ~
32. #define RXBUFFERSIZE   0x01
    
33. 
    
34. 
    " E$ ~* K6 B% k
35. char RxCommand[RXCOMMANDSIZE];
    
36. uint8_t RxBuffer[RXBUFFERSIZE] = {0}; //transmitting byte per byte
      g0 F+ U2 ^, s' Z3 i& E4 \
37. 
    ( z0 E, N4 W( ~0 P1 E) _6 k+ W
38. char temp; //initialisation character
    
39. char * s;
    
40. 
    $ G2 X( `0 S1 w9 O& A3 n1 P
41. /* USER CODE END PV */
    
42. 
    
43. /* Private function prototypes -----------------------------------------------*/
    
44. void SystemClock_Config(void);
    
45. void Error_Handler(void);
    - Z0 B( d0 {% r& l. C4 `/ Z$ f
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 -----------------------------------------------*/
    7 M! m) L2 v% K, Y$ h
51. void DecodeReception(void);
    
52. void LSE_OFF_Config(void);
    . k( ^4 z5 }* \4 ^0 e
53. extern void test_shutdown(void);  
    4 ~" _# z% |$ C2 y- |5 s# ^+ j
54. extern void test_standby(void);
    0 m* i/ T) |; l6 r8 z2 u
55. extern void test_lpsleep_2mhz(void);
    
56. extern void test_stop2(void);
    7 I6 r/ W- ?# |( C# |1 i
57. /* USER CODE END PFP */
    
58. 
    
59. /* USER CODE BEGIN 0 */
    4 ?* {! P+ @% Z" _9 ]
60. 
    
61. /* USER CODE END 0 */
    
62. 
    
63. int main(void)
    
64. {
    
65. 
    5 ]" h  Y4 {4 o+ G5 ?
66.   /* USER CODE BEGIN 1 */
    
67. 
    " i" k! j% W: {# W
68.   /* USER CODE END 1 */
    
69. 
      _* H' \) W! }0 C  M9 y; R
70.   /* MCU Configuration----------------------------------------------------------*/
    
71. 
    
72.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    2 Q2 w, @2 U- m& |- z
73.   HAL_Init();
    : S. k% e. E* M+ p5 e) M
74. 
    9 a7 `1 U0 r( U+ j8 h
75.   /* Configure the system clock */
    4 \6 D5 e' X' i5 g
76.   SystemClock_Config();
    
77. 
    3 L; t  U7 I& H4 S
78.   /* Initialize all configured peripherals */
    
79.   MX_GPIO_Init();
    / c1 |5 v/ |3 z( c8 h) d
80.   MX_USART2_UART_Init();
    ) Q4 H3 ]$ d7 W  ^6 W# g
81. 
    
82.   /* USER CODE BEGIN 2 */
    ( L$ T$ b; A6 s$ ?& i
83. 
    8 q# d; v& }  O
84.   HAL_Delay(1000);//delay 1s
    ( C! |( s0 }  {$ r/ F3 N6 g' i
85. 
    
86. /* Output a message on Hyperterminal using printf function */
    ' _! z* @) i7 r) {4 [% Q0 w
87.   printf("\n\rREADY\n\r");
    
88.   printf("Please enter the test number according below options\n\r");
    
89.   printf("      0       (SHUTDOWN) \n\r");
    : @* N0 t3 e& w, c' t1 y
90.   printf("      1       (STANDBY) \n\r");
    
91.   printf("      2       (STOP2) \n\r");
    2 @3 J: D0 W- w' v# A7 A! T/ |6 s! i
92.   printf("      3       (LPSLEEP 2MHz         - FLASH OFF) \n\r");
    
93.   
    * m1 j6 G3 h1 ~: D% l8 m
94.   printf(" --> \n\r");
    7 [0 O3 {$ j0 u
95.   
    
96.     while (CmdEnteredOk != 0x1) {
    . \7 i9 v+ u9 h/ _7 `$ _1 `
97.     ReceiveStatus = 0;
    3 {! j9 {  P* p' f# w
98.     while (ReceiveStatus != 0x1){
    
99.       /* Start the USART2 Receive process to receive the RxBuffer */
    
100.       if(HAL_UART_Receive_IT(&huart2, RxBuffer, RXBUFFERSIZE) != HAL_OK)
     
101.         {
       I1 z8 g6 F) p# U- \, r5 j  S
102.           Error_Handler();
     5 y1 w1 I3 d( d( b
103.         }
     ' ~* Y, y/ Q: F: S' J# N- B2 K
104.       while (!ReadyToReception);
     
105.       ReadyToReception = 0;
     ' e) {$ c$ x% m0 G; |7 C
106.       DecodeReception();
     
107.     }
     * Q4 k3 d! T7 i) _1 h: |! V
108.       CmdEnteredOk = 1;
     ! _6 O! i: ]' Y" p0 R
109. 
     6 ]0 z3 |9 g0 v. S) X! f
110.       s = RxCommand;
     
111.    
     ! K$ y. T. }4 U. Q4 o
112. // __EFF_NENW1NW2   __ATTRIBUTES int        strcmp(const char *, const char *);
     
113. // strcmp(s, "x\r") ==0, input char is x\r, it is true
     
114.          
     
115. // TODO 5: If receive char "0", enter into Shutdown mode   
     / y/ g  F$ S9 z8 l
116.       
     
117.       
     ! c+ a0 P, j1 F$ z& _
118. // TODO 6: If receive char "1", enter into Standby mode      
     
119.       
     
120.       
     
121. // TODO 7: If receive char "2", enter into Stop2 mode
     
122.      
     8 r: j9 K' U  W8 D( `' `/ N8 r9 i
123.       
     $ e! R6 E6 [0 v7 \. Z( a' n/ K
124. // TODO 8: If receive char "3", enter into Low Power Sleep
     : O0 e1 I/ c( C8 w
125.       
     " t0 i5 l- K4 E( K' q" E
126.          
     
127.       else {
     
128.          printf("Invalid test number.. Please enter again\n\r");
     
129.          CmdEnteredOk = 0;
     
130.          /* Reset received test number array */
     0 V  K7 h3 y4 {6 I5 J* F2 Z
131.          memset(RxCommand, 0, RXCOMMANDSIZE);
     ! C4 D6 _+ ~8 V8 t, J; P
132.        }
     
133.       
     
134.     }
     
135.   
     4 g- K+ i2 @. W; H4 I. @: T
136.   /* USER CODE END 2 */
     9 z  b* x* ^7 ?) y! f* j+ _* R
137. 
     
138.   /* Infinite loop */
     
139.   /* USER CODE BEGIN WHILE */
     # ?; h& I! y  S: k* M# K) q
140.   while (1)
     
141.   {
     
142.   /* USER CODE END WHILE */
       p& P; R4 Z0 K/ ^
143. 
     # i4 s' v+ _9 n1 q* M3 E
144.   /* USER CODE BEGIN 3 */
     9 P/ N% O9 F$ S
145. 
     . _  \; \4 k2 W
146.   }
     * m5 h5 O) a9 p5 k2 I- F( e; M9 M
147.   /* USER CODE END 3 */
     ; V: O" t, j* z* A/ c% I1 Z& L
148. 
     
149. }
     # t$ H0 s  h, c3 A1 D, F
150. 
     ) n( b0 t! Q. ]
151. /** System Clock Configuration
     
152. */
     7 X( T( R/ k6 ~* ^9 {0 f7 G  B
153. void SystemClock_Config(void)
     % p9 d- U# h/ O% e: B/ Z- F
154. {
     
155. 
     
156.   RCC_OscInitTypeDef RCC_OscInitStruct;
     
157.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
     5 w* k( X( I4 n: m7 v
158.   RCC_PeriphCLKInitTypeDef PeriphClkInit;
     
159. 
     0 T6 e, b' u" i+ V9 L& i( T! L7 f& r
160.     /**Initializes the CPU, AHB and APB busses clocks
     
161.     */
     : `7 N" M2 X5 ?; S- \, C7 P
162.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
     
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;
     9 R" m* V& M3 z, v8 N3 h  l: R$ D
167.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
168.   {
     
169.     Error_Handler();
     
170.   }
     % N" b* T$ E# L% [6 E
171. 
     
172.     /**Initializes the CPU, AHB and APB busses clocks
     
173.     */
     $ a! j" N8 S) t( |9 k
174.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
     3 ~$ g5 h3 _7 V8 E0 _; j8 P
175.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
     
176.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
     # C, q! _! U, a& u3 }( j
177.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     : ]* M) ~% f9 T
178.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     $ s8 V  Y4 ^% z" M
179.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     5 w  m/ a9 `# {$ m# h7 L% ^
180. 
     $ W& O* @2 {% H+ O! P% k
181.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     
182.   {
     + C/ f" p: W8 o& s  S& t- q2 d9 L
183.     Error_Handler();
     
184.   }
     
185. 
     
186.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
     8 `8 Q' `+ x) j! C) @3 y
187.   PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
     
188.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
     
189.   {
     9 m/ i$ b+ e. U( P
190.     Error_Handler();
     2 h$ x1 \: }1 \5 x4 i1 n# `
191.   }
     ( c# j3 b9 q7 a
192. 
     ( _0 q3 O! z/ G, F
193.     /**Configure the main internal regulator output voltage
     $ t7 p5 a" T* j' i- f4 [, B) @( p: a+ Y
194.     */
     
195.   if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
     
196.   {
     
197.     Error_Handler();
     
198.   }
     ' g: k! v5 Z- Z" F9 A' q: g0 a
199. 
       p; T$ g* ]1 N* g: J
200.     /**Configure the Systick interrupt time
     
201.     */
     
202.   HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
     
203. 
     2 x/ }% M2 q( F
204.     /**Configure the Systick
     6 z: ?0 [/ s( H$ ?
205.     */
     
206.   HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     
207. 
     0 j* H% [& W" r" W+ @  i1 J+ V. Y. G
208.   /* SysTick_IRQn interrupt configuration */
     * x) M+ Z' y; L) b, J
209.   HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
     5 _. v/ {; U6 p- t3 O2 w) i( n+ C7 @' Z
210. }
     
211. 
     ( {# A5 S. x, x) ]
212. /* USART2 init function */
     " z' q7 i- ^" `
213. static void MX_USART2_UART_Init(void)
     ( d2 S4 H5 o& W) u/ q
214. {
     9 l. T9 l- }) ?
215. 
     
216.   huart2.Instance = USART2;
     . e+ V! q7 D, N  t- c) e9 M
217.   huart2.Init.BaudRate = 9600;
     ; b% ]2 y; ?8 T- J
218.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
     
219.   huart2.Init.StopBits = UART_STOPBITS_1;
     
220.   huart2.Init.Parity = UART_PARITY_NONE;
     - Y! |7 o7 N3 a* l# c
221.   huart2.Init.Mode = UART_MODE_TX_RX;
     5 N' H! X/ q! k4 U, n
222.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     
223.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
     9 @2 Q% X  {: ^! |! \, u
224.   huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
     6 E" S' d1 r% Z7 ?$ t5 d
225.   huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
     
226.   if (HAL_UART_Init(&huart2) != HAL_OK)
     % K3 K/ f, `7 i% W
227.   {
     
228.     Error_Handler();
     8 G% U9 C: e" }
229.   }
     
230. 
     ) u/ j* I3 F1 a( H& r( w6 |
231. }
     : C3 N5 @- M  U. i
232. 
     
233. /** Configure pins as
     
234.         * Analog
     
235.         * Input
     
236.         * Output
     
237.         * EVENT_OUT
     & P( Y6 _  `3 J1 H9 u+ d) J# v
238.         * EXTI
     
239. */
     
240. static void MX_GPIO_Init(void)
     
241. {
     4 T! ~' q$ G, P/ G, S
242. 
     
243.   GPIO_InitTypeDef GPIO_InitStruct;
     
244. 
     8 |6 V% I. W! o, \8 w/ A* }
245.   /* GPIO Ports Clock Enable */
     
246.   __HAL_RCC_GPIOC_CLK_ENABLE();
     - m  l+ l0 U7 B" A1 c$ {/ Y
247.   __HAL_RCC_GPIOH_CLK_ENABLE();
     0 c9 `0 l) R, n5 v/ U- R( c' T$ x
248.   __HAL_RCC_GPIOA_CLK_ENABLE();
     ; t  S, G; c# _- ]% i
249.   __HAL_RCC_GPIOB_CLK_ENABLE();
     
250. 
     7 l, V" u3 C7 d+ r  {- I3 y
251.   /*Configure GPIO pin : PC13 */
     5 m2 Y$ e( W9 I  [+ g
252.   GPIO_InitStruct.Pin = GPIO_PIN_13;
     
253.   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
     
254.   GPIO_InitStruct.Pull = GPIO_NOPULL;
     
255.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     
256. 
     9 M- g7 ?7 n) I' {
257. }
     2 @4 }: I. E+ E  W, Y
258. 
     
259. /* USER CODE BEGIN 4 */
     
260. 
     ) c7 r" m8 L4 A- ^9 Q
261. PUTCHAR_PROTOTYPE
     . X* t6 m/ G0 e# p# v% P/ P7 D
262. {
     
263.   /* Place your implementation of fputc here */
     1 t, ~% {9 t1 [2 o2 J7 g
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);
     1 S- e+ n  Q3 |
266. 
     
267.   return ch;
     9 j5 _5 H% c! f2 y
268. }
     
269. 
     
270. void DecodeReception(void)
     
271. {
     
272.   /* Read one byte from the receive data register */
     
273.   temp = (char) RxBuffer[0];
     % U6 x+ [, n- R! O- L
274.   RxCommand[RxCmdCounter++] = temp;
     4 m8 q, q" Q1 a% f0 f0 W8 f; j" e
275. 
     7 W( Z  z5 Y( t3 I
276.   /* Check if is an LR/CR character */
     7 B- Q1 J7 g" B
277.   if ((temp == CR_ASCII_VALUE) || (temp == LR_ASCII_VALUE))
     
278.   {
     . y: x/ D7 A8 n) q* j
279.     /* echo entered command on terminal */
     # l  X- \# v0 k: e
280.     printf("You entered below test number:\n\r");
     
281.     printf(RxCommand);
     2 q2 U. p! k& e( j
282.     printf("\n\r");
     
283. 
     3 R* C3 O. C; C
284.     RxCmdCounter = 0;
     
285.      
     
286.     ReceiveStatus = 1;
     
287.   }
     ) t. }/ k! G) \- \4 \
288. }
     5 j$ G6 F5 _/ W
289. 
     
290. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     5 A+ I( V# R: u3 b/ P) h* y, U
291. {
     
292.      ReadyToReception = 1;
     " J! P' @" ?- ?% l6 h* p
293. }
     + t8 J# B3 f9 |
294. 
     1 ]: l7 a2 G, a; v& j7 g. Z
295. void SystemClock_2MHz(void)
     
296. {
     
297.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
     7 o' a1 w) Z5 h
298.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     ; Y5 c% w) G: O% v3 z8 E; ^" k
299. 
     % p1 r% t# {9 q  j* X1 `* u
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;
     2 n! ]# \& Y3 i. M, w- O
304.   RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
     , E7 Y$ r1 q% ]
305.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     
306.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
307.   {
     : t& K6 p& b6 H: N" n5 y
308.     /* Initialization Error */
     
309.     Error_Handler();
     7 t+ f1 q* C! h& {. D- C: j# S
310.   }
     
311.   
     
312.   /* Select MSI as system clock source and configure the HCLK, PCLK1 and PCLK2
     
313.      clocks dividers */
     
314.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;
     , b1 N4 {2 u+ d- m8 Z9 T
315.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
     - _4 x1 T4 H, e9 R5 X& p) b/ ]$ V, Y
316.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     8 H7 }+ @& z" f  h' j6 r
317.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;  
     
318.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     7 l1 R+ s2 f$ L7 ?6 F& W
319.   if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     ; d6 f5 `8 o! d3 e
320.   {
     ( T; d; h  y$ d' N! @
321.     /* Initialization Error */
     & t5 @, e5 a: ^, ~# D
322.     Error_Handler();
     ! }9 a" x" r. _1 I) w7 i
323.   }
     ( ?) `2 E+ N) j( V% f9 t6 L% y
324.   
     
325. }
     ; O+ @8 n: j& [  {! j9 C
326. 
     3 Q3 x' `8 X; a' N. @6 J6 m: D
327. void GPIO_AnalogState_Config(void)
     
328. {
     
329.   GPIO_InitTypeDef GPIO_InitStruct;
     ; O7 S9 e) u% Y7 |$ n# T% F/ B
330.   
     
331.   /* Set all GPIO in analog state to reduce power consumption, */
     
332.         
     ; O7 k* U- j) g% G+ G0 O
333.     __HAL_RCC_GPIOA_CLK_ENABLE();
     
334.     __HAL_RCC_GPIOB_CLK_ENABLE();
     / Q& a! m- o0 e' T. a1 D- d8 |/ p
335.     __HAL_RCC_GPIOC_CLK_ENABLE();
     % t& e1 }! Z! G9 v  P* S
336.     __HAL_RCC_GPIOD_CLK_ENABLE();
     % M, a/ Y, Z% j/ c! N
337.     __HAL_RCC_GPIOE_CLK_ENABLE();
     - ^* I! v; A& t1 K! D
338.     __HAL_RCC_GPIOF_CLK_ENABLE();
     
339.     __HAL_RCC_GPIOG_CLK_ENABLE();
     
340.     __HAL_RCC_GPIOH_CLK_ENABLE();   
     
341. 
     $ Q4 u% n) I! {+ _
342.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     
343.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     0 ]) E5 t. P; n+ K# L6 K& V
344.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     
345.     GPIO_InitStruct.Pin = GPIO_PIN_All;
     
346. 
     . Z' ]; ^. Z) w1 X1 ~) y' R! t
347.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     
348.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
     
349.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     & g/ s# U+ M; }: j( W. m
350.     HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
     ( o& V: _3 E; y$ e
351.     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
     " ?, m7 c: B2 o! X* T
352.     HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
     
353.     HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
     
354.     HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);  
     ; ~- t' K) T* |+ Z
355. 
     
356.     __HAL_RCC_GPIOA_CLK_DISABLE();
     
357.     __HAL_RCC_GPIOB_CLK_DISABLE();
     * [# y& c7 @6 P5 N/ B
358.     __HAL_RCC_GPIOC_CLK_DISABLE();
     
359.     __HAL_RCC_GPIOD_CLK_DISABLE();
     
360.     __HAL_RCC_GPIOE_CLK_DISABLE();
     
361.     __HAL_RCC_GPIOF_CLK_DISABLE();
     1 E6 s  u+ K/ z, q/ r, j
362.     __HAL_RCC_GPIOG_CLK_DISABLE();
     0 C; _( ?2 r% d. ]; V/ Z/ }* R+ Z
363.     __HAL_RCC_GPIOH_CLK_DISABLE();
     
364. 
     
365. }
     ( y; _$ `6 P% l% ~
366. 
     
367. void LSE_OFF_Config(void)
     7 m3 M: N2 C, W8 ?( U" m1 o
368. {
     
369.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     7 c( N  h9 U" S6 _& N3 Y+ Q
370. 
     5 T. V9 [/ ?0 h, @7 `) P! p1 s
371.   /* set LSE OFF */
     
372.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
     ) W/ F8 q% z3 P4 a- \& [
373.   RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
     
374.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     
375.   {
     
376.     /* Initialization Error */
     ) d: F6 w0 @) h1 @. L+ X1 F7 V
377.     Error_Handler();
     ' H8 M) Q9 x( B+ ]2 K5 s
378.   }
     2 L/ _, T) O$ V' f  v
379. 
     ) t* i# x1 b* Z- |8 b
380. }
     8 @( o0 ^( _5 i& C5 a" {+ Y4 n- x
381. 
     4 j8 u6 F  I3 S7 g$ y
382. 
     + D" k% g1 Y+ G. M
383. // TODO 1: Enter into Shutdown mode
     3 x( ~/ t+ y- P* W( D  A" t; S
384. 
     - \; r/ U) b% `  r6 p; v+ v) N' ?
385. 
     
386. // TODO 2: Enter into Standby mode
     
387. 
     
388. 
     
389. // TODO 3: Enter into Stop2 mode
     2 T0 z) |2 g, C/ p: }7 a
390. 
     4 Q5 C' S3 a+ n. e6 t
391. 
     
392. // TODO 4: Enter into Low Power Sleep mode
     
393. 
     
394. 
     
395. 
     ' Q! O- X# U" V, f( g
396. /* USER CODE END 4 */
     
397. 
     6 s' e/ }/ I5 U. T' s, X0 H. J
398. /**
     
399.   * @brief  This function is executed in case of error occurrence.
     ; o4 D' A  l* Y% ^1 G. o
400.   * @param  None
     , V3 b  f, m" s$ X$ E+ }
401.   * @retval None
     : P3 B. F" q; y9 J7 b# ~) r
402.   */
     
403. void Error_Handler(void)
     
404. {
     4 I8 @" a, @) \( E+ S
405.   /* USER CODE BEGIN Error_Handler */
     ; C" U  c/ M+ d
406.   /* User can add his own implementation to report the HAL error return state */
     ' {- v7 d# J5 ?8 P) q1 T
407.   while(1)
     , ?# c  l; e& r; D3 }
408.   {
     * Z8 Z$ O) w, y/ E) C
409.   }
     0 Q( O+ o4 e' m& X3 n
410.   /* USER CODE END Error_Handler */
     
411. }
     
412. 
     
413. #ifdef USE_FULL_ASSERT
     
414. 
     
415. /**
     
416.    * @brief Reports the name of the source file and the source line number
     
417.    * where the assert_param error has occurred.
     ! B7 k& E9 G; o+ E
418.    * @param file: pointer to the source file name
     
419.    * @param line: assert_param error line source number
     ( f8 u! @" y: }/ F
420.    * @retval None
     
421.    */
     
422. void assert_failed(uint8_t* file, uint32_t line)
     % B3 L3 ~2 C3 I( \- b
423. {
     / j$ Y- t/ X- M7 [
424.   /* USER CODE BEGIN 6 */
     
425.   /* User can add his own implementation to report the file name and line number,
     
426.     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
427.   /* USER CODE END 6 */
     ! Q8 F" W% B7 S' D9 \( i
428. 
     
429. }
     # n  R3 |2 A3 c, m; \& m7 h
430. 
     * ?6 @* t$ D' D1 z3 M
431. #endif
     
432. 
     3 ?2 ^' X4 m2 |' e
433. /**
     5 p- w6 X0 Y4 ?  B. S3 B& j; _
434.   * @}
     6 s% @- O) [6 Y7 z/ c
435.   */
     4 W* W6 G, S* T& e2 E- @) T# t0 \) ~
436. 
     
437. /**
     
438.   * @}
     
439. */
     
440. 
     
441. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
     

复制代码

上面是修改之前的代码。
5 h# ?5 l/ @+ D( }我自己测试的结果是（图上红色的数字是我的测试结果，与理论值基本吻合）：
$ g7 p/ N5 i6 v8 F

/ X- [- y+ B7 g0 e* `# v# L( D) i3 p) @大家也可以根据帖子里共享的ppt思考一下补全代码。

总之昨天学到了以下东西：
1、知道了设计低功耗产品时，硬件层面和软件层面各应该注意什么
$ j" o6 }" T, D% E" e2、能够使用CUBE MX配置工程并生成项目代码
7 Q( [( K- d, l& e. @# q3、计算理论功耗，测量实际功耗并对比

: u1 I8 B2 T+ i, I收获满满的一天，下面把学习的资料分享给大家：

9 W/ o; n# }: ]' T% v. c

00_Part0_20170516_Xi'an_MassMarket_Begin.pdf (1.22 MB, 下载次数: 193)

2017-5-17 21:15 上传

点击文件名下载附件


% t/ H( e. ]$ X) f) a# h' f 01_Part1_STM32L高性能低功耗实战设计.pdf (5.34 MB, 下载次数: 345)

2017-5-17 21:16 上传

点击文件名下载附件

02_Part2_STM32L实战案例分析_update.pdf (1.07 MB, 下载次数: 271)

2017-5-17 21:16 上传

点击文件名下载附件

03_Part3_Low Power_HandsOn.pdf (2.95 MB, 下载次数: 256)

2017-5-17 21:17 上传

点击文件名下载附件
; ?4 Z, d* m" j5 g* m
10_ULPBench Peripheral Demo Setup.pdf (1.06 MB, 下载次数: 141)

2017-5-17 21:17 上传

点击文件名下载附件

5 A# ~7 [  g9 `5 B Ecosystem.pdf (11.27 MB, 下载次数: 376)

2017-5-17 21:17 上传

点击文件名下载附件

) W( |* e2 \& x4 X& Q STM32_2017_Roadmap_ext.pdf (4.11 MB, 下载次数: 245)

2017-5-17 21:17 上传

点击文件名下载附件
; Y& _$ @6 W' p( D- L3 a! t
  U5 a2 w" v9 ~5 V HandsOnPart_Low Power Doc.pdf (2.93 MB, 下载次数: 309)

2017-5-17 21:17 上传

点击文件名下载附件

8 Y/ x" P3 O0 P

8 s+ W- C& b8 S( C; ?' H
% @6 _  s& s; ^5 l

# f( G: ~8 |$ X: P
$ F' p1 N. a' w" n/ F

+ b& c, v) u0 {$ q/ l. Z
& \9 O5 R9 k" y/ ?! Z6 u( h" [
: l! ^3 W' X" b3 @
* ^$ N. z8 A' m# i9 c& ~


7 M$ e( E4 k- f8 e; _

xjtu2013 发表于 2018-1-9 11:04
1 v+ X4 W) D! E( \9 I6 t) C9 M小马哥好啊，STM32L476低功耗培训的培训工程包能不能共享一下 啊，初学者，很需要详细的资料，谢谢 ...

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

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

支持下                  

谢谢小马哥的支持

谢谢分享

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

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

您是哪位？

jiuwangbujiu 发表于 2017-5-19 11:06
4 ]$ P: W' x! ^: C, o8 q您是哪位？

  ~4 B: }1 j( T* @8 K- A* Y. `我是你的一份粉丝

wofei1314 发表于 2017-5-19 11:08
( s3 e: K; @, k+ s7 M我是你的一份粉丝

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

* q6 {5 ~9 Z) a! y  Y. |

感谢分享！

好资料

顶马哥

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

谢谢支持，以后多多交流

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

3群的网友哦！

这个具体在哪里啊
7 `7 n3 \/ j1 x8 F% h3 _我之前在上海的时候参加过一次，现在在西安