HC32L17x的LL驱动库之RCC

#ifndef HC32L1XX_LL_RCC_H_
#define HC32L1XX_LL_RCC_H_

#ifdef __cplusplus
extern "C" {
#endif 
	
	#include "hc32l1xx.h"
	#include "hc32l1xx_ll_bus.h"
	#include "hc32l1xx_ll_bgr.h"
	#include "hc32l1xx_ll_gpio.h"
	///

	//===PLL输入时钟选择
	#define LL_RCC_PLL_CLK_SOURCE_XTH		RCC_PLL_REF_XTH
	#define LL_RCC_PLL_CLK_SOURCE_BYPASS	RCC_PLL_REF_BYPASS
	#define LL_RCC_PLL_CLK_SOURCE_RCH		RCC_PLL_REF_RCH

	//===RTC高速补偿时钟选择
	#define	LL_RCC_RTC_ADJ_4M			RCC_CR1_RTC_FREQ_ADJ_4M	
	#define	LL_RCC_RTC_ADJ_6M			RCC_CR1_RTC_FREQ_ADJ_6M	
	#define	LL_RCC_RTC_ADJ_8M			RCC_CR1_RTC_FREQ_ADJ_8M	
	#define	LL_RCC_RTC_ADJ_12M			RCC_CR1_RTC_FREQ_ADJ_12M
	#define	LL_RCC_RTC_ADJ_16M			RCC_CR1_RTC_FREQ_ADJ_16M
	#define	LL_RCC_RTC_ADJ_20M			RCC_CR1_RTC_FREQ_ADJ_20M
	#define	LL_RCC_RTC_ADJ_24M			RCC_CR1_RTC_FREQ_ADJ_24M
	#define	LL_RCC_RTC_ADJ_32M			RCC_CR1_RTC_FREQ_ADJ_32M

	//===系统时钟源
	#define LL_RCC_CLK_SOURCE_RCH		RCC_CR0_CLKSW_RCH	
	#define LL_RCC_CLK_SOURCE_XTH		RCC_CR0_CLKSW_XTH	
	#define LL_RCC_CLK_SOURCE_RCL		RCC_CR0_CLKSW_RCL	
	#define LL_RCC_CLK_SOURCE_XTL		RCC_CR0_CLKSW_XTL	
	#define LL_RCC_CLK_SOURCE_PLL		RCC_CR0_CLKSW_PLL	

	//===HCLK时钟分频
	#define	LL_RCC_HCLK_DIV1			RCC_CR0_HCLK_PRS_1	
	#define	LL_RCC_HCLK_DIV2			RCC_CR0_HCLK_PRS_2	
	#define	LL_RCC_HCLK_DIV4			RCC_CR0_HCLK_PRS_4	
	#define	LL_RCC_HCLK_DIV8			RCC_CR0_HCLK_PRS_8	
	#define	LL_RCC_HCLK_DIV16			RCC_CR0_HCLK_PRS_16	
	#define	LL_RCC_HCLK_DIV32			RCC_CR0_HCLK_PRS_32	
	#define	LL_RCC_HCLK_DIV64			RCC_CR0_HCLK_PRS_64	
	#define	LL_RCC_HCLK_DIV128			RCC_CR0_HCLK_PRS_128

	//===PCLK时钟分频
	#define	LL_RCC_PCLK_DIV1			RCC_CR0_PCLK_PRS_1	
	#define	LL_RCC_PCLK_DIV2			RCC_CR0_PCLK_PRS_2	
	#define	LL_RCC_PCLK_DIV4			RCC_CR0_PCLK_PRS_4	
	#define	LL_RCC_PCLK_DIV8			RCC_CR0_PCLK_PRS_8	
	
    ///
    //函		数：
    //功		能：解锁RCC
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_UnLock(void)
    {
        RCC->CR2 = 0x5A5A;
        RCC->CR2 = 0xA5A5;
    }

    ///
    //函		数：
    //功		能：使能外部输入时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSE_Enable_Bypass(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR0, RCC_CR0_XTHEN);
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR1, RCC_CR1_EXTH_EN);
    }

    ///
    //函		数：
    //功		能：不使能外部输入时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSE_Disable_Bypass(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR1, RCC_CR1_EXTH_EN);
    }

    ///
    //函		数：
    //功		能：使能晶振
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSE_Enable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        //---使能时钟源
        SET_BIT(RCC->CR0, RCC_CR0_XTHEN);
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR1, RCC_CR1_EXTH_EN);
    }

    ///
    //函		数：
    //功		能：不使能晶振
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSE_Disable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR0, RCC_CR0_XTHEN);
    }

    ///
    //函		数：
    //功		能：检查晶振是否准备好
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_HSE_IsReady(void)
    {
        return (uint32_t)(READ_BIT(RCC->XTH, RCC_XTH_STABLE));
    }

    ///
    //函		数：
    //功		能：设置晶振驱动能力
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSE_SetDriver(uint32_t Driver)
    {
        MODIFY_REG(RCC->XTH, RCC_XTH_DRIVER, Driver);
    }

    ///
    //函		数：
    //功		能：获取晶振驱动能力
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_HSE_GetDriver(void)
    {
        return READ_BIT(RCC->XTH, RCC_XTH_DRIVER);
    }

    ///
    //函		数：
    //功		能：设置晶振稳定时间
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSE_SetStartup(uint32_t Startup)
    {
        MODIFY_REG(RCC->XTH, RCC_XTH_STARTUP, Startup);
    }

    ///
    //函		数：
    //功		能：获取晶振稳定时间
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_HSE_GetStartup(void)
    {
        return READ_BIT(RCC->XTH, RCC_XTH_STARTUP);
    }

    ///
    //函		数：
    //功		能：设置晶振工作频率
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSE_SetFreq(uint32_t Freq)
    {
        MODIFY_REG(RCC->XTH, RCC_XTH_FREQ, Freq);
    }

    ///
    //函		数：
    //功		能：获取晶振工作频率
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_HSE_GetFreq(void)
    {
        return READ_BIT(RCC->XTH, RCC_XTH_FREQ);
    }

    ///
    //函		数：
    //功		能：使能内部时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSI_Enable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR0, RCC_CR0_RCHEN);
    }

    ///
    //函		数：
    //功		能：不使能内部时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSI_Disable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR0, RCC_CR0_RCHEN);
    }

    ///
    //函		数：
    //功		能：检查内部时钟是否准备好
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_HSI_IsReady(void)
    {
		return (uint32_t)(READ_BIT(RCC->RCH, RCC_RCH_STABLE));
    }

    ///
    //函		数：
    //功		能：设置内部时钟的校准值
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_HSI_SetCalibTrimming(uint32_t Trim)
    {
        MODIFY_REG(RCC->RCH, RCC_RCH_TRIM, Trim);
    }

    //
    //函		数：
    //功		能：获取内部时钟的校准值
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_HSI_GetCalibTrimming(void)
    {
        return (uint32_t)(READ_BIT(RCC->RCH, RCC_RCH_TRIM));
    }

    ///
    //函		数：
    //功		能：使能外部输入低频时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSE_Enable_Bypass(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR0, RCC_CR0_XTLEN);
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR1, RCC_CR1_EXTL_EN);
    }

    ///
    //函		数：
    //功		能：不使能外部输入低频时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSE_Disable_Bypass(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR1, RCC_CR1_EXTL_EN);
    }

    ///
    //函		数：
    //功		能：使能晶振
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSE_Enable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR0, RCC_CR0_XTLEN);
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR1, RCC_CR1_EXTL_EN);
    }

    ///
    //函		数：
    //功		能：不使能晶振
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSE_Disable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR0, RCC_CR0_XTLEN);
    }

    ///
    //函		数：
    //功		能：检查晶振是否准备好
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_LSE_IsReady(void)
    {
        return (uint32_t)(READ_BIT(RCC->XTL, RCC_XTL_STABLE));
    }

    ///
    //函		数：
    //功		能：设置晶振驱动能力
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSE_SetDriver(uint32_t Driver)
    {
        MODIFY_REG(RCC->XTL, RCC_XTL_DRIVER, Driver);
    }

    ///
    //函		数：
    //功		能：获取晶振驱动能力
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_LSE_GetDriver(void)
    {
        return READ_BIT(RCC->XTL, RCC_XTL_DRIVER);
    }

    ///
    //函		数：
    //功		能：设置晶振稳定时间
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSE_SetStartup(uint32_t Startup)
    {
        MODIFY_REG(RCC->XTL, RCC_XTL_STARTUP, Startup);
    }

    ///
   //函		数：
   //功		能：获取晶振稳定时间
   //输入参	数：
   //输出参	数：
   //说		明：
   //
    static inline uint32_t LL_RCC_LSE_GetStartup(void)
    {
        return READ_BIT(RCC->XTL, RCC_XTL_STARTUP);
    }

    ///
    //函		数：
    //功		能：设置低频晶振幅度
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSE_SetAmp(uint32_t Amp)
    {
        MODIFY_REG(RCC->XTL, RCC_XTL_AMP, Amp);
    }

    ///
   //函		数：
   //功		能：获取低频晶振幅度
   //输入参	数：
   //输出参	数：
   //说		明：
   //
    static inline uint32_t LL_RCC_LSE_GetAmp(void)
    {
        return READ_BIT(RCC->XTL, RCC_XTL_AMP);
    }

    ///
    //函		数：
    //功		能：使能内部时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSI_Enable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR0, RCC_CR0_RCLEN);
    }

    ///
    //函		数：
    //功		能：不使能内部时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSI_Disable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR0, RCC_CR0_RCLEN);
    }

    ///
    //函		数：
    //功		能：检查内部时钟是否准备好
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_LSI_IsReady(void)
    {
        return (uint32_t)(READ_BIT(RCC->RCL, RCC_RCL_STABLE));
    }

    ///
    //函		数：
    //功		能：设置内部时钟的校准值
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSI_SetCalibTrimming(uint32_t Trim)
    {
        MODIFY_REG(RCC->RCL, RCC_RCL_TRIM, Trim);
    }

    //
    //函		数：
    //功		能：获取内部时钟的校准值
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_LSI_GetCalibTrimming(void)
    {
        return READ_BIT(RCC->RCL, RCC_RCL_TRIM);
    }
    
    ///
    //函		数：
    //功		能：设置时钟稳定时间
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_LSI_SetStartup(uint32_t Startup)
    {
        MODIFY_REG(RCC->RCL, RCC_RCL_STARTUP, Startup);
    }

    ///
    //函		数：
    //功		能：获取时钟稳定时间
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_LSI_GetStartup(void)
    {
        return READ_BIT(RCC->RCL, RCC_RCL_STARTUP);
    }

    ///
    //函		数：
    //功		能：设置系统时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_SetSysClkSource(uint32_t Source)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        MODIFY_REG(RCC->CR0, RCC_CR0_CLKSW, Source);
    }
	
    ///
    //函		数：
    //功		能：获取系统时钟
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_GetSysClkSource(void)
    {
        return (uint32_t)(READ_BIT(RCC->CR0, RCC_CR0_CLKSW));
    }

    ///
    //函		数：
    //功		能：设置高速时钟的分屏数
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_SetAHBPrescaler(uint32_t Prescaler)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        MODIFY_REG(RCC->CR0, RCC_CR0_HCLK_PRS, Prescaler);
    }

    ///
    //函		数：
    //功		能：获取高速时钟的分屏数
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_GetAHBPrescaler(void)
    {
        return (uint32_t)(READ_BIT(RCC->CR0, RCC_CR0_HCLK_PRS));
    }
       
    ///
    //函		数：
    //功		能：设置PER0总线时钟分屏
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_SetPER0Prescaler(uint32_t Prescaler)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        MODIFY_REG(RCC->CR0, RCC_CR0_PCLK_PRS, Prescaler);
    }
    
    ///
    //函		数：
    //功		能：设置PER0总线时钟分屏
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_SetPER1Prescaler(uint32_t Prescaler)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        MODIFY_REG(RCC->CR0, RCC_CR0_PCLK_PRS, Prescaler);
    }

    ///
    //函		数：
    //功		能：获取PER0总线时钟分频数
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_GetPER0Prescaler(void)
    {
        return READ_BIT(RCC->CR0, RCC_CR0_PCLK_PRS);
    }

    ///
    //函		数：
    //功		能：获取PER1总线时钟分频数
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_GetPER1Prescaler(void)
    {
        return READ_BIT(RCC->CR0, RCC_CR0_PCLK_PRS);
    }

    ///
    //函		数：
    //功		能：PLL使能
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_PLL_Enable(void)
    {
		//---检查BGR是否开启
		if (LL_BGR_IsEnable(BGR) == 0)
		{
			if (LL_PER0_GRP1_IsEnabled_Clock(LL_PER0_GRP1_PERIPH_BGR) == 0)
			{
				LL_PER0_GRP1_Enable_Clock(LL_PER0_GRP1_PERIPH_BGR);
			}
			LL_BGR_Enable(BGR);
		}
		//---解锁RCC
		LL_RCC_UnLock();
        SET_BIT(RCC->CR0, RCC_CR0_PLLEN);
    }

    ///
    //函		数：
    //功		能：PLL使能
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_PLL_Disable(void)
    {
		//---解锁RCC
		LL_RCC_UnLock();
        CLEAR_BIT(RCC->CR0, RCC_CR0_PLLEN);
    }

    ///
    //函		数：
    //功		能：PLL使能
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_PLL_IsReady(void)
    {
        return (uint32_t)(READ_BIT(RCC->PLL, RCC_PLL_STABLE));
    }

    ///
    //函		数：
    //功		能：设置时钟稳定时间
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline void LL_RCC_PLL_SetStartup(uint32_t Startup)
    {
        MODIFY_REG(RCC->PLL, RCC_PLL_STARTUP, Startup);
    }

    ///
    //函		数：
    //功		能：获取时钟稳定时间
    //输入参	数：
    //输出参	数：
    //说		明：
    //
    static inline uint32_t LL_RCC_PLL_GetStartup(void)
    {
        return READ_BIT(RCC->PLL, RCC_PLL_STARTUP);
    }

	///
   //函		数：
   //功		能：设置PLL倍频
   //输入参	数：
   //输出参	数：
   //说		明：
   //
	static inline void LL_RCC_PLL_SetDivN(uint32_t divn)
	{
		MODIFY_REG(RCC->PLL, RCC_PLL_DIVN, divn);
	}

	///
	//函		数：
	//功		能：获取时钟稳定时间
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_RCC_PLL_GetDivN(void)
	{
		return READ_BIT(RCC->PLL, RCC_PLL_DIVN);
	}

	///
	//函		数：
	//功		能：设置时钟稳定时间
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_RCC_PLL_SetClockSource(uint32_t ClockSource)
	{
		MODIFY_REG(RCC->PLL, RCC_PLL_REF, ClockSource);
	}

	///
	//函		数：
	//功		能：获取时钟稳定时间
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_RCC_PLL_GetClockSource(void)
	{
		return READ_BIT(RCC->PLL, RCC_PLL_REF);
	}

	///
	//函		数：
	//功		能：设置PLL输入频率
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_RCC_PLL_SetInFrequency(uint32_t frequency)
	{
		MODIFY_REG(RCC->PLL, RCC_PLL_IN_FREQ, frequency);
	}

	///
	//函		数：
	//功		能：获取时钟稳定时间
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_RCC_PLL_GetInFrequency(void)
	{
		return READ_BIT(RCC->PLL, RCC_PLL_IN_FREQ);
	}


	///
	//函		数：
	//功		能：设置PLL输入频率
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline void LL_RCC_PLL_SetOutFrequency(uint32_t frequency)
	{
		MODIFY_REG(RCC->PLL, RCC_PLL_OUT_FREQ, frequency);
	}

	///
	//函		数：
	//功		能：获取时钟稳定时间
	//输入参	数：
	//输出参	数：
	//说		明：
	//
	static inline uint32_t LL_RCC_PLL_GetOutFrequency(void)
	{
		return READ_BIT(RCC->PLL, RCC_PLL_OUT_FREQ);
	}

	///
	//函		数:
	//功		能: ·设置RTC高速补偿时钟频率
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline void LL_RCC_RTC_SetAdj(uint32_t adj)
	{
		LL_RCC_UnLock();
		MODIFY_REG(RCC->CR1, RCC_CR1_RTC_FREQ_ADJ, adj);
	}

	///
	//函		数:
	//功		能: ·获取RTC高速补偿时钟频率
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline uint32_t LL_RCC_RTC_GetAdj(void)
	{
		return (uint32_t)(READ_BIT(RCC->CR1, RCC_CR1_RTC_FREQ_ADJ));
	}

	///
	//函		数:
	//功		能: 使能RTC低功耗模式
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline void LL_RCC_RTC_Enable_LowPower(void)
	{
		SET_BIT(RCC->CR1, RCC_CR1_RTC_LPW);
	}

	///
	//函		数:
	//功		能: ·不使能RTC低功耗模式
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline void LL_RCC_RTC_Disable_LowPower(void)
	{
		CLEAR_BIT(RCC->CR1, RCC_CR1_RTC_LPW);
	}

	///
	//函		数:
	//功		能: ·是否使能RTC低功耗模式
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline uint32_t LL_RCC_RTC_IsEnabled_LowPower(void)
	{
		return(uint32_t)(READ_BIT(RCC->CR1, RCC_CR1_RTC_LPW));
	}

	///
	//函		数:
	//功		能: 使能内核锁定功能
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline void LL_RCC_Enable_LockUp(void)
	{
		SET_BIT(RCC->CR1, RCC_CR1_LOCK_UP);
	}

	///
	//函		数:
	//功		能: ·不使能内核锁定功能
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline void LL_RCC_Disable_LockUp(void)
	{
		CLEAR_BIT(RCC->CR1, RCC_CR1_LOCK_UP);
	}

	///
	//函		数:
	//功		能: ·是否使能内核锁定功能
	//输入参	数:
	//输出参	数:
	//说		明:
	//
	static inline uint32_t LL_RCC_IsEnabled_LockUp(void)
	{
		return(uint32_t)(READ_BIT(RCC->CR1, RCC_CR1_LOCK_UP));
	}


	typedef struct
	{
		uint32_t SYSCLK;          //---系统时钟
		uint32_t HCLK;            //---高速时钟
		uint32_t PCLK0;           //---外设模块0时钟
		uint32_t PCLK1;           //---外设模块1时钟
	} LL_RCC_TypeDef;

    //===函数定义
    void LL_RCC_SysClkSwitchRCHToRCH(uint32_t hz);
    void LL_RCC_HSE_Init(void);
	void LL_RCC_HSI_Init(uint32_t hz);
    void LL_RCC_Bypass_Init(void);
    void LL_RCC_LSE_Init(void);
	void LL_RCC_LSI_Init(uint32_t hz);
    void LL_RCC_DeInit(void);
    void LL_RCC_GetSystemClocks(LL_RCC_TypeDef* RCC_Clocks);

	///
#ifdef __cplusplus
}
#endif 

#endif /* HC32L1XX_LL_RCC_H */
#include "hc32l1xx_ll_rcc.h"


///
//函		数:
//功		能: 系统时钟切换RCH的频率
//输入参数:
//输出参数:
//说		明:
//
void LL_RCC_SysClkSwitchRCHToRCH(uint32_t hz)
{
	//---设置HCLK分频数最大，避免时钟过快，导致异常
	LL_RCC_SetAHBPrescaler(RCC_CR0_HCLK_PRS_128);
	//---设置PCLK分频数最大，避免时钟过快，导致异常
	LL_RCC_SetAHBPrescaler(RCC_CR0_PCLK_PRS_8);
	//---从小到大调整RCH的输出频率
	//---4M
	LL_RCC_HSI_SetCalibTrimming(RCC_RCH_TRIM_4M);
	if (hz >4000000UL)
	{
		//---8M
		LL_RCC_HSI_SetCalibTrimming(RCC_RCH_TRIM_8M);
	}
	if (hz > 8000000UL)
	{
		//---16M
		LL_RCC_HSI_SetCalibTrimming(RCC_RCH_TRIM_16M);
	}
	if (hz > 16000000UL)
	{
		//---24M
		LL_RCC_HSI_SetCalibTrimming(RCC_RCH_TRIM_24M);
	}
	
}

///
//函		数:
//功		能: 系统时钟切换到RCH
//输入参数:
//输出参数:
//说		明:
//
void LL_RCC_SysClkSwitchToRCH(uint32_t hz)
{

}

///
//函		数:
//功		能: 系统时钟切换到RCL
//输入参数:
//输出参数:
//说		明:
//
void LL_RCC_SysClkSwitchToRCL(uint32_t hz)
{

}

///
//函		数:
//功		能: 系统时钟切换到XTL
//输入参数:
//输出参数:
//说		明:
//
void LL_RCC_SysClkSwitchToXTL(void)
{

}

///
//函		数:
//功		能: 系统时钟切换从RCH到PLL
//输入参数:
//输出参数:
//说		明:
//
void LL_RCC_SysClkSwitchRCHToPLL(void)
{

}

///
//函		数:
//功		能: 系统时钟切换从XTH到PLL
//输入参数:
//输出参数:
//说		明:
//
void LL_RCC_SysClkSwitchXTHToPLL(void)
{

}


///
//函		数:
//功		能: 高速晶振时钟初始化
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_HSE_Init(void)
{
	//---配置PF00和PF01位模拟输入模式
	LL_GPIO_InitTypeDef GPIO_InitStruct = { 0 };
	GPIO_InitStruct.Pin = LL_GPIO_PIN_0 | LL_GPIO_PIN_1;
	GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
	GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
	GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
	GPIO_InitStruct.DriverLevel = LL_GPIO_DRIVER_HIGH;
	GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
	LL_GPIO_Init(GPIOF, &GPIO_InitStruct);

	//---设置XTH的驱动English
	LL_RCC_HSE_SetDriver(RCC_XTH_DRIVER_NORMAL);
	//---设置XTH启动时间
	LL_RCC_HSE_SetStartup(RCC_XTH_STARTUP_16384_CLK);
	//---设置工作频率
	if (HSE_VALUE<=8000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_4M_8M);
	}
	else  if (HSE_VALUE <= 16000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_8M_16M);
	}
	else  if (HSE_VALUE <= 24000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_16M_24M);
	}
	else  if (HSE_VALUE <= 32000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_24M_32M);
	}
	else
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_4M_8M);
	}
	//---使能HSE
	LL_RCC_HSE_Enable();
	//---等待高频晶振时钟稳定
#ifndef USE_SIMULATOR
	while (LL_RCC_HSE_IsReady() != 0)
	{

	}
#endif
}

///
//函		数:
//功		能: 高速晶振时钟初始化
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_Bypass_Init(void)
{
	//---配置PF00为模拟输入模式
	LL_GPIO_InitTypeDef GPIO_InitStruct = { 0 };
	GPIO_InitStruct.Pin = LL_GPIO_PIN_0;
	GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
	GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
	GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
	GPIO_InitStruct.DriverLevel = LL_GPIO_DRIVER_HIGH;
	GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
	LL_GPIO_Init(GPIOF, &GPIO_InitStruct);

	//---设置XTH的驱动English
	LL_RCC_HSE_SetDriver(RCC_XTH_DRIVER_NORMAL);
	//---设置XTH启动时间
	LL_RCC_HSE_SetStartup(RCC_XTH_STARTUP_16384_CLK);
	//---设置工作频率
	if (HSE_VALUE <= 8000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_4M_8M);
	}
	else  if (HSE_VALUE <= 16000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_8M_16M);
	}
	else  if (HSE_VALUE <= 24000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_16M_24M);
	}
	else  if (HSE_VALUE <= 32000000UL)
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_24M_32M);
	}
	else
	{
		LL_RCC_HSE_SetFreq(RCC_XTH_FREQ_4M_8M);
	}
	//---使能Bypass
	LL_RCC_HSE_Enable_Bypass();
	//---等待高频晶振时钟稳定
#ifndef USE_SIMULATOR
	while (LL_RCC_HSE_IsReady() == 0)
	{

	}
#endif
}

///
//函		数:
//功		能: 高速晶振时钟初始化
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_HSI_Init(uint32_t hz)
{
	//---配置PF00和PF01位数字输入模式
	LL_GPIO_InitTypeDef GPIO_InitStruct = { 0 };
	GPIO_InitStruct.Pin = LL_GPIO_PIN_0 | LL_GPIO_PIN_1;
	GPIO_InitStruct.Mode = LL_GPIO_MODE_INPUT;
	GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
	GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
	GPIO_InitStruct.DriverLevel = LL_GPIO_DRIVER_HIGH;
	GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
	LL_GPIO_Init(GPIOF, &GPIO_InitStruct);
	//---设置系统主时钟为内部RC
	LL_RCC_SysClkSwitchRCHToRCH(hz);
	//---使能内部RCH
	LL_RCC_HSI_Enable();
	//---等待内部时钟稳定
#ifndef USE_SIMULATOR
	while (LL_RCC_HSI_IsReady() ==0)
	{
		
	}
#endif
	//---使能XTH
	LL_RCC_HSE_Disable();
	//--不使能外部时钟
	LL_RCC_HSE_Disable_Bypass();
}

///
//函		数:
//功		能: 初始化外部低频晶振
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_LSE_Init(void)
{
	//---配置PC14和PC15位模拟输入模式
	LL_GPIO_InitTypeDef GPIO_InitStruct = { 0 };
	GPIO_InitStruct.Pin = LL_GPIO_PIN_14|LL_GPIO_PIN_15;
	GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
	GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
	GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
	GPIO_InitStruct.DriverLevel = LL_GPIO_DRIVER_HIGH;
	GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
	LL_GPIO_Init(GPIOC, &GPIO_InitStruct);

	//---设置XTL的振荡幅度
	LL_RCC_LSE_SetAmp(RCC_XTL_AMP_HIGH);
	//---设置XTL的驱动English
	LL_RCC_LSE_SetDriver(RCC_XTL_DRIVER_NORMAL);
	//---设置XTL启动时间
	LL_RCC_LSE_SetStartup(RCC_XTL_STARTUP_16384_CLK);
	//---使能LSE
	LL_RCC_LSE_Enable();
	//---等待低频晶振时钟稳定
#ifndef USE_SIMULATOR
	while (LL_RCC_LSE_IsReady() ==0)
	{
		
	}
#endif
}

///
//函		数:
//功		能: 初始化外部低频晶振
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_LSI_Init(uint32_t hz)
{
	//---配置PC14和PC15位数字输入模式
	LL_GPIO_InitTypeDef GPIO_InitStruct = { 0 };
	GPIO_InitStruct.Pin = LL_GPIO_PIN_14 | LL_GPIO_PIN_15;
	GPIO_InitStruct.Mode = LL_GPIO_MODE_INPUT;
	GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
	GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
	GPIO_InitStruct.DriverLevel = LL_GPIO_DRIVER_HIGH;
	GPIO_InitStruct.Alternate = LL_GPIO_AF_0;
	LL_GPIO_Init(GPIOC, &GPIO_InitStruct);

	//---设置内部低速时钟RCL的频率
	if (hz==38400U)
	{
		//---切换内部低频晶振为RCL，38.4KHz
		LL_RCC_LSI_SetCalibTrimming(RCC_RCL_TRIM_38K4);
		//LL_RCC_LSI_SetCalibTrimming(RCC_RCL_TRIM_32K768);
	}
	else
	{
		//---切换内部低频晶振为RCL，32.768KHz
		LL_RCC_LSI_SetCalibTrimming(RCC_RCL_TRIM_32K768);
	}
	
	//---使能内部RCL
	LL_RCC_LSI_Enable();
	//---等待内部低速时钟稳定
#ifndef USE_SIMULATOR
	while (LL_RCC_LSI_IsReady() ==0)
	{
		
	}
#endif
}

///
//函		数:
//功		能: PLL初始化
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_PLL_Init(uint32_t clocksource,uint32_t pllclock)
{
	uint32_t rch = 0;
	uint32_t refpll = 0;
	//---使能ADC时钟
	LL_PER0_GRP1_Enable_Clock(LL_PER0_GRP1_PERIPH_ADC);
	//---使能BGR
	LL_PER0_GRP1_Enable_Clock(LL_PER0_GRP1_PERIPH_BGR);
	//---设置PLL稳定周期
	//---设置XTL启动时间
	LL_RCC_PLL_SetStartup(RCC_PLL_STARTUP_16384_CLK);
	//---校验PLL的时钟源
	if (clocksource== LL_RCC_PLL_CLK_SOURCE_RCH)
	{
		rch = RCC->RCH&RCC_RCH_TRIM;
		//---校验时钟选择
		if (rch== RCC_RCH_TRIM_4M)
		{
			refpll=4000000UL;
		}
		else if(rch == RCC_RCH_TRIM_8M)
		{
			refpll = 8000000UL;
		}
		else if (rch == RCC_RCH_TRIM_16M)
		{
			refpll = 16000000UL;
		}
		else if (rch == RCC_RCH_TRIM_22M12)
		{
			refpll = 22120000UL;
		}
		else
		{
			refpll = 24000000UL;
		}
		LL_RCC_PLL_SetClockSource(LL_RCC_PLL_CLK_SOURCE_RCH);
	}
	else
	{
		if (clocksource== LL_RCC_PLL_CLK_SOURCE_BYPASS)
		{
			LL_RCC_PLL_SetClockSource(LL_RCC_PLL_CLK_SOURCE_BYPASS);
		}
		else
		{
			LL_RCC_PLL_SetClockSource(LL_RCC_PLL_CLK_SOURCE_XTH);
		}
#ifdef HSE_VALUE
		//---外部高速时钟频率
		refpll = HSE_VALUE;
#else
		//---外部高速时钟频率
		refpll = 8000000UL;
#endif
	}
	//---判断pll输出时钟的大小
	if (pllclock>48000000UL)
	{
		pllclock = 48000000UL;
	}
	//---设置pll输入频率的范围
	if (refpll<=6000000UL)
	{
		LL_RCC_PLL_SetInFrequency(RCC_PLL_IN_FREQ_4M_6M);
	}
	else if (refpll <= 12000000UL)
	{
		LL_RCC_PLL_SetInFrequency(RCC_PLL_IN_FREQ_6M_12M);
	}
	else if (refpll <= 20000000UL)
	{
		LL_RCC_PLL_SetInFrequency(RCC_PLL_IN_FREQ_12M_20M);
	}
	else
	{
		LL_RCC_PLL_SetInFrequency(RCC_PLL_IN_FREQ_20M_24M);
	}
	//---计算PLL的倍频值
	rch = pllclock / refpll;
	//---检查倍频值是否符合设计
	switch (rch)
	{
		case 2:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_2);
			break;
		}
		case 3:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_3);
			break;
		}
		case 4:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_4);
			break;
		}
		case 5:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_5);
			break;
		}
		case 6:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_6);
			break;
		}
		case 7:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_7);
			break;
		}
		case 8:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_8);
			break;
		}
		case 9:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_9);
			break;
		}
		case 10:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_10);
			break;
		}
		case 11:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_11);
			break;
		}
		case 12:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_12);
			break;
		}
		default:
		{
			LL_RCC_PLL_SetDivN(RCC_PLL_DIVN_2);
			rch = 2;
			break;
		}
	}
	//---最后PLL输出时钟
	pllclock = refpll * rch;
	//---设置PLL输出频率选择
	if (refpll <= 12000000UL)
	{
		LL_RCC_PLL_SetOutFrequency(RCC_PLL_OUT_FREQ_8M_12M);
	}
	else if (refpll <= 18000000UL)
	{
		LL_RCC_PLL_SetOutFrequency(RCC_PLL_OUT_FREQ_12M_18M);
	}
	else if (refpll <= 24000000UL)
	{
		LL_RCC_PLL_SetOutFrequency(RCC_PLL_OUT_FREQ_18M_24M);
	}
	else if (refpll <= 36000000UL)
	{
		LL_RCC_PLL_SetOutFrequency(RCC_PLL_OUT_FREQ_24M_36M);
	}
	else
	{
		LL_RCC_PLL_SetOutFrequency(RCC_PLL_OUT_FREQ_36M_48M);
	}
	//---使能PLL
	LL_RCC_PLL_Enable();
	//---等待内部低速时钟稳定
#ifndef USE_SIMULATOR
	while (LL_RCC_PLL_IsReady() == 0)
	{

	}
#endif
}

///
//函		数:
//功		能: 时钟复位
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_DeInit(void)
{
	LL_RCC_UnLock();
	RCC->CR0 = 0x01UL;
	LL_RCC_UnLock();
	RCC->CR1 = 0x08UL;

	RCC->RCH = 0x126UL;
	RCC->XTH = 0x22UL;
	RCC->RCL = 0x33fUL;
	RCC->XTL = 0x21UL;
	RCC->PLL = 0x10B0FUL;
}

///
//函		数:
//功		能: 获取系统时钟
//输入参	数:
//输出参	数:
//说		明:
//
uint32_t LL_RCC_GetSystemClock(void)
{
	uint32_t sysclk = SystemCoreClock;
	uint32_t prs = READ_BIT(RCC->CR0, RCC_CR0_HCLK_PRS);
	prs >>= RCC_CR0_HCLK_PRS_POS;
	switch (prs)
	{
		case 0:
		{
			sysclk /= 1;
			break;
		}
		case 1:
		{
			sysclk /= 2;
			break;
		}
		case 2:
		{
			sysclk /= 4;
			break;
		}
		case 3:
		{
			sysclk /= 8;
			break;
		}
		case 4:
		{
			sysclk /= 16;
			break;
		}
		case 5:
		{
			sysclk /= 32;
			break;
		}
		case 6:
		{
			sysclk /= 64;
			break;
		}
		case 7:
		{
			sysclk /= 128;
			break;
		}
		default:
		{
			sysclk = 0;
			break;
		}
	}
	return sysclk;
}

///
//函		数:
//功		能: 获取系统高速时钟
//输入参	数:
//输出参	数:
//说		明:
//
uint32_t LL_RCC_GetHCLKClock(uint32_t sysclk)
{
	uint32_t prs = READ_BIT(RCC->CR0, RCC_CR0_HCLK_PRS);
	prs >>= RCC_CR0_HCLK_PRS_POS;
	switch (prs)
	{
		case 0:
		{
			sysclk /= 1;
			break;
		}
		case 1:
		{
			sysclk /= 2;
			break;
		}
		case 2:
		{
			sysclk /= 4;
			break;
		}
		case 3:
		{
			sysclk /= 8;
			break;
		}
		case 4:
		{
			sysclk /= 16;
			break;
		}
		case 5:
		{
			sysclk /= 32;
			break;
		}
		case 6:
		{
			sysclk /= 64;
			break;
		}
		case 7:
		{
			sysclk /= 128;
			break;
		}
		default:
		{
			sysclk =0;
			break;
		}
	}
	return sysclk;
}

///
//函		数:
//功		能: 获取外设模块0的时钟
//输入参	数:
//输出参	数:
//说		明:
//
uint32_t LL_RCC_GetPCLK0Clock(uint32_t hclk)
{
	uint32_t prs = READ_BIT(RCC->CR0, RCC_CR0_PCLK_PRS);
	prs >>= RCC_CR0_PCLK_PRS_POS;
	switch (prs)
	{
		case 0:
		{
			hclk /= 1;
			break;
		}
		case 1:
		{
			hclk /= 2;
			break;
		}
		case 2:
		{
			hclk /= 4;
			break;
		}
		case 3:
		{
			hclk /= 8;
			break;
		}
		default:
		{
			hclk = 0;
			break;
		}
	}
	return hclk;
}

///
//函		数:
//功		能: 获取外设模块1的时钟
//输入参	数:
//输出参	数:
//说		明:
//
uint32_t LL_RCC_GetPCLK1Clock(uint32_t hclk)
{
	uint32_t prs = READ_BIT(RCC->CR0, RCC_CR0_PCLK_PRS);
	prs >>= RCC_CR0_PCLK_PRS_POS;
	switch (prs)
	{
		case 0:
		{
			hclk /= 1;
			break;
		}
		case 1:
		{
			hclk /= 2;
			break;
		}
		case 2:
		{
			hclk /= 4;
			break;
		}
		case 3:
		{
			hclk /= 8;
			break;
		}
		default:
		{
			hclk = 0;
			break;
		}
	}
	return hclk;
}

///
//函		数:
//功		能: 获取系统各个外设模块的总线时钟
//输入参	数:
//输出参	数:
//说		明:
//
void LL_RCC_GetSystemClocks(LL_RCC_TypeDef* RCC_Clocks)
{
	RCC_Clocks->SYSCLK = LL_RCC_GetSystemClock();
	RCC_Clocks->HCLK   = LL_RCC_GetHCLKClock(RCC_Clocks->SYSCLK);
	RCC_Clocks->PCLK0  = LL_RCC_GetPCLK0Clock(RCC_Clocks->HCLK);
	RCC_Clocks->PCLK1  = LL_RCC_GetPCLK1Clock(RCC_Clocks->HCLK);
}