1、时钟树框图
系统时钟的选择在启动时执行，即程序在上电复位时，先运行启动文件startup_stm32f0xx.s，该汇编文件中先进行了系统初始化，在系统初始化的时候进行系统时钟（SYSCLK）的选择与配置，当系统初始化完成后，才运行main函数。在复位后，内部8MHz的RC振荡器（HSI）被选为默认的CPU时钟。用户也可以选择4-32MHz的外部时钟（HSE）作为系统时钟，选择HSE作为系统时钟时，标准库函数需要用户自己进行修改，HAL库的话用户可以直接配置。当 HSE 故障的时候， 且选择 PLL 时钟作为SYSCLK， 那么当 HSE 故障的时候，不仅HSE 不能使用，连 PLL 也会被关闭，这个时候系统会自动切换 HSI 作为系统时钟，此时SYSCLK=HSI=8M，如果没有开启 CSS 和 CSS 中断的话，那么整个系统就只能在低速率运行，这是系统跟瘫痪没什么两样。如果开启了 CSS 功能的话，那么可以当 HSE 故障时，在CSS 中断里面采取补救措施，使用 HSI，并把系统时钟设置为更高的频率。
允许应用程序通过几个分频器来配置 AHB 和 APB 的频率，AHB 和 APB 的最高频率为48MHz。

; \2 c$ d9 O# N4 Z- [/ u# Y上电复位时，启动文件运行如下程序：

. f1 w, z# n  S  v8 M

1. ; Reset handler routine 复位处理程序
   
2. Reset_Handler    PROC
   
3.                  EXPORT  Reset_Handler                 [WEAK]
   7 K9 Y! f1 m- m! d
4.         IMPORT  __main
   ' @0 ?" H0 ?* p! D2 ~: m
5.         IMPORT  SystemInit  
   
6.                  LDR     R0, =SystemInit
   
7.                  BLX     R0
   ) _8 l1 r/ C& q4 y. `5 i5 {8 m/ v
8.                  LDR     R0, =__main
   
9.                  BX      R0
   ) i7 l) K% i% n# F- r6 o
10.                  ENDP

复制代码

上电启动过程中，先调用了SystemInit()函数，再进入main()函数。
SystemInit()函数在文件system_stm32f0xx.c中，它的作用是在单片机上电复位的过程中，会来调用这个函数设置系统时钟SYSCLK，默认STM32F0系列单片机时钟最大设置为48MHz，所以系统时钟默认是已经配置好的，无需用户自己进行配置，除非有特殊需要，用户可以进行修改。

2、时钟系统特性
系统时钟（SYSCLK）有以下三种选择：
/ q, x( W. ^/ O+ X9 F, m
HSE（外部高速晶振）：晶振范围（4MHz~32MHz）
1 V( k# K8 S8 \8 B" v8 S可被外部时钟源旁路，意思就是不经过分频和倍频直接将外部时钟源选为系统时钟 SYSCLK，外部时钟信号范围1MHz~32MHz
HSI（内部高速RC振荡器）：8MHz，出厂已校准到±1%的精度
PLL经过2，3，… 16倍频（所有输出的最小频率16MHz）
其他时钟源：

9 L6 ^) l) d2 n, P2 L2 VLSI（内部低速RC振荡器）：~40KHz
LSE（外部低速晶振）：32.768kHz
可悲外部时钟源旁路，可以直接给RTCCLK提供时钟，最高频率1MHz
外部晶振的驱动能力可配置（功耗VS起振能力）
HSI14(内部高速14MHz RC振荡器)：专用于给ADC模块提供时钟
( B' ]6 _4 ?1 e# U
3、时钟参数一览
! ]" ]2 u) \0 K; Q+ E

. d9 J6 n6 ^* X8 I, N

" K3 ~* j& D2 A! Q8 D4 l6 `4、时钟配置案例
9 I7 j1 C. z2 u9 @使用标准库进行系统时钟的修改，为什么说是修改，而不是说配置，如上所述，因为程序来到main函数之前，启动文件：startup_stm32f0xx.s 已经调用SystemInit()函数把系统时钟初始化成 48MHz了，SystemInit()在 system_stm32f0xx.c 中定义，如果用户想修改系统时钟，可参照SystemInit()函数中调用的SetSysClock() 函数，自行编写修改程序，官方文件一般不进行直接修改。
6 O9 @( d7 N8 O6 H" g" L以下代码为system_stm32f0xx.c原文件中的 SystemInit() 函数和 SetSysClock() 函数，源代码分析：
1 K# W! X, Y7 d

1. void SystemInit (void)
   
2. {   
   * C9 u: l; j' V5 v& i3 R$ t
3.   /* Set HSION bit */
   . k* ]9 s6 v0 ]$ Z) d. e6 X' }
4.   /* HSI时钟使能，开启HSI振荡器 */
   
5.   RCC->CR |= (uint32_t)0x00000001;
   ! T) a" m) P5 g' G
6. 
   
7. #if defined(STM32F051)  
   9 C+ X; ~/ d" E0 k8 o9 J. A* ?' z
8.   /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE and MCOSEL[2:0] bits */
   # s2 k! @7 h  J- E3 ~! i* B% ~7 t! h
9.   /* 复位 系统时钟切换, AHB总线的分频因子, APB总线的分频因子, ADC的时钟频率 和微控制器时钟输出选择 */
   * ]- A, E3 a  R! `" Y
10.   RCC->CFGR &= (uint32_t)0xF8FFB80C;
    ' k4 M$ p2 A0 b# g' h, d
11. #else
    
12.   /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */
    7 J! c) c7 f7 ]) F3 K4 z) J# ^- D, G
13.   /* 复位 系统时钟切换, AHB总线的分频因子, APB总线的分频因子, ADC的时钟频率 ，微控制器时钟输出选择，微控制器预分频选择，
    
14.   PLL左时钟输出时是否要分频 */
    
15.   RCC->CFGR &= (uint32_t)0x08FFB80C;
    
16. #endif /* STM32F051 */
    7 r5 d( ~" l' z) f- m
17. 
      D/ y# B- s0 d* e4 m" e
18.   /* Reset HSEON, CSSON and PLLON bits */
    
19.   /* HSE时钟使能位, 时钟安全系统使能位 和PLL使能位清0 */
    ' [7 u4 O; Q" U$ d; @, `
20.   RCC->CR &= (uint32_t)0xFEF6FFFF;
    0 x, @; E9 _4 k" o
21. 
    1 ^6 }$ m6 p+ L: f0 @7 e+ d
22.   /* Reset HSEBYP bit */
    
23.   /* 外部高速时钟旁路清0 */
    ( J) P" ?5 a- m! t: X0 T
24.   RCC->CR &= (uint32_t)0xFFFBFFFF;
    + z% _2 C' l3 q
25. 
    
26.   /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */
    
27.   /* PLL输入时钟源位，分频HSE后作为PLL输入，PLL倍频系数清0 */
    " M( I$ K5 h% \6 O
28.   RCC->CFGR &= (uint32_t)0xFFC0FFFF;
    
29. 
    ( x0 v; O5 E) z3 w
30.   /* Reset PREDIV1[3:0] bits */
    1 d5 q0 @1 s4 s  ]
31.   /* PREDIV1分频因子清0 */
    5 i* q; Z3 _" \+ A
32.   RCC->CFGR2 &= (uint32_t)0xFFFFFFF0;
    3 z4 Z' N  m5 @( F3 r5 [* H' j
33. 
    
34.   /* Reset USARTSW[1:0], I2CSW, CECSW and ADCSW bits */
    
35.   /* USART1时钟源选择位，I2C时钟源选择位，HDMI CEC时钟源选择位，ADC时钟源选择位清0 */
    
36.   RCC->CFGR3 &= (uint32_t)0xFFFFFEAC;
    ' O* J* F5 |' W( D! R! X. e" P
37. 
    , C) i/ v3 N' [
38.   /* Reset HSI14 bit */
    ! ?' l' p; v8 @. [) a, s8 D5 x
39.   /* HSI14时钟使能位清0 */
    1 K9 b- y7 W& @6 B) t0 k' M# L
40.   RCC->CR2 &= (uint32_t)0xFFFFFFFE;
    ! D* F9 r" n% I3 L5 j
41. 
    
42.   /* 禁止所有时钟中断 */
    
43.   RCC->CIR = 0x00000000;
    $ o! A8 o# O7 t* V
44. 
    , k6 A: N+ ?" R- u
45.   /* Configure the System clock frequency, AHB/APBx prescalers and Flash settings */
    
46.   /* 配置系统时钟频率，AHB/APBx分频器和闪存设置 */
    
47.   SetSysClock();
    
48. }
    
49. 
    ( g7 z' u' E1 \" a( x; I8 H
50. ===========================================================================================================================
    ' d7 `8 d: t  d4 X. M1 I
51. 
    1 o5 e' {; n8 ~1 J# _
52. static void SetSysClock(void)
    + W7 }0 c" F4 F
53. {
    $ U! X# {# _+ W8 X3 m
54.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
    ( o; H+ m9 A+ a7 G$ R+ h5 m* E
55. 
    
56.   /* SYSCLK, HCLK, PCLK configuration 系统时钟，AHB总线时钟，APB总线时钟配置-----------*/
    
57.   /* Enable HSE 使能HSE */   
    
58.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);
    
59. 
    
60.   /* Wait till HSE is ready and if Time out is reached exit 等待HSE稳定，如果超时，则退出 */
    
61.   do
    9 O2 @6 c* @7 l& \
62.   {
    
63.     HSEStatus = RCC->CR & RCC_CR_HSERDY;
    
64.     StartUpCounter++;  
    % W, p+ e/ q6 Q0 s7 D+ k7 K1 c
65.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    
66. 
    " V# f1 a3 v5 m
67.   /* 到这边要么是超时了，要么就是HSE稳定了，准备好了，再次判断HSE是否准备好 */
    
68.   if ((RCC->CR & RCC_CR_HSERDY) != RESET)
    
69.   {
    1 [7 h0 _, w6 o
70.     HSEStatus = (uint32_t)0x01;                // HSE状态标识置1（稳定了）
    
71.   }
    
72.   else
    ( Q  C( n: r* \; `
73.   {
    4 L% P; x5 E, U1 d" e& o% Y
74.     HSEStatus = (uint32_t)0x00;                // HSE状态标识清0（没稳定）
    
75.   }  
    
76. 
    
77.   if (HSEStatus == (uint32_t)0x01)        //如果HSE稳定了
    
78.   {
    
79.     /* Enable Prefetch Buffer and set Flash Latency 启用 Flash 预取缓冲区 和 设置Flash延迟*/
    
80.     FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY;
    $ j6 l# g5 Y: d/ ]5 o* }7 p
81. 
    
82.     /* HCLK = SYSCLK         AHB 预分频因子设置为 1 分频， HCLK = SYSCLK */
    
83.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
    ( a' d  V5 Q# Z- c/ Z+ d
84. 
    
85.     /* PCLK = HCLK                 APB 预分频因子设置为 1 分频， PCLK = HCLK */
    
86.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE_DIV1;
    3 w% F+ z7 `+ N  ]9 p( ~7 M  g4 Y
87. 
    9 U$ O& k, l0 N- z; _; W3 {- J6 i
88.     /* PLL configuration = HSE * 6 = 48 MHz  设置 PLL 时钟来源为 HSE(外接了8MHz)，设置PLL不分频，设置 PLL 6倍频 */
    + o5 ]7 m: Q: }+ |
89.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
    9 o5 }- O7 R6 v7 k+ v8 _8 [
90.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_PREDIV1 | RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLMULL6);
    & w6 }9 {7 E# N1 ^, N2 H: N/ u
91. 
    
92.     /* Enable PLL PLL使能 */
    
93.     RCC->CR |= RCC_CR_PLLON;
      m3 i6 Y+ J' R. k
94. 
    
95.     /* Wait till PLL is ready 等待PLL稳定 */
    8 t  e4 a- V2 J4 o- I5 h( R
96.     while((RCC->CR & RCC_CR_PLLRDY) == 0)
    
97.     {
    
98.     }
    7 L7 ^' Z( j& x3 \( q9 p+ a0 C( p
99. 
    
100.     /* Select PLL as system clock source  选择PLL作为系统时钟源*/
     4 ^7 f. A- @$ A
101.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
     
102.     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;   
     
103. 
     ! e$ k7 z( i* y
104.     /* Wait till PLL is used as system clock source  等待PLL作为系统时钟源稳定 */
     
105.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_PLL)
     ) M. h- D5 U" w, ^4 B% u: B8 u* e
106.     {
     ! L0 ]& z! o: V# {; D
107.     }
     ! v, L) k( `+ |; L/ S2 `; E
108.   }
     
109.   else
     , m1 ~$ N$ y# T& K) X
110.   { /* If HSE fails to start-up, the application will have wrong clock         如果HSE启动失败，应用将使用错误的配置
     
111.          configuration. User can add here some code to deal with this error 用户可以在这里添加处理错误的代码 */
     1 Z' O$ f0 ^" g$ U3 t3 h1 j& Z
112.   }  
     $ E8 U* I. W2 [' z
113. }

复制代码

以上分析了标准库函数中配置系统时钟的程序逻辑，下面介绍当用户需要修改自己的时钟频率时的处理方法，

' f. ]! f- m6 J3 I, f4.1【标准库】的配置方式
5 b/ t) `. d* x! D4 D; |& F  u( ^( V步骤：
4 u5 v$ o  }) A1 g1 t- b1 s9 J1、只要参照 SetSysClock() 函数重新编写一个自己的配置系统时钟的函数
2、在main函数中进行调用，调用语句需要放在main函数的函数体第一行，以确保在他初始化前已经重新设置好了自己需要的系统时钟
$ I. P* A) d3 n: z9 l% t* s5 ~
1 M* A! a5 W! \& D1 ?: c

1. /*========================================= 自定义 HSE 系统时钟 =========================================*/
   8 }' L* C, P, M
2. /************************************************
   
3. 函数名称 ： HSE_SetSysClock
   
4. 功    能 ： 外部高速时钟配置
   " ?* [, I, j6 H* `8 e# [+ ?" f
5. 参    数 ： RCC_PLLMul_x：用来设置PLL的倍频因子，在调用的时候形参可以是： RCC_PLLMul_x , x:[2,3,...16]，这些宏来源于
   ! V3 v& f. |  r1 a# S6 E
6.                         库函数的定义，具体功能是配置了时钟配置寄存器 CFGR 的位 21-18 PLLMUL[3:0]，预先定义好倍频因子，方便调用
     S# K9 B9 w; b5 _
7. 返 回 值 ： 无
   
8. 作    者 ： JayYang
   
9. *************************************************/
   
10. void HSE_SetSysClock(uint32_t RCC_PLLMul_x){
    4 g: L& c( f$ y& s% X
11.         __IO uint32_t StartUpCounter = 0, HSE_StartUpStatus = 0;        //定义启动计数参数，以及外部高速时钟启动状态参数
    
12. 
    
13.     //把RCC外设初始化成复位状态，这句是必须的
    / X/ ?* T" c& N' b5 ^- Y- ^& _
14.     RCC_DeInit();
    ( v  r; z3 k7 ~: I
15. 
    8 K# c" D$ `- F, D+ c
16.     //使能HSE，开启外部晶振，本人系统中用的是 8MHz
    $ F+ J1 [* }7 }3 U, O: x
17.     RCC_HSEConfig(RCC_HSE_ON);
    9 M3 b" Q) v6 p5 ^$ `% F( J" U
18. 
    
19.     //等待 HSE 启动稳定
    ; w4 H1 {5 p, D, v$ `
20.     HSE_StartUpStatus = RCC_WaitForHSEStartUp();
    4 n( l* Z1 `; t/ x; [0 ]
21. 
    9 w  u" s6 I5 `
22.     //如果 HSE 成功启动并且稳定下来
    1 r6 ]: m* U1 R
23.     if(HSE_StartUpStatus==SUCCESS){
      N+ b$ @0 u7 e( t! }
24. 
    
25.     //-----------------------------------------------------------------//
    8 Q0 [1 G& i4 H! k9 J- r1 t, M
26.         //使能 FLASH 预存取缓冲区
    
27.         FLASH_PrefetchBufferCmd(ENABLE);
    
28. 
    7 S* s5 m  E" x$ _) f
29.         // SYSCLK 周期与闪存访问时间的比例设置，这里统一设置成 1
    $ P* i# U3 i) w0 l( G
30.         // 设置成 1 的时候， SYSCLK 低于 24M 也可以工作，如果设置成 0 的时候，
    ' W8 h/ q& G6 E7 l/ U( r
31.         // 如果配置的 SYSCLK 超出了范围的话，则会进入硬件错误，程序就死了
    " {9 g0 A: X/ t- y
32.         // 0： 0 < SYSCLK <= 24M
    2 l4 T/ I1 R+ E* H# Z" p0 M4 ~
33.         // 1： 24< SYSCLK <= 48M
    
34.         FLASH_SetLatency(FLASH_Latency_1);
    
35.     //-----------------------------------------------------------------//
    9 A! i$ ]1 c- K. g  y- u( O  N
36.         //AHB 预分频因子设置为1分频，HCLK = SYSCLK
    ' Y" ]9 R: h+ f0 a
37.         RCC_HCLKConfig(RCC_SYSCLK_Div1);
    
38. 
    
39.         //APB 预分频因子设置为1分频，PCLK = HCLK
    . `5 j9 `6 U1 v$ Y( |' R
40.         RCC_PCLKConfig(RCC_HCLK_Div1);
    
41.     //-----------------------------------------------------------------//
    6 s$ k( M0 _7 \- l) V0 }* b7 x* y9 e
42. 
    
43.     //-----------------设置各种频率主要就是在这里设置-------------------//
    
44.         // 设置 PLL 时钟来源为HSE，设置PLL倍频因子
    $ q" o8 {% W# L
45.         // PLLCLK = 8MHz * RCC_PLLMul_x
    
46.         RCC_PLLConfig(RCC_PLLSource_PREDIV1,RCC_PLLMul_x);
    
47. 
    9 L1 L' K+ Z$ b$ B* t* x
48.         //开启 PLL
    
49.         RCC_PLLCmd(ENABLE);
    
50. 
    9 c% I5 i9 A1 F3 i! Z; F
51.         //等待 PLL 稳定
    7 O( {: ~0 U  j: k. c" i5 I) T$ X
52.         while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
    
53. 
    
54.         //当PLL稳定之后，把PLL时钟切换为系统时钟SYSCLK
    . ]7 N: e9 G9 `( v
55.         RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
    
56.     }
    8 [) F- W! |" ~& I. p  r% \2 X, g
57.     else{
    ' {* R% h; \- y) a
58.         //当HSE开启失败或者故障的时候，单片机会自动把HSI设置为系统时钟，HSI 是内部的高速时钟，8MHz
    
59.         //程序就会来到这里，用户可在这里添加出错的代码处理
    
60.         while(1){
    
61.         }
    / p' s7 s1 V( g$ g1 p' q
62.     }
    4 E3 G! A# C9 c
63. }
    
64. 
    
65. /*=========================== main.c主函数调用 ===========================*/
    
66. int main(void){
    " _! d+ l8 ]6 ?4 H& m! K- r( [
67.         HSE_SetSysClock(RCC_PLLMul_9);                 //设置系统时钟为： 8MHZ * 9 =72MHZ。
    / O: @, v4 e3 ^+ x3 j9 b: p
68. }
    
69. 
    
70. 
    , h) ]" \( d$ o9 f
71. /*========================================= 自定义 HSI 系统时钟 =========================================*/
    
72. /************************************************
    
73. 函数名称 ： HSI_SetSysClk
    + `! z( }* Q  x9 U/ }- D" }
74. 功    能 ： 外部高速时钟配置
    
75. 参    数 ： RCC_PLLMul_x：用来设置PLL的倍频因子，在调用的时候形参可以是： RCC_PLLMul_x , x:[2,3,...16]，这些宏来源于
    
76.                         库函数的定义，具体功能是配置了时钟配置寄存器 CFGR 的位 21-18 PLLMUL[3:0]，预先定义好倍频因子，方便调用
    
77. 返 回 值 ： 无
    
78. 作    者 ： JayYang
    , }0 d% a) s/ {" m6 D9 a' K# q
79. *************************************************/
    ; H$ ]- x5 x( |7 C' P; W
80. void HSI_SetSysClk( uint32_t RCC_PLLMul_x)
    
81. {
    : O" S9 T1 G- D4 O
82.         __IO uint32_t HSI_StartUpStatus = 0;                //定义内部高速时钟启动状态
    - h! ~2 F8 `8 i& g) v5 I
83.         
    
84.         // 把 RCC 外设初始化成复位状态，这句是必须的
    " P/ t, S1 X. H! U) r6 u
85.         RCC_DeInit();        
    " p& C  {3 _$ w* Y% Y: C
86. 
    
87.         // 使能 HSI
    
88.         RCC_HSICmd(ENABLE);
    6 e  A, E) G, C+ P2 S3 p& ]
89.         
    
90.         // 等待 HSI 就绪
    
91.         HSI_StartUpStatus = RCC->CR & RCC_CR_HSIRDY;
    # n2 L$ @7 _2 {
92.         
    
93.         // 只有 HSI 就绪之后则继续往下执行
    
94.         if( HSI_StartUpStatus== RCC_CR_HSIRDY )
    
95.         {
    
96.         //-----------------------------------------------------------------//
    
97.         //使能 FLASH 预存取缓冲区
    
98.                 FLASH_PrefetchBufferCmd(ENABLE);
    
99. 
    & c# b0 H" ?4 `0 }4 T+ ?1 a: P
100.         // SYSCLK 周期与闪存访问时间的比例设置，这里统一设置成 1
     $ S4 K/ Q) [4 [! I0 b+ F
101.         // 设置成 1 的时候， SYSCLK 低于 24M 也可以工作，如果设置成 0 的时候，
     + v( Q$ B0 U' ]# r2 F" f
102.         // 如果配置的 SYSCLK 超出了范围的话，则会进入硬件错误，程序就死了
     
103.         // 0： 0 < SYSCLK <= 24M
     
104.         // 1： 24< SYSCLK <= 48M
     / h& f8 N# J7 O5 o& \8 a2 o# i
105.                 FLASH_SetLatency(FLASH_Latency_1);
     
106.                
     
107.         //AHB 预分频因子设置为1分频，HCLK = SYSCLK
     
108.                 RCC_HCLKConfig(RCC_SYSCLK_Div1);
     ! o. p6 o8 a. g! m6 k
109. 
     ' R$ W" u: [- j6 V7 D+ l0 X# k$ L
110.         //APB 预分频因子设置为1分频，PCLK = HCLK
     
111.                 RCC_PCLKConfig(RCC_HCLK_Div1);
     
112.     //-----------------------------------------------------------------//
     
113. 
     
114.     //-----------------设置各种频率主要就是在这里设置-------------------//
     : j3 j, c) N' a# S7 d* i4 u& l
115.                 // 配置 PLLCLK = HSI * RCC_PLLMul_x
     
116.         RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_x);
     5 U# u) F0 ?# I9 f/ H+ E4 j
117.                
     6 v2 Q- `  R3 X4 o% z. q% n
118.         // 使能PLL
     
119.                 RCC_PLLCmd(ENABLE);
     1 |+ Y  P8 ], O* v0 q
120.                
     
121.                 // 等待PLL稳定
     ' ]. G4 Z5 H9 I0 n" Z% w
122.                 while( RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET );
     : f9 X( \+ h8 x+ V
123.                
     & K- X& B9 m1 }4 z6 _
124.         //当PLL稳定之后，把PLL时钟切换为系统时钟SYSCLK
     ( q0 _2 C7 E6 }: q  ^  v" {
125.                 RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     & L0 i; @3 o" f3 {! }5 f
126.                
     : N$ J8 [$ _& i4 v
127.         //读取时钟切换状态位，确保 PLLCLK 被选为系统时钟
     ' g5 X, b0 C* u1 M1 s) y
128.         while( RCC_GetSYSCLKSource() != 0x08 );
     / E2 r! z+ c$ }2 K2 h& f
129.         }
     
130.         else
     : F' {$ _/ c$ Y$ F8 Q
131.     {
     
132.                 //当HSI开启失败或者故障的时候，程序就会来到这里，用户可在这里添加出错的代码处理
     
133.         while(1){
     6 k& t- q7 @5 ]# p* P& M5 V5 V9 |
134.         }
     & |7 V1 s+ ?4 [3 M2 O  w) T( `4 M+ H
135.         }
     4 U/ E9 x1 V7 I5 z# Y- o. h+ j- ^( ?
136. }
     ' l* C6 l; q' _* p& {, N0 Z
137. 
     
138. /*=========================== main.c主函数调用 ===========================*/
     
139. int main(void){
     
140.         HSI_SetSysClock(RCC_PLLMul_12);         //设置系统时钟为： 4MHZ * 12 =48MHZ。
     
141. }

复制代码

4.2【HAL库】的配置方式
. S- e' @1 z: m, ^1 x# F  |5 L步骤：
1、配置HSE系统时钟：在 STM32CubeMX 软件中选择 【System Core】→【RCC】→【选择HSE高速时钟】→【点击下拉菜单选择“晶体/陶瓷谐振器”，即电路中外接晶振的】
+ ]! d* S. o( H/ w6 l( {" g
* I) ~; c  c! a6 i

* I, m  |2 I. D  F

6 z/ y' S: r5 c) r7 R) X
$ ?' x8 Q6 I, [- q

. B) d5 }. \! [/ {# u' p; @
8 Q6 j+ n5 w- _2 D) H" DSTM32CubeMX软件可以直接生成MDK项目代码，双击打开项目工程，先进行项目编译，然后打开 main.c 查看源代码，找到 **SystemClock_Config();**函数，这个就是STM32CubeMX生成的系统时钟配置函数，代码已全部自动生成，无需用户再次修改任何内容，生成的系统时钟，就是上文配置的外部8MHz的晶振，经过6倍频后，最终生成了48MHz的系统时钟频率。
% H3 X; i/ o) ^. s* A( `

进入函数体内查看源代码

8 B" V8 R. }" e$ I; j4 l- B: X
2、配置HSI系统时钟，按下图设置CubeMX软件，并生成代码
  l8 `) w" O. [( l7 Y" D: N

同样打开项目中的main文件
0 K6 w" x" w, b
8 S; i9 e5 u5 k0 b  G# i- g

进入函数体内查看源代码

8 y3 w" N( |( `7 v; `

, B7 e$ v1 q* F7 C
: e7 `. H0 {3 y至此，关于STM32F0系列的系统时钟的配置及修改方法如上所述，本人刚开始写博客，有不好或者错误的地方希望各路大神指教。此博文的主要目的是，作为自己的一个学习笔记，在自己学习的过程中做好相应的记录，方便以后回顾和巩固，也方便有需要的朋友。因为我发现只看一些教学视频的讲解，和动手练习操作一遍是很难学会的，还是要通过做笔记的方式来对知识进行巩固和累积才能帮助我真正的消化和学懂相关知识，谢谢！

' l& `% O5 A6 s0 h, f( V  j