HC32L17x的LL驱动库之rtc

最新推荐文章于 2024-04-30 15:38:12 发布
最新推荐文章于 2024-04-30 15:38:12 发布
阅读量304 收藏
点赞数
分类专栏： HC32L17x 文章标签： 单片机 mcu c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Haiguozhe/article/details/129230716
版权 
#include "hc32l1xx_ll_rtc.h"

///
//函        数:
//功        能: 
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_DeInit(RTC_TypeDef *RTCx)
{
    LL_PER0_GRP1_ForceReset(LL_PER0_GRP1_PERIPH_RTC);
    LL_PER0_GRP1_ReleaseReset(LL_PER0_GRP1_PERIPH_RTC);
    return 0;
}

///
//函        数:
//功        能: 锁定RTC
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_Lock(RTC_TypeDef *RTCx)
{
    uint16_t cnt = 0;
    CLEAR_BIT(RTCx->CR1, RTC_CR1_WAIT);
    //---检查是否有效
    while (1)
    {
        if (READ_BIT(RTCx->CR1, RTC_CR1_WAITF) != 0)
        {
            break;
        }
        //---判断是否超时
        if (cnt > 1000)
        {
            return 1;
        }
        cnt++;
        //WDT_RESET();
    }
    return 0;
}

///
//函        数:
//功        能: 解锁RTC
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_UnLock(RTC_TypeDef *RTCx)
{
    uint16_t cnt = 0;
    if (LL_RTC_IsEnabled(RTCx)!=0)
    {
        SET_BIT(RTCx->CR1, RTC_CR1_WAIT);
        //---检查是否有效
        while (1)
        {
            if (READ_BIT(RTCx->CR1, RTC_CR1_WAITF)!=0)
            {
                break;
            }
            //---判断是否超时
            if (cnt>1000)
            {
                return 1;
            }
            cnt++;
            //WDT_RESET();
        }
    }
    return 0;
}

///
//函        数:
//功        能: 时间初始化
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_SetTime(RTC_TypeDef *RTCx,uint8_t hour,uint8_t minute,uint8_t second)
{
    //---解锁
    uint8_t _return = 0;
    //---不使能低功耗模式
    LL_RCC_RTC_DisableLowPower();
    //---解锁RTC日期操作
    _return = LL_RTC_UnLock(RTCx);
    //---校验结果
    if (_return==0)
    {
        //---设置秒
        LL_RTC_TIME_SetSecond(RTCx, second);
        //---设置分
        LL_RTC_TIME_SetMinute(RTCx, minute);
        //---设置时
        LL_RTC_TIME_SetHour(RTCx, hour);
        //---锁定
        _return = LL_RTC_Lock(RTCx);
    }
    //---使能低功耗模式
    LL_RCC_RTC_EnableLowPower();
    return _return;
}

///
//函        数:
//功        能: 时间初始化
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_TimeInit(RTC_TypeDef *RTCx, LL_RTC_TimeTypeDef *Timex)
{
    //---设置时间格式
    LL_RTC_TIME_SetFormat(RTCx, Timex->TimeFormat);
    //---设置是分秒
    return LL_RTC_SetTime(RTCx, Timex->Hours, Timex->Minutes, Timex->Seconds);
}

///
//函        数:
//功        能: 日期初始化
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_SetDate(RTC_TypeDef *RTCx,uint8_t year,uint8_t month,uint8_t day,uint8_t weekday)
{
    uint8_t _return = 0;
    //---不使能低功耗模式
    LL_RCC_RTC_DisableLowPower();
    //---解锁RTC日期操作
    _return = LL_RTC_UnLock(RTCx);
    //---校验结果
    if (_return == 0)
    {
        //---设置年
        LL_RTC_DATE_SetYear(RTCx, year);
        //---设置月
        LL_RTC_DATE_SetMonth(RTCx, month);
        //---设置日
        LL_RTC_DATE_SetDay(RTCx, day);
        //---设置周
        LL_RTC_DATE_SetWeekDay(RTCx, weekday);
        //---锁定
        _return = LL_RTC_Lock(RTCx);
    }
    //---使能低功耗模式
    LL_RCC_RTC_EnableLowPower();
    return _return;
}

///
//函        数:
//功        能: 日期初始化
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_DateInit(RTC_TypeDef *RTCx, LL_RTC_DateTypeDef *Datex)
{
    return LL_RTC_SetDate(RTCx,Datex->Year,Datex->Month,Datex->Day,Datex->WeekDay);
}

///
//函        数:
//功        能: 报警初始化
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_SetAlarm(RTC_TypeDef *RTCx, uint8_t hour, uint8_t minute, uint8_t second,uint8_t weekday)
{
    //---不使能低功耗模式
    LL_RCC_RTC_DisableLowPower();
    //---不使能RTC
    LL_RTC_Disable(RTCx);
    //---设置时
    LL_RTC_ALM_SetHour(RTCx, hour);
    //---设置分
    LL_RTC_ALM_SetMinute(RTCx, minute);
    //---设置秒
    LL_RTC_ALM_SetSecond(RTCx, second);
    //---设置周
    LL_RTC_ALM_SetWeekDay(RTCx, weekday);
    //---使能RTC
    LL_RTC_Enable(RTCx);
    //---使能低功耗模式
    LL_RCC_RTC_EnableLowPower();
    return 0;
}

///
//函        数:
//功        能: 报警初始化
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_AlarmInit(RTC_TypeDef *RTCx, LL_RTC_AlarmTypeDef *Alarmx)
{
    if (LL_RTC_TIME_GetFormat(RTCx)!=Alarmx->AlarmTime.TimeFormat)
    {
        LL_RTC_TIME_SetFormat(RTCx, Alarmx->AlarmTime.TimeFormat);
    }
    return LL_RTC_SetAlarm(RTCx,Alarmx->AlarmTime.Hours,
        Alarmx->AlarmTime.Minutes,
        Alarmx->AlarmTime.Seconds,
        Alarmx->AlarmWeekDay);
}

///
//函        数:
//功        能: 
//输入参    数:
//输出参    数:
//说        明:
//
uint8_t LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_TimeTypeDef *Timex, LL_RTC_DateTypeDef *Datex)
{
    uint32_t _adj = 0;
    //---解锁
    uint8_t _return = 0;
    //---设置RTC高速补偿时钟频率选择
    if (SystemCoreClock>24000000UL)
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_32M);
        _adj = LL_RCC_RTC_ADJ_32M;
    }
    else if(SystemCoreClock > 20000000UL)
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_24M);
        _adj = LL_RCC_RTC_ADJ_24M;
    }
    else if (SystemCoreClock > 16000000UL)
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_20M);
        _adj = LL_RCC_RTC_ADJ_20M;
    }
    else if (SystemCoreClock > 12000000UL)
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_16M);
        _adj = LL_RCC_RTC_ADJ_16M;
    }
    else if (SystemCoreClock > 8000000UL)
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_12M);
        _adj = LL_RCC_RTC_ADJ_12M;
    }
    else if (SystemCoreClock > 6000000UL)
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_8M);
        _adj = LL_RCC_RTC_ADJ_8M;
    }
    else if (SystemCoreClock > 4000000UL)
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_6M);
        _adj = LL_RCC_RTC_ADJ_6M;
    }
    else
    {
        //LL_RCC_RTC_SetAdj(LL_RCC_RTC_ADJ_4M);
        _adj = LL_RCC_RTC_ADJ_4M;
    }
    //---设置RTC补偿
    LL_RCC_RTC_SetAdj(_adj);
    //---不使能低功耗模式
    LL_RCC_RTC_DisableLowPower();
    //---不使能RTC
    LL_RTC_Disable(RTCx);
    //---设置时间格式
    LL_RTC_TIME_SetFormat(RTCx, Timex->TimeFormat);
    //---解锁RTC日期操作
    _return = LL_RTC_UnLock(RTCx);
    //---校验结果
    if (_return == 0)
    {
        //---设置秒
        LL_RTC_TIME_SetSecond(RTCx,Timex->Seconds);
        //---设置分
        LL_RTC_TIME_SetMinute(RTCx, Timex->Minutes);
        //---设置时
        LL_RTC_TIME_SetHour(RTCx, Timex->Hours);
        //---设置年
        LL_RTC_DATE_SetYear(RTCx, Datex->Year);
        //---设置月
        LL_RTC_DATE_SetMonth(RTCx, Datex->Month);
        //---设置日
        LL_RTC_DATE_SetDay(RTCx, Datex->Day);
        //---设置周
        LL_RTC_DATE_SetWeekDay(RTCx, Datex->WeekDay);
    }
    //---锁定
    _return = LL_RTC_Lock(RTCx);
    //---使能RTC
    LL_RTC_Enable(RTCx);
    //---使能低功耗模式
    LL_RCC_RTC_EnableLowPower();
    return _return;
}

#ifndef HC32L1XX_LL_RTC_H_
#define HC32L1XX_LL_RTC_H_

#ifdef __cplusplus
extern "C" {
#endif 
    
    #include "hc32l1xx.h"
    #include "hc32l1xx_ll_bus.h"
    #include "hc32l1xx_ll_rcc.h"
    ///
    //===AM模式或者24小时制
    #define LL_RTC_TIME_FORMAT_AM_OR_24        RTC_CR0_AM   
    //===12小时制
    #define LL_RTC_TIME_FORMAT_PM              RTC_CR0_PM          

    //===星期信息，依次是周日，周一，周二，周三，周四，周五，周六
    #define LL_RTC_WEEKDAY_SUNDAY              (0x00U)
    #define LL_RTC_WEEKDAY_MONDAY              (0x01U)
    #define LL_RTC_WEEKDAY_TUESDAY             (0x02U)
    #define LL_RTC_WEEKDAY_WEDNESDAY           (0x03U)
    #define LL_RTC_WEEKDAY_THURSDAY            (0x04U)
    #define LL_RTC_WEEKDAY_FRIDAY              (0x05U)
    #define LL_RTC_WEEKDAY_SATURDAY            (0x06U)

    //===月份信息，依次是1月，2月，3月，4月，5月，6月，7月，8月，9月，10月，11月，12月
    #define LL_RTC_MONTH_JANUARY               (0x01U)  
    #define LL_RTC_MONTH_FEBRUARY              (0x02U)  
    #define LL_RTC_MONTH_MARCH                 (0x03U)  
    #define LL_RTC_MONTH_APRIL                 (0x04U)  
    #define LL_RTC_MONTH_MAY                   (0x05U)  
    #define LL_RTC_MONTH_JUNE                  (0x06U)  
    #define LL_RTC_MONTH_JULY                  (0x07U)  
    #define LL_RTC_MONTH_AUGUST                (0x08U)  
    #define LL_RTC_MONTH_SEPTEMBER             (0x09U)  
    #define LL_RTC_MONTH_OCTOBER               (0x10U)  
    #define LL_RTC_MONTH_NOVEMBER              (0x11U)  
    #define LL_RTC_MONTH_DECEMBER              (0x12U)  

    //===24小时制
    #define LL_RTC_HOURFORMAT_24HOUR           RTC_CR0_AM      
    //===12小时制
    #define LL_RTC_HOURFORMAT_PM               RTC_CR0_PM   
    //===12小时制
    #define LL_RTC_HOURFORMAT_12HOUR           RTC_CR0_PM 

    //===报警星期信息，依次是周日，周一，周二，周三，周四，周五，周六
    #define LL_RTC_ALARM_WEEKDAY_SUNDAY        (1<<0)
    #define LL_RTC_ALARM_WEEKDAY_MONDAY        (1<<1)
    #define LL_RTC_ALARM_WEEKDAY_TUESDAY       (1<<2)
    #define LL_RTC_ALARM_WEEKDAY_WEDNESDAY     (1<<3)
    #define LL_RTC_ALARM_WEEKDAY_THURSDAY      (1<<4)
    #define LL_RTC_ALARM_WEEKDAY_FRIDAY        (1<<5)
    #define LL_RTC_ALARM_WEEKDAY_SATURDAY      (1<<6)
    #define LL_RTC_ALARM_WEEKDAY_ALL           (LL_RTC_ALARM_WEEKDAY_SUNDAY|LL_RTC_ALARM_WEEKDAY_MONDAY| \
                                                LL_RTC_ALARM_WEEKDAY_TUESDAY|LL_RTC_ALARM_WEEKDAY_WEDNESDAY| \
                                                LL_RTC_ALARM_WEEKDAY_THURSDAY|LL_RTC_ALARM_WEEKDAY_FRIDAY| \
                                                LL_RTC_ALARM_WEEKDAY_SATURDAY)

    //===RTC时钟源
    #define    LL_RTC_CLK_SOURCE_XTL                RTC_CR1_CKSEL_XTL        
    #define    LL_RTC_CLK_SOURCE_RCL                RTC_CR1_CKSEL_RCL        
    #define    LL_RTC_CLK_SOURCE_XTH_DIV128        RTC_CR1_CKSEL_XTH_PRE128
    #define    LL_RTC_CLK_SOURCE_XTH_DIV256        RTC_CR1_CKSEL_XTH_PRE256
    #define    LL_RTC_CLK_SOURCE_XTH_DIV512        RTC_CR1_CKSEL_XTH_PRE512
    #define    LL_RTC_CLK_SOURCE_XTH_DIV1024        RTC_CR1_CKSEL_XTH_PRE1024

    //===时间间隔
    #define    LL_RTC_CYCLE_SEC_0P5            (RTC_CR0_PRDX_SEC_0P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_1                (RTC_CR0_PRDX_SEC_1        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_1P5            (RTC_CR0_PRDX_SEC_1P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_2                (RTC_CR0_PRDX_SEC_2        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_2P5            (RTC_CR0_PRDX_SEC_2P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_3                (RTC_CR0_PRDX_SEC_3        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_3P5            (RTC_CR0_PRDX_SEC_3P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_4                (RTC_CR0_PRDX_SEC_4        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_4P5            (RTC_CR0_PRDX_SEC_4P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_5                (RTC_CR0_PRDX_SEC_5        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_5P5            (RTC_CR0_PRDX_SEC_5P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_6                (RTC_CR0_PRDX_SEC_6        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_6P5            (RTC_CR0_PRDX_SEC_6P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_7                (RTC_CR0_PRDX_SEC_7        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_7P5            (RTC_CR0_PRDX_SEC_7P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_8                (RTC_CR0_PRDX_SEC_8        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_8P5            (RTC_CR0_PRDX_SEC_8P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_9                (RTC_CR0_PRDX_SEC_9        +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_9P5            (RTC_CR0_PRDX_SEC_9P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_10                (RTC_CR0_PRDX_SEC_10    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_10P5            (RTC_CR0_PRDX_SEC_10P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_11                (RTC_CR0_PRDX_SEC_11    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_11P5            (RTC_CR0_PRDX_SEC_11P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_12                (RTC_CR0_PRDX_SEC_12    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_12P5            (RTC_CR0_PRDX_SEC_12P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_13                (RTC_CR0_PRDX_SEC_13    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_13P5            (RTC_CR0_PRDX_SEC_13P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_14                (RTC_CR0_PRDX_SEC_14    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_14P5            (RTC_CR0_PRDX_SEC_14P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_15                (RTC_CR0_PRDX_SEC_15    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_15P5            (RTC_CR0_PRDX_SEC_15P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_16                (RTC_CR0_PRDX_SEC_16    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_16P5            (RTC_CR0_PRDX_SEC_16P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_17                (RTC_CR0_PRDX_SEC_17    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_17P5            (RTC_CR0_PRDX_SEC_17P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_18                (RTC_CR0_PRDX_SEC_18    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_18P5            (RTC_CR0_PRDX_SEC_18P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_19                (RTC_CR0_PRDX_SEC_19    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_19P5            (RTC_CR0_PRDX_SEC_19P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_20                (RTC_CR0_PRDX_SEC_20    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_20P5            (RTC_CR0_PRDX_SEC_20P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_21                (RTC_CR0_PRDX_SEC_21    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_21P5            (RTC_CR0_PRDX_SEC_21P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_22                (RTC_CR0_PRDX_SEC_22    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_22P5            (RTC_CR0_PRDX_SEC_22P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_23                (RTC_CR0_PRDX_SEC_23    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_23P5            (RTC_CR0_PRDX_SEC_23P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_24                (RTC_CR0_PRDX_SEC_24    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_24P5            (RTC_CR0_PRDX_SEC_24P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_25                (RTC_CR0_PRDX_SEC_25    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_25P5            (RTC_CR0_PRDX_SEC_25P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_26                (RTC_CR0_PRDX_SEC_26    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_26P5            (RTC_CR0_PRDX_SEC_26P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_27                (RTC_CR0_PRDX_SEC_27    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_27P5            (RTC_CR0_PRDX_SEC_27P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_28                (RTC_CR0_PRDX_SEC_28    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_28P5            (RTC_CR0_PRDX_SEC_28P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_29                (RTC_CR0_PRDX_SEC_29    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_29P5            (RTC_CR0_PRDX_SEC_29P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_30                (RTC_CR0_PRDX_SEC_30    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_30P5            (RTC_CR0_PRDX_SEC_30P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_31                (RTC_CR0_PRDX_SEC_31    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_31P5            (RTC_CR0_PRDX_SEC_31P5    +0x80000000U)
    #define    LL_RTC_CYCLE_SEC_32                (RTC_CR0_PRDX_SEC_32    +0x80000000U)

    #define    LL_RTC_CYCLE_NONE                RTC_CR0_PRDS_NONE        
    #define    LL_RTC_CYCLE_SEC_P5                RTC_CR0_PRDS_SEC_0P5    
    #define    LL_RTC_CYCLE_SEC_1P                RTC_CR0_PRDS_SEC_1        
    #define    LL_RTC_CYCLE_MIN_1                RTC_CR0_PRDS_MIN_1        
    #define    LL_RTC_CYCLE_HOUR_1                RTC_CR0_PRDS_HOUR_1        
    #define    LL_RTC_CYCLE_DAY_1                RTC_CR0_PRDS_DAY_1        
    #define    LL_RTC_CYCLE_MON_1                RTC_CR0_PRDS_MON_1        
    
    ///
    //函        数:
    //功        能: 启动RTC计数
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_Enable(RTC_TypeDef *RTCx)
    {
        SET_BIT(RTCx->CR0, RTC_CR0_START);
    }

    ///
    //函        数:
    //功        能: 停止RTC计数
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_Disable(RTC_TypeDef *RTCx)
    {
        CLEAR_BIT(RTCx->CR0, RTC_CR0_START);
    }

    ///
    //函        数:
    //功        能: 停止RTC计数
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_IsEnabled(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_BIT(RTCx->CR0, RTC_CR0_START));
    }

    ///
    //函        数:
    //功        能: 使能闹钟中断
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_EnableIT_ALM(RTC_TypeDef *RTCx)
    {
        SET_BIT(RTCx->CR1, RTC_CR1_ALMIE);
    }

    ///
    //函        数:
    //功        能: 不使能闹钟中断
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_DisableIT_ALM(RTC_TypeDef *RTCx)
    {
        CLEAR_BIT(RTCx->CR1, RTC_CR1_ALMIE);
    }

    ///
    //函        数：
    //功        能：是否使能闹钟中断
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline uint32_t LL_RTC_IsEnabled_IT_ALM(RTC_TypeDef *RTCx)
    {
        return (READ_BIT(RTCx->CR1, RTC_CR1_ALMIE) == (RTC_CR1_ALMIE));
    }

    ///
    //函        数：
    //功        能：闹钟中断标志
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline uint32_t LL_RTC_IsActiveFlag_ALM(RTC_TypeDef *RTCx)
    {
        return (READ_BIT(RTCx->CR1, RTC_CR1_ALMF) == (RTC_CR1_ALMF));
    }

    ///
    //函        数：
    //功        能：周期中断标志
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline uint32_t LL_RTC_IsActiveFlag_Cycle(RTC_TypeDef *RTCx)
    {
        return (READ_BIT(RTCx->CR1, RTC_CR1_PRDF) == (RTC_CR1_PRDF));
    }

    ///
    //函        数：
    //功        能：闹钟中断标志
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline void LL_RTC_ClearFlag_ALM(RTC_TypeDef *RTCx)
    {
        CLEAR_BIT(RTCx->CR1, RTC_CR1_ALMF);
    }

    ///
    //函        数：
    //功        能：周期中断标志
    //输入参    数：
    //输出参    数：
    //说        明：
    //
    static inline void LL_RTC_ClearFlag_Cycle(RTC_TypeDef *RTCx)
    {
        CLEAR_BIT(RTCx->CR1, RTC_CR1_PRDF);
    }

    ///
    //函        数:
    //功        能: 设置时间格式
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_TIME_SetFormat(RTC_TypeDef *RTCx, uint32_t TimeFormat)
    {
        MODIFY_REG(RTCx->CR0, RTC_CR0_AMPM, TimeFormat);
    }

    ///
    //函        数:
    //功        能: 获取时间格式
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_TIME_GetFormat(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_BIT(RTCx->CR0, RTC_CR0_AMPM));
    }

    ///
    //函        数:
    //功        能: 设置小时
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_TIME_SetHour(RTC_TypeDef *RTCx, uint32_t Hours)
    {
        WRITE_REG(RTCx->HOUR, Hours);
    }

    ///
    //函        数:
    //功        能: 获取小时
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_TIME_GetHour(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->HOUR));
    }

    ///
    //函        数:
    //功        能: 设置分钟
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_TIME_SetMinute(RTC_TypeDef *RTCx, uint32_t Minutes)
    {
        WRITE_REG(RTCx->MIN, Minutes);
    }

    ///
    //函        数:
    //功        能: 获取分钟
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_TIME_GetMinute(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->MIN));
    }

    ///
    //函        数:
    //功        能: 设置秒
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_TIME_SetSecond(RTC_TypeDef *RTCx, uint32_t Seconds)
    {
        WRITE_REG(RTCx->SEC, Seconds);
    }

    ///
    //函        数:
    //功        能: 获取秒
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_TIME_GetSecond(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->SEC));
    }
    
    ///
    //函        数:
    //功        能: 设置年
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_DATE_SetYear(RTC_TypeDef *RTCx, uint32_t Year)
    {
        WRITE_REG(RTCx->YEAR, Year);
    }

    ///
    //函        数:
    //功        能: 获取年
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_DATE_GetYear(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->YEAR));
    }

    ///
    //函        数:
    //功        能: 设置周
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline  void LL_RTC_DATE_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
    {
        WRITE_REG(RTCx->WEEKDAY, WeekDay);
    }

    ///
    //函        数:
    //功        能: 获取周
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_DATE_GetWeekDay(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->WEEKDAY));
    }

    ///
    //函        数:
    //功        能: 设置月信息
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_DATE_SetMonth(RTC_TypeDef *RTCx, uint32_t Month)
    {
        WRITE_REG(RTCx->MONTH, Month);
    }

    ///
    //函        数:
    //功        能: 获取月信息
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_DATE_GetMonth(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->MONTH));
    }

    ///
    //函        数:
    //功        能: 设置天信息
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_DATE_SetDay(RTC_TypeDef *RTCx, uint32_t Day)
    {
        WRITE_REG(RTCx->DAY,Day);
    }
    
    ///
    //函        数:
    //功        能: 获取天信息
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_DATE_GetDay(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->DAY));
    }

    ///
    //函        数:
    //功        能: 使能闹钟
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_ALM_Enable(RTC_TypeDef *RTCx)
    {
        SET_BIT(RTCx->CR1, RTC_CR1_ALMEN);
    }

    ///
    //函        数:
    //功        能: 不使能闹钟
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_ALM_Disable(RTC_TypeDef *RTCx)
    {
        CLEAR_BIT(RTCx->CR1, RTC_CR1_ALMEN);
    }
    
    ///
    //函        数:
    //功        能: 闹钟设置小时
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_ALM_SetHour(RTC_TypeDef *RTCx, uint32_t Hours)
    {
        WRITE_REG(RTCx->ALMHOUR, Hours);
    }

    ///
    //函        数:
    //功        能: 闹钟获取小时
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_ALM_GetHour(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->ALMHOUR));
    }

    ///
    //函        数:
    //功        能: 闹钟设置分钟
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_ALM_SetMinute(RTC_TypeDef *RTCx, uint32_t Minutes)
    {
        WRITE_REG(RTCx->ALMMIN, Minutes);
    }

    ///
    //函        数:
    //功        能: 闹钟获取分钟
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_ALM_GetMinute(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->ALMMIN));
    }

    ///
    //函        数:
    //功        能: 闹钟设置秒
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_ALM_SetSecond(RTC_TypeDef *RTCx, uint32_t Seconds)
    {
#if defined(HC32L17xP)||\
    defined(HC32L17xM)||\
    defined(HC32L17xK)||\
    defined(HC32L17xJ)
        WRITE_REG(RTCx->ALMSEC, Seconds);
#endif
    }

    ///
    //函        数:
    //功        能: 闹钟获取秒
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_ALM_GetSecond(RTC_TypeDef *RTCx)
    {
#if defined(HC32L17xP)||\
    defined(HC32L17xM)||\
    defined(HC32L17xK)||\
    defined(HC32L17xJ)
        return (uint32_t)(READ_REG(RTCx->ALMSEC));
#else
        return 0;
#endif 
    }

    ///
    //函        数:
    //功        能: 闹钟设置周
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline  void LL_RTC_ALM_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
    {
        WRITE_REG(RTCx->ALMWEEKDAY, WeekDay);
    }

    ///
    //函        数:
    //功        能: 闹钟获取周
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_ALM_GetWeekDay(RTC_TypeDef *RTCx)
    {
        return (uint32_t)(READ_REG(RTCx->ALMWEEKDAY));
    }

    ///
    //函        数:
    //功        能: 使能1HZ输出
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_Enable1Hz(RTC_TypeDef *RTCx)
    {
        SET_BIT(RTCx->CR0, RTC_CR0_1HZEN);
    }

    ///
    //函        数:
    //功        能: 使能1HZ输出
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_Disable1Hz(RTC_TypeDef *RTCx)
    {
        CLEAR_BIT(RTCx->CR0, RTC_CR0_1HZEN);
    }

    ///
    //函        数:
    //功        能: 设置RTC时钟选择项
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_SetClockSource(RTC_TypeDef *RTCx,uint32_t ClockSource)
    {
        MODIFY_REG(RTCx->CR1, RTC_CR1_CKSEL, ClockSource);
    }

    ///
    //函        数:
    //功        能: 获取RTC时钟选择项
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint32_t LL_RTC_GetClockSource(RTC_TypeDef *RTCx)
    {
        return (uint32_t)READ_BIT(RTCx->CR1, RTC_CR1_CKSEL);
    }

    ///
    //函        数:
    //功        能: 
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_SetCycle(RTC_TypeDef *RTCx, uint32_t TimeInterval)
    {
        uint32_t mask = 0;
        if ((TimeInterval& 0x80000000U)!=0)
        {
            mask |= RTC_CR0_PRDSEL;
            mask &= ~RTC_CR0_PRDX;
            TimeInterval |= RTC_CR0_PRDSEL;
            TimeInterval -= 0x80000000U;
        }
        else if ((TimeInterval & (~RTC_CR0_PRDS_MASK)) == 0)
        {
            mask &= ~RTC_CR0_PRDSEL;
            mask &= ~RTC_CR0_PRDS;
            TimeInterval &= ~RTC_CR0_PRDSEL;
        }
        else
        {
            mask &= ~RTC_CR0_PRDSEL;
            mask &= ~RTC_CR0_PRDS;
            TimeInterval = LL_RTC_CYCLE_NONE;
            TimeInterval &= ~RTC_CR0_PRDSEL;
        }
        uint32_t reg_temp = 0;
        //switch (TimeInterval)
        //{
        //    case LL_RTC_CYCLE_SEC_0P5    :
        //    case LL_RTC_CYCLE_SEC_1        :
        //    case LL_RTC_CYCLE_SEC_1P5    :
        //    case LL_RTC_CYCLE_SEC_2        :
        //    case LL_RTC_CYCLE_SEC_2P5    :
        //    case LL_RTC_CYCLE_SEC_3        :
        //    case LL_RTC_CYCLE_SEC_3P5    :
        //    case LL_RTC_CYCLE_SEC_4        :
        //    case LL_RTC_CYCLE_SEC_4P5    :
        //    case LL_RTC_CYCLE_SEC_5        :
        //    case LL_RTC_CYCLE_SEC_5P5    :
        //    case LL_RTC_CYCLE_SEC_6        :
        //    case LL_RTC_CYCLE_SEC_6P5    :
        //    case LL_RTC_CYCLE_SEC_7        :
        //    case LL_RTC_CYCLE_SEC_7P5    :
        //    case LL_RTC_CYCLE_SEC_8        :
        //    case LL_RTC_CYCLE_SEC_8P5    :
        //    case LL_RTC_CYCLE_SEC_9        :
        //    case LL_RTC_CYCLE_SEC_9P5    :
        //    case LL_RTC_CYCLE_SEC_10    :
        //    case LL_RTC_CYCLE_SEC_10P5    :
        //    case LL_RTC_CYCLE_SEC_11    :
        //    case LL_RTC_CYCLE_SEC_11P5    :
        //    case LL_RTC_CYCLE_SEC_12    :
        //    case LL_RTC_CYCLE_SEC_12P5    :
        //    case LL_RTC_CYCLE_SEC_13    :
        //    case LL_RTC_CYCLE_SEC_13P5    :
        //    case LL_RTC_CYCLE_SEC_14    :
        //    case LL_RTC_CYCLE_SEC_14P5    :
        //    case LL_RTC_CYCLE_SEC_15    :
        //    case LL_RTC_CYCLE_SEC_15P5    :
        //    case LL_RTC_CYCLE_SEC_16    :
        //    case LL_RTC_CYCLE_SEC_16P5    :
        //    case LL_RTC_CYCLE_SEC_17    :
        //    case LL_RTC_CYCLE_SEC_17P5    :
        //    case LL_RTC_CYCLE_SEC_18    :
        //    case LL_RTC_CYCLE_SEC_18P5    :
        //    case LL_RTC_CYCLE_SEC_19    :
        //    case LL_RTC_CYCLE_SEC_19P5    :
        //    case LL_RTC_CYCLE_SEC_20    :
        //    case LL_RTC_CYCLE_SEC_20P5    :
        //    case LL_RTC_CYCLE_SEC_21    :
        //    case LL_RTC_CYCLE_SEC_21P5    :
        //    case LL_RTC_CYCLE_SEC_22    :
        //    case LL_RTC_CYCLE_SEC_22P5    :
        //    case LL_RTC_CYCLE_SEC_23    :
        //    case LL_RTC_CYCLE_SEC_23P5    :
        //    case LL_RTC_CYCLE_SEC_24    :
        //    case LL_RTC_CYCLE_SEC_24P5    :
        //    case LL_RTC_CYCLE_SEC_25    :
        //    case LL_RTC_CYCLE_SEC_25P5    :
        //    case LL_RTC_CYCLE_SEC_26    :
        //    case LL_RTC_CYCLE_SEC_26P5    :
        //    case LL_RTC_CYCLE_SEC_27    :
        //    case LL_RTC_CYCLE_SEC_27P5    :
        //    case LL_RTC_CYCLE_SEC_28    :
        //    case LL_RTC_CYCLE_SEC_28P5    :
        //    case LL_RTC_CYCLE_SEC_29    :
        //    case LL_RTC_CYCLE_SEC_29P5    :
        //    case LL_RTC_CYCLE_SEC_30    :
        //    case LL_RTC_CYCLE_SEC_30P5    :
        //    case LL_RTC_CYCLE_SEC_31    :
        //    case LL_RTC_CYCLE_SEC_31P5    :
        //    case LL_RTC_CYCLE_SEC_32    :
        //    {
        //        mask |= RTC_CR0_PRDSEL;
        //        mask &= ~RTC_CR0_PRDX;
        //        TimeInterval|= RTC_CR0_PRDSEL;
        //        TimeInterval -= 0x80000000U;
        //        break;
        //    }
        //    case LL_RTC_CYCLE_NONE        :
        //    case LL_RTC_CYCLE_SEC_P5    :
        //    case LL_RTC_CYCLE_SEC_1P    :
        //    case LL_RTC_CYCLE_MIN_1        :
        //    case LL_RTC_CYCLE_HOUR_1    :
        //    case LL_RTC_CYCLE_DAY_1        :
        //    case LL_RTC_CYCLE_MON_1        :
        //    {
        //        mask &= ~RTC_CR0_PRDSEL;
        //        mask &= ~RTC_CR0_PRDS;
        //        TimeInterval &= ~RTC_CR0_PRDSEL;
        //        break;
        //    }
        //    default:
        //    {    
        //        mask &= ~RTC_CR0_PRDSEL;
        //        mask &= ~RTC_CR0_PRDS;
        //        TimeInterval = LL_RTC_CYCLE_NONE;
        //        TimeInterval &= ~RTC_CR0_PRDSEL;
        //        break;
        //    }
        //}
        //---判断是否使能低功耗模式
        LL_RCC_RTC_DisableLowPower();
        //---不使能中断
        NVIC_DisableIRQ(RTC_IRQn);
        //---写入数据
        MODIFY_REG(RTCx->CR0, mask, TimeInterval);
        //---判断RTC是否使能
        if (LL_RTC_IsEnabled(RTCx) != 0)
        {
            LL_RTC_ClearFlag_ALM(RTCx);
            LL_RTC_ClearFlag_Cycle(RTCx);
            //---使能中断
            NVIC_EnableIRQ(RTC_IRQn);
        }
        //---使能低功耗模式
        LL_RCC_RTC_EnableLowPower();
    }
    
    ///
    //函        数:
    //功        能: 不使能闹钟中断
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_DisableIT_Cycle(RTC_TypeDef *RTCx)
    {
        LL_RTC_SetCycle(RTCx, LL_RTC_CYCLE_NONE);
    }

    ///
    //函        数:
    //功        能: 使能时钟误差补偿
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_COMP_Enable(RTC_TypeDef* RTCx)
    {
        SET_BIT(RTCx->COMPEM, RTC_COMPEM_EN);
    }

    ///
    //函        数:
    //功        能: 不使能时钟误差补偿
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_COMP_Disable(RTC_TypeDef* RTCx)
    {
        CLEAR_BIT(RTCx->COMPEM, RTC_COMPEM_EN);
    }

    ///
    //函        数:
    //功        能: 设置时钟误差补偿
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline void LL_RTC_COMP_SetAdj(RTC_TypeDef* RTCx,uint16_t adj)
    {
        MODIFY_REG(RTCx->COMPEM, RTC_COMPEM_VAL,adj);
    }

    ///
    //函        数:
    //功        能: 获取时钟误差补偿
    //输入参    数:
    //输出参    数:
    //说        明:
    //
    static inline uint16_t LL_RTC_COMP_GetAdj(RTC_TypeDef* RTCx, uint16_t adj)
    {
        return (uint16_t)READ_BIT(RTCx->COMPEM, RTC_COMPEM_VAL);
    }
    
    //===时间结构体
    typedef struct
    {
        uint32_t TimeFormat;        //---时间格式
        uint32_t Hours;                //---时
        uint32_t Minutes;            //---分
        uint32_t Seconds;            //---秒
    } LL_RTC_TimeTypeDef;

    //===日期信息
    typedef struct
    {
        uint32_t WeekDay;            //---周
        uint32_t Month;                //---月
        uint32_t Day;                //---日
        uint32_t Year;                //---年
    } LL_RTC_DateTypeDef;

    //===闹钟
    typedef struct
    {
        LL_RTC_TimeTypeDef AlarmTime;    //---闹钟时间
        uint32_t AlarmWeekDay;            //---闹钟周
    } LL_RTC_AlarmTypeDef;

    //===函数定义
    uint8_t LL_RTC_DeInit(RTC_TypeDef *RTCx);
    uint8_t LL_RTC_Lock(RTC_TypeDef *RTCx);
    uint8_t LL_RTC_UnLock(RTC_TypeDef *RTCx);
    uint8_t LL_RTC_SetTime(RTC_TypeDef *RTCx, uint8_t hour, uint8_t minute, uint8_t second);
    uint8_t LL_RTC_TimeInit(RTC_TypeDef *RTCx, LL_RTC_TimeTypeDef *Timex);
    uint8_t LL_RTC_SetDate(RTC_TypeDef *RTCx, uint8_t year, uint8_t month, uint8_t day, uint8_t weekday);
    uint8_t LL_RTC_DateInit(RTC_TypeDef *RTCx, LL_RTC_DateTypeDef *Datex);
    uint8_t LL_RTC_SetAlarm(RTC_TypeDef *RTCx, uint8_t hour, uint8_t minute, uint8_t second, uint8_t weekday);
    uint8_t LL_RTC_AlarmInit(RTC_TypeDef *RTCx, LL_RTC_AlarmTypeDef *Alarmx);
    uint8_t LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_TimeTypeDef *Timex, LL_RTC_DateTypeDef *Datex);

    ///
#ifdef __cplusplus
}
#endif 

#endif /* HC32L1XX_LL_RTC_H */

Haiguozhe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HC32L17_L19系列用户手册Rev1.02
08-03
**HC32L17_L19系列用户手册Rev1.02** 是华大半导体有限公司为基于32位ARM Cortex-M0+微控制器的HC32L17和HC32L19系列设计的一份详尽的技术文档。这份手册主要面向的是使用这些系列微控制器进行产品开发的工程师，...
HC32L19x-L17x系列参考手册
10-17
《HC32L19x-L17x系列微控制器参考手册》是针对华大半导体推出的32位ARM Cortex-M0+微控制器的详细技术文档。该系列芯片旨在为各种应用提供高性能和低功耗解决方案。手册包含了丰富的硬件和软件信息，帮助开发者深入...
STM32 LL库踩坑系列一（RTC）
weixin_42831633的博客
07-04 4794
这个作者很懒，想到什么就写什么！ 写在前面 这个是记录学习LL库的踩坑系列，这个资料很少，想要找例程可以在电脑用户文件下的STM32Cube\Repository里，前提是下载好那个单片机的pack。 部分单片机没有的可以先借鉴同类型的。 STM32 LL库踩坑系列一（RTC） 本次踩坑RTC实时时钟作为Calender使用。 打开cubemx，配置好时钟模块，选择外部LSE。 然后选择生成LL库，编译，添加代码，一个是设置，一个读取。 /* Define used to indicate da
基于STM32F103单片机，使用LL库开发RTC，制作实时时钟并具有闹钟定时功能。
X_X_Smile的博客
11-28 1122
1、首先获取单片机RTC累加计数器的数值，先获取RTC计数寄存器高位CNTH的数值，强转为32位并向左偏移16位.，之后获取RTC计数寄存器低位CNTL的数值，并将其强转为32位，然后与高位相加，得到当前时间转化为秒钟数的个数。2、计算出自己所要设闹钟距离现在还有多少秒，使用刚读取的RTC累加寄存器数值加上此秒数就是闹钟寄存器所要设置的数值。当(ALRH+ALRL)中的数值等于（CNTH+CNTL）中的数值时，触发闹钟事件。在”rtc.c“中的“MX_RTC_Init”函数的。闹钟：高：ALRH;
XHSC 小华 HC32L170
最新发布
July692的博客
04-30 119
⚫ HC32L170/ HC32L176系列具有灵活的功耗管理系统，超低功耗性能 – 0.6μA @ 3V深度休眠模式：所有时钟关闭，上电复位有效，IO状态保持，IO中断有效，所有寄存器、RAM和CPU数据保存状态时的功耗 – 1.0μA @3V深度休眠模式+ RTC工作 – 8μA @32.768KHz低速工作模式：CPU运行，外设关闭，从Flash运行程序 – 30μA/MHz@3V@24MHz休眠模式：CPU停止，外设关闭，主时钟运行 – 130μA/MHz@3V@24MHz工作模式：CPU
STM32RTC唤醒功能配置（基于LL库）
久久的学习之路
05-08 3230
/* * 函数名称: RTC_Wake_Init * 函数说明: RTC唤醒初始化（需要在时钟初始化中打开LSE） * 输入参数: 无 * 返回参数: 无 */ void RTC_Wake_Init(void) { /* 设置RTC时钟源 */ LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSE); /* 使能RTC时钟 */ LL_RCC_EnableRTC(); /* 失能RTC写保护 */ LL_RTC_Disabl.
STM32F030R8 LL库 配置 RTC亚秒中断
edanLee的博客
04-24 1531
用STM32CubeMX 配置好RTC 因为用的是LL库，生成的代码并不完整。关于中断只有两行代码. /* RTC interrupt Init */ NVIC_SetPriority(RTC_IRQn, 0); NVIC_EnableIRQ(RTC_IRQn); 这样是不可以使用的。 需要增加以下代码： MX_RTC_Init(void) { /* USER C...
华大半导体HC32F17x-19x HC32L17x-19x HC32L072-073系列MCU芯片ALTIUM原理图库文件
04-06
华大半导体HC32F17x-19x HC32L17x-19x HC32L072-073系列MCU芯片ALTIUM原理图库文件： HC32F170-LQFP48 HC32F170-LQFP52 HC32F170-QNF32 HC32F170-QNF32_1 HC32F176-LQFP100 HC32F176-LQFP48 HC32F176-LQFP64 HC32...
国产MCU华大半导体HC32L17x系列单片机软硬件设计SDK资料包参考设计原理图应用笔记等资料.zip
11-11
国产MCU华大半导体HC32L17x系列单片机软硬件设计SDK资料包参考设计原理图应用笔记等资料: HC32L176_L170系列数据手册Rev1.3.pdf HC32L17X_L19X管脚功能查询及配置.xlsx HC32L17_L19_F17_F19系列勘误手册.pdf HC32L17...
HC32L17X_L19X_F17X_F19X系列用户手册v1.11
08-03
本手册是华大半导体为开发者提供的关于HC32L17X、HC32L19X、HC32F17X和HC32F19X系列32位ARM Cortex-M0+微控制器的操作指南。这些微控制器以其超低功耗特性而设计，适用于需要高效能和节能的应用场景。 一、产品特性...
IAR环境下V01_hc32l17x_template【FreeRTOS裸机项目工程】.zip
08-17
IAR8.32.1环境下移植ok的HC32L176MATA+FreeRTOS 的demo程序，自测ok
RTC&Time;时间戳
05-21
RTC&Time;时间戳
华大半导体HC32L110系列国产MCU软硬件设计SDK资料包参考设计原理图软件驱动库及样例.zip
11-11
华大半导体HC32L110系列国产MCU软硬件设计SDK资料包参考设计原理图软件驱动库及样例： 1.用户手册和数据手册 2. 产品变更通知 3. 环境相关 HC32L110_HC32F003_HC32F005系列的MCU开发工具用户手册Rev1.0.pdf MCU封装库及Demo板参考原理图 仿真及编程工具 应用注意事项 应用笔记 最小开发工程模板 集成开发环境支持包 驱动库及样例 ADVANCED_TIMER模块Rev1.2.pdf FLASH操作说明Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的ADC误差分析及校准方法Rev1.1.pdf HC32L110_HC32F003_HC32F005系列的BASE_TIMER Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的CRC Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的GPIO模块Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的LVD Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的UART和LPUART模块Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的VC Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的内部RC时钟Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的时钟控制模块Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的特殊端口使用及注意事项说明Rev1.0.pdf HC32L110_HC32F003_HC32F005系列的系统时钟异常切换Rev1.0.pdf HC32L110_HC32F003_HC32F005系列硬件开发指南Rev1.0.pdf HC32L110系列的RTC硬件补偿算法Rev1.0.pdf HC32L110系列的XTL Layout指导说明Rev1.0.pdf HC32L110系列的工作模式Rev1.0.pdf HC32Lxxx系列的RTC模块Rev1.1.pdf MCU低功耗模式调试说明Rev1.0.pdf RCH特殊频率校准方法Rev1.0.pdf
STM32 LL库RTC秒中断
01-25 638
STM32 LL库RTC秒中断设置，主要是预分频器要设置对。
HC32L17x的LL驱动库之GPIO
childboy的博客
12-02 494
#define FLASH_BASE 0x00000000U #define FLASH_END 0x0001FFFFU #define FLASH_BANK1_END 0x0001FFFFU #define SRAM_BASE 0x20000000U #define SRAM_ENDsss 0x20003FFFU #define PERIPH_BASE
HC32L17x的LL驱动库之rng
Haiguozhe的博客
02-26 184
【代码】HC32L17x的LL驱动库之rng。
HC32L17x的LL驱动库之aes
Haiguozhe的博客
05-11 168
#ifndef HC32L1XX_LL_AES_H_ #define HC32L1XX_LL_AES_H_ //////////////////////////////////////////////////////////////////////////////////////////// #ifdef __cplusplus extern "C" { #endif ///////////////////////////////////////////////////////////////////.
STM32L053基于LL库、HAL库两种库RTC闹钟唤醒
火红色祥云
08-16 2266
L053RTC时钟唤醒，LL库和HAL库
STM32F1单片机使用HAL库和LL库共同开发RTC实时时钟，解决待机模式24小时日期不变的问题
X_X_Smile的博客
10-17 991
STM32F1使用HAL库和LL库共同解决RTC时钟24小时待机模式后年月日正常。
hc32l17x boot
09-10
HC32L17xx是华大智能运算芯片系列产品中的一员。它是一款高性能、低功耗的单片机集成电路，适用于各种消费电子、工控、仪器仪表、智能家居等领域的应用开发。 HC32L17xx的引导（boot）过程是指单片机在上电或复位后，执行一段特定的程序，用于初始化各个外设和寄存器，并加载用户程序或操作系统。在集成电路中，引导过程非常重要，它能确保系统正常启动并能够顺利执行用户的应用程序。 HC32L17xx的引导过程一般包括以下几个步骤： 1. 上电复位：当芯片上电或复位时，所有寄存器和外设都会被初始化，确保系统处于一个可控的初始状态。 2. 时钟配置：根据系统需求，需要设置CPU时钟和外设时钟的频率和工作模式。 3. 外设初始化：根据具体应用的需要，需要初始化各个外设，如GPIO、UART、SPI等。 4. 加载用户程序：当所有外设初始化完成后，可以将用户程序从外部存储器中加载到内部存储器，并跳转到用户程序的入口地址开始执行。 HC32L17xx提供了丰富的开发工具和参考资料，如集成开发环境、编译工具链、用户手册等，可以帮助开发者快速上手并进行应用开发。通过合理的引导和配置，可以充分发挥HC32L17xx的性能优势，实现各种功能需求，并确保系统的稳定性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值