今天有人问我关于外部晶振不起振以及如歌更改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的效果：
 

 
倍频系数的更改
 
至此，两个问题解决。

 
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选项观察结构体里面的值

RTThread 使用外部晶振
 
 
 
以25M外部晶振对STM32F407VET6设置为例
 
 
1、打开路径\drivers\stm32f4xx_hal_conf.h 修改
 
#define HSE_VALUE ((uint32_t)25000000U)
 
​ 定义为你项目的外置时钟频率。
 
2、打开路径\drivers\board.h 修改
 
#define BSP_CLOCK_SOURCE ("HSE")
 #define BSP_CLOCK_SOURCE_FREQ_MHZ ((int32_t)0)
 #define BSP_CLOCK_SYSTEM_FREQ_MHZ ((int32_t)336)
 
3、打开路径\drivers\drv_clk.h 修改
 
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
//  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;`
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 25;	
RCC_OscInitStruct.PLL.PLLN = target_freq_mhz;	//336倍频
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;		//2分频 168
RCC_OscInitStruct.PLL.PLLQ = 7;
 
Done

STM32的时钟源
 STM32F103有两种主时钟方案，一个是依靠内部RC振荡器的HSI（内部高速时钟），另一个是HSE（外部高速时钟）。
 
内部高速时钟源（HSI）
 看数据手册，内部的HSI是由ST出厂时校准过的，但是精度并不高，在0到70℃下误差范围达到 -1.3%到2%，即便是在标准的25℃下，也有 -1.1%到1.8% 的误差（如下图）。
 对于高波特率的异步串口通讯，或者需要高精度定时的场合（如：需要跑积分算法的时候），用HSI就有隐患，甚至根本达不到设计要求。
 

 外部高速时钟源（HSE）
 为了更高的时钟精度，就要用HSE做主时钟源，起码做到30ppm还是很容易的。无源晶振相对便宜一些，要求不是非常高的话也足够了。
 对于外部无源晶振，需要做一些匹配工作。当然，直接baidu一个原理图，啥也不想，直接照着抄也可以运行。但是这样的设计，批量生产会不会出问题？某些特定环境下会不会崩溃？系统稳定性会不会很低？……都是未知数。这就是给自己的设计埋下隐患，说不定什么时候就崩了。
 所以还是来看看怎么匹配吧–
 就以 STM32F103 和 晶技HC-49SMD 8M 20pF 20ppm 的匹配为例
 
1. 负载电容匹配
 负载电容就是下图中的CL1、CL2，一般取CL1 = CL2，这两个电容和晶体Q构成三点式电容振荡器。
 
那么要把CL1、CL2跟谁匹配呢？其实就是跟晶振的参数：Load Capacitance匹配，简称CL，从晶振的数据手册可以查到，见下图：
 
我们选择的是20pF系列的晶振，所以CL = 20pF
 当然我们知道，在电路板走线上还有寄生电容，连接的芯片输入端也有等效电容，这部分也要考虑进去。从ST手册可以查到，STM32F103的晶振输入电容是5pF，而PCB走线的寄生电容一般可以估值3pF到5pF。我们这里就取Cs = 10pF。下面看公式：
 
由于我们取了CL1 = CL2，公式就可以变为：CL1 = CL2 = 2 * （CL - Cs）
 把Cs = 10pF，CL = 20pF带入上面的公式，能求出：CL1 = CL2 = 20pF
 因此CL1、CL2均取为20pF。
 
2. 晶振跨导计算
 为了确保晶振能顺利起振，并运行在稳定状态，就得有足够的增益来维持。一般要求就是，单片机的gm比晶振的gmcrit大5倍以上就可以。下面就求一下这个比值，看看是否大于5倍。
 首先看STM32F103手册，可以直接获知：gm = 25mA/V
 
有了gm = 25mA/V，就要用它跟晶振的最小稳定跨导gmcrit相比较。gmcrit是要我们计算一下的：
 
这里面的几个未知参数的意义是：
 ESR——晶振的等效串联电阻，手册里查到
 F——晶振的振荡频率
 C0——晶振的Shunt Capacitance
 CL——晶振的负载电容Load Capacitance
 
好，下面看晶振的手册，找这几个参数：
 
F = 8MHz，C0 = 7pF，CL = 20pF，ESR = 80Ω。参数Get√，计算：
 gmcrit = 4*80*(2Π*8*10^6)^2*(7*10^-12 + 20*10^-12)^2
 gmcrit = 0.1886
 现在gm、gmcrit都有了，可以比一下了
 
比值 = gm/gmcrit = 25/0.1886 = 132
 可见，这个比值是132，远大于5倍的最低要求，所以我们选择的晶振是合适的。如果算出来是不合适的，那就要选用更小ESR，更低CL的晶振。其实STM32对于高速晶振的要求不高，但是对于外部低速RTC晶振的要求高一些，选型时要多加留意。
 
3. 驱动电平DL（Drive Level）
 驱动电平其实就是指晶振工作消耗的功率，如果这个功率过大，超过晶振承受能力，则晶振寿命将减少，容易过早失效。晶振的推荐功率，可以在上图（晶振数据手册）中找到，我们选择的这个晶振的DL范围是1到500uW，推荐是100uW。如果实际工作功率过大，就串联一个Rext来限制功耗。实际功耗怎么获得？这个得自己用示波器测量，然后带入ESR计算出来。
 
4. 反馈电阻Rf （Feedback Resistance）
 把这个放最后，其实不是因为他没啥用，而是因为ST已经把他集成到芯片里面了，我们不用太多关心这个问题了。这个Rf的作用就是让放大器Vin = Vout，来强制工作在放大区间
 

 总结
 以上写的4项，对于STM32F103的高速外部晶振，其实主要考虑“1.负载电容计算”就可以了，这个是直接性影响最大的。
 
如有前辈偶然看到我的博客，还望指出我的疏漏和错误⊙ω⊙
 
参考：ST应用手册AN2867
 ————————————————
 版权声明：本文为CSDN博主「Seaman_TY」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
 原文链接：https://blog.csdn.net/Seaman_TY/article/details/93090532