STM32的时钟系统RCC详细整理

STM32的时钟系统

本文档由“~风中的叶~”整理；QQ：654705188

一、综述：

1、时钟源

在STM32 中，一共有5 个时钟源，分别是HSI 、HSE 、LSI 、LSE 、PLL 。

①HSI 是高速内部时钟，RC 振荡器，频率为8MHz ；

②HSE 是高速外部时钟，可接石英/ 陶瓷谐振器，或者接外部时钟源，频率范围是4MHz – 16MHz ；

③LSI 是低速内部时钟，RC 振荡器，频率为40KHz ；

④LSE 是低速外部时钟，接频率为32.768KHz 的石英晶体；

⑤PLL 为锁相环倍频输出，严格的来说并不算一个独立的时钟源，PLL 的输入可以接HSI/2 、HSE 或

者HSE/2 。PLL倍频可选择为 2 – 16 倍，但是其输出频率最大不得超过72MHz 。

其中，40kHz的LSI供独立看门狗IWDG使用，另外它还可以被选择为实时时钟RTC的时钟源。另外，实时时钟RTC的时钟源还可以选择LSE，或者是HSE的128分频。

STM32中有一个全速功能的USB模块，其串行接口引擎需要一个频率为48MHz的时钟源。该时钟源只能从PLL端获取，可以选择为1.5分频或者1分频，也就是，当需使用到USB模块时，PLL必须使能，并且时钟配置为48MHz或72MHz。

另外STM32还可以选择一个时钟信号输出到MCO脚(PA.8)上，可以选择为PLL输出的2分频、HSI、HSE或者系统时钟。

系统时钟SYSCLK，它是提供STM32中绝大部分部件工作的时钟源。系统时钟可以选择为PLL输出、HSI、HSE。系系统时钟最大频率为72MHz，它通过AHB分频器分频后送给各个模块使用，AHB分频器可以选择1、2、4、8、16、64、128、256、512分频，AHB分频器输出的时钟送给5大模块使用：

①送给AHB总线、内核、内存和DMA使用的HCLK时钟；

②通过8分频后送给Cortex的系统定时器时钟STCLK；

③直接送给Cortex的空闲运行时钟FCLK；

④送给APB1分频器。APB1分频器可以选择1、2、4、8、16分频，其输出一路供APB1

外设使用（PCLK1，最大频率36MHz），另一路送给定时器(Timer)2、3、4倍频器使用。

该倍频器根据PCLK1的分频值自动选择1或者2倍频，时钟输出供定时器2、3、4使用。

⑤送给APB2分频器。APB2分频器可以选择1、2、4、8、16分频，其输出一路供APB2

外设使用（PCLK2，最大频率72MHz），另外一路送给定时器(Timer)1倍频使用。该倍频器根

据PCLK2的分频值自动选择1或2倍频，时钟输出供定时器1使用。另外APB2分频器还有一

路输出供ADC分频器使用，分频后送给ADC模块使用。ADC分频器可选择为2、4、6、

8分频。

需要注意的是定时器的倍频器，当APB的分频为1时，它的倍频值为1，否则它的倍频值就为2。

2、APB1和APB2连接的模块

①连接在APB1(低速外设)上的设备有：电源接口、备份接口、CAN、USB、I2C1、I2C2、UART2、UART3、SPI2、窗口看门狗、Timer2、Timer3、Timer4。注意USB模块虽然需要一个单独的48MHz 的时钟信号，但是它应该不是供USB模块工作的时钟，而只是提供给串行接口引擎(SIE)使用的时钟。USB 模块的工作时钟应该是由APB1提供的。

②连接在APB2（高速外设）上的设备有：UART1、SPI1、Timer1、ADC1、ADC2、

GPIOx(PA~PE)、第二功能IO 口。

二、寄存器介绍：

typedef struct

{

__IO uint32_t CR;

__IO uint32_t CFGR;

__IO uint32_t CIR;

__IO uint32_t APB2RSTR;

__IO uint32_t APB1RSTR;

__IO uint32_t AHBENR;

__IO uint32_t APB2ENR;

__IO uint32_t APB1ENR;

__IO uint32_t BDCR;

__IO uint32_t CSR;

#ifdef STM32F10X_CL

__IO uint32_t AHBRSTR;

__IO uint32_t CFGR2;

#endif /* STM32F10X_CL */

#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)

uint32_t RESERVED0;

__IO uint32_t CFGR2;

#endif /* STM32F10X_LD_VL || STM32F10X_MD_VL || STM32F10X_HD_VL */

} RCC_TypeDef;

1、时钟控制寄存器(RCC_CR)：（复位值为0x0000 xx83，内部低速时钟使能和就绪，内部时钟校准）

主要功能：内外部高速时钟的使能和就绪标志（含内部高速时钟校准调整），外部高速时钟旁路，时钟安全系统CSS使能，PLL使能和PLL就绪标志。

2、时钟配置寄存器(RCC_CFGR)：（复位值为0x0000 0000）

主要功能：系统时钟源切换及状态，AHB、APB1、APB2、ADC、USB预分频，PLL输入时钟源选择及HSE输入PLL分频选择，PLL倍频系数，MCO（PA8）引脚微控制器时钟输出。

3、时钟中断寄存器 (RCC_CIR)：（复位值: 0x0000 0000）

主要功能：LSI、LSE、HIS、HSE、PLL就绪中断标志，HSE时钟失效导致时钟安全系统中断标志，LSI、LSE、HIS、HSE、PLL就绪中断使能，清除LSI、LSE、HIS、HSE、PLL就绪中断，清除时钟安全系统中断。

4、APB2外设复位寄存器 (RCC_APB2RSTR)：（复位值: 0x0000 0000）

主要功能：AFIO、IOPA、IOPB、IOPC、IOPD、IOPE、IOPF、IOPG、ADC1、ADC2、TIM1、SPI1、TIM8、USART1、ADC3复位。

5、APB1外设复位寄存器 (RCC_APB1RSTR) ：（复位值: 0x0000 0000）

主要功能：TIM2、TIM3、TIM4、TIM5、TIM6、TIM7、WWDG、SPI2、SPI3、USART2、USART3、USART4、USART5、I2C1、I2C2、USB、CAN、BKP、PWR、DAC复位。

6、AHB外设时钟使能寄存器 (RCC_AHBENR) ：（复位值: 0x0000 0014睡眠模式时SRAM、闪存接口电路时钟开启）

主要功能：DMA1、DMA2、SRAM、FLITF、CRC、FSMC、SDIO时钟使能。

7、APB2外设时钟使能寄存器(RCC_APB2ENR) ：（复位值: 0x0000 0000）

主要功能：AFIO、IOPA、IOPB、IOPC、IOPD、IOPE、IOPF、IOPG、ADC1、ADC2、TIM1、SPI1、TIM8、USART1、ADC3时钟使能。

8、APB1外设时钟使能寄存器(RCC_APB1ENR) ：（复位值: 0x0000 0000）

主要功能：TIM2、TIM3、TIM4、TIM5、TIM6、TIM7、WWDG、SPI2、SPI3、USART2、USART3、USART4、USART5、I2C1、I2C2、USB、CAN、BKP、PWR、DAC时钟使能。

9、备份域控制寄存器 (RCC_BDCR) ：（复位值: 0x0000 0000）

主要功能：外部低速振荡器使能和就绪标志及旁路、RTC时钟源选择和时钟使能、备份域软件复位。

10、控制/状态寄存器 (RCC_CSR) ：（复位值: 0x0C00 0000 NRST引脚复位标志、上电/掉电复位标志）

主要功能：内部低速振荡器就绪、清除复位标志、NRST引脚复位标志、上电/掉电复位标志、软件复位标志、独立看门狗复位标志、窗口看门狗复位标志、低功耗复位标志。

三、初始化设置

采用8MHz 外部HSE 时钟，在MDK 编译平台中，程序的时钟设置参数流程如下：

将RCC 寄存器重新设置为默认值：RCC_DeInit();

打开外部高速时钟晶振HSE ：RCC_HSEConfig(RCC_HSE_ON);

等待外部高速时钟晶振工作：HSEStartUpStatus = RCC_WaitForHSEStartUp();

设置AHB 时钟(HCLK) ：RCC_HCLKConfig(RCC_SYSCLK_Div1);

设置APB 2时钟(APB2) ：RCC_PCLK2Config(RCC_HCLK_Div1);

设置APB1 时钟(APB1) ：RCC_PCLK1Config(RCC_HCLK_Div2);

设置PLL ：RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

打开PLL ：RCC_PLLCmd(ENABLE);

等待PLL 工作：while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

设置系统时钟：RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

判断PLL 是否是系统时钟：while(RCC_GetSYSCLKSource() != 0x08);

1、使用库函数进行时钟系统初始化配置

void RCC_config()//如果外部晶振为8M，PLLCLK=SYSCLK=72M，HCLK=72M，//P2CLK=72M，P1CLK=36M，ADCCLK=36M，USBCLK=48M，TIMCLK=72M

{

ErrorStatus HSEStartUpStatus;//定义错误状态变量

RCC_DeInit();//将RCC寄存器重新设置为默认值

RCC_HSEConfig(RCC_HSE_ON);//打开外部高速时钟晶振

HSEStartUpStatus = RCC_WaitForHSEStartUp();//等待外部高速时钟晶振工作

if(HSEStartUpStatus == SUCCESS)

{

RCC_HCLKConfig(RCC_SYSCLK_Div1);//设置AHB不分频，HCLK=SYSCLK

RCC_PCLK2Config(RCC_HCLK_Div1);//设置APB2不分频，P2CLK=HCLK

RCC_PCLK1Config(RCC_HCLK_Div2);//设置APB1 为2分频，P1CLK=HCLK/2

FLASH_SetLatency(FLASH_Latency_2);//设置FLASH代码延时

FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);//使能预取指缓存

RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);//设置PLL时钟源，

//外部时钟不分频，为HSE的9倍频8MHz * 9 = 72MHz

RCC_PLLCmd(ENABLE);//使能PLL

while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);//等待PLL准备就绪

RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//设置PLL为系统时钟源

while(RCC_GetSYSCLKSource() != 0x08);//判断PLL是否是系统时钟

}

/*RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOD, ENABLE);//打开PB和PD用于点亮LED灯*/

}

2、使用寄存器进行RCC时钟初始化配置

void RCC_init(u8 PLL)//输入PLL的倍频值2—16倍频

//HCLK=PLLCLK=SYSCLK=P2CLK=P1CLK*2=ADCCLK*2=TIMCLK=USBCLK*2/3

{

unsigned char temp=0;

//RCC_DeInit(); //将RCC寄存器重新设置为默认值

RCC->CR|=0x00010000; //外部高速时钟使能HSEON

while(!(RCC->CR>>17));//等待外部时钟就绪

RCC->CFGR=0X00000400; //APB1=DIV2;APB2=DIV1;AHB=DIV1;

PLL-=2;//抵消2个单位

RCC->CFGR|=PLL<<18; //设置PLL倍频值2~16

RCC->CFGR|=1<<16; //PLL时钟源选择

FLASH->ACR|=0x32; //FLASH 2个延时周期

RCC->CR|=0x01000000; //PLLON

while(!(RCC->CR>>25));//等待PLL锁定

RCC->CFGR|=0x00000002;//PLL作为系统时钟

while(temp!=0x02) //等待PLL作为系统时钟设置成功

{

temp=RCC->CFGR>>2;

temp&=0x03;

}

}

四、相关库函数解析

1、库中所涉及到的结构体

typedef struct

{

uint32_t SYSCLK_Frequency; /*!< returns SYSCLK clock frequency expressed in Hz */

uint32_t HCLK_Frequency; /*!< returns HCLK clock frequency expressed in Hz */

uint32_t PCLK1_Frequency; /*!< returns PCLK1 clock frequency expressed in Hz */

uint32_t PCLK2_Frequency; /*!< returns PCLK2 clock frequency expressed in Hz */

uint32_t ADCCLK_Frequency; /*!< returns ADCCLK clock frequency expressed in Hz */ }RCC_ClocksTypeDef;

2、库函数解析

void RCC_DeInit(void);//将外设RCC寄存器设为缺省值；（除RCC_BDCR和RCC_CSR）void RCC_HSEConfig(uint32_t RCC_HSE);//设置外部高速晶振（HSE）；

//输入：RCC_HSE_OFF，RCC_HSE_ON，RCC_HSE_Bypass(HSE旁路)

ErrorStatus RCC_WaitForHSEStartUp(void);//等待HSE起振；

//返回值：SUCCESS,HSE晶振稳定且就绪；ERROR，HSE晶振未就绪

void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue);//调整内部高速晶振（HSI）校准值

//输入：校准补偿值（该参数取值必须在0到0x1F之间）

void RCC_HSICmd(FunctionalState NewState);//使能或者失能内部高速晶振（HSI）

//输入：ENABLE或者DISABLE（如果HSI被用于系统时钟，或者FLASH编写操作进行中，那么它不能被停振）

void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul);//设置PLL时钟源及倍频系数

//输入：RCC_PLLSource_HSI_Div2，RCC_PLLSource_HSE_Div1，RCC_PLLSource_HSE_Div2

//输入：RCC_PLLMul_2到RCC_PLLMul_16

void RCC_PLLCmd(FunctionalState NewState);//使能或者失能PLL

//输入：ENABLE或者DISABLE

#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL) || defined (STM32F10X_CL)

void RCC_PREDIV1Config(uint32_t RCC_PREDIV1_Source, uint32_t RCC_PREDIV1_Div);//

#endif

#ifdef STM32F10X_CL

void RCC_PREDIV2Config(uint32_t RCC_PREDIV2_Div);//

void RCC_PLL2Config(uint32_t RCC_PLL2Mul);//

void RCC_PLL2Cmd(FunctionalState NewState);//

void RCC_PLL3Config(uint32_t RCC_PLL3Mul);//

void RCC_PLL3Cmd(FunctionalState NewState);//

#endif /* STM32F10X_CL */

void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource);//设置系统时钟(SYSCLK)源

// RCC_SYSCLKSource_HSI，RCC_SYSCLKSource_HSE，RCC_SYSCLKSource_PLLCLK

uint8_t RCC_GetSYSCLKSource(void);//返回用作系统时钟的时钟源

//返回值：0x00 HSI作为系统时钟，0x04 HSE作为系统时钟，0x08 PLL作为系统时钟

void RCC_HCLKConfig(uint32_t RCC_SYSCLK);//设置AHB时钟（HCLK）

//输入：RCC_SYSCLK_Div1，RCC_SYSCLK_Div2，RCC_SYSCLK_Div4，RCC_SYSCLK_Div8，

RCC_SYSCLK_Div16，

//RCC_SYSCLK_Div32，RCC_SYSCLK_Div64，RCC_SYSCLK_Div128，RCC_SYSCLK_Div256，

RCC_SYSCLK_Div512

void RCC_PCLK1Config(uint32_t RCC_HCLK);//设置低速AHB时钟（PCLK1）

//输入：RCC_HCLK_Div1,RCC_HCLK_Div2,RCC_HCLK_Div4,RCC_HCLK_Div8,RCC_HCLK_Div16

void RCC_PCLK2Config(uint32_t RCC_HCLK);//设置高速AHB时钟（PCLK2）

//输入：RCC_HCLK_Div1,RCC_HCLK_Div2,RCC_HCLK_Div4,RCC_HCLK_Div8,RCC_HCLK_Div16 void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState);//使能或者失能指定的RCC中断

//输入：RCC_IT_LSIRDY LSI就绪中断->ENABLE或者DISABLE

//RCC_IT_LSERDY LSE就绪中断，RCC_IT_HSIRDY HSI就绪中断

//RCC_IT_HSERDY HSE就绪中断，RCC_IT_PLLRDY PLL就绪中断

#ifndef STM32F10X_CL

void RCC_USBCLKConfig(uint32_t RCC_USBCLKSource);//设置USB时钟（USBCLK）

//输入：RCC_USBCLKSource_PLLCLK_1Div5，USB时钟= PLL时钟除以1.5

RCC_USBCLKSource_PLLCLK_Div1，USB时钟= PLL时钟

#else

void RCC_OTGFSCLKConfig(uint32_t RCC_OTGFSCLKSource);//

#endif /* STM32F10X_CL */

void RCC_ADCCLKConfig(uint32_t RCC_PCLK2);//设置ADC时钟（ADCCLK）

//RCC_PCLK2_Div2,ADC时钟 = PCLK / 2;RCC_PCLK2_Div4,ADC时钟 = PCLK / 4;

//RCC_PCLK2_Div6,ADC时钟 = PCLK / 6;RCC_PCLK2_Div8,ADC时钟 = PCLK / 8

#ifdef STM32F10X_CL

void RCC_I2S2CLKConfig(uint32_t RCC_I2S2CLKSource); //

void RCC_I2S3CLKConfig(uint32_t RCC_I2S3CLKSource);//

#endif /* STM32F10X_CL */

void RCC_LSEConfig(uint8_t RCC_LSE);//设置外部低速晶振（LSE）

//输入：RCC_LSE_OFF,LSE晶振OFF;RCC_LSE_ON,LSE晶振ON;

//RCC_LSE_Bypass,LSE晶振被外部时钟旁路

void RCC_LSICmd(FunctionalState NewState);//使能或者失能内部低速晶振（LSI）

//输入：ENABLE或者DISABLE (IWDG运行的话，LSI不能被失能)

void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource);//设置RTC时钟(RTCCLK)源(RTC时钟一经选定即不能更改，除非复位后备域)

//输入：RCC_RTCCLKSource_LSE,选择LSE作为RTC时钟;RCC_RTCCLKSource_LSI,选择LSI作为RTC时钟;RCC_RTCCLKSource_HSE_Div128,选择HSE时钟频率除以128作为RTC时钟

void RCC_RTCCLKCmd(FunctionalState NewState);//使能或者失能RTC时钟

//输入：ENABLE或者DISABLE

void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks);//返回时钟的频率

//输入：指向结构RCC_ClocksTypeDef的指针，包含了各个时钟的频率（单位为Hz）

void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);//使能或者失能AHB 外设时钟

//输入：RCC_AHBPeriph_DMA，DMA时钟->ENABLE或者DISABLE；

//RCC_AHBPeriph_SRAM，SRAM时钟；RCC_AHBPeriph_FLITF，FLITF时钟

//RCC_AHBPeriph_DMA1，DMA1时钟；RCC_AHBPeriph_DMA2，DMA2时钟

//RCC_AHBPeriph_CRC，CRC时钟；RCC_AHBPeriph_FSMC，FSMC时钟

//RCC_AHBPeriph_SDIO，SDIO时钟

void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);//使能或者失能APB2外设时钟

//输入：RCC_APB2Periph_AFIO，功能复用IO时钟->ENABLE或者DISABLE；

//RCC_APB2Periph_GPIOA，GPIOA时钟；RCC_APB2Periph_GPIOB,GPIOB时钟;

//RCC_APB2Periph_GPIOC,GPIOC时钟;RCC_APB2Periph_GPIOD,GPIOD时钟;

//RCC_APB2Periph_GPIOE,GPIOE时钟;RCC_APB2Periph_ADC1,ADC1时钟;

//RCC_APB2Periph_ADC2,ADC2时钟;RCC_APB2Periph_TIM1,TIM1时钟;

//RCC_APB2Periph_SPI1,SPI1时钟;RCC_APB2Periph_USART1,USART1时钟;

//RCC_APB2Periph_ALL,全部APB2外设时钟

void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);//使能或者失能APB1外设时钟

//输入：RCC_APB1Periph_TIM2，TIM2时钟->ENABLE或者DISABLE;

//RCC_APB1Periph_TIM3,TIM3时钟;RCC_APB1Periph_TIM4,TIM4时钟

//RCC_APB1Periph_WWDG,WWDG时钟;RCC_APB1Periph_SPI2,SPI2时钟

//RCC_APB1Periph_USART2,USART2时钟;RCC_APB1Periph_USART3,USART3时钟

//RCC_APB1Periph_I2C1,I2C1时钟;RCC_APB1Periph_I2C2,I2C2时钟

//RCC_APB1Periph_USB,USB时钟;RCC_APB1Periph_CAN,CAN时钟

//RCC_APB1Periph_BKP,BKP时钟;RCC_APB1Periph_PWR,PWR时钟

//RCC_APB1Periph_ALL,全部APB1外设时钟

#ifdef STM32F10X_CL

void RCC_AHBPeriphResetCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);//

#endif /* STM32F10X_CL */

void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);//强制或者释放高速APB（APB2）外设复位

//输入：同void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);函数的值void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);//强制或者释放低速APB（APB1）外设复位

//输入：同void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);函数的值//例：/* Enter the SPI1 peripheral to reset */

//RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);

/* Exit the SPI1 peripheral from reset */

//RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE);

void RCC_BackupResetCmd(FunctionalState NewState);//强制或者释放后备域复位

void RCC_ClockSecuritySystemCmd(FunctionalState NewState);//使能或者失能时钟安全系统

//输入：ENABLE或者DISABLE

void RCC_MCOConfig(uint8_t RCC_MCO);//选择在MCO管脚上输出的时钟源

//输入：RCC_MCO_NoClock 无时钟被选中；RCC_MCO_SYSCLK 选中系统时钟；

//RCC_MCO_HSI 选中HSI ；RCC_MCO_HSE 选中HSE ；

//RCC_MCO_PLLCLK_Div2 选中PLL时钟除以2

//警告：当选中系统时钟作为MCO管脚的输出时，注意它的时钟频率不超过50MHz(最大I/O速率)。

FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG);//检查指定的RCC标志位设置与否

//输入：待检查的RCC标志位

//RCC_FLAG_HSIRDY ，HSI晶振就绪；RCC_FLAG_HSERDY ，HSE晶振就绪；

//RCC_FLAG_PLLRDY ，PLL就绪；RCC_FLAG_LSERDY ，LSI晶振就绪；

//RCC_FLAG_LSIRDY ，LSE晶振就绪；RCC_FLAG_PINRST ，管脚复位；

//RCC_FLAG_PORRST ，POR/PDR复位；RCC_FLAG_SFTRST ，软件复位；

//RCC_FLAG_IWDGRST ，IWDG复位；RCC_FLAG_WWDGRST ，WWDG复位；

//RCC_FLAG_LPWRRST ，低功耗复位

//返回值：RCC_FLAG的新状态（SET或者RESET）

//例：/* Test if the PLL clock is ready or not */

//FlagStatus Status;

//Status = RCC_GetFlagStatus(RCC_FLAG_PLLRDY);

//if(Status == RESET)

//{

//...

//}

//else

void RCC_ClearFlag(void);//清除RCC的复位标志位

//(可以清除的复位标志位有：RCC_FLAG_PINRST, RCC_FLAG_PORRST,

//RCC_FLAG_SFTRST, RCC_FLAG_IWDGRST, RCC_FLAG_WWDGRST,

RCC_FLAG_LPWRRST)

ITStatus RCC_GetITStatus(uint8_t RCC_IT);//检查指定的RCC中断发生与否

//输入：RCC_IT_LSIRDY，LSI晶振就绪中断；RCC_IT_LSERDY，LSE晶振就绪中断//RCC_IT_HSIRDY，HSI晶振就绪中断；RCC_IT_HSERDY，HSE晶振就绪中断

//RCC_IT_PLLRDY，PLL就绪中断；RCC_IT_CSS，时钟安全系统中断

//返回值：RCC_IT的新状态

//例：

/* Test if the PLL Ready interrupt has occurred or not */

//ITStatus Status;

//Status = RCC_GetITStatus(RCC_IT_PLLRDY);

//if(Status == RESET)

//{

//...

//}

//else

//{

//...

//}

void RCC_ClearITPendingBit(uint8_t RCC_IT);//清除RCC的中断待处理位

//RCC_IT_LSIRDY,LSI晶振就绪中断;RCC_IT_LSERDY,LSE晶振就绪中断

//RCC_IT_HSIRDY,HSI晶振就绪中断;RCC_IT_HSERDY,HSE晶振就绪中断

//RCC_IT_PLLRDY,PLL就绪中断;RCC_IT_CSS,时钟安全系统中断

五、实例详解

#if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL) || (defined

STM32F10X_HD_VL)//如果定义了这些系统时钟将设为24M，如果没有定义则为72M

/* #define SYSCLK_FREQ_HSE HSE_VALUE */

#define SYSCLK_FREQ_24MHz 24000000

#else

/* #define SYSCLK_FREQ_HSE HSE_VALUE */

/* #define SYSCLK_FREQ_24MHz 24000000 */

/* #define SYSCLK_FREQ_36MHz 36000000 */

/* #define SYSCLK_FREQ_48MHz 48000000 */

/* #define SYSCLK_FREQ_56MHz 56000000 */

#define SYSCLK_FREQ_72MHz 72000000 //系统时钟默认值的定义，如果没有定义外部高速时钟则用内部高速时钟，为8000000

/*只需修改以上几句就可以自动设置使用外部倍频作为系统时钟，如果以上宏都未定义则在下边把内部高速时钟作为系统时钟*/

#endif

/*!< Uncomment the following line if you need to use external SRAM mounted

on STM3210E-EVAL board (STM32 High density and XL-density devices) or on STM32100E-EVAL board (STM32 High-density value line devices) as data memory */

#if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)//内外部SRAM选择

/* #define DATA_IN_ExtSRAM */

#endif

/*!< Uncomment the following line if you need to relocate your vector Table in Internal SRAM. */

/* #define VECT_TAB_SRAM */

#define VECT_TAB_OFFSET 0x0 /*!< Vector Table base offset field. //向量表的基址偏移量

This value must be a multiple of 0x100. */

/**

* @}

*/

/** @addtogroup STM32F10x_System_Private_Macros

* @{

*/

/**

* @}

*/

/** @addtogroup STM32F10x_System_Private_Variables

* @{

*/

/****************************************************************************** *

* Clock Definitions;以下为把系统时钟的定义值传给系统内核时钟变量,如果没有定义外部高速时钟则用内部高速时钟，为8M

******************************************************************************* /

#ifdef SYSCLK_FREQ_HSE

uint32_t SystemCoreClock = SYSCLK_FREQ_HSE; /*!< System Clock Frequency (Core Clock) */

#elif defined SYSCLK_FREQ_24MHz

uint32_t SystemCoreClock = SYSCLK_FREQ_24MHz; /*!< System Clock Frequency (Core Clock) */

#elif defined SYSCLK_FREQ_36MHz

uint32_t SystemCoreClock = SYSCLK_FREQ_36MHz; /*!< System Clock Frequency (Core Clock) */

#elif defined SYSCLK_FREQ_48MHz

uint32_t SystemCoreClock = SYSCLK_FREQ_48MHz; /*!< System Clock Frequency (Core Clock) */

#elif defined SYSCLK_FREQ_56MHz

uint32_t SystemCoreClock = SYSCLK_FREQ_56MHz; /*!< System Clock Frequency (Core Clock) */

#elif defined SYSCLK_FREQ_72MHz

uint32_t SystemCoreClock = SYSCLK_FREQ_72MHz; /*!< System Clock Frequency (Core Clock) */

#else /*!< HSI Selected as System Clock source */

uint32_t SystemCoreClock = HSI_VALUE; /*!< System Clock Frequency (Core Clock) 如果没有定义外部高速时钟则用内部高速时钟，为8000000*/ #endif

__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};//AHB 配方表

/**

* @}

*/

/** @addtogroup STM32F10x_System_Private_FunctionPrototypes

* @{

*/

/****************************************************************************** ***

以下为函数声明

******************************************************************************* **/

static void SetSysClock(void); //设置系统时钟的函数声明

//以下为根据不同的系统时钟的定义来声明用到的相应的函数，为后面的函数调用做好准备#ifdef SYSCLK_FREQ_HSE

static void SetSysClockToHSE(void);

#elif defined SYSCLK_FREQ_24MHz

static void SetSysClockTo24(void);

#elif defined SYSCLK_FREQ_36MHz

static void SetSysClockTo36(void);

#elif defined SYSCLK_FREQ_48MHz

static void SetSysClockTo48(void);

#elif defined SYSCLK_FREQ_56MHz

static void SetSysClockTo56(void);

#elif defined SYSCLK_FREQ_72MHz

static void SetSysClockTo72(void);

#endif

#ifdef DATA_IN_ExtSRAM //外部SRAM选择后的初始化函数声明

static void SystemInit_ExtMemCtl(void);

#endif /* DATA_IN_ExtSRAM */

/**

* @}

*/

/** @addtogroup STM32F10x_System_Private_Functions

* @{

*/

/**

* @brief Setup the microcontroller system

* Initialize the Embedded Flash Interface, the PLL and update the * SystemCoreClock variable.

* @note This function should be used only after reset.

* @param None

* @retval None

*/

void SystemInit (void)//系统初始化函数，设置系统的时钟及时钟中断（在

startup_stm32f10x_md.s中调用）(复位RCC时钟配置为默认状态，直到设置时钟函数) {

/* Reset the RCC clock configuration to the default reset state(for debug purpose) */

/* Set HSION bit */

RCC->CR |= (uint32_t)0x00000001; //内部高速时钟使能,内部8MHz时钟开启

/* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */

#ifndef STM32F10X_CL

RCC->CFGR &= (uint32_t)0xF8FF0000;//MCO微控制器没有时钟输出(对外部引脚),ADC

预分频PCLK2 2分频后作为ADC时钟,APB预分频HCLK不分频,AHB预分频SYSCLK不分频,HSI 作为系统时钟

//HSI作为系统时钟输出（已输出），

SYSCLK=PCLK=PCLK1=PCLK2=8M，ADCCLK=1/2(PCLK2)=4M

#else

RCC->CFGR &= (uint32_t)0xF0FF0000;//同上；RCC->CFGR的27位为保留位始终为0 ，HSI作为系统时钟输出（未输出原因为未编译）

#endif /* STM32F10X_CL */

/* Reset HSEON, CSSON and PLLON bits */

RCC->CR &= (uint32_t)0xFEF6FFFF;//时钟监测器关闭,HSE振荡器关闭

/* Reset HSEBYP bit */

RCC->CR &= (uint32_t)0xFFFBFFFF;//外部4-25MHz振荡器没有旁路

/* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */

RCC->CFGR &= (uint32_t)0xFF80FFFF; //PLL时钟1.5倍分频作为USB时钟,PLL 2倍频输出,HSE不分频,HSI时钟2分频后作为PLL输入时钟

//PLLCLK=HSICLK=8M（还未输

出）,HSECLK=HSEOSC,USBCLK=PLLCLK/1.5 ，除PLL外其他分频系数都为0

#ifdef STM32F10X_CL

/* Reset PLL2ON and PLL3ON bits */

RCC->CR &= (uint32_t)0xEBFFFFFF;//CR中的26和28位置0

/* Disable all interrupts and clear pending bits */

RCC->CIR = 0x00FF0000;//清除中断标志，关闭一些中断

/* Reset CFGR2 register */

RCC->CFGR2 = 0x00000000; //没有此寄存器

#elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined

STM32F10X_HD_VL)

/* Disable all interrupts and clear pending bits */

RCC->CIR = 0x009F0000;//清除中断标志，关闭一些中断

/* Reset CFGR2 register */

RCC->CFGR2 = 0x00000000; //没有此寄存器

#else

/* Disable all interrupts and clear pending bits */

RCC->CIR = 0x009F0000; //清除中断标志，关闭一些中断

#endif /* STM32F10X_CL */

#if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL) #ifdef DATA_IN_ExtSRAM

SystemInit_ExtMemCtl();//如果宏定义了外部SRAM则对其初始化控制

#endif /* DATA_IN_ExtSRAM */

#endif

/* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */ /* Configure the Flash Latency cycles and enable prefetch buffer */

SetSysClock();//设置系统时钟

#ifdef VECT_TAB_SRAM

SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. 向量表放在内部SRAM中*/

#else

SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. 向量表放在内部flash中*/

#endif

}

/**

* @brief Update SystemCoreClock according to Clock Register Values

* @note None

* @param None

* @retval None

*/

void SystemCoreClockUpdate (void)

{

uint32_t tmp = 0, pllmull = 0, pllsource = 0;

#ifdef STM32F10X_CL

uint32_t prediv1source = 0, prediv1factor = 0, prediv2factor = 0, pll2mull = 0; #endif /* STM32F10X_CL */

#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined

STM32F10X_HD_VL)

uint32_t prediv1factor = 0;

#endif /* STM32F10X_LD_VL or STM32F10X_MD_VL or STM32F10X_HD_VL */

/* Get SYSCLK source -------------------------------------------------------*/ tmp = RCC->CFGR & RCC_CFGR_SWS;

switch (tmp)

{

case 0x00: /* HSI used as system clock */

SystemCoreClock = HSI_VALUE;

break;

case 0x04: /* HSE used as system clock */

SystemCoreClock = HSE_VALUE;

break;

case 0x08: /* PLL used as system clock */

/* Get PLL clock source and multiplication factor ----------------------*/ pllmull = RCC->CFGR & RCC_CFGR_PLLMULL;

pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;

#ifndef STM32F10X_CL

pllmull = ( pllmull >> 18) + 2;

if (pllsource == 0x00)

{

/* HSI oscillator clock divided by 2 selected as PLL clock entry */

SystemCoreClock = (HSI_VALUE >> 1) * pllmull;

}

else

{

#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined

STM32F10X_HD_VL)

prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;

/* HSE oscillator clock selected as PREDIV1 clock entry */

SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;

#else

/* HSE selected as PLL clock entry */

if ((RCC->CFGR & RCC_CFGR_PLLXTPRE) != (uint32_t)RESET)

{/* HSE oscillator clock divided by 2 */

SystemCoreClock = (HSE_VALUE >> 1) * pllmull;

}

else

{

SystemCoreClock = HSE_VALUE * pllmull;

}

#endif

}

#else

pllmull = pllmull >> 18;

if (pllmull != 0x0D)

{

pllmull += 2;

}

else

{ /* PLL multiplication factor = PLL input clock * 6.5 */

pllmull = 13 / 2;

}

if (pllsource == 0x00)

{

/* HSI oscillator clock divided by 2 selected as PLL clock entry */ SystemCoreClock = (HSI_VALUE >> 1) * pllmull;

}

else

{/* PREDIV1 selected as PLL clock entry */

/* Get PREDIV1 clock source and division factor */

prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC;

prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;

if (prediv1source == 0)

{

/* HSE oscillator clock selected as PREDIV1 clock entry */

SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull; }

else

{/* PLL2 clock selected as PREDIV1 clock entry */

/* Get PREDIV2 division factor and PLL2 multiplication factor */ prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1;

pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2;

SystemCoreClock = (((HSE_VALUE / prediv2factor) * pll2mull) / prediv1factor) * pllmull;

}

}

#endif /* STM32F10X_CL */

break;

default:

SystemCoreClock = HSI_VALUE;

break;

}

/* Compute HCLK clock frequency ----------------*/

/* Get HCLK prescaler */

tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];

/* HCLK clock frequency */

SystemCoreClock >>= tmp;

}

/**

* @brief Configures the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers. * @param None

* @retval None

*/

static void SetSysClock(void)//根据不同的宏定义，设置不同的系统时钟

{

#ifdef SYSCLK_FREQ_HSE

SetSysClockToHSE();

#elif defined SYSCLK_FREQ_24MHz

SetSysClockTo24();

#elif defined SYSCLK_FREQ_36MHz

SetSysClockTo36();

#elif defined SYSCLK_FREQ_48MHz

SetSysClockTo48();

#elif defined SYSCLK_FREQ_56MHz

SetSysClockTo56();

#elif defined SYSCLK_FREQ_72MHz

SetSysClockTo72();

#endif

/* If none of the define above is enabled, the HSI is used as System clock

source (default after reset) */

}

/**

* @brief Setup the external memory controller. Called in startup_stm32f10x.s * before jump to __main

* @param None

* @retval None

*/

#ifdef DATA_IN_ExtSRAM

/**

* @brief Setup the external memory controller.

* Called in startup_stm32f10x_xx.s/.c before jump to main.

* This function configures the external SRAM mounted on STM3210E-EVAL * board (STM32 High density devices). This SRAM will be used as program * data memory (including heap and stack).

* @param None

* @retval None

*/

void SystemInit_ExtMemCtl(void)

{

/*!< FSMC Bank1 NOR/SRAM3 is used for the STM3210E-EVAL, if another Bank is

required, then adjust the Register Addresses */

/* Enable FSMC clock */

RCC->AHBENR = 0x00000114;

/* Enable GPIOD, GPIOE, GPIOF and GPIOG clocks */

RCC->APB2ENR = 0x000001E0;

/* --------------- SRAM Data lines, NOE and NWE configuration ---------------*/ /*---------------- SRAM Address lines configuration -------------------------*/ /*---------------- NOE and NWE configuration --------------------------------*/ /*---------------- NE3 configuration ----------------------------------------*/ /*---------------- NBL0, NBL1 configuration ---------------------------------*/

GPIOD->CRL = 0x44BB44BB;

GPIOD->CRH = 0xBBBBBBBB;

GPIOE->CRL = 0xB44444BB;

GPIOE->CRH = 0xBBBBBBBB;

GPIOF->CRL = 0x44BBBBBB;

GPIOF->CRH = 0xBBBB4444;

GPIOG->CRL = 0x44BBBBBB;

GPIOG->CRH = 0x44444B44;

/*---------------- FSMC Configuration

---------------------------------------*/

/*---------------- Enable FSMC Bank1_SRAM Bank ------------------------------*/

FSMC_Bank1->BTCR[4] = 0x00001011;

FSMC_Bank1->BTCR[5] = 0x00000200;

}

#endif /* DATA_IN_ExtSRAM */

#ifdef SYSCLK_FREQ_HSE

/**

* @brief Selects HSE as System clock source and configure HCLK, PCLK2

* and PCLK1 prescalers.

* @note This function should be used only after reset.

* @param None

* @retval None

*/

static void SetSysClockToHSE(void)

{

__IO uint32_t StartUpCounter = 0, HSEStatus = 0;