FR8008GP-U RTC例程有没有?



  • FR8008GP-U RTC例程有没有?



  • 0_1787644286262_6eef0dac-8e35-4b2b-9edc-c90dba0f38c1-19c6922a430e8bfa185f50b08a9c4047.png

    RTC.c驱动部分

    
    /*
      ******************************************************************************
      * @file    driver_rtc.c
      * @author  FreqChip Firmware Team
      * @version V1.0.0
      * @date    2021
      * @brief   rtc module driver.
      *          This file provides firmware functions to manage the 
      *          Real Time Clock (RTC) peripheral
      ******************************************************************************
      * @attention
      *
      * Copyright (c) 2021 FreqChip.
      * All rights reserved.
      ******************************************************************************
    */
    #include "driver_rtc.h"
    
    str_Time_t AlarmTime_A;
    str_Time_t AlarmTime_B;
    
    /*********************************************************************
     * @fn      rtc_GetCount
     *
     * @brief   Get rtc current counter value
     *
     * @param   None.
     * @return  None.
     */
    void rtc_init(void)
    {
        uint8_t lu8_TempValue;
    
        /* RTC clock enable */
        lu8_TempValue = ool_read(PMU_REG_CLK_EN);
    
        ool_write(PMU_REG_CLK_EN, lu8_TempValue | PMU_RTC_CLK_EN);
    
        /* RTC Reset disable */
        lu8_TempValue = ool_read(PMU_REG_RST_CTRL);
    
        ool_write(PMU_REG_RST_CTRL, lu8_TempValue & ~PMU_RTC_SFT_RST);
    }
    
    /*********************************************************************
     * @fn      rtc_AlarmConfig
     *
     * @brief   rtc alarm config
     *
     * @param   fe_Alarm:   alarm select.
                lu8_hour:   hour
                lu8_Minute: minute
                lu8_Second: second
     * @return  None.
     */
    void rtc_AlarmConfig(e_alarm_t fe_Alarm, uint32_t fu32_hour, uint32_t fu32_Minute, uint32_t fu32_Second)
    {
        uint32_t lu32_Second;
    
        lu32_Second  = fu32_hour * 3600;
        lu32_Second += fu32_Minute * 60;
        lu32_Second += fu32_Second;
    
        switch (fe_Alarm)
        {
            case AlARM_A: 
            {
                /* Timing backup */
                if (AlarmTime_A.FirstBackup == 0)
                    AlarmTime_A.FirstBackup = lu32_Second;
    
                AlarmTime_A.CycleBackup = lu32_Second;
                
                /* Convert to count value */
                lu32_Second *= pmu_get_rc_clk(false);
                lu32_Second += rtc_GetCount();
        
                pmu_enable_isr(PMU_RTC_ALMA_INT_EN);
    
                ool_pd_write32(PMU_REG_PD_RTC_ALARMA_CNT_0, lu32_Second);
    
                rtc_AlarmEnable(AlARM_A);
            }break;
    
            case AlARM_B: 
            {
                /* Timing backup */
                if (AlarmTime_B.FirstBackup == 0)
                    AlarmTime_B.FirstBackup = lu32_Second;
    
                AlarmTime_B.CycleBackup = lu32_Second;
                
                /* Convert to count value */
                lu32_Second *= pmu_get_rc_clk(false);
                lu32_Second += rtc_GetCount();
    
                pmu_enable_isr(PMU_RTC_ALMB_INT_EN);
    
                ool_pd_write32(PMU_REG_PD_RTC_ALARMB_CNT_0, lu32_Second);
    
                rtc_AlarmEnable(AlARM_B);
            }break;
    
            default: break; 
        }
    }
    
    /*********************************************************************
     * @fn      rtc_GetCount
     *
     * @brief   Get rtc current counter value
     *
     * @param   None.
     * @return  lu32_CountValue: rtc current counter value.
     */
    uint32_t rtc_GetCount(void)
    {
        uint32_t lu32_CountValue;
    
        lu32_CountValue = ool_pd_read32(PMU_REG_PD_RTC_UPD_CNT_0);
        
        return lu32_CountValue;
    }
    
    /*********************************************************************
     * @fn      rtc_CountUpdate
     *
     * @brief   Update RTC counter
     *
     * @param   fu32_Count: update value.
     * @return  None.
     */
    void rtc_CountUpdate(uint32_t fu32_Count)
    {
        uint8_t lu8_TempValue;
        
        ool_pd_write32(PMU_REG_PD_RTC_ALARMA_CNT_0, fu32_Count);
    
        lu8_TempValue = ool_pd_read(PMU_REG_PD_RTC_CTRL);
    
        ool_pd_write(PMU_REG_PD_RTC_CTRL, lu8_TempValue |  PMU_RTC_UPD_EN);
        ool_pd_write(PMU_REG_PD_RTC_CTRL, lu8_TempValue & ~PMU_RTC_UPD_EN);
    
        AlarmTime_A.FirstBackup = 0;
        AlarmTime_B.FirstBackup = 0;
    }
    
    /*********************************************************************
     * @fn      rtc_AlarmUpdate
     *
     * @brief   rtc alarm Update. 
     *          Update according to the periodic period in the rtc_AlarmConfig function.
     *
     * @param   fe_Alarm:   alarm select.
     */
    void rtc_AlarmUpdate(e_alarm_t fe_Alarm)
    {
        uint32_t lu32_AddValue;
        uint32_t lu32_AlarmValue;
    
        /* Convert to count value */
        if (fe_Alarm == AlARM_A)
            lu32_AddValue = AlarmTime_A.FirstBackup * pmu_get_rc_clk(false);
        else
            lu32_AddValue = AlarmTime_B.FirstBackup * pmu_get_rc_clk(false);
    
        lu32_AlarmValue = rtc_AlarmRead(fe_Alarm);
    
        lu32_AlarmValue += lu32_AddValue;
    
        rtc_AlarmSet(fe_Alarm, lu32_AlarmValue);
    }
    
    /*********************************************************************
     * @fn      rtc_ClockEnable
     *
     * @brief   RTC clock enable
     */
    void rtc_ClockEnable(void)
    {
        uint8_t lu8_TempValue;
        
        /* RTC clock enable */
        lu8_TempValue = ool_read(PMU_REG_CLK_EN);
        ool_write(PMU_REG_CLK_EN, lu8_TempValue | PMU_RTC_CLK_EN);
    }
    
    /*********************************************************************
     * @fn      rtc_ClockDisable
     *
     * @brief   RTC clock disable
     */
    void rtc_ClockDisable(void)
    {
        uint8_t lu8_TempValue;
        
        /* RTC clock enable */
        lu8_TempValue = ool_read(PMU_REG_CLK_EN);
        ool_write(PMU_REG_CLK_EN, lu8_TempValue & ~PMU_RTC_CLK_EN);
    }
    
    /*********************************************************************
     * @fn      rtc_ResetEnable
     *
     * @brief   RTC reset enable
     */
    void rtc_ResetEnable(void)
    {
        uint8_t lu8_TempValue;
    
        /* RTC Reset disable */
        lu8_TempValue = ool_read(PMU_REG_RST_CTRL);
        ool_write(PMU_REG_RST_CTRL, lu8_TempValue | PMU_RTC_SFT_RST);
    }
    
    /*********************************************************************
     * @fn      rtc_ResetDisable
     *
     * @brief   RTC reset disable
     */
    void rtc_ResetDisable(void)
    {
        uint8_t lu8_TempValue;
        
        /* RTC Reset disable */
        lu8_TempValue = ool_read(PMU_REG_RST_CTRL);
        ool_write(PMU_REG_RST_CTRL, lu8_TempValue & ~PMU_RTC_SFT_RST);
    }
    
    /*********************************************************************
     * @fn      rtc_AlarmEnable
     *
     * @brief   Alarm Enable
     */
    void rtc_AlarmEnable(e_alarm_t fe_Alarm)
    {
        uint8_t lu8_TempValue;
    
        /* RTC Alarm Enable */
        lu8_TempValue = ool_pd_read(PMU_REG_PD_RTC_CTRL);
        ool_pd_write(PMU_REG_PD_RTC_CTRL, lu8_TempValue | fe_Alarm);
    } 
    
    /*********************************************************************
     * @fn      rtc_ALarmDisable
     *
     * @brief   Alarm Disable
     */
    void rtc_AlarmDisable(e_alarm_t fe_Alarm)
    {
        uint8_t lu8_TempValue;
    
        /* RTC Alarm Disable */
        lu8_TempValue = ool_pd_read(PMU_REG_PD_RTC_CTRL);
        ool_pd_write(PMU_REG_PD_RTC_CTRL, lu8_TempValue & ~fe_Alarm);
    }
    
    /*********************************************************************
     * @fn      rtc_AlarmRead
     *
     * @brief   read rtc alarm config value
     *
     * @param   None.
     * @return  lu32_ConfigValue: alarm config value.
     */
    uint32_t rtc_AlarmRead(e_alarm_t fe_Alarm)
    {
        uint32_t lu32_ConfigValue;
    
        switch (fe_Alarm)
        {
            case AlARM_A: 
            {
                lu32_ConfigValue  = ool_pd_read32(PMU_REG_PD_RTC_ALARMA_CNT_0);
            }break;
    
            case AlARM_B: 
            {
                lu32_ConfigValue  = ool_pd_read32(PMU_REG_PD_RTC_ALARMB_CNT_0);
            }break;
    
            default: break; 
        }
        
        return lu32_ConfigValue;
    }
    
    /*********************************************************************
     * @fn      rtc_AlarmSet
     *
     * @brief   Set rtc alarm config value
     *
     * @param   None.
     * @return  lu32_ConfigValue: alarm config value.
     */
    void rtc_AlarmSet(e_alarm_t fe_Alarm, uint32_t fu32_ConfigValue)
    {
        switch (fe_Alarm)
        {
            case AlARM_A: 
            {
                ool_pd_write32(PMU_REG_PD_RTC_ALARMA_CNT_0, fu32_ConfigValue);
            }break;
    
            case AlARM_B: 
            {
                ool_pd_write32(PMU_REG_PD_RTC_ALARMB_CNT_0, fu32_ConfigValue);
            }break;
        }
    }
    
    /*********************************************************************
     * @fn      rtc_AlarmHandler
     *
     * @brief   Alarm interrupt handler 
     */
    __attribute__((section("ram_code"))) void rtc_AlarmHandler(void)
    {
        if (pmu_get_isr_state() & PMU_RTC_ALMA_INT_STATUS) 
        {
            pmu_clear_isr_state(PMU_RTC_ALMA_INT_CLR);
    
            /* Update according to the periodic period in the rtc_AlarmConfig function. */
            rtc_AlarmUpdate(AlARM_A);
        }
        else if (pmu_get_isr_state() & PMU_RTC_ALMB_INT_STATUS) 
        {
            pmu_clear_isr_state(PMU_RTC_ALMB_INT_CLR);
    
            /* Update according to the periodic period in the rtc_AlarmConfig function. */
            rtc_AlarmUpdate(AlARM_B);
        }
    }