01. STM32F4时钟系统概述
时钟系统是 CPU 的脉搏，就像人的心跳一样。所以时钟系统的重要性就不言而喻了。 STM32F4 的时钟系统比较复杂，不像简单的 51 单片机一个系统时钟就可以解决一切。于是有人要问，采用一个系统时钟不是很简单吗？为什么 STM32 要有多个时钟源呢？ 因为首先 STM32 本身非常复杂，外设非常的多，但是并不是所有外设都需要系统时钟这么高的频率，比如看门狗以及 RTC 只需要几十 k 的时钟即可。同一个电路，时钟越快功耗越大，同时抗电磁干扰能力也会越弱，所以对于较为复杂的 MCU 一般都是采取多时钟源的方法来解决这些问题。
$ a/ O+ ~; ^; J8 P1 ^' W- S: s; g4 f
02. STM32F4时钟系统图
! o& f) E, u) O% l
4 ?$ I- F: S( P

在 STM32F4 中，有 5 个最重要的时钟源，为 HSI、HSE、LSI、LSE、PLL。其中 PLL 实际是分为两个时钟源，分别为主 PLL 和专用 PLL。从时钟频率来分可以分为高速时钟源和低速时钟源，在这 5 个中 HSI，HSE 以及 PLL 是高速时钟，LSI 和 LSE 是低速时钟。从来源可分为外部时钟源和内部时钟源，外部时钟源就是从外部通过接晶振的方式获取时钟源，其中 HSE 和LSE 是外部时钟源，其他的是内部时钟源。下面我们看看 STM32F4 的这 5 个时钟源，我们讲解顺序是按图中红圈标示的顺序：
( S, o& P) |+ {2 F' y# m6 M
! H$ ^% w! O. H+ M) A( p8 A, ~! p①、LSI 是低速内部时钟，RC 振荡器，频率为 32kHz 左右。供独立看门狗和自动唤醒单元使用。
' P: }$ |# @- `$ i; H②、LSE 是低速外部时钟，接频率为 32.768kHz 的石英晶体。这个主要是 RTC 的时钟源。
/ |, u) F8 E. ?( S! N③、HSE 是高速外部时钟，可接石英/陶瓷谐振器，或者接外部时钟源，频率范围为 4MHz~26MHz。我们的开发板接的是 8M 的晶振。HSE 也可以直接做为系统时钟或者 PLL 输入。
④、HSI 是高速内部时钟，RC 振荡器，频率为 16MHz。可以直接作为系统时钟或者用作 PLL输入。
8 W; r, o' Z+ v% g! ?) ?5 H
⑤、PLL 为锁相环倍频输出。STM32F4 有两个 PLL:
5 F1 p* q( _3 L& Z5 r+ @3 o1） 主 PLL(PLL)由 HSE 或者 HSI 提供时钟信号，并具有两个不同的输出时钟。
第一个输出 PLLP 用于生成高速的系统时钟（最高 168MHz）
" x3 j( L/ ~/ s* a2 }: d第二个输出 PLLQ 用于生成 USB OTG FS 的时钟（48MHz），随机数发生器的时钟和 SDIO时钟。
. k. |$ F$ O, A' B2）专用 PLL(PLLI2S)用于生成精确时钟，从而在 I2S 接口实现高品质音频性能。

A. 这里是看门狗时钟输入。从图中可以看出，看门狗时钟源只能是低速的 LSI 时钟。
9 C1 ]9 X2 d: ]5 n/ [) a3 ^  V( f
) _/ P3 u. g" j! i4 pB. 这里是 RTC 时钟源，从图上可以看出，RTC 的时钟源可以选择 LSI，LSE，以及HSE 分频后的时钟，HSE 分频系数为 2~31。
7 `( b/ m7 F4 }- F  }! J( ?
C. 这里是 STM32F4 输出时钟 MCO1 和 MCO2。MCO1 是向芯片的 PA8 引脚输出时钟。它有四个时钟来源分别为：HSI,LSE,HSE 和 PLL 时钟。MCO2 是向芯片的PC9 输出时钟，它同样有四个时钟来源分别为：HSE,PLL，SYSCLK 以及 PLLI2S时钟。MCO 输出时钟频率最大不超过 100MHz。
$ l  ?& B, N# E8 f
D. 这里是系统时钟。从图 4.3.1 可以看出，SYSCLK 系统时钟来源有三个方面：HSI,HSE 和 PLL。在我们实际应用中，因为对时钟速度要求都比较高我们才会选用 STM32F4 这种级别的处理器，所以一般情况下，都是采用 PLL 作为 SYSCLK时钟源。根据前面的计算公式，大家就可以算出你的系统的 SYSCLK 是多少。
  n8 r& S+ e9 [( j' H- K
E. 这里我们指的是以太网 PTP 时钟，AHB 时钟，APB2 高速时钟，APB1 低速时钟。这些时钟都是来源于 SYSCLK 系统时钟。其中以太网 PTP 时钟是使用系统时钟。AHB,APB2 和 APB1 时钟是经过 SYSCLK 时钟分频得来。这里大家记住，AHB最大时钟为168MHz, APB2高速时钟最大频率为84MHz,而APB1低速时钟最大频率为 42MHz。
% V0 Y: c% V& K  p# g5 H2 z5 z0 ]# U
' {( C- |: f# o0 tF. 这里是指 I2S 时钟源。从图 4.3.1 可以看出，I2S 的时钟源来源于 PLLI2S 或者映射到 I2S_CKIN 引脚的外部时钟。I2S 出于音质的考虑，对时钟精度要求很高。探索者 STM32F4 开发板使用的是内部 PLLI2SCLK。
1 }5 I- T0 d" P, [# Z7 D) n% {' H
! |  }0 N+ ~8 {9 E% A; `$ {  ZG. 这是 STM32F4 内部以太网 MAC 时钟的来源。对于 MII 接口来说，必须向外部PHY 芯片提供 25Mhz 的时钟，这个时钟，可以由 PHY 芯片外接晶振，或者使用STM32F4 的 MCO 输出来提供。然后，PHY 芯片再给 STM32F4 提供ETH_MII_TX_CLK 和 ETH_MII_RX_CLK 时钟。对于 RMII 接口来说，外部必须提供 50Mhz 的时钟驱动 PHY 和 STM32F4 的 ETH_RMII_REF_CLK，这个 50Mhz时钟可以来自 PHY、有源晶振或者 STM32F4 的 MCO。我们的开发板使用的是RMII 接 口 ， 使 用 PHY 芯 片 提 供 50Mhz 时 钟 驱 动 STM32F4 的ETH_RMII_REF_CLK。

H. 这里是指外部 PHY 提供的 USB OTG HS（60MHZ）时钟。

03. STM32F4时钟初始化配置
STM32F4 时钟系统初始化是在 system_stm32f4xx.c 中的 SystemInit()函数中完成的。对于系统时钟关键寄存器设置主要是在 SystemInit 函数中调用 SetSysClock()函数来设置的。我们可以先看看 SystemInit ()函数体。

* r, }3 @( R  ~

1. /**
   
2.   * @brief  Setup the microcontroller system
   
3.   *         Initialize the Embedded Flash Interface, the PLL and update the
   
4.   *         SystemFrequency variable.
   
5.   * @param  None
   2 ^5 V' t7 b5 S7 E
6.   * @retval None
   " G: S; t5 w: f& l  z2 D3 l
7.   */
   ( k% a% j9 b# {. P
8. void SystemInit(void)
   3 [& E+ D9 M# S% }
9. {
   
10.   /* FPU settings ------------------------------------------------------------*/
    
11.   #if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
    
12.     SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2));  /* set CP10 and CP11 Full Access */
    0 p& ^! H) Z2 e( G  Q
13.   #endif
    + @" Y  G# |, B: r  A* _/ l
14.   /* Reset the RCC clock configuration to the default reset state ------------*/
    9 [4 A% m8 h3 ~: H
15.   /* Set HSION bit */
    & A# \6 J& w9 ~( Q" F6 ~) I& G2 K) n
16.   RCC->CR |= (uint32_t)0x00000001;
    
17. 
    
18.   /* Reset CFGR register */
    / c$ q; w0 t0 D6 c* }% n/ ^
19.   RCC->CFGR = 0x00000000;
    
20. 
    . b! Y/ c3 [) b/ J: I. {
21.   /* Reset HSEON, CSSON and PLLON bits */
    ) L0 v' B6 w4 f. e0 {5 A
22.   RCC->CR &= (uint32_t)0xFEF6FFFF;
    
23. 
    
24.   /* Reset PLLCFGR register */
      B9 q0 u$ [0 j9 |% ]7 X
25.   RCC->PLLCFGR = 0x24003010;
    
26. 
    8 e% [. _8 x; Z; e, n3 U9 o7 N
27.   /* Reset HSEBYP bit */
    
28.   RCC->CR &= (uint32_t)0xFFFBFFFF;
    " A- ?( f8 X. t* t8 k, f/ r
29. 
    9 D& N8 s$ t* Y7 _' B' S
30.   /* Disable all interrupts */
    6 w- c' h. [6 r1 |4 o% K4 t
31.   RCC->CIR = 0x00000000;
    
32. 
    8 \) N' I1 V9 {1 W0 G
33. #if defined(DATA_IN_ExtSRAM) || defined(DATA_IN_ExtSDRAM)
    
34.   SystemInit_ExtMemCtl();
    
35. #endif /* DATA_IN_ExtSRAM || DATA_IN_ExtSDRAM */
    4 U( r. t& O' O, q
36. 
    
37.   /* Configure the System clock source, PLL Multiplier and Divider factors,
    8 b# S. B% P- K& x* B$ \+ v
38.      AHB/APBx prescalers and Flash settings ----------------------------------*/
    ; t5 ?0 V4 w, m9 I, V: D
39.   SetSysClock();
    + @9 {0 X- I, g. G8 O# x$ R* h
40. 
    
41.   /* Configure the Vector Table location add offset address ------------------*/
    
42. #ifdef VECT_TAB_SRAM
    6 ~0 ~* x2 g- s, `3 q8 i: A
43.   SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM */
    1 z+ R5 d# g. c- l' p
44. #else
    6 t( x6 |' t8 O. v0 f% E
45.   SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH */
    
46. #endif
    
47. }

复制代码

+ }  V1 i( `2 M* b在设置完相关寄存器后，接下来 SystemInit 函数内部会调用 SetSysClock 函数。
) D8 ~0 Y) V2 p- c/ H. g

1. /**
   + J5 @6 Y% p+ ]+ K4 F9 n
2.   * @brief  Configures the System clock source, PLL Multiplier and Divider factors,
   6 |* D: J' w; Z+ S- k. Z) v. z
3.   *         AHB/APBx prescalers and Flash settings
   - o- w/ i) _# m% E. J
4.   * @Note   This function should be called only once the RCC clock configuration  
   ' w0 K0 K1 P4 C3 C, f5 G6 s3 `
5.   *         is reset to the default reset state (done in SystemInit() function).   
   - q; [; h, j3 R3 C  z: u4 O4 l
6.   * @param  None
   
7.   * @retval None
   
8.   */
   6 r  w* H2 f% G. ]' w: l
9. static void SetSysClock(void)
   3 T5 h( @+ Q% b2 q
10. {
    . O; N7 R0 ]$ }, y7 Y
11. #if defined(STM32F40_41xxx) || defined(STM32F427_437xx) || defined(STM32F429_439xx) || defined(STM32F401xx) || defined(STM32F412xG) || defined(STM32F413_423xx) || defined(STM32F446xx)|| defined(STM32F469_479xx)
    
12. /******************************************************************************/
      P) y; K7 {( n, y- X' A% t
13. /*            PLL (clocked by HSE) used as System clock source                */
    
14. /******************************************************************************/
    
15.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
    
16. 
    6 U+ M* ~. P7 q4 ^* ~1 a1 u
17.   /* Enable HSE */ //HSE时钟使能
    & s, q. g  S1 f# a) ~2 Y! |$ r) w
18.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);
    ) I# N* o/ ~5 D% E  @
19.   //等待HSE时钟稳定
    8 Q+ z2 ?) j: ~5 A# q( l+ R
20.   /* Wait till HSE is ready and if Time out is reached exit */
    
21.   do
    $ b7 [& b) w1 X5 r- g7 I8 u
22.   {
      ~9 y' Y" {( |
23.     HSEStatus = RCC->CR & RCC_CR_HSERDY;
    ) ]! X/ p, C4 n) `
24.     StartUpCounter++;
    
25.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    " ~& h* P2 E  Z! ^0 ]
26. 
    - T! h9 A7 [/ p! k3 |
27.   if ((RCC->CR & RCC_CR_HSERDY) != RESET)
    ( P8 w9 I. X' G  B- k) K
28.   {
    
29.     HSEStatus = (uint32_t)0x01;
    
30.   }
    " X( I( l: ~0 W. x
31.   else
    
32.   {
    
33.     HSEStatus = (uint32_t)0x00;
    9 h% S0 Z8 l# i9 C  T# j( f
34.   }
    
35. 
    
36.   if (HSEStatus == (uint32_t)0x01)
    . r) ]9 ?/ v$ l, `
37.   {
    
38.     /* Select regulator voltage output Scale 1 mode */
    
39.     RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    
40.     PWR->CR |= PWR_CR_VOS;
    
41.         //AHB不分频
    
42.     /* HCLK = SYSCLK / 1*/
    
43.     RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
    & v. a" T2 K5 M* [' f0 ~
44. 
    
45. #if defined(STM32F40_41xxx) || defined(STM32F427_437xx) || defined(STM32F429_439xx) ||  defined(STM32F412xG) || defined(STM32F446xx) || defined(STM32F469_479xx)   
    
46.     /* PCLK2 = HCLK / 2*/ //高速APB二分频
    - Z* F# ~- n" G( ^( j' |, T& {6 H, [6 a
47.     RCC->CFGR |= RCC_CFGR_PPRE2_DIV2;
    
48. 
    
49.     /* PCLK1 = HCLK / 4*/ //低速APB4分频
    $ t- P5 D1 i  f' {0 n- Z* ]
50.     RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;
    
51. #endif /* STM32F40_41xxx || STM32F427_437x || STM32F429_439xx  || STM32F412xG || STM32F446xx || STM32F469_479xx */
    
52. 
    
53. #if defined(STM32F401xx) || defined(STM32F413_423xx)
    
54.     /* PCLK2 = HCLK / 1*/
    
55.     RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;
    
56. 
    6 I. p9 R2 z! u! r! c
57.     /* PCLK1 = HCLK / 2*/
    
58.     RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;
    ' C" ]4 b) c* e! g5 N( U+ n
59. #endif /* STM32F401xx || STM32F413_423xx */
    
60. 
    ( S2 s) J' ~' p+ T: w" R7 M9 s, N
61. #if defined(STM32F40_41xxx) || defined(STM32F427_437xx) || defined(STM32F429_439xx) || defined(STM32F401xx) || defined(STM32F469_479xx)   
    
62.     /* Configure the main PLL */
      P: t" \0 v# `4 C
63.     RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
    
64.                    (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);
    
65. #endif /* STM32F40_41xxx || STM32F401xx || STM32F427_437x || STM32F429_439xx || STM32F469_479xx */
    $ d2 |; I  V4 L, T7 @2 B" p
66. 
    
67. #if  defined(STM32F412xG) || defined(STM32F413_423xx) || defined(STM32F446xx)
    0 W0 S: [) s! Q. l% ^% T
68.     /* Configure the main PLL */
    $ @3 q& C$ ?. H" |0 B! P
69.     RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
    / ]2 k: [/ u. l: k# q) [2 }& a1 I
70.                    (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24) | (PLL_R << 28);
    
71. #endif /* STM32F412xG || STM32F413_423xx || STM32F446xx */   
    ; I: ?8 z5 N% H% y; B& R2 i
72. 
    
73.     /* Enable the main PLL */
    " ]! n/ E3 ?5 K6 h+ q3 H
74.     RCC->CR |= RCC_CR_PLLON;
    : Q0 E" N5 q; N0 E" m. w. m
75. 
    
76.     /* Wait till the main PLL is ready */
    - M( ~, D/ i% _% m& K1 D& o: P
77.     while((RCC->CR & RCC_CR_PLLRDY) == 0)
    
78.     {
    4 q3 p. ~$ B+ F( g% l  @
79.     }
    
80. 
    3 t, l- b" ]$ v) w; w
81. #if defined(STM32F427_437xx) || defined(STM32F429_439xx) || defined(STM32F446xx) || defined(STM32F469_479xx)
    ( [# ?9 ^$ X$ H4 c5 J1 M8 }
82.     /* Enable the Over-drive to extend the clock frequency to 180 Mhz */
    8 Q8 [2 m4 S2 H# ?' _3 y  H+ y' z' k
83.     PWR->CR |= PWR_CR_ODEN;
    
84.     while((PWR->CSR & PWR_CSR_ODRDY) == 0)
    
85.     {
    ) K6 g6 O5 S  k
86.     }
    8 `( W( S$ l. _6 M5 y
87.     PWR->CR |= PWR_CR_ODSWEN;
    
88.     while((PWR->CSR & PWR_CSR_ODSWRDY) == 0)
    
89.     {
    ! L! S+ f' y+ s, D- s
90.     }      
    
91.     /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    
92.     FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
    
93. #endif /* STM32F427_437x || STM32F429_439xx || STM32F446xx || STM32F469_479xx */
    
94. 
    
95. #if defined(STM32F40_41xxx)  || defined(STM32F412xG)  
    : s4 E! w% [2 s4 A0 Z# Y
96.     /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    ) [/ |$ ~& S# h
97.     FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
    7 X# z( U; U3 X
98. #endif /* STM32F40_41xxx  || STM32F412xG */
    
99. 
    
100. #if defined(STM32F413_423xx)  
     2 C5 Q$ @# s' ~! d( J$ j( |
101.     /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
     ( Z* q# ~2 @2 i/ ^8 M( q
102.     FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_3WS;
     
103. #endif /* STM32F413_423xx */
     % F7 b- @# \  E0 b# I
104. 
     7 @+ K. k+ H; i. H$ E* x
105. #if defined(STM32F401xx)
     9 S. d$ l  `& b+ R4 C' M7 {& H5 r
106.     /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
     8 N7 I; G( n" F5 {  v
107.     FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_2WS;
     
108. #endif /* STM32F401xx */
     8 D! [' R. M/ P
109. 
     4 d0 E1 u, c4 |+ ~6 Y$ P
110.     /* Select the main PLL as system clock source */
     
111.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
     ' z/ {8 Q+ C* o+ ~" ~3 \
112.     RCC->CFGR |= RCC_CFGR_SW_PLL;
     
113. 
     & K- L7 w. p( d7 C( n8 N
114.     /* Wait till the main PLL is used as system clock source */
     
115.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
     
116.     {
     
117.     }
     
118.   }
       M7 T! B6 M9 U& j! v* l8 L1 G
119.   else
     5 Z$ t. ^) a7 a7 f) L
120.   { /* If HSE fails to start-up, the application will have wrong clock
     
121.          configuration. User can add here some code to deal with this error */
     
122.   }
     . d7 W( U) S* T4 o; Y1 Q" R
123. #elif defined(STM32F410xx) || defined(STM32F411xE)
     ; ~, y0 u; p) Y- ]
124. #if defined(USE_HSE_BYPASS)
     
125. /******************************************************************************/
     
126. /*            PLL (clocked by HSE) used as System clock source                */
     
127. /******************************************************************************/
     
128.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
     
129. 
     
130.   /* Enable HSE and HSE BYPASS */
     
131.   RCC->CR |= ((uint32_t)RCC_CR_HSEON | RCC_CR_HSEBYP);
     
132. 
     
133.   /* Wait till HSE is ready and if Time out is reached exit */
     8 {& @2 ^) D4 t* D+ ?$ ?. @3 O! t
134.   do
     
135.   {
     8 \$ m+ |& x9 t: Y2 E' W
136.     HSEStatus = RCC->CR & RCC_CR_HSERDY;
     
137.     StartUpCounter++;
     
138.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
     3 V" R& i4 v- Q+ s7 x
139. 
     7 [* P9 y* R# }; B5 Q" m
140.   if ((RCC->CR & RCC_CR_HSERDY) != RESET)
     - O4 j$ s2 T$ N$ Y. ?( g2 w7 E
141.   {
     ( t6 h" C) _+ S6 r- b
142.     HSEStatus = (uint32_t)0x01;
     
143.   }
     
144.   else
     
145.   {
     
146.     HSEStatus = (uint32_t)0x00;
     
147.   }
     - P7 e. {  D+ L( J. I6 q$ E
148. 
     * a- L7 H; X" z
149.   if (HSEStatus == (uint32_t)0x01)
     
150.   {
     3 e6 m. X" M: o) M5 T  c* W
151.     /* Select regulator voltage output Scale 1 mode */
     
152.     RCC->APB1ENR |= RCC_APB1ENR_PWREN;
     
153.     PWR->CR |= PWR_CR_VOS;
     & p- P" m. k( s9 o. w( y3 ?$ F: u
154. 
     
155.     /* HCLK = SYSCLK / 1*/
     ( }9 h" Q0 m. B+ ?+ U' @
156.     RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
     7 X. N( E, p4 C% h) M8 J) \2 `
157. 
     
158.     /* PCLK2 = HCLK / 2*/
     # @* F2 t% Q7 I2 d4 g" B$ n: {
159.     RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;
     
160. 
     4 S7 U! a$ Y& B% p7 r+ {: r- I
161.     /* PCLK1 = HCLK / 4*/
     
162.     RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;
     ; U. d9 y9 g% r& t8 L
163. 
     . x0 T) l; _. L# T6 k* }
164.     /* Configure the main PLL */
     
165.     RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
     
166.                    (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);
     
167. 
     8 h% i* ~8 [. s( h
168.     /* Enable the main PLL */
     . U& G$ X& H$ y) B/ H8 |
169.     RCC->CR |= RCC_CR_PLLON;
     " H1 F$ d4 X4 @7 p! s& S% M( y) f7 G
170. 
     
171.     /* Wait till the main PLL is ready */
     
172.     while((RCC->CR & RCC_CR_PLLRDY) == 0)
     * t# I: f( m5 _* V% v& [
173.     {
     3 A* T' Y+ C/ g6 n' {
174.     }
     
175. 
     
176.     /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
     % `8 {: e* D' ]( }1 [% ~/ X3 O$ ?
177.     FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_2WS;
     3 _+ j1 o0 l  Q$ l% _
178. 
     
179.     /* Select the main PLL as system clock source */
     6 x% J( ~# {3 }
180.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
     
181.     RCC->CFGR |= RCC_CFGR_SW_PLL;
     - F8 {9 z+ B* W. u4 i
182. 
     
183.     /* Wait till the main PLL is used as system clock source */
     
184.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
     
185.     {
     
186.     }
     
187.   }
     
188.   else
     6 m4 h" s1 M; p* h& {+ l2 C2 _/ w8 {
189.   { /* If HSE fails to start-up, the application will have wrong clock
     
190.          configuration. User can add here some code to deal with this error */
     ' {  A+ ^% F& t$ @6 F' H7 C9 i
191.   }
     . B1 C/ t2 Z  w+ s
192. #else /* HSI will be used as PLL clock source */
     0 N9 A2 Y# w( i6 X! z5 E* l# q
193.   /* Select regulator voltage output Scale 1 mode */
     * [! o+ P& s0 j* g; y$ O
194.   RCC->APB1ENR |= RCC_APB1ENR_PWREN;
     
195.   PWR->CR |= PWR_CR_VOS;
     . D4 S$ x9 T6 ]0 O: h
196. 
     
197.   /* HCLK = SYSCLK / 1*/
     
198.   RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
     4 P( v5 P" C1 b% q* D
199. 
     
200.   /* PCLK2 = HCLK / 2*/
     
201.   RCC->CFGR |= RCC_CFGR_PPRE2_DIV1;
     0 x: f# F2 r, D: ]
202. 
     
203.   /* PCLK1 = HCLK / 4*/
     
204.   RCC->CFGR |= RCC_CFGR_PPRE1_DIV2;
     . S1 [' Z+ N  ^3 ~# k  Y
205. 
     
206.   /* Configure the main PLL */
     ' _1 A+ l/ P( ]; I3 q+ ]" Q) R
207.   RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) | (PLL_Q << 24);
     / ?! B+ L# I0 _3 A* l+ {* e
208. 
     
209.   /* Enable the main PLL */
     ; v. r0 [" m1 A3 F6 P
210.   RCC->CR |= RCC_CR_PLLON;
     
211. 
     
212.   /* Wait till the main PLL is ready */
     
213.   while((RCC->CR & RCC_CR_PLLRDY) == 0)
     
214.   {
       I1 P3 o% z1 Y/ ?$ {: k7 p) i! e
215.   }
     3 n5 }, L+ j0 I/ E* @
216. 
     0 e( [. M; R( C1 |4 k! P7 p; n3 {
217.   /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
     
218.   FLASH->ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_2WS;
     
219. 
     
220.   /* Select the main PLL as system clock source */
     , R/ x2 Q4 u% @' _- E
221.   RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
     
222.   RCC->CFGR |= RCC_CFGR_SW_PLL;
     : Q/ T" Z2 {4 N* b
223. 
     
224.   /* Wait till the main PLL is used as system clock source */
     
225.   while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
     
226.   {
     ; L, u- [' C$ j* i
227.   }
     
228. #endif /* USE_HSE_BYPASS */  
     
229. #endif /* STM32F40_41xxx || STM32F427_437xx || STM32F429_439xx || STM32F401xx || STM32F469_479xx */  
     : H2 F8 W4 H4 y. t. _8 h: p
230. }

复制代码

先使能外部时钟 HSE，等待 HSE 稳定之后，配置AHB,APB1,APB2 时钟相关的分频因子，也就是相关外设的时钟。等待这些都配置完成之后，打开主 PLL 时钟，然后设置主 PLL 作为系统时钟 SYSCLK 时钟源。如果 HSE 不能达到就绪状态（比如外部晶振不能稳定或者没有外部晶振），那么依然会是 HSI 作为系统时钟。

5 L3 M( M2 h( V5 l在这里要特别提出来，在设置主 PLL 时钟的时候，会要设置一系列的分频系数和倍频系数参数。大家可以从 SetSysClock 函数的这行代码看出：

1.     /* Configure the main PLL */
   ! V7 I/ C  Q  a7 i" O/ h
2.     RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
   
3.                    (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);

复制代码

8 v7 a' W0 o6 L) Q# y这些参数是通过宏定义标识符的值来设置的。默认的配置在 System_stm32f4xx.c 文件开头的地方配置。对于我们开发板，我们的设置参数值如下：
" x' n" c1 g& Q& k2 ]& s# z1 r
' M$ t! k; J( s: {

1. #define PLL_M 8
   
2. #define PLL_Q 7
   / ~9 v) Q' ~! a) \- {5 n" `( j
3. #define PLL_N 336
   % N0 q  F) `7 r& X/ t0 c* B. j
4. #define PLL_P 2

复制代码

4 w3 f' O' B; t5 @+ t这里还有个特别需要注意的地方，就是我们还要同步修改 stm32f4xx.h 中宏定义标识符HSE_VALUE 的值为我们的外部时钟：
* m2 _5 o3 P2 X& t, Q1 s

1. #if !defined (HSE_VALUE)
   
2. #define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
   
3. #endif /* HSE_VALUE */

复制代码

这里默认固件库配置的是 25000000，我们外部时钟为 8MHz，所以我们根据我们硬件情况修改为 8000000 即可。
; W: j7 E9 m$ R% E2 q
2 _* `7 j& h6 J04. 时钟配置总结
最后我们总结一下 SystemInit()函数中设置的系统时钟大小：
SYSCLK（系统时钟） =168MHz
" s8 I" ^5 R) K. C9 Z1 B# n0 kAHB 总线时钟(HCLK=SYSCLK) =168MHz
APB1 总线时钟(PCLK1=SYSCLK/4) =42MHz
3 G- h4 W  K& K$ v, rAPB2 总线时钟(PCLK2=SYSCLK/2) =84MHz
9 }2 P3 y0 [1 Y0 PPLL 主时钟 =168MHz
; {4 c5 x' \% X3 Z, j4 T