HVAC_M7
/
PeripheralDriver_Flagchip_FC7240_V2
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
PeripheralDriver_Flagchip_F.../Src/module_driver_rtc.c

541 lines
15 KiB
C
Raw Permalink Blame History

/**
* @file module_driver_rtc.c
* @author Flagchip
* @brief rtc driver type definition and API
* @version 2.0.0
* @date 2024-08-20
*
* SDK Version: 2.6.0
*
* @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd.
*
* @details
*/
/********************************************************************************
* Revision History:
*
* Version Date Initials CR# Descriptions
* --------- ---------- ------------ ---------- ---------------
* 0.2.0 2022-2-7 Flagchip076 N/A First version for FC7300
* 2.0.0 2024-8-13 HowardWang N/A Vesion 2.0
********************************************************************************/
#include "module_driver_rtc.h"
#if RTC_INSTANCE_COUNT > 0U
#include "module_driver_csc.h"
#ifndef RTC_DEV_ERROR_REPORT
#define RTC_DEV_ERROR_REPORT STD_OFF
#endif
#if RTC_DEV_ERROR_REPORT == STD_ON
#define RTC_ReportDevError(func, error) ReportDevError(RTC_MODULE_ID, func, error)
#endif
/********* Local variable ************/
static RTC_Type * const s_pRtcBasePtrs[RTC_INSTANCE_COUNT] = RTC_BASE_PTRS;
/* Table of month length (in days) for the Common-year*/
static const uint8_t ComYear[] = {0U, 31U, 28U, 31U, 30U, 31U, 30U, 31U, 31U, 30U, 31U, 30U, 31U};
/* Table of month length (in days) for the Leap-year*/
static const uint8_t LeapYear[] = {0U, 31U, 29U, 31U, 30U, 31U, 30U, 31U, 31U, 30U, 31U, 30U, 31U};
static bool RTC_IsLeapYear(uint16_t u16Year)
{
bool bYearLeap = false;
if ((u16Year % 4U) > 0U)
{
bYearLeap = false;
}
else if ((u16Year % 100U) > 0U)
{
bYearLeap = true;
}
else if ((u16Year % 400U) > 0U)
{
bYearLeap = false;
}
else
{
bYearLeap = true;
}
/* Return the exit code */
return bYearLeap;
}
static bool RTC_CheckTimeDate(const RTC_TimeDate * const pTimeDate)
{
bool bCheckReturn = true;
const uint8_t * pMonth;
pMonth = RTC_IsLeapYear(pTimeDate->u16Year) ? LeapYear : ComYear;
if (pTimeDate->u16Year < START_YEAR || pTimeDate->u16Year > END_YEAR
|| pTimeDate->u8Month < 1U || pTimeDate->u8Month > 12U
|| pTimeDate->u8Day < 1U || pTimeDate->u8Day > pMonth[pTimeDate->u8Month]
|| pTimeDate->u8Hour >= 24
|| pTimeDate->u8Minute >= 60
|| pTimeDate->u8Second >= 60)
{
bCheckReturn = false;
}
return bCheckReturn;
}
static void RTC_TimeDate_To_Second(RTC_TimeDate * const pTimeDate, uint32_t u32Second)
{
uint32_t u32CountDays;
uint32_t u32TempCount;
uint32_t u32TempDays;
u32CountDays = u32Second / SECONDS_DAY;
u32TempCount = u32Second % SECONDS_DAY;
pTimeDate->u8Hour = (uint8_t)(u32TempCount / SECONDS_HOUR);
u32TempCount = u32TempCount % SECONDS_HOUR;
pTimeDate->u8Minute = (uint8_t)(u32TempCount / SECONDS_MINUTE);
pTimeDate->u8Second = (uint8_t)(u32TempCount % SECONDS_MINUTE);
pTimeDate->u16Year = (uint16_t)START_YEAR;
u32TempDays = DAYS_COM_YEAR;
while (u32CountDays >= u32TempDays)
{
pTimeDate->u16Year++;
u32CountDays -= u32TempDays;
u32TempDays = (RTC_IsLeapYear(pTimeDate->u16Year)) ? DAYS_LEAP_YEAR : DAYS_COM_YEAR;
}
u32CountDays += 1;
for (uint8_t u8TempMonth = 1; u8TempMonth <= 12; u8TempMonth++)
{
u32TempCount = (RTC_IsLeapYear(pTimeDate->u16Year)) ? (uint32_t)LeapYear[u8TempMonth] : (uint32_t)ComYear[u8TempMonth];
if (u32CountDays <= u32TempCount)
{
pTimeDate->u8Month = (uint8_t)u8TempMonth;
pTimeDate->u8Day = (uint8_t)u32CountDays;
break;
}
else
{
u32CountDays -= u32TempCount;
}
}
}
static uint32_t RTC_Second_To_TimeDate(const RTC_TimeDate * const pTimeDate)
{
uint32_t u32Second;
uint32_t u32TempDay;
u32Second = (pTimeDate->u16Year - START_YEAR) * SECONDS_DAY * DAYS_COM_YEAR;
for (uint32_t u32TempYear = START_YEAR; u32TempYear < pTimeDate->u16Year; u32TempYear++)
{
if (RTC_IsLeapYear((uint16_t)u32TempYear))
{
u32Second += SECONDS_DAY;
}
}
for (uint8_t u8TempMonth = 1; u8TempMonth < pTimeDate->u8Month; u8TempMonth++)
{
u32TempDay = (RTC_IsLeapYear(pTimeDate->u16Year)) ? (uint32_t)LeapYear[u8TempMonth] : (uint32_t)ComYear[u8TempMonth];
u32Second += (u32TempDay * SECONDS_DAY);
}
u32Second += ((uint32_t)((pTimeDate->u8Day - 1U) * SECONDS_DAY) + \
pTimeDate->u8Hour * SECONDS_HOUR + \
pTimeDate->u8Minute * SECONDS_MINUTE + \
pTimeDate->u8Second);
return u32Second;
}
/**
* @brief Initialize Rtc instance
*
* @param pRtcHandle the RTC instance
* @param pInitStruct Rtc initialization structure
* @note This function could only write once after POR.
*/
void RTC_Init(RTC_HandleType* pRtcHandle, const RTC_InitType *const pInitStruct)
{
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
#if RTC_DEV_ERROR_REPORT == STD_ON
uint32_t u32RtcClockFrequency = 0U;
bool bCSC0ClockValid = CSC0_GetCSC0ClockFreq(CSC0_RTC_CLK, &u32ClockFreq);
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_INIT_ID, RTC_E_PARAM_INSTANCE);
}
else if (NULL == pInitStruct)
{
RTC_ReportDevError(RTC_INIT_ID, RTC_E_PARAM_POINTER);
}
else if (false == bCSC0ClockValid)
{
RTC_ReportDevError(RTC_INIT_ID, RTC_E_PARAM_CLOCK);
}
else if (0U == u32RtcClockFrequency)
{
RTC_ReportDevError(RTC_INIT_ID, RTC_E_PARAM_CLOCK);
}
else
{
#endif
/* Disable interrupt */
RTC_HWA_DisableOverflowInterrupt(pRtc);
/*Disable Second interrupt*/
RTC_HWA_DisableSecondInterrupt(pRtc);
/*Disable Alarm interrupt*/
RTC_HWA_DisableAlarmInterrupt(pRtc);
/* disable the rtc clock*/
RTC_HWA_DisableRtcCounter(pRtc);
/* clear PR register */
RTC_HWA_SetPrescalerCounterValue(pRtc, 0U);
/* clear CR register */
RTC_HWA_ConfigControl(pRtc, 0U);
if (pInitStruct->bStableClkoutFreq)
{
RTC_HWA_SetClkoutFreqStable(pRtc);
}
else
{
RTC_HWA_SetClkoutFromSelectFreq(pRtc);
}
/* TSIC should only be altered when TSIE is clear */
RTC_HWA_SetSecondAndClkoutFreq(pRtc, pInitStruct->eSecIntAndClkoutFreq);
/* Set alarm value */
RTC_HWA_SetAlarmCounterValue(pRtc, pInitStruct->u32AlarmValue - (uint32_t)1U);
/* save alarm value */
pRtcHandle->u32AlarmValue = pInitStruct->u32AlarmValue;
/* disable the rtc timer */
RTC_HWA_DisableRtcCounter(pRtc);
/* enable alarm interrupt */
RTC_HWA_EnableAlarmInterrupt(pRtc, pInitStruct->bAlarmIntEn);
/* enable overflow interrupt */
RTC_HWA_EnableOverflowInterrupt(pRtc, pInitStruct->bOverflowIntEn);
/* enable second interrupt */
RTC_HWA_EnableSecondInterrupt(pRtc, pInitStruct->bSecondIntEn);
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
/**
* @brief De-initialize Rtc instance
*
*/
void RTC_Deinit(RTC_HandleType* pRtcHandle)
{
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_DEINIT_ID, RTC_E_PARAM_INSTANCE);
}
else
{
#endif
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
/* disable the rtc timer */
RTC_HWA_DisableRtcCounter(pRtc);
/* clear PR register */
RTC_HWA_SetPrescalerCounterValue(pRtc, 0U);
/* clear SR register */
RTC_HWA_SetSecondCounterValue(pRtc, 0U);
/* clear TAR register */
RTC_HWA_SetAlarmCounterValue(pRtc, 0U);
/* clear IER register */
RTC_HWA_SetInterruptValue(pRtc, 0U);
/* clear CR register */
RTC_HWA_ConfigControl(pRtc, 0U);
pRtcHandle->tSettings.pAlarmCallback = NULL;
pRtcHandle->tSettings.pSecondCallback = NULL;
pRtcHandle->tSettings.pOverflowCallback = NULL;
__NVIC_DisableIRQ(RTC0_IRQn);
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
/**
* @brief rtc start
*
*/
void RTC_Start(RTC_HandleType* pRtcHandle)
{
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_START_ID, RTC_E_PARAM_INSTANCE);
}
else
{
#endif
/*enable the rtc clock*/
RTC_HWA_EnableRtcCounter(pRtc);
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
/**
* @brief Rtc stop
*
*/
void RTC_Stop(RTC_HandleType* pRtcHandle)
{
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_STOP_ID, RTC_E_PARAM_INSTANCE);
}
else
{
#endif
/*disable the rtc clock*/
RTC_HWA_DisableRtcCounter(pRtc);
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
/**
* @brief set count value
*
*/
void RTC_SetCountValue(RTC_HandleType* pRtcHandle, const uint32_t u32CounetValue)
{
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_SET_COUNT_ID, RTC_E_PARAM_INSTANCE);
}
else
{
#endif
/*disable the rtc clock*/
RTC_HWA_DisableRtcCounter(pRtc);
/* Set count value */
RTC_HWA_SetSecondCounterValue(pRtc, u32CounetValue);
/*enable the rtc clock*/
RTC_HWA_EnableRtcCounter(pRtc);
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
/**
* @brief Rtc alarm value
*
* @param u32AlarmValue Input value
*/
void RTC_UpdateAlarmValue(RTC_HandleType* pRtcHandle, const uint32_t u32AlarmValue)
{
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_UPDATE_ALARM_ID, RTC_E_PARAM_INSTANCE);
}
else
{
#endif
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
/*disable the rtc clock*/
RTC_HWA_DisableRtcCounter(pRtc);
/* clear PR register */
RTC_HWA_SetPrescalerCounterValue(pRtc, 0U);
/* Set alarm value */
RTC_HWA_SetAlarmCounterValue(pRtc, RTC_HWA_ReadSecondValue(pRtc) + u32AlarmValue - (uint32_t)1U);
pRtcHandle->u32AlarmValue = u32AlarmValue;
/*enable the rtc clock*/
RTC_HWA_EnableRtcCounter(pRtc);
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
/**
* @brief Check RTC overflow flag
*
* @return Overflow flag
*/
uint32_t RTC_CheckOverflowFlag(RTC_HandleType* pRtcHandle)
{
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_CHECK_OVERFLOW_FLAF_ID, RTC_E_PARAM_INSTANCE);
}
else
{
#endif
return RTC_HWA_ReadOverflowFlag(pRtc);
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
/**
* @brief Get time and date
*
*/
void RTC_GetTimeDate(RTC_HandleType* pRtcHandle, RTC_TimeDate * const pTimeDate)
{
uint32_t u32Second;
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_GET_TIMEDATE_ID, RTC_E_PARAM_INSTANCE);
}
#endif
u32Second = RTC_HWA_ReadSecondValue(pRtc);
RTC_TimeDate_To_Second(pTimeDate, u32Second);
}
/**
* @brief Set time and date
*
*/
void RTC_SetTimeDate(RTC_HandleType* pRtcHandle, const RTC_TimeDate * const pTimeDate)
{
uint32_t u32Second;
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_SET_TIMEDATE_ID, RTC_E_PARAM_INSTANCE);
}
else if (NULL == pTimeDate)
{
RTC_ReportDevError(RTC_SET_TIMEDATE_ID, RTC_E_PARAM_POINTER);
}
#endif
if (true == RTC_CheckTimeDate(pTimeDate))
{
u32Second = RTC_Second_To_TimeDate(pTimeDate);
RTC_SetCountValue(pRtcHandle, u32Second);
}
#if RTC_DEV_ERROR_REPORT == STD_ON
else
{
RTC_ReportDevError(RTC_SET_TIMEDATE_ID, RTC_E_PARAM_FORMAT);
}
#endif
}
/**
* @brief Get time and date compensation information.
*
*/
void RTC_GetCompensation(RTC_HandleType* pRtcHandle, RTC_Compensation * const pCompensation)
{
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_GET_COMPENSATION_ID, RTC_E_PARAM_INSTANCE);
}
#endif
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
pCompensation->u8Interval = (uint8_t)(RTC_HWA_ReadCompInterval(pRtc));
pCompensation->u8Value = (uint8_t)(RTC_HWA_ReadCompValue(pRtc));
}
/**
* @brief Set time and date compensation value.
*
*/
void RTC_SetCompensation(RTC_HandleType* pRtcHandle, const RTC_Compensation * const pCompensation)
{
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RRTC_SET_COMPENSATION_ID, RTC_E_PARAM_INSTANCE);
}
else if (NULL == pCompensation)
{
RTC_ReportDevError(RTC_SET_COMPENSATION_ID, RTC_E_PARAM_POINTER);
}
#endif
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
RTC_HWA_SetCompInterval(pRtc, pCompensation->u8Interval);
RTC_HWA_SetCompValue(pRtc, pCompensation->u8Interval);
}
/**
* @brief RTC common interrupt function
*
* @param eIntEvent RTC interrupt event
*/
void Rtc_CommonProcessInterrupt(RTC_HandleType* pRtcHandle)
{
RTC_Type * const pRtc = s_pRtcBasePtrs[pRtcHandle->eInstance];
#if RTC_DEV_ERROR_REPORT == STD_ON
if ((uint32_t)pRtcHandle->eInstance >= RTC_INSTANCE_COUNT)
{
RTC_ReportDevError(RTC_INTE_PROC_ID, RTC_E_PARAM_INSTANCE);
}
else
{
#endif
if ((RTC_HWA_ReadOverflowFlag(pRtc)) && (RTC_HWA_ReadOverflowEnable(pRtc)))
{
/*enable the rtc clock*/
RTC_HWA_DisableRtcCounter(pRtc);
/* Set time counter value */
RTC_HWA_SetSecondCounterValue(pRtc, 0u);
/*enable the rtc clock*/
RTC_HWA_EnableRtcCounter(pRtc);
if (NULL != pRtcHandle->tSettings.pOverflowCallback)
{
pRtcHandle->tSettings.pOverflowCallback(pRtcHandle);
}
}
else if ((RTC_HWA_ReadAlarmFlag(pRtc)) && (RTC_HWA_ReadAlarmEnable(pRtc)))
{
if (NULL != pRtcHandle->tSettings.pAlarmCallback)
{
pRtcHandle->tSettings.pAlarmCallback(pRtcHandle);
}
uint32_t u32CountValue = RTC_HWA_ReadSecondValue(pRtc);
/* Set alarm value */
RTC_HWA_SetAlarmCounterValue(pRtc, u32CountValue + pRtcHandle->u32AlarmValue - 1U);
}
else
{
if (NULL != pRtcHandle->tSettings.pSecondCallback)
{
pRtcHandle->tSettings.pSecondCallback(pRtcHandle);
}
}
#if RTC_DEV_ERROR_REPORT == STD_ON
}
#endif
}
#endif
Reference in New Issue View Git Blame Copy Permalink