目录
1.STM32F429时钟概述
时钟系统是 CPU 的脉搏，就像人的心跳一样。所以时钟系统的重要性就不言而喻了。 STM32有多个时钟来源的选择，采用一个系统时钟不是很简单吗？为什么 STM32 要有多个时钟源呢？ 因为首先 STM32 本身非常复杂，外设非常的多，但是并不是所有外设都需要系统时钟这么高的频率，比如看门狗以及 RTC 只需要几十 k 的时钟即可。同一个电路，时钟越快功耗越大，同时抗电磁干扰能力也会越弱，所以对于较为复杂的 MCU 一般都是采取多时钟源的方法来解决这些问题。
下面是stm32f4的时钟系统图：
STM32 有5个时钟源:HSI、HSE、LSI、LSE、PLL。
①、HSI是高速内部时钟，RC振荡器，频率为16MHz，精度不高。可以直接作为系统时钟或者用作PLL时钟输入。
②、HSE是高速外部时钟，可接石英/陶瓷谐振器，或者接外部时钟源，频率范围为4MHz~26MHz。(此处以25M为例)
③、LSI是低速内部时钟，RC振荡器，频率为32kHz，提供低功耗时钟。主要供独立看门狗和自动唤醒单元使用。
④、LSE是低速外部时钟，接频率为32.768kHz的石英晶体。RTC
⑤、PLL为锁相环倍频输出。
附录：
PLL 为锁相环倍频输出。 STM32F4 有三个 PLL:
1） 主 PLL(PLL)由 HSE 或者 HSI 提供时钟信号，并具有两个不同的输出时钟。第一个输出 PLLP 用于生成高速的系统时钟（最高 180MHz）第二个输出 PLLQ 为 48M 时钟， 用于 USB OTG FS 时钟，随机数发生器的时钟和 SDIO时钟。
2） 第一个专用 PLL(PLLI2S)用于生成精确时钟， 在 I2S 和 SAI1 上实现高品质音频性能。 其中， N 是用于 PLLI2S vco 的倍频系数，其取值范围是： 192~432； R 是 I2S 时钟的分频系数，其取值范围是： 2~7； Q 是 SAI 时钟分频系数，其取值范围是： 2~15； P 没用到。
3） 第二个专用 PLL(PLLSAI)同样用于生成精确时钟，用于 SAI1 输入时钟，同时还为 LCD_TFT接口提供精确时钟。 其中， N 是用于 PLLSAI vco 的倍频系数，其取值范围是： 192~432；Q 是 SAI 时钟分频系数，其取值范围是： 2~15； R 是 LTDC 时钟的分频系数，其取值范围是： 2~7； P 没用到。
例子：主 PLL 时钟第一个高速时钟输出 PLLP 的计算方法：配置180MHz为例：
分析：主 PLL 时钟的时钟源要先经过一个分频系数为 M 的分频器，然后经过倍频系数为 N 的倍频器出来之后还需要经过一个分频系数为 P（第一个输出 PLLP）或者 Q（第二个输出 PLLQ）的分频器分频之后，最后才生成最终的主 PLL 时钟。例如我们的外部晶振选择 25MHz。同时我们设置相应的分频器 M=25，倍频器倍频系数 N=360，分频器分频系数 P=2，那么主 PLL 生成的第一个输出高速时钟 PLLP 为：
PLL=25MHz * N/ (M*P)=25MHz* 360 /(25*2) = 180MHz
配置过程如下图所示：
2.系统时钟的初始化寄存器源码分析
在系统进入主函数之前，首先会执行SystemInit这个函数对系统进行初始化
看一看这个程序的内容：
源代码如下：
void SystemInit(void)
{
/* FPU 设置------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
/* 复位 RCC 时钟配置为默认配置-----------*/
RCC->CR |= (uint32_t)0x00000001;//打开 HSION 位
RCC->CFGR = 0x00000000;//复位 CFGR 寄存器
RCC->CR &= (uint32_t)0xFEF6FFFF;//复位 HSEON, CSSON and PLLON 位
RCC->PLLCFGR = 0x24003010; //复位寄存器 PLLCFGR
RCC->CR &= (uint32_t)0xFFFBFFFF;//复位 HSEBYP 位
RCC->CIR = 0x00000000;//关闭所有中断
#if defined (DATA_IN_ExtSRAM) || defined (DATA_IN_ExtSDRAM)
SystemInit_ExtMemCtl();
#endif /* DATA_IN_ExtSRAM || DATA_IN_ExtSDRAM */
/* 配置中断向量表地址=基地址+偏移地址 ------------------*/
#ifdef VECT_TAB_SRAM
SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET;
#else
SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET;
#endif
}可以看出这段代码的作用是：
1） FPU 设置
2） 复位 RCC 时钟配置为默认复位值（默认开始了 HIS）
3） 外部存储器配置
4） 中断向量表地址配置
做了这些工作，但是在F4的HAL库汇总SystemInit函数，并没有设置系统的主频和外设时钟的频率，所以所以需要自己去写这个函数。
首先先分析一下使用寄存器版本来写的SystemInit函数吧：
//系统时钟初始化函数
//plln:主PLL倍频系数(PLL倍频),取值范围:64~432.
//pllm:主PLL和音频PLL分频系数(PLL之前的分频),取值范围:2~63.
//pllp:系统时钟的主PLL分频系数(PLL之后的分频),取值范围:2,4,6,8.(仅限这4个值!)
//pllq:USB/SDIO/随机数产生器等的主PLL分频系数(PLL之后的分频),取值范围:2~15.
void Stm32_Clock_Init(u32 plln,u32 pllm,u32 pllp,u32 pllq)
{
RCC->CR|=0x00000001; //设置HISON,开启内部高速RC振荡
RCC->CFGR=0x00000000; //CFGR清零
RCC->CR&=0xFEF6FFFF; //HSEON,CSSON,PLLON清零
RCC->PLLCFGR=0x24003010; //PLLCFGR恢复复位值
RCC->CR&=~(1<<18); //HSEBYP清零,外部晶振不旁路
RCC->CIR=0x00000000; //禁止RCC时钟中断
Sys_Clock_Set(plln,pllm,pllp,pllq);//设置时钟
//配置向量表
#ifdef VECT_TAB_RAM
MY_NVIC_SetVectorTable(1<<29,0x0);
#else
MY_NVIC_SetVectorTable(0,0x0);
#endif
} 这个函数需要的参数是4个，分别与系统原理图对应的是，如下图所示：
接下来，查看时钟控制CR寄存器的描述：
1.开启HISON，开启内部高速RC震荡
2.时钟配置寄存器CFRG清零
3.配置时钟控制CR寄存器， 使位HSEON,CSSON,PLLON清零（第16、19、24位）
4.RCC PLL 配置寄存器 (RCC_PLLCFGR),恢复默认值：RCC->PLLCFGR=0x24003010; //PLLCFGR恢复复位值
5.设置CR寄存器，外部晶振不旁路
6.RCC 时钟中断寄存器 (RCC_CIR)，RCC->CR=0X00000000; //禁止RCC时钟中断
7.设置时钟，使用函数Sys_Clock_Set(plln,pllm,pllp,pllq);//设置时钟，函数原型如下：
u8 Sys_Clock_Set(u32 plln,u32 pllm,u32 pllp,u32 pllq)
{
u16 retry=0;
u8 status=0;
RCC->CR|=1<<16; //HSE 开启
while(((RCC->CR&(1<<17))==0)&&(retry<0X1FFF))retry++;//等待HSE RDY
if(retry==0X1FFF)status=1; //HSE无法就绪
else
{
RCC->APB1ENR|=1<<28; //电源接口时钟使能
PWR->CR|=3<<14; //高性能模式,时钟可到180Mhz
RCC->CFGR|=(0<<4)|(5<<10)|(4<<13);//HCLK 不分频;APB1 4分频;APB2 2分频.
RCC->CR&=~(1<<24); //关闭主PLL
RCC->PLLCFGR=pllm|(plln<<6)|(((pllp>>1)-1)<<16)|(pllq<<24)|(1<<22);//配置主PLL,PLL时钟源来自HSE
RCC->CR|=1<<24; //打开主PLL
while((RCC->CR&(1<<25))==0);//等待PLL准备好
FLASH->ACR|=1<<8; //指令预取使能.
FLASH->ACR|=1<<9; //指令cache使能.
FLASH->ACR|=1<<10; //数据cache使能.
FLASH->ACR|=5<<0; //5个CPU等待周期.
RCC->CFGR&=~(3<<0); //清零
RCC->CFGR|=2<<0; //选择主PLL作为系统时钟
while((RCC->CFGR&(3<<2))!=(2<<2));//等待主PLL作为系统时钟成功.
}
return status;
} 8.RCC->CR|=1<<16; //设置CR寄存器的第16位为1，HSE 开启
9.等待HSE时钟就绪，判断CR寄存器的第17位是否为1，返回1准备就绪，如果超时，返回标志位status=1.
10.如果准备就绪，使能电源接口时钟，RCC->APB1ENR|=1<<28; //设置APB1ENR寄存器28位为1电源接口时钟使能
11.开始电源的高性能模式，PWR->CR|=3<<14; //高性能模式,时钟可到180Mhz
11.配置RCC的CFGR寄存器，//HCLK 不分频;APB1 4分频;APB2 2分频
12.RCC->CR&=~(1<<24); //关闭主PLL，配置主PLL的一些参数，配置完再重新打开
13.//配置主PLL,PLL时钟源来自HSE，RCC->PLLCFGR=pllm|(plln<<6)|(((pllp>>1)-1)<<16)|(pllq<<24)|(1<<22);
- pllm,设置PLLM
- (plln<<6)，设置PLLN
- (((pllp>>1)-1)<<16),设置系统时钟的主PLL分频系数(PLL之后的分频),取值范围:2,4,6,8.(仅限这4个值!)
为何是：(((pllp>>1)-1)<<16)呢？如下解释，当我们取值pllp为2时，可以得到(((pllp>>1)-1)<<16)=0
当pllp取值为4时，(((pllp>>1)-1)<<16)=1，同理，pllp取值为6时，(((pllp>>1)-1)<<16)=3.其实就是在调用函数的时候方便设置。可以看都这个寄存器的位，当第17:16为0时，就是这只pllp为2分频。
- (pllq<<24)，pllq:USB/SDIO/随机数产生器等的主PLL分频系数(PLL之后的分频),取值范围:2~15.
- (1<<22)，选择主PLL的时钟源是HSE外部震荡时钟、
所以第13步骤，完成的工作就是如下如所示的设置：
14.设置完主PLL之后，重新打开主PLL: RCC->CR|=1<<24; //打开主PLL
15.每次打开PLL之前，都要等待就绪：while((RCC->CR&(1<<25))==0);//等待PLL准备好
16.设置FLASH寄存器参数：
FLASH->ACR|=1<<8; //指令预取使能.
FLASH->ACR|=1<<9; //指令cache使能.
FLASH->ACR|=1<<10; //数据cache使能.
FLASH->ACR|=5<<0; //5个CPU等待周期.
17.设置CFRG(RCC时钟配置寄存器)选择PLL作为系统时钟，RCC->CFGR&=~(3<<0); //清零 RCC->CFGR|=2<<0;
18.等待主PLL设置为系统主时钟成功：while((RCC->CFGR&(3<<2))!=(2<<2));
语句含义：当CFGR的3：2位不等于01时就说明主PLL还未就绪，就绪等待。
19.最后一步，配置向量表。
通过这样的设置系统时钟的整体配置就OK了。
如果调用函数：u8 Sys_Clock_Set(u32 plln,u32 pllm,u32 pllp,u32 pllq)，产生180Mhz的主频
设置参数：外部晶振为25M的时候:plln=360,pllm=25,pllp=2,pllq=8.
3.系统时钟的初始化HAL库函数源码分析
3.1.HAL库主要是把寄存器进行封装，然后把一些参数合并到一个结构体，通过调用结构体的方式对寄存器进行赋值，间接的完成对STM32寄存器的配置。
主要是下面两个结构体：
1.RCC_OscInitTypeDef结构体：
解释：从结构体的名称可以看的出来，这个结构体主要是选择时钟源，然后是时钟的状态（开启还是关闭）
可以看到RCC_OscInitTypeDef 里面还嵌套了一个RCC_PLLInitTypeDef结构体，主要是用于主PLL配置用的。比如设置M分频，vco倍频等。
- RCC_PLLInitTypeDef 结构体如下:
1.所以，第一步是定义一个RCC_OscInitTypeDef 结构体变量，并给这个结构体变量赋值，然后调用，HAL_RCC_OscConfig函数，把这个结构体变量传进去，使设置生效。
代码如下：
RCC_OscInitTypeDef RCC_OscInitStructure; //定义一个结构体变量
RCC_OscInitStructure.OscillatorType=RCC_OSCILLATORTYPE_HSE; //时钟源为HSE
RCC_OscInitStructure.HSEState=RCC_HSE_ON; //打开HSE
RCC_OscInitStructure.PLL.PLLState=RCC_PLL_ON;//打开PLL
RCC_OscInitStructure.PLL.PLLSource=RCC_PLLSOURCE_HSE;//PLL时钟源选择HSE
RCC_OscInitStructure.PLL.PLLM=pllm; //主PLL和音频PLL分频系数(PLL之前的分频),取值范围:2~63.
RCC_OscInitStructure.PLL.PLLN=plln; //主PLL倍频系数(PLL倍频),取值范围:64~432.
RCC_OscInitStructure.PLL.PLLP=pllp; //系统时钟的主PLL分频系数(PLL之后的分频),取值范围:2,4,6,8.(仅限这4个值!)
RCC_OscInitStructure.PLL.PLLQ=pllq; //USB/SDIO/随机数产生器等的主PLL分频系数(PLL之后的分频),取值范围:2~15.
ret=HAL_RCC_OscConfig(&RCC_OscInitStructure);//初始化最重要的还是看一下HAL库里面是如何对我们赋予这个结构体变量的值进行操作的：也就是HAL_RCC_OscConfig函数：
- OscillatorType 这个成员变量是选择时钟时钟源的，可以看一下他的取值范围：取值范围小于15
其实在HAL库有对每一个时钟源进行宏定义的，如下：
在程序中，我们设置这个成员变量的值是：RCC_OSCILLATORTYPE_HSE ，就是值为：0x00000001
- HSEState 是选择时钟的工作方式，此处选择：RCC_HSE_ON,值为：0x01
在HAL_RCC_OscConfig，函数中对HSE的配置如下,贴出一部分代码：
/* Check the parameters */
assert_param(IS_RCC_OSCILLATORTYPE(RCC_OscInitStruct->OscillatorType));
/*------------------------------- HSE Configuration ------------------------*/
if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_HSE) == RCC_OSCILLATORTYPE_HSE)
{
/* Check the parameters */
assert_param(IS_RCC_HSE(RCC_OscInitStruct->HSEState));
/* When the HSE is used as system clock or clock source for PLL in these cases HSE will not disabled */
//判断HSE是否作为系统时钟，或者作为PLL时钟的来源
// RCC_CFGR_SWS_HSE=0x00000004
//__HAL_RCC_GET_SYSCLK_SOURCE函数，获取CFGR位 3:2 SWS： 系统时钟切换状态 (System clock switch status)
//判断3:2位是否为01，含义：01： HSE 振荡器用作系统时钟，这两个位为只读
//也就是判断此时系统时钟或者主PLL时钟是否已经设置为HSE
//RCC_CFGR_SWS_PLL=0x00000008 ,判断CFGR的第3为是否为1
if((__HAL_RCC_GET_SYSCLK_SOURCE() == RCC_CFGR_SWS_HSE) ||\
((__HAL_RCC_GET_SYSCLK_SOURCE() == RCC_CFGR_SWS_PLL) && ((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLCFGR_PLLSRC_HSE)))
{ //PLL作为系统时钟， RCC_PLLCFGR_PLLSRC=0x00400000，第22位，是否选择：1：选择 HSE 振荡器时钟作为 PLL 和 PLLI2S 时钟输入
//如果HSE作为系统时钟来源，或者作为PLL时钟来源的话
if((__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET) && (RCC_OscInitStruct->HSEState == RCC_HSE_OFF))
{
//此时HSE已经打开了，或HSE没有使能，这里的任何一种情况都会导致失败
return HAL_ERROR;
}
}
else //否则的话，系统的时钟还没有进行初始化
{
/* Reset HSEON and HSEBYP bits before configuring the HSE --------------*/
//对RCC->CFGR 寄存器的23:16 清零，也就是复位HSEON(关闭振荡器) 和重置就绪位
__HAL_RCC_HSE_CONFIG(RCC_HSE_OFF);
//获取当前系统时间戳，用于判断关闭HSE是否超时
/* Get Start Tick*/
tickstart = HAL_GetTick();
/* Wait till HSE is disabled */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET) //等待HSE关闭
{
if((HAL_GetTick() - tickstart ) > HSE_TIMEOUT_VALUE)
{
return HAL_TIMEOUT; //超过最大时间为关闭HSE则，出错
}
}
/* Set the new HSE configuration ---------------------------------------*/
//重新设置HSE,这个值来自于结构体，我们使用就需要使能，通过设置就可以对RCC->CFGR 寄存器的23:16，写此值
__HAL_RCC_HSE_CONFIG(RCC_OscInitStruct->HSEState);
/* Check the HSE State */
//再一次进行确认，我们是否设置了打开HSE
if((RCC_OscInitStruct->HSEState) != RCC_HSE_OFF)
{
//进入说明，我们的确是打开了
/* Get Start Tick*/
//获取当前系统时间戳
tickstart = HAL_GetTick();
/* Wait till HSE is ready */
//获取HSE就绪标志位，未就绪就等待
while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) == RESET)
{
if((HAL_GetTick() - tickstart ) > HSE_TIMEOUT_VALUE)
{
return HAL_TIMEOUT;
}
}
}
else //否则没有打开HSE的开关咯
{
/* Get Start Tick*/
tickstart = HAL_GetTick();
/* Wait till HSE is bypassed or disabled */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET)
{
if((HAL_GetTick() - tickstart ) > HSE_TIMEOUT_VALUE) //HSE_TIMEOUT_VALUE=5000
{
return HAL_TIMEOUT;
}
}
}
}
}分析：
1.第一句是判断我们选择的时钟来源，此处选择的是RCC_OSCILLATORTYPE_HSE ，所以这个条件成立：
if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_HSE) == RCC_OSCILLATORTYPE_HSE)2.接着再进行判断
if((__HAL_RCC_GET_SYSCLK_SOURCE() == RCC_CFGR_SWS_HSE) ||\
((__HAL_RCC_GET_SYSCLK_SOURCE() == RCC_CFGR_SWS_PLL) && ((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLCFGR_PLLSRC_HSE)))
{ //PLL作为系统时钟， RCC_PLLCFGR_PLLSRC=0x00400000，第22位，是否选择：1：选择 HSE 振荡器时钟作为 PLL 和 PLLI2S 时钟输入
//如果HSE作为系统时钟来源，或者作为PLL时钟来源的话
if((__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET) && (RCC_OscInitStruct->HSEState == RCC_HSE_OFF))
{
//此时HSE已经打开了，或HSE没有使能，这里的任何一种情况都会导致失败
return HAL_ERROR;
}
}此处有三个条件的判断，成立才会执行if里面的语句，否则执行后面else的语句咯。
重点看一下函数：__HAL_RCC_GET_SYSCLK_SOURCE()，是什么意思。
再看看，RCC_CFGR_SWS_HSE 是什么意思，就是一个数组
那if语句的第一个判断条件的意思就是，判断当前的系统时钟来源是否是HSE(外部高速时钟)，如果是的话，因为后面接的是一个或的符号，那么这个条件就算成立了。
再者后面还有一条语句如下,看看什么意思：
((__HAL_RCC_GET_SYSCLK_SOURCE() == RCC_CFGR_SWS_PLL) && ((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLCFGR_PLLSRC_HSE))&&前面的一个语句，就是判断当前系统时钟来源是否为PLL,后面语句是获取RCC的PLL配置寄存器的内容
从下面的宏定义可以看的出来，其实就是获取获取RCC的PLL配置寄存器的22位进行判断此位是0还是1
那第22位的含义是什么？还是得查数据手册，查手册得知，此位就是用于判断PLL的时钟来源，是HSE还是HSI
那么总结上面的整条语句的意思：
就是说，如果系统检测到你当前的系统时钟来源是HSE，或者说检测到系统失踪来源是PLL，而且PLL的时钟来源是HSE的话，那我就执行if里面的语句，其实里面就是返回一个错误提示，很好理解，因为上面的条件成立，说明你已经配置过时钟了，就不需要重新配置了。
其实在时钟系统图上也可以这样表示：
已上任何一种情况都代表系统时钟已经初始化了。所以就没必要再执行下面的语句了。
3.如果上面的条件不成立，那么就说明系统时钟还没有进行配置，接下来就是进行系统时钟的配置了
//对RCC->CFGR 寄存器的23:16 清零，也就是复位HSEON(关闭振荡器) 和重置就绪位
__HAL_RCC_HSE_CONFIG(RCC_HSE_OFF);通过查看__HAL_RCC_HSE_CONFIG(),即可知，这个函数的含义就是网一个寄存器里面写一个值
那么这个地址是什么意思呢？其实上面也是有英文备注的，备注是CR寄存器的第三个字节的基地址
那我们具体到数据手册看看吧，找到寄存器地址映射
返回的其实是四字节的一个地址，现在强制把它转换为一个8位的地址，那其实就是RCC的CR寄存器的第三个字节咯，直接往这个地址写入我们想要的值。
可以看看CR寄存器的第三个字节表达的什么意思？
再次回到源程序中，在此函数中写入的是：RCC_HSE_OFF,字面意思就是关闭HSE呗，这些的含义其实是一个8为的二进制数值
此处就是把CR寄存器的第三个字节的数据全部清零，目的就是为了关闭HSE。
4.获取当前系统的戳，判断关闭HSE是否超时
//获取当前系统时间戳，用于判断关闭HSE是否超时
/* Get Start Tick*/
tickstart = HAL_GetTick();5.检测HSE就绪状态标志位
/* Wait till HSE is disabled */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET) //等待HSE关闭
{
if((HAL_GetTick() - tickstart ) > HSE_TIMEOUT_VALUE)
{
return HAL_TIMEOUT; //超过最大时间为关闭HSE则，出错
}
}其中最重要的是这个函数：__HAL_RCC_GET_FLAG（__FLAG__）
看看函数的定义如下，这个函数看起来有点长，对于初次接触这种函数的人来说，其实研究透了真的会觉得很奇妙，原来函数还可以这样写，接下来就分析一下吧，顺便学习一下他们的编程方式：
#define __HAL_RCC_GET_FLAG(__FLAG__)
(((((((__FLAG__) >> 5) == 1)? RCC->CR :((((__FLAG__) >> 5) == 2) ? RCC->BDCR :((((__FLAG__) >> 5) == 3)? RCC->CSR :RCC->CIR))) & ((uint32_t)1 << ((__FLAG__) & RCC_FLAG_MASK)))!= 0)? 1 : 0)首先先解释一下这个函数的功能，可以从这个函数中看到有
1.RCC->CR 2.RCC->BDCR 3.RCC->BDCR 4.RCC->CSR
还有__HAL_RCC_GET_FLAG（__FLAG__）函数需要一个参数，根据参数的值不同，通过计算就可以得到上面这四个寄存器中我们想要位的值，而在stm32f4xx_hal_rcc.h 这个文件中有定义，如下：
比如这个程序中获取的是 RCC_FLAG_HSERDY 的值，从字面意思就是获取CR寄存器中 HSERDY位的值（RCC中CR寄存器的第17位）这个数值是：0x31,转换成二进制为：00110001。
此处有点不好解释，因为这句好长好长，勉强解释一下：
#define __HAL_RCC_GET_FLAG(__FLAG__)
(((((((__FLAG__) >> 5) == 1)? RCC->CR :((((__FLAG__) >> 5) == 2) ? RCC->BDCR :((((__FLAG__) >> 5) == 3)? RCC->CSR :RCC->CIR))) & ((uint32_t)1 << ((__FLAG__) & RCC_FLAG_MASK)))!= 0)? 1 : 0)上面这个是源语句，提取处倒数第一个问号之前的语句，当这个语句的判定结果为真时，返回的结果是1，否则返回0，如下：
((((((__FLAG__) >> 5) == 1)? RCC->CR :((((__FLAG__) >> 5) == 2) ? RCC->BDCR :((((__FLAG__) >> 5) == 3)? RCC->CSR :RCC->CIR))) & ((uint32_t)1 << ((__FLAG__) & RCC_FLAG_MASK)))!= 0)
再从上面中提取处 ！= 符号之前的语句，当此处的返回结果为不等于0（等于1），返回真，否则返回假，那么完整的语句就可以简化为下面的语句，如果下面的语句的结果大于0，最终结果返回1，否则返回0。
(((((__FLAG__) >> 5) == 1)? RCC->CR :((((__FLAG__) >> 5) == 2) ? RCC->BDCR :((((__FLAG__) >> 5) == 3)? RCC->CSR :RCC->CIR))) & ((uint32_t)1 << ((__FLAG__) & RCC_FLAG_MASK)))
上面这条语句还可以分成两个部分，使用颜色区分一下
((((__FLAG__) >> 5) == 1)? RCC->CR :((((__FLAG__) >> 5) == 2) ? RCC->BDCR :((((__FLAG__) >> 5) == 3)? RCC->CSR :RCC->CIR)))
其中粉红色的部分是根据__FLAG__的值返回相应的寄存器的（如，CR、BDCR、CSR、CIR）
上面假设获取获取CR寄存器中 HSERDY位的值，那么__FLAG__ 的值为:0x31.
①.如果(__FLAG__) >> 5 ==1 的话那就是返回 RCC->CR 寄存器的值②.否则返回 ((((__FLAG__) >> 5) == 2) ? RCC->BDCR :((((__FLAG__) >> 5) == 3)? RCC->CSR :RCC->CIR))
含义是什么？
③.如果 (__FLAG__) >> 5 不为1，则执行上面这句，执行(__FLAG__) >> 5 判断是否为2，如果为2
返回RCC->BDCR 寄存器。④.如果 (__FLAG__) >> 5 不等于2 ,就执行(((__FLAG__) >> 5) == 3)是否成立，如果成立返回
RCC->CSR 否则返回RCC->CIR
结论：其实就是判断我们输入的 (__FLAG__) 数值右移5位的结果，如果右移动5为1，返回RCC->CR寄存器值右移5位为2，返回RCC->BDCR寄存器值，右移5位为3，返回RCC->CSR寄存器值，右移5位不等于前面情况的数值，则返回RCC->CIR 寄存器的值。上面返回的结果还要 与（&）上 ((uint32_t)1 << ((__FLAG__) & RCC_FLAG_MASK))
注意：
此处：#define RCC_FLAG_MASK ((uint8_t)0x1F)
则：((uint32_t)1 << ((__FLAG__) & 0x1F))
把__FLAG__ 的值使用0x31代替，则有：((uint32_t)1 << ((0x31) & 0x1F))==>((uint32_t)1 << 0x11)==>
((uint32_t)1 << 17)==> 0x0200
即如果__FLAG__ 的值使用0x31，最终得到的结果就是 :CR & 0x0200 获取CR寄存器第17位的数值是否为1，如果为1，最终结果返回1，否则返回0.
可以看数据手册，CR寄存器的第十七位，正是HSERDY(HSE振荡器准备就绪位)
所以当我调用了语句：__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) ，返回1代表CR寄存器HSERDY位为1，否则为0.
这个函数的其他参数也是一样的效果，只是获取的是不同的位而已。
接着上面的分析吧、
/* Wait till HSE is disabled */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET) //等待HSE关闭
{
if((HAL_GetTick() - tickstart ) > HSE_TIMEOUT_VALUE)
{
return HAL_TIMEOUT; //超过最大时间为关闭HSE则，出错
}
}所以上面的整体语句就是，HSERDY 不等于0，则等待，如果超时则退出。
6.选择 HSE 振荡器作为系统时钟
/* Set the new HSE configuration ---------------------------------------*/
//重新设置HSE,这个值来自于结构体，我们使用就需要使能，通过设置就可以对RCC->CFGR 寄存器的23:16，写此值
__HAL_RCC_HSE_CONFIG(RCC_OscInitStruct->HSEState); 7.打开HSE振荡器，然后等待就绪
/* Check the HSE State */
//再一次进行确认，我们是否设置了打开HSE
if((RCC_OscInitStruct->HSEState) != RCC_HSE_OFF)
{
//进入说明，我们的确是打开了
/* Get Start Tick*/
//获取当前系统时间戳
tickstart = HAL_GetTick();
/* Wait till HSE is ready */
//获取HSE就绪标志位，未就绪就等待
while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) == RESET)
{
if((HAL_GetTick() - tickstart ) > HSE_TIMEOUT_VALUE)
{
return HAL_TIMEOUT;
}
}
}8.未打开HSE，等待打开
else //否则没有打开HSE的开关咯
{
/* Get Start Tick*/
tickstart = HAL_GetTick();
/* Wait till HSE is bypassed or disabled */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET)
{
if((HAL_GetTick() - tickstart ) > HSE_TIMEOUT_VALUE) //HSE_TIMEOUT_VALUE=5000
{
return HAL_TIMEOUT;
}
}
}经过上面的设置我们就打开了一个HSE振荡器，还有就是等待HSE就绪，还挺麻烦，但是相对来说严谨一点，毕竟人家是官方的嘛。
那么接下来的步骤也就是配置主 PLL 咯。配置的源码又是下面的一串代码，这得很有耐心啊。
/*-------------------------------- PLL Configuration -----------------------*/
/* Check the parameters */
assert_param(IS_RCC_PLL(RCC_OscInitStruct->PLL.PLLState));
if ((RCC_OscInitStruct->PLL.PLLState) != RCC_PLL_NONE)
{
/* Check if the PLL is used as system clock or not */
if(__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL)
{
if((RCC_OscInitStruct->PLL.PLLState) == RCC_PLL_ON)
{
/* Check the parameters */
assert_param(IS_RCC_PLLSOURCE(RCC_OscInitStruct->PLL.PLLSource));
assert_param(IS_RCC_PLLM_VALUE(RCC_OscInitStruct->PLL.PLLM));
assert_param(IS_RCC_PLLN_VALUE(RCC_OscInitStruct->PLL.PLLN));
assert_param(IS_RCC_PLLP_VALUE(RCC_OscInitStruct->PLL.PLLP));
assert_param(IS_RCC_PLLQ_VALUE(RCC_OscInitStruct->PLL.PLLQ));
/* Disable the main PLL. */
__HAL_RCC_PLL_DISABLE();
/* Get Start Tick*/
tickstart = HAL_GetTick();
/* Wait till PLL is ready */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY) != RESET)
{
if((HAL_GetTick() - tickstart ) > PLL_TIMEOUT_VALUE)
{
return HAL_TIMEOUT;
}
}
/* Configure the main PLL clock source, multiplication and division factors. */
WRITE_REG(RCC->PLLCFGR, (RCC_OscInitStruct->PLL.PLLSource | \
RCC_OscInitStruct->PLL.PLLM | \
(RCC_OscInitStruct->PLL.PLLN << POSITION_VAL(RCC_PLLCFGR_PLLN)) | \
(((RCC_OscInitStruct->PLL.PLLP >> 1) -1) << POSITION_VAL(RCC_PLLCFGR_PLLP)) | \
(RCC_OscInitStruct->PLL.PLLQ << POSITION_VAL(RCC_PLLCFGR_PLLQ))));
/* Enable the main PLL. */
__HAL_RCC_PLL_ENABLE();
/* Get Start Tick*/
tickstart = HAL_GetTick();
/* Wait till PLL is ready */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY) == RESET)
{
if((HAL_GetTick() - tickstart ) > PLL_TIMEOUT_VALUE)
{
return HAL_TIMEOUT;
}
}
}
else
{
/* Disable the main PLL. */
__HAL_RCC_PLL_DISABLE();
/* Get Start Tick*/
tickstart = HAL_GetTick();
/* Wait till PLL is ready */
while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY) != RESET)
{
if((HAL_GetTick() - tickstart ) > PLL_TIMEOUT_VALUE)
{
return HAL_TIMEOUT;
}
}
}
}
else
{
return HAL_ERROR;
}
}再看看调用这个函数设置的数值吧。
RCC_OscInitStructure.PLL.PLLState=RCC_PLL_ON;//打开PLL
#define RCC_PLL_NONE ((uint8_t)0x00)
#define RCC_PLL_OFF ((uint8_t)0x01)
#define RCC_PLL_ON ((uint8_t)0x02)
RCC_OscInitStructure.PLL.PLLSource=RCC_PLLSOURCE_HSE;//PLL时钟源选择HSE#define RCC_PLLSOURCE_HSI RCC_PLLCFGR_PLLSRC_HSI
#define RCC_PLLSOURCE_HSE RCC_PLLCFGR_PLLSRC_HSE#define RCC_PLLCFGR_PLLSRC ((uint32_t)0x00400000)
#define RCC_PLLCFGR_PLLSRC_HSE ((uint32_t)0x00400000)
#define RCC_PLLCFGR_PLLSRC_HSI ((uint32_t)0x00000000)
RCC_OscInitStructure.PLL.PLLM=pllm; //主PLL和音频PLL分频系数(PLL之前的分频),取值范围:2~63.
RCC_OscInitStructure.PLL.PLLN=plln; //主PLL倍频系数(PLL倍频),取值范围:64~432.
RCC_OscInitStructure.PLL.PLLP=pllp; //系统时钟的主PLL分频系数(PLL之后的分频),取值范围:2,4,6,8.(仅限这4个值!)
RCC_OscInitStructure.PLL.PLLQ=pllq; //USB/SDIO/随机数产生器等的主PLL分频系数(PLL之后的分频),取值范围:2~15.
1.首先判断我们是否设置PLL的开关是否打开
2.判断PLL是否设置为系统时钟
if(__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL)__HAL_RCC_GET_SYSCLK_SOURCE()，这条语句的作用？
原句如下：
#define __HAL_RCC_GET_SYSCLK_SOURCE() ((uint32_t)(RCC->CFGR & RCC_CFGR_SWS))/*!< SWS configuration */
#define RCC_CFGR_SWS ((uint32_t)0x0000000C) /*!< SWS[1:0] bits (System Clock Switch Status) */
#define RCC_CFGR_SWS_0 ((uint32_t)0x00000004) /*!< Bit 0 */
#define RCC_CFGR_SWS_1 ((uint32_t)0x00000008) /*!< Bit 1 */
所以__HAL_RCC_GET_SYSCLK_SOURCE(）的作用就是获取CFGR寄存器的SWS位的数值：
以正点原子系统初始化函数为例子进行分析：
//时钟设置函数
// VCO 频率 Fvco=Fs*(plln/pllm);
//系统时钟频率 Fsys=Fvco/pllp=Fs*(plln/(pllm*pllp));
// USB,SDIO,RNG 等的时钟频率 Fusb=Fvco/pllq=Fs*(plln/(pllm*pllq));
//Fs:PLL 输入时钟频率,可以是 HSI,HSE 等.
//plln:主 PLL 倍频系数(PLL 倍频),取值范围:64~432.
//pllm:主 PLL 和音频 PLL 分频系数(PLL 之前的分频),取值范围:2~63.
//pllp:系统时钟的主 PLL 分频系数(PLL 之后的分频),取值范围:2,4,6,8.(仅限这 4 个值!)
//pllq:USB/SDIO/随机数产生器等的主 PLL 分频系数(PLL 之后的分频),取值范围:2~15.
//外部晶振为 25M 的时候,推荐值:plln=360,pllm=25,pllp=2,pllq=8.
//得到:Fvco=25*(360/25)=360Mhz
// Fsys=360/2=180Mhz
// Fusb=360/8=45Mhz
//返回值:0,成功;1,失败
void Stm32_Clock_Init(u32 plln,u32 pllm,u32 pllp,u32 pllq)
{
HAL_StatusTypeDef ret = HAL_OK;
RCC_OscInitTypeDef RCC_OscInitStructure;
RCC_ClkInitTypeDef RCC_ClkInitStructure;
__HAL_RCC_PWR_CLK_ENABLE(); //使能 PWR 时钟
//下面这个设置用来设置调压器输出电压级别，以便在器件未以最大频率工作
//时使性能与功耗实现平衡，此功能只有 STM32F42xx 和 STM32F43xx 器件有，
__HAL_PWR_VOLTAGESCALING_CONFIG(
PWR_REGULATOR_VOLTAGE_SCALE1);
RCC_OscInitStructure.OscillatorType=RCC_OSCILLATORTYPE_HSE; //时钟源为 HSE
RCC_OscInitStructure.HSEState=RCC_HSE_ON; //打开 HSE
RCC_OscInitStructure.PLL.PLLState=RCC_PLL_ON; //打开 PLL
RCC_OscInitStructure.PLL.PLLSource=RCC_PLLSOURCE_HSE;//PLL 时钟源为 HSE
RCC_OscInitStructure.PLL.PLLM=pllm;
RCC_OscInitStructure.PLL.PLLN=plln;
RCC_OscInitStructure.PLL.PLLP=pllp;
RCC_OscInitStructure.PLL.PLLQ=pllq;
ret=HAL_RCC_OscConfig(&RCC_OscInitStructure);
if(ret!=HAL_OK) while(1);
ret=HAL_PWREx_EnableOverDrive(); //开启 Over-Driver 功能
if(ret!=HAL_OK) while(1);
//选中 PLL 作为系统时钟源并且配置 HCLK,PCLK1 和 PCLK2
RCC_ClkInitStructure.ClockType=(RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_PCLK1
|RCC_CLOCKTYPE_PCLK2);
RCC_ClkInitStructure.SYSCLKSource=RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStructure.AHBCLKDivider=RCC_SYSCLK_DIV1;
RCC_ClkInitStructure.APB1CLKDivider=RCC_HCLK_DIV4;
RCC_ClkInitStructure.APB2CLKDivider=RCC_HCLK_DIV2;
ret=HAL_RCC_ClockConfig(&RCC_ClkInitStructure,FLASH_LATENCY_5);
if(ret!=HAL_OK) while(1);
}
