5个时钟源
HSI，HSE，LSI，LSE，PLL

HSE为高速外部时钟，频率范围4~16 MHz

PLL的时钟源可以为：
HSE/2
HSE
HSI/2
倍频系数为2~16倍

STM32可以选择一个时钟信号输出到MCO脚，即PA8上，可以选择位PLL输出的二分频，HSI，HSE或系统时钟

注意：任何一个外设之前，都必须使能其对应的时钟

1. /**
   
2.   * @brief Reset and Clock Control
   
3.   */
   
4. 
   
5. typedef struct
   
6. {
   
7.   __IO uint32_t CR;
   
8.   __IO uint32_t CFGR;
   
9.   __IO uint32_t CIR;
   
10.   __IO uint32_t APB2RSTR;
    
11.   __IO uint32_t APB1RSTR;
    
12.   __IO uint32_t AHBENR;
    
13.   __IO uint32_t APB2ENR;
    
14.   __IO uint32_t APB1ENR;
    
15.   __IO uint32_t BDCR;
    
16.   __IO uint32_t CSR;
    
17. 
    
18. #ifdef STM32F10X_CL  
    
19.   __IO uint32_t AHBRSTR;
    
20.   __IO uint32_t CFGR2;
    
21. #endif /* STM32F10X_CL */
    
22. 
    
23. #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)   
    
24.   uint32_t RESERVED0;
    
25.   __IO uint32_t CFGR2;
    
26. #endif /* STM32F10X_LD_VL || STM32F10X_MD_VL || STM32F10X_HD_VL */
    
27. } RCC_TypeDef;

复制代码

如何查看SystemInit函数



可以看到这里有SystemInit函数的声明



打开这个文件，可以看到SystemInit函数的定义

1. 
   
2. /**
   
3.   * @brief  Setup the microcontroller system
   
4.   *         Initialize the Embedded Flash Interface, the PLL and update the
   
5.   *         SystemCoreClock variable.
   
6.   * @note   This function should be used only after reset.
   
7.   * @param  None
   
8.   * @retval None
   
9.   */
   
10. void SystemInit (void)
    
11. {
    
12.   /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
    
13.   /* Set HSION bit */
    
14.   RCC->CR |= (uint32_t)0x00000001;
    
15. 
    
16.   /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
    
17. #ifndef STM32F10X_CL
    
18.   RCC->CFGR &= (uint32_t)0xF8FF0000;
    
19. #else
    
20.   RCC->CFGR &= (uint32_t)0xF0FF0000;
    
21. #endif /* STM32F10X_CL */   
    
22.   
    
23.   /* Reset HSEON, CSSON and PLLON bits */
    
24.   RCC->CR &= (uint32_t)0xFEF6FFFF;
    
25. 
    
26.   /* Reset HSEBYP bit */
    
27.   RCC->CR &= (uint32_t)0xFFFBFFFF;
    
28. 
    
29.   /* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
    
30.   RCC->CFGR &= (uint32_t)0xFF80FFFF;
    
31. 
    
32. #ifdef STM32F10X_CL
    
33.   /* Reset PLL2ON and PLL3ON bits */
    
34.   RCC->CR &= (uint32_t)0xEBFFFFFF;
    
35. 
    
36.   /* Disable all interrupts and clear pending bits  */
    
37.   RCC->CIR = 0x00FF0000;
    
38. 
    
39.   /* Reset CFGR2 register */
    
40.   RCC->CFGR2 = 0x00000000;
    
41. #elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
    
42.   /* Disable all interrupts and clear pending bits  */
    
43.   RCC->CIR = 0x009F0000;
    
44. 
    
45.   /* Reset CFGR2 register */
    
46.   RCC->CFGR2 = 0x00000000;      
    
47. #else
    
48.   /* Disable all interrupts and clear pending bits  */
    
49.   RCC->CIR = 0x009F0000;
    
50. #endif /* STM32F10X_CL */
    
51.    
    
52. #if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)
    
53.   #ifdef DATA_IN_ExtSRAM
    
54.     SystemInit_ExtMemCtl();
    
55.   #endif /* DATA_IN_ExtSRAM */
    
56. #endif
    
57. 
    
58.   /* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
    
59.   /* Configure the Flash Latency cycles and enable prefetch buffer */
    
60.   SetSysClock();
    
61. 
    
62. #ifdef VECT_TAB_SRAM
    
63.   SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. */
    
64. #else
    
65.   SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. */
    
66. #endif
    
67. }

复制代码

如下图所示



函数解析

1. /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
   
2.   /* Set HSION bit */
   
3.   RCC->CR |= (uint32_t)0x00000001;

复制代码

首先把CR寄存器的最低位置1

Set HSION Bit 相对于打开HSION，相对于把内部的8 MHz晶振打开



也就是这个

1. /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
   
2. #ifndef STM32F10X_CL
   
3.   RCC->CFGR &= (uint32_t)0xF8FF0000;
   
4. #else
   
5.   RCC->CFGR &= (uint32_t)0xF0FF0000;
   
6. #endif /* STM32F10X_CL */   

复制代码

以上代码主要是看你所用的芯片是大容量还是小容量，可以在魔术棒-C/C++里的宏处查看，例如，大容量为：

STM32F10X_HD

因此，这里相对于是根据所用的芯片容量选择RCC->CFGR寄存器的初始状态

1.   /* Reset HSEON, CSSON and PLLON bits */
   
2.   RCC->CR &= (uint32_t)0xFEF6FFFF;

复制代码

把HSEON，CSSON和PLLON对应的位清0

1.   /* Reset HSEBYP bit */
   
2.   RCC->CR &= (uint32_t)0xFFFBFFFF;

复制代码

把HSEBYP对应的位清0

1.   /* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
   
2.   RCC->CFGR &= (uint32_t)0xFF80FFFF;

复制代码

类似

接下来是一个条件编译

1. 
   
2. #ifdef STM32F10X_CL
   
3.   /* Reset PLL2ON and PLL3ON bits */
   
4.   RCC->CR &= (uint32_t)0xEBFFFFFF;
   
5. 
   
6.   /* Disable all interrupts and clear pending bits  */
   
7.   RCC->CIR = 0x00FF0000;
   
8. 
   
9.   /* Reset CFGR2 register */
   
10.   RCC->CFGR2 = 0x00000000;
    
11. #elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
    
12.   /* Disable all interrupts and clear pending bits  */
    
13.   RCC->CIR = 0x009F0000;
    
14. 
    
15.   /* Reset CFGR2 register */
    
16.   RCC->CFGR2 = 0x00000000;      
    
17. #else
    
18.   /* Disable all interrupts and clear pending bits  */
    
19.   RCC->CIR = 0x009F0000;
    
20. #endif /* STM32F10X_CL */

复制代码

执行的是这一段：



也就是关闭所有的中断，并清除所有的标志位

接下来调用了一个非常重要的函数

1.   /* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
   
2.   /* Configure the Flash Latency cycles and enable prefetch buffer */
   
3.   SetSysClock();

复制代码

看一下这个函数的实现：

1. /**
   
2.   * @brief  Configures the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers.
   
3.   * @param  None
   
4.   * @retval None
   
5.   */
   
6. static void SetSysClock(void)
   
7. {
   
8. #ifdef SYSCLK_FREQ_HSE
   
9.   SetSysClockToHSE();
   
10. #elif defined SYSCLK_FREQ_24MHz
    
11.   SetSysClockTo24();
    
12. #elif defined SYSCLK_FREQ_36MHz
    
13.   SetSysClockTo36();
    
14. #elif defined SYSCLK_FREQ_48MHz
    
15.   SetSysClockTo48();
    
16. #elif defined SYSCLK_FREQ_56MHz
    
17.   SetSysClockTo56();  
    
18. #elif defined SYSCLK_FREQ_72MHz
    
19.   SetSysClockTo72();
    
20. #endif

复制代码

这个函数主要是看看这些标志符有没有被定义，这个定义我们是设置在下面这个文件中，我们进去看一下：

system_stm32f10x.c

1. #if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
   
2. /* #define SYSCLK_FREQ_HSE    HSE_VALUE */
   
3. #define SYSCLK_FREQ_24MHz  24000000
   
4. #else
   
5. /* #define SYSCLK_FREQ_HSE    HSE_VALUE */
   
6. /* #define SYSCLK_FREQ_24MHz  24000000 */
   
7. /* #define SYSCLK_FREQ_36MHz  36000000 */
   
8. /* #define SYSCLK_FREQ_48MHz  48000000 */
   
9. /* #define SYSCLK_FREQ_56MHz  56000000 */
   
10. #define SYSCLK_FREQ_72MHz  72000000
    
11. #endif

复制代码

SetSysClock函数通过判断宏定义标志符来判断要调用哪个函数

例如，我们在宏定义中定义了SYSCLK_FREQ_72MHz，那么SetSysClock函数就会调用SetSysClockTo72函数


SetSysClockTo72函数的实现

1. /**
   
2.   * @brief  Sets System clock frequency to 72MHz and configure HCLK, PCLK2
   
3.   *          and PCLK1 prescalers.
   
4.   * @note   This function should be used only after reset.
   
5.   * @param  None
   
6.   * @retval None
   
7.   */
   
8. static void SetSysClockTo72(void)
   
9. {
   
10.   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
    
11.   
    
12.   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/   
    
13.   /* Enable HSE */   
    
14.   RCC->CR |= ((uint32_t)RCC_CR_HSEON);
    
15. 
    
16.   /* Wait till HSE is ready and if Time out is reached exit */
    
17.   do
    
18.   {
    
19.     HSEStatus = RCC->CR & RCC_CR_HSERDY;
    
20.     StartUpCounter++;  
    
21.   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
    
22. 
    
23.   if ((RCC->CR & RCC_CR_HSERDY) != RESET)
    
24.   {
    
25.     HSEStatus = (uint32_t)0x01;
    
26.   }
    
27.   else
    
28.   {
    
29.     HSEStatus = (uint32_t)0x00;
    
30.   }  
    
31. 
    
32.   if (HSEStatus == (uint32_t)0x01)
    
33.   {
    
34.     /* Enable Prefetch Buffer */
    
35.     FLASH->ACR |= FLASH_ACR_PRFTBE;
    
36. 
    
37.     /* Flash 2 wait state */
    
38.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
    
39.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;   
    
40. 
    
41. 
    
42.     /* HCLK = SYSCLK */
    
43.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
    
44.       
    
45.     /* PCLK2 = HCLK */
    
46.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
    
47.    
    
48.     /* PCLK1 = HCLK */
    
49.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
    
50. 
    
51. #ifdef STM32F10X_CL
    
52.     /* Configure PLLs ------------------------------------------------------*/
    
53.     /* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
    
54.     /* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
    
55.         
    
56.     RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
    
57.                               RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
    
58.     RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
    
59.                              RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
    
60.   
    
61.     /* Enable PLL2 */
    
62.     RCC->CR |= RCC_CR_PLL2ON;
    
63.     /* Wait till PLL2 is ready */
    
64.     while((RCC->CR & RCC_CR_PLL2RDY) == 0)
    
65.     {
    
66.     }
    
67.    
    
68.    
    
69.     /* PLL configuration: PLLCLK = PREDIV1 * 9 = 72 MHz */
    
70.     RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
    
71.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
    
72.                             RCC_CFGR_PLLMULL9);
    
73. #else   
    
74.     /*  PLL configuration: PLLCLK = HSE * 9 = 72 MHz */
    
75.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |
    
76.                                         RCC_CFGR_PLLMULL));
    
77.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);
    
78. #endif /* STM32F10X_CL */
    
79. 
    
80.     /* Enable PLL */
    
81.     RCC->CR |= RCC_CR_PLLON;
    
82. 
    
83.     /* Wait till PLL is ready */
    
84.     while((RCC->CR & RCC_CR_PLLRDY) == 0)
    
85.     {
    
86.     }
    
87.    
    
88.     /* Select PLL as system clock source */
    
89.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    
90.     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;   
    
91. 
    
92.     /* Wait till PLL is used as system clock source */
    
93.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
    
94.     {
    
95.     }
    
96.   }
    
97.   else
    
98.   { /* If HSE fails to start-up, the application will have wrong clock
    
99.          configuration. User can add here some code to deal with this error */
    
100.   }
     
101. }

复制代码

首先，通过配置CR寄存器打开HSE，即外部高速时钟使能







接下来等待HSE的稳定，方法是查看CR寄存器的HSERDY位





若就绪，则HSEStatus = 1
接下来，当HSEStatus = 1时执行如下操作

1.   if (HSEStatus == (uint32_t)0x01)
   
2.   {
   
3.     /* Enable Prefetch Buffer */
   
4.     FLASH->ACR |= FLASH_ACR_PRFTBE;
   
5. 
   
6.     /* Flash 2 wait state */
   
7.     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
   
8.     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;   
   
9. 
   
10. 
    
11.     /* HCLK = SYSCLK */
    
12.     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
    
13.       
    
14.     /* PCLK2 = HCLK */
    
15.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
    
16.    
    
17.     /* PCLK1 = HCLK */
    
18.     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
    
19. 
    
20. #ifdef STM32F10X_CL
    
21.     /* Configure PLLs ------------------------------------------------------*/
    
22.     /* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
    
23.     /* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
    
24.         
    
25.     RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
    
26.                               RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
    
27.     RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
    
28.                              RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
    
29.   
    
30.     /* Enable PLL2 */
    
31.     RCC->CR |= RCC_CR_PLL2ON;
    
32.     /* Wait till PLL2 is ready */
    
33.     while((RCC->CR & RCC_CR_PLL2RDY) == 0)
    
34.     {
    
35.     }
    
36.    
    
37.    
    
38.     /* PLL configuration: PLLCLK = PREDIV1 * 9 = 72 MHz */
    
39.     RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
    
40.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
    
41.                             RCC_CFGR_PLLMULL9);
    
42. #else   
    
43.     /*  PLL configuration: PLLCLK = HSE * 9 = 72 MHz */
    
44.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |
    
45.                                         RCC_CFGR_PLLMULL));
    
46.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);
    
47. #endif /* STM32F10X_CL */
    
48. 
    
49.     /* Enable PLL */
    
50.     RCC->CR |= RCC_CR_PLLON;
    
51. 
    
52.     /* Wait till PLL is ready */
    
53.     while((RCC->CR & RCC_CR_PLLRDY) == 0)
    
54.     {
    
55.     }
    
56.    
    
57.     /* Select PLL as system clock source */
    
58.     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    
59.     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;   
    
60. 
    
61.     /* Wait till PLL is used as system clock source */
    
62.     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
    
63.     {
    
64.     }
    
65.   }
    
66.   else
    
67.   { /* If HSE fails to start-up, the application will have wrong clock
    
68.          configuration. User can add here some code to deal with this error */
    
69.   }

复制代码

由CPU的速度是远远快于FLASH的速度的，因此需要对FLASH控制器进行配置



通过CFGR寄存器设置AHB Prescale 设为1，泽恩HCLK就等于SYSCLK
















本质上是将APB2的Prescale设置为1









经过以上配置：
HCLK = SYSCLK
PCLK2  = SYSCLK
PCLK1 = SYSCLK




此处条件编译

执行的是这段

1. CC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
   
2.     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_PREDIV1 | RCC_CFGR_PLLXTPRE_PREDIV1_Div2 | RCC_CFGR_PLLMULL6);

复制代码

将HSE作为时钟源，倍频系数为9，即将HSE直接作为时钟源，倍频9后的PLLCLK作为系统时钟,后面的预分频都是72 MHz









等待PLL就绪





PLL作为系统时钟，并等待其稳定



调用SystemInit函数的地方



startup_stm32f10x_hd.s
这里定义先执行SystemInit函数，再执行main函数



————————————————
版权声明：CodeForCoffee