今天有人问我关于外部晶振不起振以及如歌更改32的外部晶振，在此我做一个简单的记录(以stm32f1系列为例，其余类似)。
1.晶振不起振
此次遇到的问题倒不是出在电路上，实际上还是软件上的问题。画的新板子，换了一块贴片的晶振，与原来的直插式有点区别。首先，打印当前系统时钟频率，调用函数：RCC_GetClocksFreq(&RCC_Clocks);
printf("SYSCLK_Frequency: %d\r\n",RCC_Clocks.SYSCLK_Frequency);
结果打出来的是：SYSCLK_Frequency: 8000000
事实上，正常的f1系列的主频应该为72Mhz，所以应该打印出72000000。由此判断，应该是晶振出现了毛病。于是准备开仿真调试一下，结果尴尬了，居然打印除了72000000？你说啥？这就不懂了，怎么仿真的时候正常，下进去的程序就不行了？仔细回想一下32的启动过程，想到系统初始化的时候在main函数调用之前会进入SystemInit函数，如下(文件为startup_stm32f10x_hd.s启动文件)：
启动文件源码截图
从这里入手，经过层层深入，根据宏定义，发现其最终调用了SetSysClockTo72()函数，里面有一个等待HSE(外部高速晶振)起振的超时：
SetSysClockTo72()函数
在仿真的过程中，由于使用单步调试，在进入第996行的while循环中，其实HSE_STARTUP_TIMEOUT已经失去了它的作用(因为鼠标点一下的时间对于单片机来说已经过去很久了，所有这里没用了)，这也算是仿真和实际运行的一大区别吧。结合上述的现象，猜一猜或许是给的晶振允许起振的时间不够？打开HSE_STARTUP_TIMEOUT，其实就是一个宏定义，默认是0x0500：/**
* @brief In the following line adjust the External High Speed oscillator (HSE) Startup
Timeout value
*/
#define HSE_STARTUP_TIMEOUT   ((uint16_t)0x0500) /*!< Time out for HSE start up */
试着加大，改成0xf000，再次编译，下载，好了，终于成功打印出了72000000。
2.更改外部晶振值
这个问题相对于上一个问题就简单了，如果保持系统的主频72Mhz不变，那么改变外部晶振之后(如12Mhz)，只需要改变两个宏定义就可以了。首先是stm32f10x.h文件中，大概在119行的位置，将HSE_VALUE的值改为你所更换的晶振的值，原来(8Mhz)是8000000，此时(12Mhz)是12000000：
HSE_VALUE宏定义
其次，在system_stm32f10x.c文件中，依然在SetSysClockTo72()函数里，大概在1056行的位置，将倍频系数RCC_CFGR_PLLMULL9改成RCC_CFGR_PLLMULL6就可以了。默认是9倍的原因是外部晶振8Mhz*9=72Mhz，此时外部晶振为12Mhz，改成RCC_CFGR_PLLMULL6即可达到12Mhz*6=72Mhz的效果：
倍频系数的更改
至此，两个问题解决。

STM32F4外部晶振配置
system_stm32f4xx.c这个文件里面有晶振使用的配置，一般情况下，跑一个单片机需要做系统晶振初始化，以STM32为例，主循环需要先配置SystemInit();

SystemInit();里面也可以选外部晶振或者内部晶振



搜索USE_HSE_BYPASS，如果有定义则使用的外部晶振，没有定义则使用的内部晶振，目前我是屏蔽的。

而使用外部晶振的话，晶振大小在哪里改呢



如图改PLL_M，目前我用的是25M.

STM32外部晶振和内部晶振切换


以前做STM32的项目都是移植的正点原子官方的Demo，晶振是默认使用外部晶振8MHz，倍频到72MHz来实际运用的，实际上大家为了麻烦也都是用的这种方法。

最近有几个项目都没有外部晶振，是使用内部晶振，虽然精度相对来说没有外部的高，但是项目也没有使用到很精确时钟的地方。下面来分析一下怎么在正点原子官方Demo的基础上修改成内部晶振。

首先要明确的是内部晶振精度相对来说没有外部晶振高，而且不能像外部晶振一样倍频到很高，注意官方的说明，内部晶振是不能超过最大值，好像是64MHz晶振，感兴趣的话可以做一下实验。
我们先来看下，晶振是怎么启动的—>打开启动文件（汇编语言）
; Reset handler
Reset_Handler    PROC
                 EXPORT  Reset_Handler             [WEAK]
     IMPORT  __main
     IMPORT  SystemInit
                 LDR     R0, =SystemInit
                 BLX     R0
                 LDR     R0, =__main
                 BX      R0
                 ENDP

是先初始化晶振，然后再运行main函数。
然后我们看到SystemInit函数
void SystemInit (void)
{
  /* Reset the RCC clock configuration to the default reset state(for debug purpose) */
  /* Set HSION bit */
  RCC->CR |= (uint32_t)0x00000001;

  /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
#ifndef STM32F10X_CL
  RCC->CFGR &= (uint32_t)0xF8FF0000;
#else
  RCC->CFGR &= (uint32_t)0xF0FF0000;
#endif /* STM32F10X_CL */   
  
  /* Reset HSEON, CSSON and PLLON bits */
  RCC->CR &= (uint32_t)0xFEF6FFFF;

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

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

#ifdef STM32F10X_CL
  /* Reset PLL2ON and PLL3ON bits */
  RCC->CR &= (uint32_t)0xEBFFFFFF;

  /* 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(); 
  #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. */
#else
  SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. */
#endif 
}

做了一堆的初始化，最后设置系统时钟

进入SetSysClock函数----在此之前我们先修改一个宏定义，修改为48MHz
#if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
/* #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
#endif

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) */ 
}

然后顺势进入SetSysClockTo48函数
static void SetSysClockTo48(void)
{
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
  
  /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/    
  /* Enable HSE */    
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);
 
  /* Wait till HSE is ready and if Time out is reached exit */
  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)
  {
    /* Enable Prefetch Buffer */
    FLASH->ACR |= FLASH_ACR_PRFTBE;

    /* Flash 1 wait state */
    FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
    FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_1;    
 
    /* HCLK = SYSCLK */
    RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
      
    /* PCLK2 = HCLK */
    RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
    
    /* PCLK1 = HCLK */
    RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
    
#ifdef STM32F10X_CL
    /* Configure PLLs ------------------------------------------------------*/
    /* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
    /* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
        
    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);
  
    /* Enable PLL2 */
    RCC->CR |= RCC_CR_PLL2ON;
    /* Wait till PLL2 is ready */
    while((RCC->CR & RCC_CR_PLL2RDY) == 0)
    {
    }
    
   
    /* PLL configuration: PLLCLK = PREDIV1 * 6 = 48 MHz */ 
    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_PLLMULL6); 
#else    
    /*  PLL configuration: PLLCLK = HSE * 6 = 48 MHz */
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
    RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL6);
#endif /* STM32F10X_CL */

    /* Enable PLL */
    RCC->CR |= RCC_CR_PLLON;

    /* Wait till PLL is ready */
    while((RCC->CR & RCC_CR_PLLRDY) == 0)
    {
    }

    /* Select PLL as system clock source */
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;    

    /* Wait till PLL is used as system clock source */
    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
    {
    }
  }
  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 */
	  
	//如果外部晶振启动失败，则初始化内部晶振
	  SetSysClock_HSI_To48();
  } 
}

你们可以看到，本身如果外部晶振启动失败的话，是直接出去，但SystemInit函数一开始就使能了内部晶振，因为一开始，系统就是靠内部晶振起来的，所以如果外部晶振初始化失败，直接对内部晶振惊醒配置就好了，这里给出一段配置内部晶振倍频到48MHz的参考程序，如果想配置成其他的频率对应着修改参数就可以了。。。

如下：
void SetSysClock_HSI_To48(void)
{
	// Reset HSEON bit
	RCC->CR &= ~((uint32_t)RCC_CR_HSEON);//实际发现不关掉外部晶振很容易进入硬件错误中断
	 
	// Set HSION bit 
	RCC->CR |= (uint32_t)0x00000001;

	// select HSI/2 as PLL source = 8MHz / 2 = 4MHz
	RCC->CFGR |= (uint32_t)RCC_CFGR_PLLSRC_HSI_Div2;        

	//PLLCLK = 4MHz * 12 = 48M
	RCC->CFGR |= (uint32_t)RCC_CFGR_PLLMULL12;
			
	// HCLK = SYSCLK/1     
	RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
			 
	/* Enable PLL */
	RCC->CR |= RCC_CR_PLLON;
			
	/* Wait till PLL is ready */
	while((RCC->CR & RCC_CR_PLLRDY) == 0)
	{
	}
	/* Select PLL as system clock source */
	RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
	RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;    
					
	/* Wait till PLL is used as system clock source */
	while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
	{
		
	}
}

网上有一个解决办法，是直接在SystemInit函数里面修改对应的代码，虽然最终也能使用，但个人认为这样对代码移植起来比较麻烦，代码的可读性也不强，个人认为，对代码的修改最好不要直接一通修改。

再一个，我这样修改之后有个比较好的地方就是，如果外部晶振接上能直接用外部晶振，如果没接我可以用内部晶振，两不误。

当然内外部晶振使用时分别对应多少主时钟频率，还需要自己去设置，这里只是提供一种方法和思路。
最后再提一个最终频率的查看方法：
RCC_ClocksTypeDef get_rcc_clock;//获取系统时钟数据

int main(void)
{	
	RCC_GetClocksFreq(&get_rcc_clock);//查看时钟频率

可以通过debug里面的watch选项观察结构体里面的值

STM32系列修改外部晶振以及代码的修改

借用原子哥的一句话


			
很多初学者，用库函数开发STM32的时候不知道如何修改系统主频？不知道如何修改外部晶振频率？

			这里，我们针对这两个问题，给大家做一个简单的教程。希望大家能够掌握，以后可以轻松修改主频

			
 

			
 

			
8M晶振修改为12M  主频72M不变

			
STM32F1的固件库，外部晶振频率的定义在stm32f10x.h里面，如下：

			[mw_shl_code=c,true]#if !defined HSE_VALUE

			#ifdef STM32F10X_CL 

			#define HSE_VALUE ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */

			#else 
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

			#endif /* STM32F10X_CL */

			#endif /* HSE_VALUE */[/mw_shl_code]
其中，HSE_VALUE就是外部晶振的频率，对通用型STM32，默认是8M，对互联型，默认是25M。

			如果我们使用12M外部晶振，那么修改HSE_VALUE 的值为：12000000，即可，代码如下：

			[mw_shl_code=c,true]#if !defined HSE_VALUE

			#ifdef STM32F10X_CL 

			#define HSE_VALUE ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */

			#else 
#define HSE_VALUE ((uint32_t)12000000) /*!< Value of the External oscillator in Hz */

			#endif /* STM32F10X_CL */

			#endif /* HSE_VALUE */[/mw_shl_code]

			
 

			
 

			

然后，还是使用72M的主频，在system_stm32f10x.c里面，有如下宏定义：

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

			/* #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

			#endif


			默认定义了：SYSCLK_FREQ_72MHz 72000000，也就是72M，所以这里不用改，但是，事实上，修改主频为72M的是通过

			SetSysClockTo72函数实现的，该函数核心代码如下：

			 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    

			    /*  PLL configuration: PLLCLK = HSE * 9 = 72 MHz */

			    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |

			                                        RCC_CFGR_PLLMULL));

			    RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);

			#endif /* STM32F10X_CL */


			    /* Enable PLL */

			    RCC->CR |= RCC_CR_PLLON;其中，修改主频的核心代码为：
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);

			通过RCC_CFGR_PLLMULL9将倍频系数设置为9，如果默认外部晶振是8M，那么刚好得到72M的频率。

			不过，我们修改外部晶振为12M了，所以这里得改为6，修改后代码如下：
 RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL6);

			


			
8M晶振 

			
 

			


			
 

			
16M晶振2分频  再倍频*9=72