四、相关库函数解析

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

typedef struct

{

  uint32_t SYSCLK_Frequency;  

  uint32_t HCLK_Frequency;    

  uint32_t PCLK1_Frequency;   

  uint32_t PCLK2_Frequency;   

  uint32_t ADCCLK_Frequency;

}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

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

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

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

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);函数的值

//例：

//RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);

 

//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）

//例：

//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的新状态

//例：

 

//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_24MHz  24000000
#else

 



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

#endif

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

#endif

 

#define VECT_TAB_OFFSET  0x0

#ifdef SYSCLK_FREQ_HSE
  uint32_t SystemCoreClock         = SYSCLK_FREQ_HSE;       
#elif defined SYSCLK_FREQ_24MHz
  uint32_t SystemCoreClock         = SYSCLK_FREQ_24MHz;       
#elif defined SYSCLK_FREQ_36MHz
  uint32_t SystemCoreClock         = SYSCLK_FREQ_36MHz;       
#elif defined SYSCLK_FREQ_48MHz
  uint32_t SystemCoreClock         = SYSCLK_FREQ_48MHz;       
#elif defined SYSCLK_FREQ_56MHz
  uint32_t SystemCoreClock         = SYSCLK_FREQ_56MHz;       
#elif defined SYSCLK_FREQ_72MHz
  uint32_t SystemCoreClock         = SYSCLK_FREQ_72MHz;       
#else 
  uint32_t SystemCoreClock         = HSI_VALUE;       
#endif

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

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

 

 

void SystemInit (void)//系统初始化函数，设置系统的时钟及时钟中断（在startup_stm32f10x_md.s中调用）(复位RCC时钟配置为默认状态，直到设置时钟函数)
{
 
 
  RCC->CR |= (uint32_t)0x00000001; //内部高速时钟使能,内部8MHz时钟开启

 
#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    
  
 
  RCC->CR &= (uint32_t)0xFEF6FFFF;//时钟监测器关闭,HSE振荡器关闭

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

 
  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
 
  RCC->CR &= (uint32_t)0xEBFFFFFF;//CR中的26和28位置0

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

 
  RCC->CFGR2 = 0x00000000; //没有此寄存器
#elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
 
  RCC->CIR = 0x009F0000;//清除中断标志，关闭一些中断

 
  RCC->CFGR2 = 0x00000000; //没有此寄存器     
#else
 
  RCC->CIR = 0x009F0000; //清除中断标志，关闭一些中断
#endif
    
#if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)
  #ifdef DATA_IN_ExtSRAM
    SystemInit_ExtMemCtl();//如果宏定义了外部SRAM则对其初始化控制
  #endif
#endif

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

#ifdef VECT_TAB_SRAM
  SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET;
#else
  SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET;
#endif 
}

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

#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
  uint32_t prediv1factor = 0;
#endif
    
 
  tmp = RCC->CFGR & RCC_CFGR_SWS;
  
  switch (tmp)
  {
    case 0x00: 
      SystemCoreClock = HSI_VALUE;
      break;
    case 0x04: 
      SystemCoreClock = HSE_VALUE;
      break;
    case 0x08: 

     
      pllmull = RCC->CFGR & RCC_CFGR_PLLMULL;
      pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
      
#ifndef STM32F10X_CL      
      pllmull = ( pllmull >> 18) + 2;
      
      if (pllsource == 0x00)
      {
       
        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;
      
       SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull; 
 #else
       
        if ((RCC->CFGR & RCC_CFGR_PLLXTPRE) != (uint32_t)RESET)
        {
          SystemCoreClock = (HSE_VALUE >> 1) * pllmull;
        }
        else
        {
          SystemCoreClock = HSE_VALUE * pllmull;
        }
 #endif
      }
#else
      pllmull = pllmull >> 18;
      
      if (pllmull != 0x0D)
      {
         pllmull += 2;
      }
      else
      {
        pllmull = 13 / 2; 
      }
            
      if (pllsource == 0x00)
      {
       
        SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
      }
      else
      {
        
       
        prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC;
        prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;
        
        if (prediv1source == 0)
        { 
         
          SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;          
        }
        else
        {
          
         
          prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1;
          pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2; 
          SystemCoreClock = (((HSE_VALUE / prediv2factor) * pll2mull) / prediv1factor) * pllmull;                         
        }
      }
#endif  
      break;

    default:
      SystemCoreClock = HSI_VALUE;
      break;
  }
  
 
 
  tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
 
  SystemCoreClock >>= tmp;  
}

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
 
  
}

 
#ifdef DATA_IN_ExtSRAM
 
void SystemInit_ExtMemCtl(void) 
{

 
  RCC->AHBENR = 0x00000114;
  
    
  RCC->APB2ENR = 0x000001E0;
  


  


  
  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_Bank1->BTCR[4] = 0x00001011;
  FSMC_Bank1->BTCR[5] = 0x00000200;
}
#endif

#ifdef SYSCLK_FREQ_HSE

static void SetSysClockToHSE(void)
{
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
  
      
      
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);
 
 
  do
  {
    HSEStatus = RCC->CR & RCC_CR_HSERDY;
    StartUpCounter++;  
  } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
    HSEStatus = (uint32_t)0x01;
  }
  else
  {
    HSEStatus = (uint32_t)0x00;
  } 

  if (HSEStatus == (uint32_t)0x01)
  {

#if !defined STM32F10X_LD_VL && !defined STM32F10X_MD_VL && !defined STM32F10X_HD_VL
   
    FLASH->ACR |= FLASH_ACR_PRFTBE;

   
    FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);

#ifndef STM32F10X_CL
    FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;
#else
    if (HSE_VALUE <= 24000000)
 {
      FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;
 }
 else
 {
      FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_1;
 }
#endif
#endif
 
   
    RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
      
   
    RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
    
   
    RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
    
   
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    RCC->CFGR |= (uint32_t)RCC_CFGR_SW_HSE;   

   
    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x04)
    {
    }
  }
  else
  {
  }  
}
#elif defined SYSCLK_FREQ_24MHz

static void SetSysClockTo72(void)//系统时钟设置为72M：SYSCLK=72M，HCLK=72M，PCLK1=36M（最高36M），PCLK2=72M，ADCCLK=36M,
{
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;//启动计数，HSE状态
  
      
      
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);//HSE使能
 
 
  do //循环，直到HSE使能成功或者超时
  {
    HSEStatus = RCC->CR & RCC_CR_HSERDY;
    StartUpCounter++;  
  } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
    HSEStatus = (uint32_t)0x01;//HSE使能成功
  }
  else
  {
    HSEStatus = (uint32_t)0x00;//HSE使能不成功
  } 

  if (HSEStatus == (uint32_t)0x01)//HSE使能成功
  {
   
    FLASH->ACR |= FLASH_ACR_PRFTBE;//flash缓存使能

   
    FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);//
    FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;//   

 
   
    RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;//RCC_CFGR_HPRE_DIV1=0，CFGR中的值不变
      
   
    RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;//RCC_CFGR_PPRE2_DIV1=0，CFGR中的值不变
    
   
    RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;//低速APB预分频把HCLK 2分频,APB1CLK=HCLK/2

#ifdef STM32F10X_CL
   
   
   
        
    RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
                              RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
    RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
                             RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
  
   
    RCC->CR |= RCC_CR_PLL2ON;
   
    while((RCC->CR & RCC_CR_PLL2RDY) == 0)
    {
    }
    
   
     
    RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
    RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 | 
                            RCC_CFGR_PLLMULL9); 
#else    
   
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |  //PLL输入时钟源HSI时钟2分频后作为PLL输入时钟,HSE分频器作为PLL输入HSE不分频 
                                        RCC_CFGR_PLLMULL)); //PLL倍频系数PLL 2倍频输出（为了清零其他位）
    RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);//PLL输入时钟源HSE时钟作为PLL输入时钟,PLL倍频系数PLL 9倍频输出 
#endif

   
    RCC->CR |= RCC_CR_PLLON; //PLL使能

   
    while((RCC->CR & RCC_CR_PLLRDY) == 0)//等待PLL使能成功
    {
    }
    
   
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));//HSI作为系统时钟(为了清零其他位)
    RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL; //PLL输出作为系统时钟  

   
    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)//等待直到PLL成功用作系统时钟源
    {
    }
  }
  else
  {
  }
}
#endif

来源：http://www.51hei.com/bbs/dpj-30961-1.html