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

/ H: e" |9 }& p' S3 f) J1 G( D7 x

5 Z0 b# A8 i- r9 N
/ X% [1 O/ F% M' Y9 e) t2 I        作为一个技术狗，我直接跳过ST关于产品线的介绍，直接杀入主题--基于STM32L476的低功耗设计，当然在这之前先介绍几个ST发布发布的非常好用的工具。
- i9 B8 r. m0 T' u' r) O% n
5 Y$ l9 j" @! e! J! S* r) E( r        一、ST MCU Finder
3 @5 {9 |: Z. l3 r             这个软件我最早是在苹果软件商店发现的，下载下来觉得挺好用，所以还推荐给我群里的人了，后来又发布了安卓版本和PC桌面版（包含WINDOWS\LINUX\MAC OS）作为一个ST的忠实粉丝，我也是第一时间下载使用并推荐给群里的人。也在摩尔吧开过一次直播，和大家探讨基于ST MCU Finder 和cube MX以及keil进行产品快捷开发的课题，链接为：https://www.moore8.com/courses/1444。当然，啰嗦了这么多，还是没有给大家说说这个软件是干嘛的，我直接上图
  i* R. S5 ^* W7 }' m9 Z$ Z
) h% l3 }! `1 Z0 O8 q上面的是图标，下面是软件打开后界面：
; u9 Z% [( ]. p% i; Q7 s% @

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

       二、STM32CubeMX
            这又是一件利器，它可以方便的查看芯片的IO管脚图，时钟树等，不只是可以看，而且可以配合，是一款很好的IO分配，时钟树配置软件，而且它可以进行电源功耗计算。其实最厉害的应该是代码自动生成。
4 N8 [5 Z+ }/ p' l: I) q
& |  ^- `8 h! d5 |) d# v4 O1 x上面是STM32CubeMX的图标，下面是使用的详图：
* G0 V0 y! w7 M; L
+ `8 b. s7 I* v以STM32L476 nucleo板子为例，创建一个项目
/ O: b, V4 O* e) I) u) G6 ^  f$ S
- d- J# Q& [5 {; T' J3 p
具体功能大家看图，下载软件使用一下就爽翻了，我就不详细描述了。

        三：常用的网站及公众号：
               STM32社区：https://www.stmcu.org.cn/
               STM32中文官网：http://www.stmcu.com.cn
, f, T6 L# e1 O' q7 V+ ?1 Z1 C               STM32四轴飞行器教程：https://www.moore8.com/courses/course/1308
' N2 N/ c5 E8 E7 {# e               公众号：STM32单片机
% v) k3 ~* s3 k9 |$ G& {& o

1 C2 \/ g! Q& @" L6 {
- P1 Y. V& Q5 A7 c        安利完上面两个软件，开始正式总结回忆低功耗课程的内容：
        1、在低功耗案例分享中学习到的东西有以下几点：
              #、影响低功耗设计的几个因素：
+ Y* `" {' q4 p* h                      *芯片的工艺和制程：不同的制程芯片内部晶体管的开关功耗不同，导致整个芯片功耗不同
                      *晶体管数量不同：这个是显而易见的一个因素
                      *模拟外设的使用：模拟外设相对耗电量比较大
: b2 X; [6 a& M0 n                      *RAM与Falsh大小：不同的存储容量耗电也不一样，存储功耗近似和存储空间大小成正比
                      *MCU供电特性：提供的电压越低，功耗也就越低，但是此时频率也越低，和电脑超频耗电量大一个道理
                      *时钟频率：时钟频率越高，耗电量越大
                      *工作模式：不同的工作模式耗电量不同，这个是显而易见的
7 f/ Y% {1 |9 c5 `/ w              #、功耗分为静态功耗和动态功耗，动态功耗与电压、频率、负载等关系相关
1 f2 j5 ~' \. j/ w9 r              #、L4系列独有的电压转换器，可调时钟源，SMPS等.
              #、外设和GPIO连接的时候，如果两端电压不一致，就会导致电流产生，从而消耗功耗，所以要仔细阅读外设手册并进行合理配置
0 ~! r: x, V1 j6 \9 }$ _3 E/ S              #、IIC等外设的管脚必须外加强上拉，在进入低功耗之前把IIC的管脚设置为上拉输入模式
              #、中断标识未清除也可能导致功耗上升
              #、虚焊等其他情况也可能导致功耗异常
              #、在数据传输未结束的时候，尽量不要切换到低功耗模式，可能会失败
7 ^/ r/ U/ N2 G              #、使用低功耗串口唤醒系统的时候，如果串口波特率太高可能导致前面的数据丢失
9 t/ Z1 F( V7 ]1 p) w" ?; K              #、一些特殊场景可以考虑把代码优先级修改为速度优先，用空间换时间
        2、HandsOn环节的实验学习（具体实验安排我就不说了，请参考ppt）：
8 _! Y" Y( ?8 C. s+ ]" y              代码如下：

1. /* Includes ------------------------------------------------------------------*/
   
2. #include "main.h"
   
3. #include "stm32l4xx_hal.h"
   
4. 
   
5. /* USER CODE BEGIN Includes */
   
6. #include <stdio.h>
   
7. #include "string.h"
   
8. 
   " X" F- ?& D$ C. Z" e* T% _& X% J  e
9. #ifdef __GNUC__
   , o; I6 ^3 a7 {5 p% F1 A2 W$ h
10.   /* With GCC, small printf (option LD Linker->Libraries->Small printf
    + w; G4 V( V# e. O
11.      set to 'Yes') calls __io_putchar() */
    ) W6 f) U( t& M2 `$ l# v
12.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    + l" G) d3 r7 z% E/ z& v& t3 A) s
13. #else
    9 U7 ?$ [& ]3 @3 Z( T
14.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    6 L" H2 Q; r3 d& r$ l, N% ~
15. #endif /* __GNUC__ */
    7 x, w  V$ r8 ~+ K
16. 
    
17. /* USER CODE END Includes */
    
18. 
    7 I5 X: g: ?$ k
19. /* Private variables ---------------------------------------------------------*/
    
20. UART_HandleTypeDef huart2;
    
21. 
    
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;
    0 N, A+ @9 k$ b% i4 v
27. __IO uint8_t CmdEnteredOk  = 0;
    
28. 
    
29. #define LR_ASCII_VALUE ((uint8_t)0x0A)
    
30. #define CR_ASCII_VALUE ((uint8_t)0x0D)
    
31. #define RXCOMMANDSIZE   0x20
    8 Z$ l3 V$ f: J/ t4 C1 w* P
32. #define RXBUFFERSIZE   0x01
    
33. 
    " x" J( s/ n8 O) z
34. 
    & [3 |# p9 v4 g: d$ P
35. char RxCommand[RXCOMMANDSIZE];
    3 o4 c' L  s% p" a+ N  f4 @
36. uint8_t RxBuffer[RXBUFFERSIZE] = {0}; //transmitting byte per byte
    
37. 
    
38. char temp; //initialisation character
    
39. char * s;
    
40. 
    4 {% _( b) U/ J- Y
41. /* USER CODE END PV */
    8 l. w: W" I- }! t
42. 
    
43. /* Private function prototypes -----------------------------------------------*/
    
44. void SystemClock_Config(void);
    . m2 ?# E$ j- S/ ]
45. void Error_Handler(void);
    5 r4 r3 n( b$ M" S1 L' V
46. static void MX_GPIO_Init(void);
    
47. static void MX_USART2_UART_Init(void);
    5 {1 p9 Y6 k8 R/ E$ X+ @: `" b* W
48. 
    2 q' l. g# }5 z
49. /* USER CODE BEGIN PFP */
    
50. /* Private function prototypes -----------------------------------------------*/
    + g! S/ t1 {& ~! ?
51. void DecodeReception(void);
    - w6 r9 }! G# W3 M% N: k
52. void LSE_OFF_Config(void);
    7 P' C4 i8 ~  }$ T% e0 S
53. extern void test_shutdown(void);  
    * u! F/ x# B* Q
54. extern void test_standby(void);
    
55. extern void test_lpsleep_2mhz(void);
    , }! {/ D% [% {
56. extern void test_stop2(void);
    
57. /* USER CODE END PFP */
    4 \5 t& q+ _4 c- ?/ I
58. 
    
59. /* USER CODE BEGIN 0 */
    " n9 {- d; v. {! D
60. 
    
61. /* USER CODE END 0 */
    
62. 
    
63. int main(void)
    * {8 K! o" \* p6 p+ {6 Y
64. {
    # |0 a; [/ \* r  R( U( g
65. 
    + i9 E1 ?  ^8 J9 |
66.   /* USER CODE BEGIN 1 */
    - P& u4 W4 h: _  C( n1 s( R* z' V
67. 
    9 i# T) W; L3 l. i) g4 M
68.   /* USER CODE END 1 */
    
69. 
    ; G4 y8 P; m, C; N
70.   /* MCU Configuration----------------------------------------------------------*/
    
71. 
    $ I; o9 C3 F1 l" V+ ?
72.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
73.   HAL_Init();
    
74. 
    5 v; ^* j4 Y7 C; n" ]( ~
75.   /* Configure the system clock */
    
76.   SystemClock_Config();
    . n+ m/ P+ o& a/ L$ s$ ]2 W
77. 
    
78.   /* Initialize all configured peripherals */
    3 U, I( z6 _" T) ?: u/ h
79.   MX_GPIO_Init();
    
80.   MX_USART2_UART_Init();
    
81. 
    7 B! d; `+ r# Z! Z$ K
82.   /* USER CODE BEGIN 2 */
    0 Q" U. V0 T9 i
83. 
    
84.   HAL_Delay(1000);//delay 1s
    
85. 
    . l+ D# S/ [- D% _
86. /* Output a message on Hyperterminal using printf function */
    
87.   printf("\n\rREADY\n\r");
    , n% }+ T5 C; E0 r+ @8 _
88.   printf("Please enter the test number according below options\n\r");
    
89.   printf("      0       (SHUTDOWN) \n\r");
    7 S0 i" K8 E# \
90.   printf("      1       (STANDBY) \n\r");
    + ?7 O1 r6 h9 b0 x& A8 ^
91.   printf("      2       (STOP2) \n\r");
    
92.   printf("      3       (LPSLEEP 2MHz         - FLASH OFF) \n\r");
    
93.   
    
94.   printf(" --> \n\r");
    
95.   
    & _* _: C" j* G/ K; H$ Z+ R) `' l8 m
96.     while (CmdEnteredOk != 0x1) {
    # q( n3 v2 T8 Y% Q" V' u4 p
97.     ReceiveStatus = 0;
    ( K" N4 u+ ]- }7 `/ p! \- j
98.     while (ReceiveStatus != 0x1){
    
99.       /* Start the USART2 Receive process to receive the RxBuffer */
    ) V1 e" h: B1 n
100.       if(HAL_UART_Receive_IT(&huart2, RxBuffer, RXBUFFERSIZE) != HAL_OK)
     
101.         {
     
102.           Error_Handler();
     
103.         }
     
104.       while (!ReadyToReception);
     8 M" p5 [- i' u1 V; \9 \
105.       ReadyToReception = 0;
     
106.       DecodeReception();
     
107.     }
     ( X, G, ^0 l% w1 ]
108.       CmdEnteredOk = 1;
     & Z9 m3 ]- H  S2 F$ ~/ l
109. 
     
110.       s = RxCommand;
     ' x/ f' r; G* X' i# e
111.    
     
112. // __EFF_NENW1NW2   __ATTRIBUTES int        strcmp(const char *, const char *);
     8 L. I! v" ]6 C4 U3 Z
113. // strcmp(s, "x\r") ==0, input char is x\r, it is true
     9 H' r1 Y& ?/ T9 h
114.          
     % {$ j4 d* k- m  h8 i* \5 V- V
115. // TODO 5: If receive char "0", enter into Shutdown mode   
     , w* x( l: J) v2 D; E; g2 n
116.       
     
117.       
     
118. // TODO 6: If receive char "1", enter into Standby mode      
     9 V* h3 c% R6 Q  L
119.       
     
120.       
     ; _- {7 X! K% M1 S
121. // TODO 7: If receive char "2", enter into Stop2 mode
     " u. g6 m" B# f/ M- {
122.      
     
123.       
     # p4 o1 g* W" C! F) f
124. // TODO 8: If receive char "3", enter into Low Power Sleep
     - `! d' v+ @: Z+ I' M- G
125.       
     
126.          
     : w, M+ x- T2 s" _
127.       else {
     
128.          printf("Invalid test number.. Please enter again\n\r");
     2 u# M; R( N8 o
129.          CmdEnteredOk = 0;
     
130.          /* Reset received test number array */
     
131.          memset(RxCommand, 0, RXCOMMANDSIZE);
     ; _9 I" S. k* I8 \
132.        }
     ! T0 m( r- T+ W8 y$ N; [
133.       
     
134.     }
     0 m; r  Z: b' W% A7 s9 a% b7 T
135.   
     ) I+ ^( ]* f+ o, k1 {" _
136.   /* USER CODE END 2 */
     : A  A9 F3 S( D' s0 M4 l6 V" j
137. 
     * X! D9 d6 B; W% G
138.   /* Infinite loop */
       N) ?/ J8 \% s
139.   /* USER CODE BEGIN WHILE */
     ! B3 p" p5 u( V7 {" q* R
140.   while (1)
     
141.   {
     
142.   /* USER CODE END WHILE */
     1 J& x* G0 K4 q/ }0 P2 ~; Y
143. 
     ' L9 X6 L8 L. Z/ B* n4 ?
144.   /* USER CODE BEGIN 3 */
     
145. 
     
146.   }
     * b( {- }/ F4 V
147.   /* USER CODE END 3 */
     
148. 
     
149. }
     
150. 
     2 x& j$ v5 @# m* _
151. /** System Clock Configuration
     
152. */
     
153. void SystemClock_Config(void)
     
154. {
     3 o  s4 G, J2 j& K4 a
155. 
     1 }5 m( z& k, X/ o' _6 }
156.   RCC_OscInitTypeDef RCC_OscInitStruct;
     ! X' W: h) Z! ~/ x2 a
157.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
     6 A9 j7 V  {; q
158.   RCC_PeriphCLKInitTypeDef PeriphClkInit;
     
159. 
     ! h0 p$ [, B! }/ s
160.     /**Initializes the CPU, AHB and APB busses clocks
       C  C8 g8 U' M: L
161.     */
     + _4 N1 f- C/ E9 ^/ L: a: ?
162.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
     % k* R: e# E" H2 m2 ]
163.   RCC_OscInitStruct.MSIState = RCC_MSI_ON;
     ) A$ m1 x5 ?& `2 _  U
164.   RCC_OscInitStruct.MSICalibrationValue = 0;
     
165.   RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6;
     
166.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     . j; G  i' ~5 C/ U+ r4 t
167.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     + T' t: E% g8 L3 S
168.   {
     
169.     Error_Handler();
     + E9 {2 {) a& k+ L4 e' W
170.   }
     
171. 
     & l1 b. |. n, L2 w* e6 a0 a7 L0 p
172.     /**Initializes the CPU, AHB and APB busses clocks
     
173.     */
     
174.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
     
175.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
     & u/ Q: `; A- x6 G' |& t
176.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
     
177.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     5 X5 i0 L5 i9 E, k' J4 b7 X- F. z' v2 U
178.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     ; ~' y% ?1 E: j& e; ^  k
179.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     & m9 R0 S* e* t
180. 
     
181.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     + \. B! k  z- ]3 D0 O- ?
182.   {
     
183.     Error_Handler();
     7 v6 n! H$ Y. x" Q4 x9 j
184.   }
     
185. 
     
186.   PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
     
187.   PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
     
188.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
     8 K! C9 }0 W1 ?0 g# S4 d
189.   {
     
190.     Error_Handler();
     7 @% |! a( G2 y$ x' F. G4 N
191.   }
     
192. 
     4 ]4 ~6 t$ N1 _
193.     /**Configure the main internal regulator output voltage
       U# J8 s5 @- \+ J' {  e
194.     */
     : n! K6 X2 P7 q  t: W+ r  ~& `( l9 w
195.   if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
     : F5 \; Q2 O9 s7 [
196.   {
     
197.     Error_Handler();
     
198.   }
     
199. 
     
200.     /**Configure the Systick interrupt time
     2 m6 Z5 Z8 A3 s8 j3 G: t$ y4 i, m
201.     */
     3 j) P2 a- U, A" l, N7 h
202.   HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
     
203. 
     4 F2 m, Z  b  d) P& M
204.     /**Configure the Systick
     
205.     */
     
206.   HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     % K  Z# V! D5 z8 x
207. 
     
208.   /* SysTick_IRQn interrupt configuration */
     1 t2 ?3 p" d$ t4 O+ T3 k. a
209.   HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
     ( e& @2 L: |7 ~* p/ R8 e- I3 }
210. }
     
211. 
     
212. /* USART2 init function */
     
213. static void MX_USART2_UART_Init(void)
       R' M0 [( B; E. s5 W" o
214. {
     6 u  k6 m, g) G' Z: }( f
215. 
     1 p. g& D! F! [- {: f% D
216.   huart2.Instance = USART2;
     
217.   huart2.Init.BaudRate = 9600;
     
218.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
     
219.   huart2.Init.StopBits = UART_STOPBITS_1;
     5 K5 J+ T% G/ @$ e* N0 X
220.   huart2.Init.Parity = UART_PARITY_NONE;
     
221.   huart2.Init.Mode = UART_MODE_TX_RX;
     
222.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     
223.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
     9 [0 ]- d" h  N2 }2 |; `
224.   huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
     # u  V1 \3 m9 v
225.   huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
     
226.   if (HAL_UART_Init(&huart2) != HAL_OK)
     - z9 k0 U5 D& Q, E
227.   {
     
228.     Error_Handler();
     
229.   }
     
230. 
     9 O  ^( C9 K# i3 n/ O+ Y
231. }
     
232. 
     
233. /** Configure pins as
     
234.         * Analog
     
235.         * Input
     & i0 j$ C, z$ B# g, a0 u! _
236.         * Output
     8 j6 q% g: g: v7 R" g( {
237.         * EVENT_OUT
     
238.         * EXTI
     ! b! @% [" X+ G
239. */
     1 y9 n3 f6 q3 w" a1 q: [
240. static void MX_GPIO_Init(void)
     
241. {
     
242. 
     
243.   GPIO_InitTypeDef GPIO_InitStruct;
     
244. 
     
245.   /* GPIO Ports Clock Enable */
     
246.   __HAL_RCC_GPIOC_CLK_ENABLE();
     $ G% Y0 t8 e  b, ?4 |
247.   __HAL_RCC_GPIOH_CLK_ENABLE();
     
248.   __HAL_RCC_GPIOA_CLK_ENABLE();
     3 @% t: q) ]3 z. M3 L
249.   __HAL_RCC_GPIOB_CLK_ENABLE();
     6 b* J8 b4 V1 s0 n$ u/ D
250. 
     " B) v5 L2 ~) i8 k) V/ L& O) U
251.   /*Configure GPIO pin : PC13 */
     
252.   GPIO_InitStruct.Pin = GPIO_PIN_13;
     
253.   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
     4 q# ^9 J8 b. z! o) g
254.   GPIO_InitStruct.Pull = GPIO_NOPULL;
     # P  U' U1 H3 {8 J- y; q2 ~( V1 _) i
255.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     
256. 
     
257. }
     
258. 
     
259. /* USER CODE BEGIN 4 */
     - |, ?! z$ Z+ F
260. 
     
261. PUTCHAR_PROTOTYPE
     & {6 B! r$ u* ]1 y: h( F
262. {
     
263.   /* Place your implementation of fputc here */
     + h3 @& z! ]5 P: i* W% M. l0 \
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);
     % v) \! E5 X0 w! v  Y; u4 I/ r: H
266. 
     6 T* y( q6 Q0 t4 A4 V( I0 E9 \3 f
267.   return ch;
     
268. }
     # l% f8 c! h; X5 j
269. 
     5 Z/ c! R9 i& f9 n
270. void DecodeReception(void)
     + I+ |1 J5 k+ d. ~
271. {
     6 U9 o8 j* M: k5 \9 z) X% i( {
272.   /* Read one byte from the receive data register */
     
273.   temp = (char) RxBuffer[0];
     
274.   RxCommand[RxCmdCounter++] = temp;
     
275. 
     * _6 p4 ?7 ]- B/ T8 L
276.   /* Check if is an LR/CR character */
     ! I/ n) M! S: E- B( u% }6 M' ^
277.   if ((temp == CR_ASCII_VALUE) || (temp == LR_ASCII_VALUE))
     0 K  u4 s, @2 X3 ^6 [2 p$ q' P* R  B
278.   {
     # k" x6 g, c9 M) v
279.     /* echo entered command on terminal */
     
280.     printf("You entered below test number:\n\r");
     , ]5 y0 W! l! a7 m: T
281.     printf(RxCommand);
     
282.     printf("\n\r");
     
283. 
     7 v: g, v4 }( z$ R
284.     RxCmdCounter = 0;
     
285.      
     
286.     ReceiveStatus = 1;
     3 O; m6 G1 ]4 M
287.   }
     
288. }
     
289. 
     
290. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     
291. {
     
292.      ReadyToReception = 1;
     
293. }
     " K) n( _; V. }& ~# n" p' \
294. 
     ; n" s- A3 S% u( ]
295. void SystemClock_2MHz(void)
     
296. {
     + S9 }1 n4 H7 e# W5 o
297.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
     2 m- F$ y4 e7 x: M6 h" o7 o
298.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     
299. 
     0 T/ A3 B5 k; V+ ^: {6 A# r/ T
300.   /* MSI is enabled after System reset, update MSI to 2Mhz (RCC_MSIRANGE_5) */
     + O. J1 b' D9 \$ {0 g: Z
301.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
     , L# [; S5 G. J- [0 |6 J0 N
302.   RCC_OscInitStruct.MSIState = RCC_MSI_ON;
     
303.   RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_5;
     
304.   RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
     / {; {! o1 A4 }) }8 M; U5 o' k
305.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     
306.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     0 g! I; D- M- }8 A* O& X2 P
307.   {
     # z! A6 e/ ?/ \* S; Z' F6 h! Y
308.     /* Initialization Error */
     4 B* ~) T! K4 ~& C' E, U& M" O
309.     Error_Handler();
     
310.   }
     " Z$ N' F8 v) X8 K
311.   
     # y' _( N& }6 s  W* D4 K
312.   /* Select MSI as system clock source and configure the HCLK, PCLK1 and PCLK2
     5 h9 R% B/ C% T
313.      clocks dividers */
     
314.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;
     9 L9 S. K1 h$ L, O% x  ]1 P
315.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
     " x+ Z. \, i+ y) |$ ~; a: O
316.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     ( t5 d3 A9 r4 T8 r& G' V- N! B7 u
317.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;  
     . E! @' a7 n1 c& E
318.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     4 s6 ]& I, f+ Z. ^4 ]
319.   if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
     ( T& l3 z% z# D# X; W, S+ J$ G
320.   {
     ( {. ?5 V$ z7 |
321.     /* Initialization Error */
     
322.     Error_Handler();
     7 {* A' h# T# F$ _$ h4 U
323.   }
     
324.   
     
325. }
     1 ^" J$ g6 x! H" Y7 U2 k$ z
326. 
     . O' b  H# r# @# V5 M7 W9 C) Z
327. void GPIO_AnalogState_Config(void)
     : C( B2 i9 k# q$ N8 z# O6 f' M
328. {
     & Z% z: f* f9 t+ j/ f, ^, z* }
329.   GPIO_InitTypeDef GPIO_InitStruct;
     1 Z2 F) G4 U9 C! I  ?1 K! R1 p
330.   
     8 \  E5 t2 [! \" v' k8 j, R
331.   /* Set all GPIO in analog state to reduce power consumption, */
     ( o2 E6 }* e' ?2 u/ O- x2 z6 ~5 ?- F$ o! o
332.         
     4 u0 S# b* k$ K1 v: S  r' N8 x: T
333.     __HAL_RCC_GPIOA_CLK_ENABLE();
     
334.     __HAL_RCC_GPIOB_CLK_ENABLE();
     + G" D+ ]- J' B# _! A* C* A: w
335.     __HAL_RCC_GPIOC_CLK_ENABLE();
     4 e; F% y7 D$ @) c, @
336.     __HAL_RCC_GPIOD_CLK_ENABLE();
     ; h3 F, D  t- q  B  k" ^9 g
337.     __HAL_RCC_GPIOE_CLK_ENABLE();
     ' Y2 G5 C, Y; @$ _- ]4 k4 o
338.     __HAL_RCC_GPIOF_CLK_ENABLE();
     ( ?0 j; r# {& q2 u8 R6 h, [& P* x6 G0 H$ ^
339.     __HAL_RCC_GPIOG_CLK_ENABLE();
     
340.     __HAL_RCC_GPIOH_CLK_ENABLE();   
     
341. 
     4 Q- A) O9 N) g! O" ^7 p
342.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     & ?. C+ L/ ?, v' C
343.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
     ; u4 l( V  i) p  B% E- g& |6 n
344.     GPIO_InitStruct.Pull = GPIO_NOPULL;
     
345.     GPIO_InitStruct.Pin = GPIO_PIN_All;
     
346. 
     
347.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     * W* Z1 W' a( a; `! N4 v3 I$ F- O
348.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
     
349.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
     
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);
     
354.     HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);  
     
355. 
     6 Q! n( v; j1 b+ V' a" X( u6 W
356.     __HAL_RCC_GPIOA_CLK_DISABLE();
     
357.     __HAL_RCC_GPIOB_CLK_DISABLE();
     
358.     __HAL_RCC_GPIOC_CLK_DISABLE();
     6 D1 i: E$ u6 B  X; m3 b
359.     __HAL_RCC_GPIOD_CLK_DISABLE();
     2 E4 {" C7 ?8 U1 a( c/ b
360.     __HAL_RCC_GPIOE_CLK_DISABLE();
     
361.     __HAL_RCC_GPIOF_CLK_DISABLE();
     " {' F( T. {9 o5 V) j
362.     __HAL_RCC_GPIOG_CLK_DISABLE();
     0 s* \7 h0 M1 R4 y5 l: V. J6 G
363.     __HAL_RCC_GPIOH_CLK_DISABLE();
     
364. 
     
365. }
     
366. 
     
367. void LSE_OFF_Config(void)
     
368. {
     
369.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
     + C' Q& |; |9 l
370. 
     $ w% O3 w  i8 v5 b! i3 B) f
371.   /* set LSE OFF */
     
372.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
     ; k, \* P+ h$ V' l+ M, P& O4 ?2 s
373.   RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
     
374.   if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
     / \. i/ ?+ W1 _3 |2 a0 F
375.   {
     3 z9 G/ v6 k' o. L; w3 n: l+ {; v' [
376.     /* Initialization Error */
     1 L$ |! V8 O" ?+ {: i* g6 H0 X
377.     Error_Handler();
     3 y) e& ~) {  b* B: B! L' B2 s
378.   }
       a7 @# d: b3 Y
379. 
     
380. }
     , X! {  T0 q; ], ]4 n
381. 
     
382. 
     $ q2 _, r" m; o% w* q  ~
383. // TODO 1: Enter into Shutdown mode
     $ r& j% `* B2 l: X5 G
384. 
     
385. 
     
386. // TODO 2: Enter into Standby mode
     : z  h4 q7 B% ~) g  W
387. 
     
388. 
     ; `. j; F2 I) l9 x
389. // TODO 3: Enter into Stop2 mode
     6 J' Q$ C+ X" w. d
390. 
     2 I1 c% A$ P5 i
391. 
     2 z  H4 `  S7 _( F; o: {. o
392. // TODO 4: Enter into Low Power Sleep mode
     
393. 
     
394. 
     " x6 ]8 @& x8 X5 A; ^
395. 
     , A. }; s( `& L
396. /* USER CODE END 4 */
     
397. 
     
398. /**
     1 J6 _: X0 p# R! o/ o8 I
399.   * @brief  This function is executed in case of error occurrence.
     
400.   * @param  None
     
401.   * @retval None
     
402.   */
     
403. void Error_Handler(void)
     7 {- R4 J# _, N2 q5 Z
404. {
     
405.   /* USER CODE BEGIN Error_Handler */
     
406.   /* User can add his own implementation to report the HAL error return state */
     
407.   while(1)
     
408.   {
     ! L' i& w. R. V. ?0 _. X7 r  I- O
409.   }
     
410.   /* USER CODE END Error_Handler */
     - k2 E, P6 @: z6 V6 {
411. }
     - t4 Z6 N" U$ L
412. 
     
413. #ifdef USE_FULL_ASSERT
     ( Z3 q9 w+ ~# `0 V6 ?  t- U
414. 
     
415. /**
     9 M9 _' {. u2 C: ]8 U7 ^
416.    * @brief Reports the name of the source file and the source line number
     / e; C2 s1 v! E& k
417.    * where the assert_param error has occurred.
     ( y, k. j/ s+ l! R' r7 {
418.    * @param file: pointer to the source file name
     9 t  T6 C7 E; O- e1 s
419.    * @param line: assert_param error line source number
     ! O& N3 q1 {! @
420.    * @retval None
     8 R2 [9 A; `5 X. Y! }
421.    */
     4 U8 r4 |+ A! V2 d. y
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,
     
426.     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     / e: _/ q' z0 k1 B; E& u
427.   /* USER CODE END 6 */
     ' m5 I! R+ |1 `3 V
428. 
     
429. }
     # I7 j6 g# s8 D3 d' n6 H/ V) B0 ]/ F
430. 
     
431. #endif
     
432. 
     # `( s5 d4 ~3 Q3 Y" {3 W% k
433. /**
     
434.   * @}
     
435.   */
     ' s" v3 E9 @  r# E+ \& r
436. 
     $ h- |- u4 O8 F  A- N
437. /**
     7 E+ S; _, }" O
438.   * @}
     
439. */
     
440. 
     7 s- g7 e4 E. c% w
441. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
     4 {2 e, n2 g  ^+ ?- `5 Q9 ^$ ~

复制代码

上面是修改之前的代码。
& |4 `  x7 l9 R! _$ f0 @我自己测试的结果是（图上红色的数字是我的测试结果，与理论值基本吻合）：
6 c6 l1 N' L, y+ x1 c( w
6 {1 `7 h$ D/ F2 @; P6 K4 K  J. ^
大家也可以根据帖子里共享的ppt思考一下补全代码。

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

. k/ A+ r: @. z收获满满的一天，下面把学习的资料分享给大家：

4 H  H8 a7 d3 L. s3 a/ N* x5 r
, C7 @/ c1 E  s" b: l: B, J
, m1 M* m8 S* ?( B/ y8 F 00_Part0_20170516_Xi'an_MassMarket_Begin.pdf (1.22 MB, 下载次数: 193)

2017-5-17 21:15 上传

点击文件名下载附件


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 上传

点击文件名下载附件
2 y& ^& N4 p3 h) l2 L/ _0 Y
  c! i: Q1 |5 D 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 上传

点击文件名下载附件
1 s- x' G) d, K3 L& C
. Y: D+ \$ y  h0 W4 `  G Ecosystem.pdf (11.27 MB, 下载次数: 376)

2017-5-17 21:17 上传

点击文件名下载附件

STM32_2017_Roadmap_ext.pdf (4.11 MB, 下载次数: 245)

2017-5-17 21:17 上传

点击文件名下载附件

  ?: S; @  ~; U  K4 b$ t+ b/ ~4 ? HandsOnPart_Low Power Doc.pdf (2.93 MB, 下载次数: 309)

2017-5-17 21:17 上传

点击文件名下载附件




( S) }/ Y' K: D# W1 _* ]3 m

$ f7 z4 L6 W3 O; J: }: {
' l1 P/ r/ F& Z8 @; I: w+ Q
& b8 ]5 A# x. B/ _+ f
0 `& J- B" s/ K5 c
/ z6 N+ M% e  x( H$ u  ^
2 s* a. N/ E# H( J


2 p" u5 ~5 ^3 p& m
3 H5 _! T2 ^8 E, E- P3 l, t
0 @) M0 p( [1 I2 O! k
* ?2 T6 q. w1 g8 {$ o6 u2 W( K" b

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

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

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

支持下                  

谢谢小马哥的支持

谢谢分享

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

wofei1314 发表于 2017-5-19 10:51
( x  w0 s3 c8 B+ r6 d原来楼主是小马哥啊，谢谢分享~

您是哪位？

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

我是你的一份粉丝

wofei1314 发表于 2017-5-19 11:08
# a( p9 s* T* J. b+ ~) L我是你的一份粉丝

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

) r/ {0 a( s. p/ \" K; H

感谢分享！

好资料

顶马哥

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

谢谢支持，以后多多交流

jiuwangbujiu 发表于 2017-5-19 11:06
2 T6 e1 ^7 S' s, {( q0 x9 [您是哪位？

6 j; O8 h# a1 J; _/ L3群的网友哦！

这个具体在哪里啊
+ o& h% w, M+ \& J, S我之前在上海的时候参加过一次，现在在西安