Пример #1
0
/*******************************************************************************
* Function Name  : RCC_Configuration
* Description    : Configures the different system clocks.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void RCC_Configuration(void)
{   
  /* RCC system reset(for debug purpose) */
  RCC_DeInit();

  /* Enable HSE */
  RCC_HSEConfig(RCC_HSE_ON);

  /* Wait till HSE is ready */
  HSEStartUpStatus = RCC_WaitForHSEStartUp();

  if(HSEStartUpStatus == SUCCESS)
  {
    /* Enable Prefetch Buffer */
    FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

    /* Flash 2 wait state */
    FLASH_SetLatency(FLASH_Latency_2);
 	
    /* HCLK = SYSCLK */
    RCC_HCLKConfig(RCC_SYSCLK_Div1); 
  
    /* PCLK2 = HCLK */
    RCC_PCLK2Config(RCC_HCLK_Div1); 

    /* PCLK1 = HCLK/2 */
    RCC_PCLK1Config(RCC_HCLK_Div2);

    /* PLLCLK = 8MHz * 9 = 72 MHz */
    RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

    /* Enable PLL */ 
    RCC_PLLCmd(ENABLE);

    /* Wait till PLL is ready */
    while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
    {
    }

    /* Select PLL as system clock source */
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

    /* Wait till PLL is used as system clock source */
    while(RCC_GetSYSCLKSource() != 0x08)
    {
    }
  }
}
Пример #2
0
void fastMode() {
    RCC_DeInit();

    RCC_HSEConfig(RCC_HSE_ON);
    if (RCC_WaitForHSEStartUp() == ERROR) {
        return;
    }
    RCC_PLLConfig(RCC_PLLSource_HSE, 8, 336, 2, 15);
    RCC_PLLCmd(ENABLE);

    RCC_WaitForPLLSturtUp();

    RCC_HCLKConfig(RCC_SYSCLK_Div4);
    RCC_PCLK1Config(RCC_HCLK_Div1);
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
}
Пример #3
0
void Sys_Clock_Init(void)
{
	ErrorStatus HSEStartUpStatus; 
	RCC_DeInit(); //     	/* RCC system reset(for debug purpose) 重置了RCC的设置*/
	RCC_HSEConfig(RCC_HSE_ON);		/* Enable HSE */  		/* 使能外部高速晶振 */
	HSEStartUpStatus = RCC_WaitForHSEStartUp();	  /* Wait till HSE is ready 等待高速晶振稳定*/ 	
	if(HSEStartUpStatus == SUCCESS)
	{
//		FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);	 	/* Enable Prefetch Buffer 使能flash预读取缓冲区*/  		
//		FLASH_SetLatency(FLASH_Latency_2);		  /* Flash 2 wait state 
//		令Flash处于等待状态,2是针对高频时钟的,这两句跟RCC没直接关系,可以暂且略过*/	   	
		RCC_HCLKConfig(RCC_SYSCLK_Div1);		  	/* HCLK = SYSCLK 设置高速总线时钟=系统时钟*/	   	
		RCC_PCLK2Config(RCC_HCLK_Div1);			  	/* PCLK2 = HCLK 设置低速总线2时钟=高速总线时钟*/  		
		RCC_PCLK1Config(RCC_HCLK_Div2);				/* PCLK1 = HCLK/2 设置低速总线1的时钟=高速时钟的二分频*/  
		 	
        RCC_ADCCLKConfig(RCC_PCLK2_Div6);		   	/* ADCCLK = PCLK2/6 设置ADC外设时钟=低速总线2时钟的六分频*/	

/*		RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);  // PLLCLK = 8MHz * 9 = 72 MHz 利用锁相环讲外部8Mhz晶振9倍频到72Mhz 	 
		RCC_PLLCmd(ENABLE);			// Enable PLL 使能锁相环		 																
		while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)		// Wait till PLL is ready 等待锁相环输出稳定
		{
		} */
		RCC_SYSCLKConfig(RCC_SYSCLKSource_HSE);
		//RCC_SYSCLKSource_HSI:	高速内部时钟信号 stm32单片机内带的时钟 (8M频率)	 
		//RCC_SYSCLKSource_HSE:(1)HSE外部晶体/陶瓷谐振器(晶振)  (2)HSE用户外部时钟
		//RCC_SYSCLKSource_PLLCLK:Select PLL as system clock source 将锁相环输出设置为系统时钟*/	
		while(RCC_GetSYSCLKSource() != 0x04)	//HSE used as system clock
// 		while(RCC_GetSYSCLKSource() != 0x08)	/* Wait till PLL is used as system clock source 等待PLL校验成功*/
		{
		}
	}
	/* 这个配置可使外部晶振停振的时候,产生一个NMI中断,不需要用的可屏蔽掉*/
	//RCC_ClockSecuritySystemCmd(ENABLE);
	/* Enable FSMC, GPIOD, GPIOE, GPIOF, GPIOG and AFIO clocks */
    //使能外围接口总线时钟,注意各外设的隶属情况,不同芯片的分配不同,查手册就可
	/* Enable peripheral clocks -------------------------------*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, ENABLE);	  
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE); 	
//  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
//	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE |
//                         RCC_APB2Periph_GPIOF | RCC_APB2Periph_GPIOG |
//                         RCC_APB2Periph_AFIO, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);	  // AFIO时钟,用来禁止JTAG
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	  // 串口1时钟,
//	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);     //ADC1时钟 
//	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);//使能DMA1时钟 	
} 
Пример #4
0
/***************************************************************************//**
 * @brief  Selects HSE as System clock source and configure HCLK, PCLK2 and PCLK1 prescalers.
 ******************************************************************************/
void SetSysClockToHSE(void) 
{
    /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
    /* RCC system reset(for debug purpose) */
    RCC_DeInit();

    /* Enable HSE */
    RCC_HSEConfig( RCC_HSE_ON);

    /* Wait till HSE is ready */
    HSEStartUpStatus = RCC_WaitForHSEStartUp();

    if (HSEStartUpStatus == SUCCESS) 
    {
        /* Enable Prefetch Buffer */
        FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

        /* Flash 0 wait state */
        FLASH_SetLatency( FLASH_Latency_0);

        /* HCLK = SYSCLK */
        RCC_HCLKConfig( RCC_SYSCLK_Div1);

        /* PCLK2 = HCLK */
        RCC_PCLK2Config( RCC_HCLK_Div1);

        /* PCLK1 = HCLK */
        RCC_PCLK1Config(RCC_HCLK_Div1);

        /* Select HSE as system clock source */
        RCC_SYSCLKConfig( RCC_SYSCLKSource_HSE);

        /* Wait till PLL is used as system clock source */
        while (RCC_GetSYSCLKSource() != 0x04) 
        {
        }
    } 
    else 
    { /* If HSE fails to start-up, the application will have wrong clock configuration.
     User can add here some code to deal with this error */

        /* Go to infinite loop */
        while (1) 
        {
        }
    }
}
Пример #5
0
void setToMaxSpeed(void) {
    int internalClockCounter;
    RCC_PLLCmd(DISABLE);
    while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY));
    RCC_HSEConfig(RCC_HSE_OFF);
    RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_12);
    RCC_PREDIV1Config(RCC_PREDIV1_Div1);
    RCC_PLLCmd(ENABLE);
    while(!RCC_GetFlagStatus(RCC_FLAG_PLLRDY));
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
    for(internalClockCounter=0; internalClockCounter<1024; internalClockCounter++) {
        if(RCC_GetSYSCLKSource()==RCC_SYSCLKSource_PLLCLK) {
            SystemCoreClockUpdate();
            break;
        }
    }
}
Пример #6
0
void RCC_Config(void)
{
  RCC_DeInit();                 //RCC寄存器初始化
  RCC_HSEConfig(RCC_HSE_ON);    //使用外部時鐘
  //if(RCC_WaitForHSEStarUp()==SUCCESS)
  //{
    RCC_PLLCmd(DISABLE);//PLL前應先關閉主PLL
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//選擇PLL時鐘為系統時鐘
    RCC_HCLKConfig(RCC_SYSCLK_Div1);//HCLK(AHB)時鐘為系統時鐘1分頻
    RCC_PCLK1Config(RCC_HCLK_Div4);//PCLK1(AHB1)時鐘為HCLK時鐘8分頻,則TIM2時鐘為HCLK時鐘4分頻
    RCC_PCLK2Config(RCC_HCLK_Div2);//PCLK1(AHB1)時鐘為HCLK時鐘2分頻
    RCC_PLLConfig(RCC_PLLSource_HSE,27,162,2,7);//PLL時鐘配置,公式見system_stm43f4xx.c'line149
    RCC_PLLCmd(ENABLE);         //PLL時鐘開啟
    while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET){}//等待PLL時鐘準備好
    
  //}
}
Пример #7
0
void cpu_init(void) {
  RCC_DeInit();

  RCC_HSEConfig(RCC_HSE_ON);
  ErrorStatus HSEStartUpStatus = RCC_WaitForHSEStartUp();

  if (HSEStartUpStatus == SUCCESS) {
    
    // Enable flash buffers and prefetching
    FLASH_PrefetchBufferCmd(ENABLE);
    FLASH_InstructionCacheCmd(ENABLE);
    FLASH_DataCacheCmd(ENABLE);

    // Set startup speed
    cpu_reclock(&sysclock_120m);
  }
}
Пример #8
0
/**************************************************************/
//程 序 名: RCC_Config()
//开 发 者: Haichao.Xie
//入口参数: 无
//功能说明: 系统时钟配置
//**************************************************************/
void RCC_Config(void)
{
	ErrorStatus HSEStartUpStatus;	//定义结构体
	/* RCC system reset(for debug purpose)将外设 RCC寄存器重设为缺省值 */
	RCC_DeInit();
	/* Enable HSE 设置外部高速晶振(HSE)*/
	RCC_HSEConfig(RCC_HSE_ON);
	/* Wait till HSE is ready 等待 HSE 起振*/
	HSEStartUpStatus = RCC_WaitForHSEStartUp();

	if (HSEStartUpStatus == SUCCESS)
	{
		/* Enable Prefetch Buffer 预取指缓存使能*/
		FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

		/* Flash 2 wait state 设置代码延时值*/
		FLASH_SetLatency(FLASH_Latency_2);

		/* HCLK = SYSCLK 设置 AHB 时钟(HCLK)*/
		RCC_HCLKConfig(RCC_SYSCLK_Div1);

		/* PCLK2 = HCLK 设置高速 AHB 时钟(PCLK2)*/
		RCC_PCLK2Config(RCC_HCLK_Div1);

		/* PCLK1 = HCLK/1 设置低速 AHB 时钟(PCLK1)*/
		RCC_PCLK1Config(RCC_HCLK_Div1);

		/* PLLCLK = 12MHz * 6 = 72 MHz 设置 PLL 时钟源及倍频系数*/
		RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_6);

		/* Enable PLL 使能或者失能 PLL*/
		RCC_PLLCmd(ENABLE);

		/* Wait till PLL is ready 等待指定的 RCC 标志位设置成功 等待PLL初始化成功*/
		while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
		{
		}
		/* Select PLL as system clock source 设置系统时钟(SYSCLK) 设置PLL为系统时钟源*/
		RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

		/* Wait till PLL is used as system clock source 等待PLL成功用作于系统时钟的时钟源*/
		while(RCC_GetSYSCLKSource() != 0x08)
		{
		}
	}
}
Пример #9
0
static void RCC_Configuration(void)
{
  /*---------------------------------*/
  /*  /!\  PLL2 not configured  /!\  */
  /*---------------------------------*/
  ErrorStatus HSEStartUpStatus;
  // RCC system reset(for debug purpose)
  RCC_DeInit();
  // Enable HSE
  RCC_HSEConfig(RCC_HSE_ON);
  // Wait till HSE is ready
  HSEStartUpStatus = RCC_WaitForHSEStartUp();

  if(HSEStartUpStatus == SUCCESS)
  {
    // Enable Prefetch Buffer
    FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
    // Flash 2 wait state
    FLASH_SetLatency(FLASH_Latency_2);
    // HCLK = SYSCLK
    RCC_HCLKConfig(RCC_SYSCLK_Div1);
    // PCLK2 = HCLK
    RCC_PCLK2Config(RCC_HCLK_Div1);
    // PCLK1 = HCLK/2
    RCC_PCLK1Config(RCC_HCLK_Div2);
    /* ADCCLK = PCLK2/4 */
    RCC_ADCCLKConfig(RCC_PCLK2_Div4);
    // PLLCLK = 8MHz * 9 = 72 MHz
    RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
    // Enable PLL
    RCC_PLLCmd(ENABLE);
    // Wait till PLL is ready
    while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
    {;}
    // Select PLL as system clock source
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
    // Wait till PLL is used as system clock source
    while(RCC_GetSYSCLKSource() != 0x08)  ///????
    {;}
  }

    /* Enable peripheral clocks (FOR USART1)---------------------------------*/
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    /* Enable GPIOA / GPIOC clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
}
Пример #10
0
void vHardwareInit()
{
  // Enable HSE:
  RCC_HSEConfig(RCC_HSE_ON);

  // Wait for HSE to be ready:
  while (RCC_WaitForHSEStartUp() != SUCCESS);

  // Set PLL to be 9 * HSE = 72 MHz:
  RCC_PLLCmd(DISABLE);
  RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
  RCC_PLLCmd(ENABLE);

  // Wait for PLL to be ready:
  while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) != SET);

  // Two wait states, if 48 MHz < SYSCLK <= 72 MHz:
  FLASH_SetLatency(FLASH_Latency_2);

  // Set PLL as system clock:
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

  // Disable HSI:
  RCC_HSICmd(DISABLE);

  // Set APB low-speed clock (PCLK1), divide by 2:
  RCC_PCLK1Config(RCC_HCLK_Div2);

  // Set APB high-speed clock (PCLK2), do not divide:
  RCC_PCLK2Config(RCC_HCLK_Div1);

  // Set AHB clock (HCLK), do not divide:
  RCC_HCLKConfig(RCC_SYSCLK_Div1);

  // 3 bits for pre-emption priority 1 bits for subpriority:
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_3);

  // Set core clock as SYSTICK source:
  SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);

#ifdef RAM_BOOT
  // Put vector interrupt table in RAM:
  NVIC_SetVectorTable(NVIC_VectTab_RAM, SCB_VTOR_TBLBASE);
#endif
}
Пример #11
0
int main(void)
{
	// Check that you flashed to the correct microcontroller
	uint32_t chipId1 = TM_ID_GetUnique32(0);
	uint32_t chipId2 = TM_ID_GetUnique32(1);
	uint32_t chipId3 = TM_ID_GetUnique32(2);
	if(chipId1 != 0x00290044 || chipId2 != 0x30345117 || chipId3 != 0x37333838){
		while(1);
	}
	
	// Configure the system clock.
	// The system clock is 168Mhz.
	RCC_HSEConfig(RCC_HSE_ON); // ENABLE HSE (HSE = 8Mhz)
	while(!RCC_WaitForHSEStartUp());  // Wait for HSE to stabilize
	
	SystemCoreClockUpdate();
	RCC_PCLK1Config(RCC_HCLK_Div4); // Set APB1=42Mhz (168/4)

	
	// Initialize peripheral modules
	InitGPIO();
	InitNVIC();
	InitPedalIntegrity();
	InitADC();
	InitCAN();
//	MCO_Config(); // Clock output
	
	
	
	
	/* Main code */
	while(1)
	{
		Delay(0xFF);
		/*
		if(CAN_GetITStatus(CAN1,CAN_IT_FMP0) == SET){
		
		CAN_Receive(CAN1,CAN_FIFO0,&msgRx);
		if(msgRx.StdId == 0x1){
			GPIOC->ODR |= GPIO_Pin_6;
		}
	}
		*/
	}
}
Пример #12
0
/*
 * RCC时钟频率引脚配置
 */
void RCC_Configuration(void)
{
	//定义错误状态变量
	ErrorStatus HSEStartUpStatus;
	
	//将RCC寄存器重新设置为默认值
	RCC_DeInit();
	
	//打开外部高速时钟晶振
	RCC_HSEConfig(RCC_HSE_ON);
	
	//等待外部高速时钟晶振工作
	HSEStartUpStatus = RCC_WaitForHSEStartUp();
	if(HSEStartUpStatus != SUCCESS) return;
	
	//使能预取指缓存
	FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
	
	//设置FLASH代码延时
	FLASH_SetLatency(FLASH_Latency_2);

	//设置AHB时钟(HCLK)为系统时钟
	RCC_HCLKConfig(RCC_SYSCLK_Div1); 

	//设置高速AHB时钟(APB2)为HCLK时钟
	RCC_PCLK2Config(RCC_HCLK_Div1); 

  //设置低速AHB时钟(APB1)为HCLK的2分频
	RCC_PCLK1Config(RCC_HCLK_Div2);	

  //设置PLL时钟,为HSE的12倍频 PLLCLK = 12MHz/2 * 12 = 72 MHz
	RCC_PLLConfig(RCC_PLLSource_HSE_Div2, RCC_PLLMul_12);

	//使能PLL
	RCC_PLLCmd(ENABLE);

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

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

	//判断PLL是否是系统时钟
	while(RCC_GetSYSCLKSource() != 0x08);
}
Пример #13
0
void RCC_Configuration(void)
{
  ErrorStatus HSEStartUpStatus;
 
  RCC_DeInit();                                                      
  RCC_HSEConfig(RCC_HSE_ON);                    
  HSEStartUpStatus = RCC_WaitForHSEStartUp(); 
  if(HSEStartUpStatus == SUCCESS)                      
    {          
      RCC_HCLKConfig(RCC_SYSCLK_Div1);        
      RCC_PCLK2Config(RCC_HCLK_Div1);
      RCC_PCLK1Config(RCC_HCLK_Div2);
      FLASH_SetLatency(FLASH_Latency_2);
			FLASH_PrefetchBufferCmd(ENABLE);
			RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);
      RCC_PLLCmd(ENABLE);                              
      while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET);                                                              
      RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);  
      while(RCC_GetSYSCLKSource() !=0x08);
			
			// the following is the selected part of the clock inicialization, according to your connecting devices
			
			//SPI1 clock open
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
			
			//USART-XTend (wireless data transmittion) clock open
			RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
      
			//USART-GPS clock open
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
			
			//USART-sensor clock open
			RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
			
			//GPIO LED clock open
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
			
			//GPIO Launching clock open
			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
			
			SysTick_ITConfig(ENABLE);
   }
}
Пример #14
0
void RCC_HSE_Configuration(void){
	RCC_DeInit(); /*将外设RCC寄存器重设为缺省值 */ 
	RCC_HSEConfig(RCC_HSE_ON); 	 /*设置外部高速晶振打开*/

	if(RCC_WaitForHSEStartUp() == SUCCESS) {  /*等待HSE起振,晶振稳定且就绪*/

		RCC_HCLKConfig(RCC_SYSCLK_Div1);/*设置AHB时钟*/
		RCC_PCLK2Config(RCC_HCLK_Div1); /*设置高速AHB时钟*/
		RCC_PCLK1Config(RCC_HCLK_Div2); /*设置低速AHB时钟*/

		RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);/*设置PLL时钟源、倍频系数*/		 
		RCC_PLLCmd(ENABLE);//使能PLL
		while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);//检查指定RCC标志位

		RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); //设置系统时钟
		while(RCC_GetSYSCLKSource() != 0x08);    //PLL作为系统时钟
	}
}
Пример #15
0
void TSVN_FOSC_Init(void)
{
	RCC_DeInit();								
	RCC_HSEConfig(RCC_HSE_ON);	
	while(RCC_WaitForHSEStartUp() != SUCCESS);
	RCC_PREDIV1Config(RCC_PREDIV1_Source_HSE, RCC_PREDIV1_Div1);
	RCC_HCLKConfig(RCC_SYSCLK_Div1); 
	RCC_PCLK2Config(RCC_HCLK_Div2);     
	RCC_PCLK1Config(RCC_HCLK_Div2);  
	RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
	RCC_PLLCmd(ENABLE);	
	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
	RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); 
	while(RCC_GetSYSCLKSource() != 0x08)
	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
	SystemCoreClockUpdate();
	SysTick_Config(SystemCoreClock/1000);
}
Пример #16
0
void Startup::clkInit()
{
	// Set STKALIGN in NVIC
	SCB->CCR |= 0x200;

	// 1. Clocking the controller from internal HSI RC (8 MHz)
	RCC_HSICmd(ENABLE);
	// wait until the HSI is ready
	while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);
	RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);
	// 2. Enable ext. high frequency OSC
	RCC_HSEConfig(RCC_HSE_ON);
	// wait until the HSE is ready
	while(RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET);
	// 3. Init PLL
	RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9); // 72MHz
//  RCC_PLLConfig(RCC_PLLSource_HSE_Div2,RCC_PLLMul_9); // 72MHz
	RCC_PLLCmd(ENABLE);
	// wait until the PLL is ready
	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
	// 4. Set system clock dividers
	RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5);
	RCC_ADCCLKConfig(RCC_PCLK2_Div8);
	RCC_PCLK2Config(RCC_HCLK_Div1);
	RCC_PCLK1Config(RCC_HCLK_Div2);
	RCC_HCLKConfig(RCC_SYSCLK_Div1);

	// Flash 1 wait state
//	*(vu32 *)0x40022000 = 0x12;
//	*(vu32 *)0x40022000 = 0x01;

    // Enable Prefetch Buffer
    FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
    // Flash 2 wait state
    FLASH_SetLatency(FLASH_Latency_2);

	// Select PLL as system clock source
	RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

    // Wait till PLL is used as system clock source
    while(RCC_GetSYSCLKSource() != 0x08)
    {
    }
}
Пример #17
0
Файл: bsp.c Проект: xinmulan/RGB
void RCC_Configuration(void)
{
     /* 定义枚举型变量HSEStartUpStatus */
    ErrorStatus HSEStartUpStatus;
    /* 复位系统时钟设置*/
    RCC_DeInit();
    /* 开启HSE*/
    RCC_HSEConfig(RCC_HSE_ON);
    /* 等待HSE启振并稳定*/
    HSEStartUpStatus = RCC_WaitForHSEStartUp();

    /*判断HSE是否起振成功, */
    if(HSEStartUpStatus == SUCCESS)
    {
        /* 选择HCLK(AHB)时钟源为 SYSCLK 1分频 */
        RCC_HCLKConfig(RCC_SYSCLK_Div1);
        /* 选择PCLK2时钟源为HCLK(AHB) 1分频*/
        RCC_PCLK2Config(RCC_HCLK_Div1);
        /* 选择PCLK1时钟源为HCLK(AHB) 2分频*/
        RCC_PCLK1Config(RCC_HCLK_Div2);
        /* 设置FLASH延时周期数为2 */
        FLASH_SetLatency(FLASH_Latency_2);
        /* 使能FLASH预缓存 */
        FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
        /* 选择锁相环(PLL)时钟源为HSE 1分频,倍频数为9,则PLL输出频率 8MHz * 9 = 72MHz */
        RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
        /* 使能PLL */
        RCC_PLLCmd(ENABLE);
        /* 等待PLL输出稳定 */
        while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
        /* 选择SYSCLK时钟源为PLL */
        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
        /* 等待PLL成为SYSCLK时钟源*/
        while(RCC_GetSYSCLKSource() != 0x08);
    }

    /* 打开APB2总线上的GPIOA时钟*/
		RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_GPIOB|
													 RCC_APB2Periph_AFIO  |RCC_APB2Periph_USART1 ,ENABLE);       
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 | RCC_APB1Periph_TIM4,ENABLE);
		

}
Пример #18
0
void RtcRecoverMcuStatus( void )
{	
	if ( TimerGetLowPowerEnable( ) == true )
	{
		if ( ( LowPowerDisableDuringTask == false ) && ( RtcTimerEventAllowsLowPower == true ) )
		{	
			// Disable IRQ while the MCU is not running on HSE
			__disable_irq( );
	
			/* After wake-up from STOP reconfigure the system clock */
			/* Enable HSE */
			RCC_HSEConfig( RCC_HSE_ON );
			
			/* Wait till HSE is ready */
			while ( RCC_GetFlagStatus( RCC_FLAG_HSERDY ) == RESET )
			{}
			
			/* Enable PLL */
			RCC_PLLCmd( ENABLE );
			
			/* Wait till PLL is ready */
			while ( RCC_GetFlagStatus( RCC_FLAG_PLLRDY ) == RESET )
			{}
			
			/* Select PLL as system clock source */
			RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK );
			
			/* Wait till PLL is used as system clock source */
			while ( RCC_GetSYSCLKSource( ) != 0x0C )
			{}
	
			/* Set MCU in ULP (Ultra Low Power) */
			PWR_UltraLowPowerCmd( DISABLE ); // add up to 3ms wakeup time
			
			/* Enable the Power Voltage Detector */
			PWR_PVDCmd( ENABLE );
				
			BoardInitMcu( );
	
			__enable_irq( );
		}
	}
}
Пример #19
0
void RCC_HSE_Configuration(void) //HSE作为PLL时钟,PLL作为SYSCLK 
{ 
   RCC_DeInit(); /*将外设RCC寄存器重设为缺省值 */ 
   RCC_HSEConfig(RCC_HSE_ON); 	 /*设置外部高速晶振(HSE) HSE晶振打开(ON)*/ 

   if(RCC_WaitForHSEStartUp() == SUCCESS) {  /*等待HSE起振,  SUCCESS:HSE晶振稳定且就绪*/  

   RCC_HCLKConfig(RCC_SYSCLK_Div1);/*设置AHB时钟(HCLK)RCC_SYSCLK_Div1——AHB时钟 = 系统时*/  
   RCC_PCLK2Config(RCC_HCLK_Div1); /*设置高速AHB时钟(PCLK2)RCC_HCLK_Div1——APB2时钟 = HCLK*/     
   RCC_PCLK1Config(RCC_HCLK_Div2); /*设置低速AHB时钟(PCLK1)RCC_HCLK_Div2——APB1时钟 = HCLK / 2*/      

   RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);/*设置PLL时钟源及倍频系数*/    
   RCC_PLLCmd(ENABLE); 	 /*使能PLL */ 
   while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) ; /*检查指定的RCC标志位(PLL准备好标志)设置与否*/ 
    
   RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);  /*设置系统时钟(SYSCLK) */  
   while(RCC_GetSYSCLKSource() != 0x08);     /*0x08:PLL作为系统时钟 */	    
 } 
} 
Пример #20
0
/* Przerwanie NMI jest generowane m. in. przez system nadzoru zegara. Jeżeli zegar zewnętrzny
 * padnie, wtedy można przełączyć się na zegar wewnętrzny. Niestety, aby płynnie przechodzić między
 * domenami zegara bez zmiany konfiguracji peryferiów, zegar systemowy nie może być szybszy niż maks
 * co się dla uzyskać PLL napędzanej z HSI, czyli 64MHz. Obsługa jest mało koszerna, gdyż trwa długo
 * ale jak pada zegar, to chyba jest to mało ważne, czy obsługjemy inne przerwania, ważne, żeby
 * przywrócić system do działania.
 */
void NMI_Handler(void)
{
	if (RCC_GetITStatus(RCC_IT_CSS) == SET) {
		RCC_HSEConfig(RCC_HSE_ON);
		if (RCC_WaitForHSEStartUp() == SUCCESS) {
			RCC_PLLCmd(ENABLE);
			while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
			RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
			while (RCC_GetSYSCLKSource() != 0x08);
		} else {
			RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_16);
			RCC_PLLCmd(ENABLE);
			while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
			RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
			while (RCC_GetSYSCLKSource() != 0x08);
		}
		RCC_ClearITPendingBit(RCC_IT_CSS);
	}
}
Пример #21
0
/**
* @brief  This function handles EXTI0_IRQ Handler.
* @param  None
* @retval None
*/
void EXTI0_IRQHandler(void) {

  if (EXTI_GetITStatus(EXTI_Line0) != RESET) {

//    if (USB_OTG_dev.dev.DevRemoteWakeup) {

      if((USB_OTG_dev.cfg.low_power)&&(USB_OTG_dev.dev.device_status==USB_OTG_SUSPENDED)) {

        /* Reset SLEEPDEEP and SLEEPONEXIT bits */
        SCB->SCR &= (uint32_t)~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));

        /* After wake-up from sleep mode, reconfigure the system clock */
        /* After wake-up from STOP reconfigure the system clock */

        /* Enable HSE */
        RCC_HSEConfig(RCC_HSE_ON);

        /* Wait till HSE is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET);

        /* Enable PLL */
        RCC_PLLCmd(ENABLE);

        /* Wait till PLL is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

        /* Select PLL as system clock source */
        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

        /* Wait till PLL is used as system clock source */
        while (RCC_GetSYSCLKSource() != 0x08);

        USB_OTG_UngateClock(&USB_OTG_dev);
      }
      USB_OTG_ActiveRemoteWakeup(&USB_OTG_dev);
      USB_OTG_dev.dev.device_status = USB_OTG_dev.dev.device_old_status;

//    }
    /* Clear the EXTI line pending bit */
    EXTI_ClearITPendingBit(EXTI_Line0);

  }
}
Пример #22
0
void RCC_Configuration(void)
{
    RCC_DeInit();                                    //将外设RCC寄存器重设为缺省值

#ifdef ExtOSC

    RCC_HSEConfig(RCC_HSE_ON);                    //开启外部高速晶振(HSE)

    //等待HSE起振
    if( RCC_WaitForHSEStartUp() == SUCCESS)               //若成功起振,(下面为系统总线时钟设置)
    {
        FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable); //使能FLASH预取指缓存

        //FLASH_SetLatency(FLASH_Latency_0);   //设置FLASH存储器延时时钟周期数(根据不同的系统时钟选取不同的值)
        //RCC_HCLKConfig(RCC_SYSCLK_Div1);   //设置AHB时钟=72 MHz
        //RCC_PCLK2Config(RCC_HCLK_Div2);   //设置APB1时钟=36 MHz(APB1时钟最大值)
        //RCC_PCLK1Config(RCC_HCLK_Div1);   //设置APB2时钟=72 MHz
        //4*8=32Mhz
        RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_4); //PLL必须在其激活前完成配置(设置PLL时钟源及倍频系数)
        RCC_PLLCmd(ENABLE);

        // while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

        // while(RCC_GetSYSCLKSource() != 0x08);

    }
    //DebugPrint("Use ExtOSC PLL \r\n",);
#else

    /*  使用内部RC晶振 */
    RCC_HSICmd(ENABLE);//使能内部高速晶振 ;
    while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);

    RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);//选择内部高速时钟作为系统时钟SYSCLOCK=8MHZ
    RCC_HCLKConfig(RCC_SYSCLK_Div1);//选择HCLK时钟源为系统时钟SYYSCLOCK
    //DebugPrint("Use IntOSC\r\n");
#endif


    SystemCoreClockUpdate(); //更新时钟必须调用
}
Пример #23
0
void RCC_Config_30MHz(void){
RCC_DeInit();
FLASH_SetLatency(FLASH_Latency_2);
/*configurar clock externo a 72Mhz */

//bypass pois está ligado no OSC_IN um circuito oscilatorio externo
RCC_HSEConfig(RCC_HSE_Bypass);
//Após a ativação do HSE deveremos esperar até que o sinal de relógio esteja pronto e estável
ErrorStatus HSEStartUpStatus;
HSEStartUpStatus=RCC_WaitForHSEStartUp();

if(HSEStartUpStatus==SUCCESS) /*retorna SUCCESS ou ERROR*/
{   

    //divisão do prescaler AHB por 1
    RCC_HCLKConfig(RCC_SYSCLK_Div1);
    //divisão do prescaler APB1 por 2
    RCC_PCLK1Config(RCC_HCLK_Div1);
    //divisão do prescaler APB2 por 1
    RCC_PCLK2Config(RCC_HCLK_Div1);
    //configuar a PLL para 30Mhz
    RCC_PLLConfig(RCC_PLLSource_HSE_Div2,RCC_PLLMul_5);
    //activar a pll
    RCC_PLLCmd(ENABLE);
    
    while(RCC_GetFlagStatus( RCC_FLAG_PLLRDY)==RESET);
    //activa o sysclk pll
    
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

    
    //confirmar que o clock está correcto logo esperar que a fonte de relógio esteja correta
    while(RCC_GetSYSCLKSource()!=0x08);
    //clock configurado com sucesso 
}
else
 while(1); /*se deu erro o micro nao arranca*/




}
Пример #24
0
void RCC_Configuration(void)
{
    ErrorStatus HSEStartUpStatus;
    RCC_DeInit();

    RCC_HSEConfig(RCC_HSE_ON);
    HSEStartUpStatus = RCC_WaitForHSEStartUp();
    if(HSEStartUpStatus == SUCCESS)
    {
      RCC_HCLKConfig(RCC_SYSCLK_Div1);
      RCC_PCLK2Config(RCC_HCLK_Div1);
      RCC_PCLK1Config(RCC_HCLK_Div2);
      RCC_PLLConfig(RCC_PLLSource_HSE, 8, 168, 2, 6);
      RCC_PLLCmd(ENABLE);
      while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
      RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
      while(RCC_GetSYSCLKSource() != 0x08);
      
    }
}
Пример #25
0
int main(void)
{
	// Configure the system clock.
	// The system clock is 168Mhz.
	RCC_HSEConfig(RCC_HSE_ON); // ENABLE HSE (HSE = 8Mhz)
	while(!RCC_WaitForHSEStartUp());  // Wait for HSE to stabilize
	
	SystemCoreClockUpdate();
	RCC_PCLK1Config(RCC_HCLK_Div4); // Set APB1=42Mhz (168/4)

	// Initialize peripheral modules
	InitCAN();
	InitGPIO();
	InitButtons();
	InitEXTI();
	InitNVIC();
	InitTim();
	InitSystick();
	InitWatchdog();
	
	/* 
	Check if the IWDG reset has occoured
	*/
	/*if(RCC_GetFlagStatus(RCC_FLAG_IWDGRST) == SET){
		GPIOA->ODR |= GPIO_Pin_6; //temp action
		RCC_ClearFlag();
	}*/
	
	while(1)
	{ 	
		if(clk10msWheel == COMPLETE){
			TxWheelrpm();
			clk10msWheel = RESTART;
		}
		
		checkButtons();
		
		LED_SetState(LED_GREEN, (GPIOE->IDR & BUTTON_START_GPIO_PIN) ? DISABLE : ENABLE);
		LED_SetState(LED_RED,   (GPIOE->IDR & BUTTON_STOP_GPIO_PIN)  ? ENABLE : DISABLE);
	}
}
Пример #26
0
/**
 * We want to use the ADC in this app, which needs the HSI, which runs at 16MHz,
 * by default the 32L starts up in voltage range 2, which only allows 8Mhz 
 * without inserting wait states for flash and so on.
 */
void SystemInit(void)
{
    // we need clocks to reach the power part...
    RCC->APB1ENR |= RCC_APB1ENR_PWREN;

    /* Select the Voltage Range 1 (1.8 V) */
    PWR->CR = PWR_CR_VOS_0;

    /* Wait Until the Voltage Regulator is ready */
    while ((PWR->CSR & PWR_CSR_VOSF) != RESET)
        ;

    /* HSI is 16mhz RC clock directly fed to SYSCLK (rm00038, figure 9) */

    //#define USE_RAW_CMSIS
#ifdef USE_RAW_CMSIS
    // Do it all by hand with RCC->CR and so on...
#else // use stm32 lib methods...
    /* enable the HSI clock (high speed internal) */
    RCC_HSICmd(ENABLE);

    /* wail til HSI ready */
    while (RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET)
        ;

    /* now switch to this source */
    RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);

    // Turn off unneeded clocks...
    // We're not using LSE yet, but we might want to experiment with it...
    RCC_HSEConfig(RCC_HSE_OFF);
    RCC_LSICmd(DISABLE);
    RCC_MSICmd(DISABLE);
    RCC_PLLCmd(DISABLE);
#endif
    // we don't really need to wait for them to shut down...

    // not sure how to use this yet...
    // SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. */
    //SCB->VTOR = FLASH_BASE | 0x0; /* Vector Table Relocation in Internal FLASH. */
}
Пример #27
0
//配置系统时钟
void RCC_Configuration(void){
	//定义枚举类型变量
	ErrorStatus	HSEStartUpStatus;
	
	//复位系统时钟设置
	RCC_DeInit();  
	
	//开启HSE时钟
	RCC_HSEConfig(RCC_HSE_ON);
	//等待HSE起振并稳定
	HSEStartUpStatus=RCC_WaitForHSEStartUp();
	//判断HSE是否起振成功
	if(HSEStartUpStatus == SUCCESS){
		//选择HCLK(AHB)时钟源为SYSCLK	1分频
		RCC_HCLKConfig(RCC_SYSCLK_Div1);
		//选择PCLK2时钟源为HCLK(AHB)	1分频
		RCC_PCLK2Config(RCC_HCLK_Div1);
		//选择PCLK1时钟源为HCLK(AHB)	2分频
		RCC_PCLK1Config(RCC_HCLK_Div2);
		
		//设置flash延时周期数为2
		FLASH_SetLatency(FLASH_Latency_2);
		//使能预取缓冲
		FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

		//选择锁相环(PLL时钟源为HSE 1分频,倍频数为9,则PLL输出频率为8M * 9 = 72M)
		RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
		//使能PLL
		RCC_PLLCmd(ENABLE);
		//等待PLL输出稳定
		while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){};

		//选择PLL为系统时钟源,并等待PLL准备好
		RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
		while(RCC_GetSYSCLKSource() != 0x08){};
	}
	//4个LED对应PE2 PE3 PE4 PE5
	//因此要使能APB2总线上的GPIOE时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
	
}
Пример #28
0
Файл: moto.c Проект: nbei/Car
//设置系统时钟为72MHz
void RCC_Configuration(void)
{
	RCC_DeInit();
	RCC_HSEConfig(RCC_HSE_ON);	//使能外部高速时钟
	while(RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET) ; //等待外部的高速时钟就绪

	FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);      //使能指令预存取
	FLASH_SetLatency(FLASH_Latency_2);        

	RCC_HCLKConfig(RCC_SYSCLK_Div1); //设置AHB时钟为系统时钟
	RCC_PCLK2Config(RCC_HCLK_Div1);	//设置APB2的时钟为AHB时钟
	RCC_PCLK1Config(RCC_HCLK_Div1);	//设置APB1的时钟为AHB时钟
	RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);	//设置PLL时钟为外部告诉时钟的9倍频
	RCC_PLLCmd(ENABLE);

	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

	RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); //配置PLL时钟为系统时钟
	while(RCC_GetSYSCLKSource()!=0x08); 

}
Пример #29
0
void OTG_HS_WKUP_IRQHandler(void)
{
  
  if (remote_wakeup ==1)
  {
    remote_wakeup = 0;
  }
  else
  {
    if(USB_OTG_dev.cfg.low_power)
    {
      /* Reset SLEEPDEEP and SLEEPONEXIT bits */
      SCB->SCR &= (uint32_t)~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
      
      /* After wake-up from sleep mode, reconfigure the system clock */
      RCC_HSEConfig(RCC_HSE_ON);
      
      /* Wait till HSE is ready */
      while (RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET)
      {}
      
      /* Enable PLL */
      RCC_PLLCmd(ENABLE);
      
      /* Wait till PLL is ready */
      while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
      {}
      
      /* Select PLL as system clock source */
      RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
      
      /* Wait till PLL is used as system clock source */
      while (RCC_GetSYSCLKSource() != 0x08)
      {}
      
      USB_OTG_UngateClock(&USB_OTG_dev);
    }
  }
  EXTI_ClearITPendingBit(EXTI_Line20);
}
Пример #30
0
/*******************************************************************************
* 
*            RCC配置
* 
*******************************************************************************/
void RCC_Configuration(void)
{   
	ErrorStatus HSEStartUpStatus;

	//复位RCC外部设备寄存器到默认值
	RCC_DeInit();  
	//打开外部高速晶振
  	RCC_HSEConfig(RCC_HSE_ON); 
	//等待外部高速时钟准备好
  	HSEStartUpStatus = RCC_WaitForHSEStartUp(); 
	//外部高速时钟已经准别好
  	if(HSEStartUpStatus == SUCCESS)  
  	{
    	FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
		FLASH_SetLatency(FLASH_Latency_2);
  
   		//配置AHB(HCLK)时钟=SYSCLK
    	RCC_HCLKConfig(RCC_SYSCLK_Div1);
		//配置APB2(PCLK2)钟=AHB时钟
    	RCC_PCLK2Config(RCC_HCLK_Div1); 
		//配置APB1(PCLK1)钟=AHB 1/2时钟
    	RCC_PCLK1Config(RCC_HCLK_Div2);  	
		//配置ADC时钟=PCLK2 1/4
    	RCC_ADCCLKConfig(RCC_PCLK2_Div4); 
		//配置PLL时钟 == 外部高速晶体时钟*9
    	RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9); 
		//配置ADC时钟= PCLK2/4
    	RCC_ADCCLKConfig(RCC_PCLK2_Div4);
		//使能PLL时钟
    	RCC_PLLCmd(ENABLE);  

   		//等待PLL时钟就绪
    	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
    
		//配置系统时钟 = PLL时钟
    	RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); 
		//检查PLL时钟是否作为系统时钟
    	while(RCC_GetSYSCLKSource() != 0x08);
  	}
}