/**
* @brief Update RTC Current Time
*
* @param[in] u32Hour The hour time digit of current RTC setting.
* @param[in] u32Minute The minute time digit of current RTC setting.
* @param[in] u32Second The second time digit of current RTC setting.
* @param[in] u32TimeMode The 24-Hour / 12-Hour Time Scale Selection. [RTC_CLOCK_12 / RTC_CLOCK_24]
* @param[in] u32AmPm 12-hour time scale with AM and PM indication. Only Time Scale select 12-hour used. [RTC_AM / RTC_PM]
*
* @return None
*
* @details This API is used to update current time to RTC.
*/
void RTC_SetTime(uint32_t u32Hour, uint32_t u32Minute, uint32_t u32Second, uint32_t u32TimeMode, uint32_t u32AmPm)
{
uint32_t u32RegTIME;
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
/* Important, range of 12-hour PM mode is 21 up to 32 */
if((u32TimeMode == (uint32_t)RTC_CLOCK_12) && (u32AmPm == (uint32_t)RTC_PM))
{
u32Hour += 20UL;
}
u32RegTIME = ((u32Hour / 10UL) << 20);
u32RegTIME |= ((u32Hour % 10UL) << 16);
u32RegTIME |= ((u32Minute / 10UL) << 12);
u32RegTIME |= ((u32Minute % 10UL) << 8);
u32RegTIME |= ((u32Second / 10UL) << 4);
u32RegTIME |= (u32Second % 10UL);
/*-----------------------------------------------------------------------------------------------------*/
/* Set RTC 24/12 hour setting and Day of the Week */
/*-----------------------------------------------------------------------------------------------------*/
RTC_WaitAccessEnable();
if(u32TimeMode == (uint32_t)RTC_CLOCK_12)
{
pRTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;
}
else
{
pRTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;
}
RTC_WaitAccessEnable();
pRTC->TIME = (uint32_t)u32RegTIME;
}
/**
* @brief Update RTC Alarm Date
*
* @param[in] u32Year The year calendar digit of RTC alarm setting.
* @param[in] u32Month The month calendar digit of RTC alarm setting.
* @param[in] u32Day The day calendar digit of RTC alarm setting.
*
* @return None
*
* @details This API is used to update alarm date setting to RTC.
*/
void RTC_SetAlarmDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day)
{
uint32_t u32RegCAR;
u32RegCAR = ((u32Year - RTC_YEAR2000) / 10) << 20;
u32RegCAR |= (((u32Year - RTC_YEAR2000) % 10) << 16);
u32RegCAR |= ((u32Month / 10) << 12);
u32RegCAR |= ((u32Month % 10) << 8);
u32RegCAR |= ((u32Day / 10) << 4);
u32RegCAR |= (u32Day % 10);
RTC_WaitAccessEnable();
/* Set RTC Alarm Date */
RTC->CAR = (uint32_t)u32RegCAR;
}
/**
* @brief Set 32k Frequency Compensation Data
*
* @param[in] i32FrequencyX100 Specify the RTC clock X100, ex: 3277365 means 32773.65.
*
* @return None
*
* @details This API is used to compensate the 32 kHz frequency by current LXT frequency for RTC application.
*/
void RTC_32KCalibration(int32_t i32FrequencyX100)
{
int32_t i32RegInt, i32RegFra;
/* Compute integer and fraction for RTC FCR register */
i32RegInt = (i32FrequencyX100 / 100) - RTC_FCR_REFERENCE;
i32RegFra = (((i32FrequencyX100 % 100)) * 60) / 100;
/* Judge Integer part is reasonable */
if((i32RegInt < 0) | (i32RegInt > 15))
{
return ;
}
RTC_WaitAccessEnable();
RTC->FCR = (uint32_t)((i32RegInt << 8) | i32RegFra);
}
/*---------------------------------------------------------------------------------------------------------*/
void RTC_TickInterruptTest(void)
{
printf("# Set RTC Tick Interrupt Period Time is 1/8 second. \n");
printf("# Use TIMER0 One-Shot mode to gererate interrupt event after 2 second, \n");
printf(" and the RTC Tick Interrupt counts should be 16. \n");
printf("Press any key to start test ... \n\n");
getchar();
/* Configure TIMER0 clock source as 12 MHz, run in One-Shot mode */
_TIMER_RESET(TIMER0);
TIMER0->TCMPR = __XTAL;
/* Wait RTC Register Access Enable */
RTC_WaitAccessEnable();
/* Enable RTC NVIC */
NVIC_EnableIRQ(RTC_IRQn);
/* Set RTC tick period time 1/8 sec */
_RTC_SET_TTR(RTC_TTR_1DIV8);
/* Enable RTC tick interrupt */
_RTC_TICK_INT_ENABLE();
g_u32RTCTickINT = 0;
/* Start TIMER0 counting */
TIMER0->TCSR = TIMER_TCSR_CEN_Msk | TIMER_TCSR_MODE_ONESHOT | TIMER_TCSR_TDR_EN_Msk | TIMER_TCSR_PRESCALE(2);
/* Wait TIMER0 Compare Match Interrupt Flag then show current RTC Date/Time */
while (_TIMER_GET_CMP_INT_FLAG(TIMER0) == 0);
_TIMER_CLEAR_CMP_INT_FLAG(TIMER0);
/* Disable RTC NVIC */
NVIC_DisableIRQ(RTC_IRQn);
/* Disable RTC tick interrupt */
_RTC_TICK_INT_DISABLE();
/* Stop TIMER0 countuing */
_TIMER_RESET(TIMER0);
printf("RTC Tick Interrupt event counts is %d in 2 second time period. \n", g_u32RTCTickINT);
printf("\n");
}
/**
* @brief Disable Spare Register
*
* @param None
*
* @return None
*
* @details This API is used to disable the spare register 0~19 cannot be accessed.
*/
void RTC_DisableSpareRegister(void)
{
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
RTC_WaitAccessEnable();
pRTC->SPRCTL &= ~RTC_SPRCTL_SPRRWEN_Msk;
}
/**
* @brief Enable Spare Registers Access
*
* @param None
*
* @return None
*
* @details This API is used to enable the spare registers 0~19 can be accessed.
*/
void RTC_EnableSpareAccess(void)
{
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
RTC_WaitAccessEnable();
pRTC->SPRCTL |= RTC_SPRCTL_SPRRWEN_Msk;
}
/**
* @brief Set RTC Tick Period Time
*
* @param[in] u32TickSelection It is used to set the RTC tick period time for Periodic Time Tick request. \n
* It consists of:
* - \ref RTC_TICK_1_SEC : Time tick is 1 second
* - \ref RTC_TICK_1_2_SEC : Time tick is 1/2 second
* - \ref RTC_TICK_1_4_SEC : Time tick is 1/4 second
* - \ref RTC_TICK_1_8_SEC : Time tick is 1/8 second
* - \ref RTC_TICK_1_16_SEC : Time tick is 1/16 second
* - \ref RTC_TICK_1_32_SEC : Time tick is 1/32 second
* - \ref RTC_TICK_1_64_SEC : Time tick is 1/64 second
* - \ref RTC_TICK_1_128_SEC : Time tick is 1/128 second
*
* @return None
*
* @details This API is used to set RTC tick period time for each tick interrupt.
*/
void RTC_SetTickPeriod(uint32_t u32TickSelection)
{
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
RTC_WaitAccessEnable();
pRTC->TICK = (pRTC->TICK & ~RTC_TICK_TICK_Msk) | u32TickSelection;
}
/*---------------------------------------------------------------------------------------------------------*/
void SetRTCStartupDateTime(void)
{
/* Wait RTC Register Access Enable */
RTC_WaitAccessEnable();
RTC_SetCurrentCalendar(12, 7, 10);
RTC_SetCurrentTime(8, 40, 0);
_RTC_SET_DWR(RTC_DWR_TUESDAY);
/* Check if RTC Date/Time are ok except [SEC] data */
if ((_RTC_GET_YEAR() != 12) || (_RTC_GET_MON() != 7) || (_RTC_GET_DAY() != 10) ||
(_RTC_GET_HOUR() != 8) || (_RTC_GET_MIN() != 40) || (_RTC_GET_DWR() != RTC_DWR_TUESDAY))
{
printf("Set RTC start-up Date/Time fail. \n\n");
return ;
}
printf("# Set RTC start-up Date/Time is 2012/07/10 08:40:00 on Tuesday. \n");
}
/**
* @brief Update RTC Current Date
*
* @param[in] u32Year The year calendar digit of current RTC setting.
* @param[in] u32Month The month calendar digit of current RTC setting.
* @param[in] u32Day The day calendar digit of current RTC setting.
* @param[in] u32DayOfWeek The Day of the week. [RTC_SUNDAY / RTC_MONDAY / RTC_TUESDAY /
* RTC_WEDNESDAY / RTC_THURSDAY / RTC_FRIDAY /
* RTC_SATURDAY]
*
* @return None
*
* @details This API is used to update current date to RTC.
*/
void RTC_SetDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day, uint32_t u32DayOfWeek)
{
uint32_t u32RegCLR;
u32RegCLR = ((u32Year - RTC_YEAR2000) / 10) << 20;
u32RegCLR |= (((u32Year - RTC_YEAR2000) % 10) << 16);
u32RegCLR |= ((u32Month / 10) << 12);
u32RegCLR |= ((u32Month % 10) << 8);
u32RegCLR |= ((u32Day / 10) << 4);
u32RegCLR |= (u32Day % 10);
RTC_WaitAccessEnable();
/* Set Day of the Week */
RTC->DWR = u32DayOfWeek & RTC_DWR_DWR_Msk;
/* Set RTC Calender Loading */
RTC->CLR = (uint32_t)u32RegCLR;
}
/**
* @brief Set RTC Alarm Time Mask Function
*
* @param[in] u8IsTenHMsk 1: enable 10-Hour digit alarm mask; 0: disabled.
* @param[in] u8IsHMsk 1: enable 1-Hour digit alarm mask; 0: disabled.
* @param[in] u8IsTenMMsk 1: enable 10-Min digit alarm mask; 0: disabled.
* @param[in] u8IsMMsk 1: enable 1-Min digit alarm mask; 0: disabled.
* @param[in] u8IsTenSMsk 1: enable 10-Sec digit alarm mask; 0: disabled.
* @param[in] u8IsSMsk 1: enable 1-Sec digit alarm mask; 0: disabled.
*
* @return None
*
* @details This API is used to enable or disable RTC alarm time mask function.
*/
void RTC_SetAlarmTimeMask(uint8_t u8IsTenHMsk, uint8_t u8IsHMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenSMsk, uint8_t u8IsSMsk)
{
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
RTC_WaitAccessEnable();
pRTC->TAMSK = ((uint32_t)u8IsTenHMsk << RTC_TAMSK_MTENHR_Pos) |
((uint32_t)u8IsHMsk << RTC_TAMSK_MHR_Pos) |
((uint32_t)u8IsTenMMsk << RTC_TAMSK_MTENMIN_Pos) |
((uint32_t)u8IsMMsk << RTC_TAMSK_MMIN_Pos) |
((uint32_t)u8IsTenSMsk << RTC_TAMSK_MTENSEC_Pos) |
((uint32_t)u8IsSMsk << RTC_TAMSK_MSEC_Pos);
}
/**
* @brief Set RTC Alarm Date Mask Function
*
* @param[in] u8IsTenYMsk 1: enable 10-Year digit alarm mask; 0: disabled.
* @param[in] u8IsYMsk 1: enable 1-Year digit alarm mask; 0: disabled.
* @param[in] u8IsTenMMsk 1: enable 10-Mon digit alarm mask; 0: disabled.
* @param[in] u8IsMMsk 1: enable 1-Mon digit alarm mask; 0: disabled.
* @param[in] u8IsTenDMsk 1: enable 10-Day digit alarm mask; 0: disabled.
* @param[in] u8IsDMsk 1: enable 1-Day digit alarm mask; 0: disabled.
*
* @return None
*
* @details This API is used to enable or disable RTC alarm date mask function.
*/
void RTC_SetAlarmDateMask(uint8_t u8IsTenYMsk, uint8_t u8IsYMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenDMsk, uint8_t u8IsDMsk)
{
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
RTC_WaitAccessEnable();
pRTC->CAMSK = ((uint32_t)u8IsTenYMsk << RTC_CAMSK_MTENYEAR_Pos) |
((uint32_t)u8IsYMsk << RTC_CAMSK_MYEAR_Pos) |
((uint32_t)u8IsTenMMsk << RTC_CAMSK_MTENMON_Pos) |
((uint32_t)u8IsMMsk << RTC_CAMSK_MMON_Pos) |
((uint32_t)u8IsTenDMsk << RTC_CAMSK_MTENDAY_Pos) |
((uint32_t)u8IsDMsk << RTC_CAMSK_MDAY_Pos);
}
/*---------------------------------------------------------------------------------------------------------*/
int main(void)
{
uint32_t i, u32ReadData;
/* Unlock protected registers */
SYS_UnlockReg();
/* Init System, peripheral clock and multi-function I/O */
SYS_Init();
/* Lock protected registers */
SYS_LockReg();
/* Init UART0 for printf */
UART0_Init();
printf("\n\nCPU @ %dHz\n", SystemCoreClock);
printf("+------------------------------------------+\n");
printf("| RTC Spare Register R/W Sample Code |\n");
printf("+------------------------------------------+\n\n");
/* Initial RTC and stay in normal state */
if(RTC->INIT != RTC_INIT_ACTIVE_Msk)
{
RTC->INIT = RTC_INIT_KEY;
while(RTC->INIT != RTC_INIT_ACTIVE_Msk);
}
/* Enable Spare registers access function */
RTC_WaitAccessEnable();
RTC->SPRCTL = RTC_SPRCTL_SPRRWEN_Msk;
while(!(RTC->SPRCTL & RTC_SPRCTL_SPRRWRDY_Msk));
for(i = 0; i < 20; i++)
{
printf("Write Spare register-%02d to 0x%08X ... ", i, (0x5A5A0000 + i));
RTC_WaitAccessEnable();
RTC_WRITE_SPARE_REGISTER(i, 0x5A5A0000 + i);
while(!(RTC->SPRCTL & RTC_SPRCTL_SPRRWRDY_Msk));
printf("DONE.\n");
}
printf("\n");
for(i = 0; i < 20; i++)
{
printf("Read Spare register-%02d value is ", i);
RTC_WaitAccessEnable();
u32ReadData = RTC_READ_SPARE_REGISTER(i);
if(u32ReadData == (0x5A5A0000 + i))
{
printf("0x%08X ... PASS.\n", u32ReadData);
}
else
{
printf("0x%08X ... FAIL.\n", u32ReadData);
while(1);
}
while(!(RTC->SPRCTL & RTC_SPRCTL_SPRRWRDY_Msk));
}
while(1);
}
/**
* @brief Disable Snooper Pin Detect
*
* @param None
*
* @return None
*
* @details This API is used to disable the snooper pin detect function.
*/
void RTC_DisableSnooperDetection(void)
{
RTC_WaitAccessEnable();
RTC->SPRCTL &= ~RTC_SPRCTL_SNOOPEN_Msk;
}
/**
* @brief Enable Snooper Pin Detect
*
* @param[in] u32PinCondition Snooper pin trigger condition. Possible options are
* - \ref RTC_SNOOPER_LOW_LEVEL
* - \ref RTC_SNOOPER_HIGH_LEVEL
* - \ref RTC_SNOOPER_FALLING_EDGE
* - \ref RTC_SNOOPER_RISING_EDGE
*
* @return None
*
* @details This API is used to enable the snooper pin detect function with specify trigger condition.
*/
void RTC_EnableSnooperDetection(uint32_t u32PinCondition)
{
RTC_WaitAccessEnable();
RTC->SPRCTL = ((RTC->SPRCTL & ~RTC_SNOOPER_DETECT_Msk) | u32PinCondition) | RTC_SPRCTL_SNOOPEN_Msk;
}
/**
* @brief Disable Spare Register
*
* @param None
*
* @return None
*
* @details This API is used to disable the spare register 0~19 cannot be accessed.
*/
void RTC_DisableSpareRegister(void)
{
RTC_WaitAccessEnable();
RTC->SPRCTL &= ~RTC_SPRCTL_SPREN_Msk;
}
/**
* @brief Set RTC Tick Period Time
*
* @param[in] u32TickSelection It is used to set the RTC time tick period for Periodic Time Tick request. \n
* It consists of: \n
* RTC_TICK_1_SEC: Time tick is 1 second \n
* RTC_TICK_1_2_SEC: Time tick is 1/2 second \n
* RTC_TICK_1_4_SEC: Time tick is 1/4 second \n
* RTC_TICK_1_8_SEC: Time tick is 1/8 second \n
* RTC_TICK_1_16_SEC: Time tick is 1/16 second \n
* RTC_TICK_1_32_SEC: Time tick is 1/32 second \n
* RTC_TICK_1_64_SEC: Time tick is 1/64 second \n
* RTC_TICK_1_128_SEC: Time tick is 1/128 second
*
* @return None
*
* @details This API is used to set time tick period for periodic time tick interrupt.
*/
void RTC_SetTickPeriod(uint32_t u32TickSelection)
{
RTC_WaitAccessEnable();
RTC->TTR = (RTC->TTR & ~RTC_TTR_TTR_Msk) | u32TickSelection;
}
/**
* @brief Update RTC Alarm Date and Time
*
* @param[in] sPt Specify the time property and alarm date and time. It includes: \n
* u32Year: Year value, range between 2000 ~ 2099. \n
* u32Month: Month value, range between 1 ~ 12. \n
* u32Day: Day value, range between 1 ~ 31. \n
* u32DayOfWeek: Day of the week. [RTC_SUNDAY / RTC_MONDAY / RTC_TUESDAY /
* RTC_WEDNESDAY / RTC_THURSDAY / RTC_FRIDAY /
* RTC_SATURDAY] \n
* u32Hour: Hour value, range between 0 ~ 23. \n
* u32Minute: Minute value, range between 0 ~ 59. \n
* u32Second: Second value, range between 0 ~ 59. \n
* u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24] \n
* u8AmPm: [RTC_AM / RTC_PM] \n
*
* @return None
*
* @details This API is used to update alarm date and time setting to RTC.
*/
void RTC_SetAlarmDateAndTime(S_RTC_TIME_DATA_T *sPt)
{
uint32_t u32RegCALM, u32RegTALM;
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
if(sPt == 0)
{
; /* No RTC date/time data */
}
else
{
/*-----------------------------------------------------------------------------------------------------*/
/* Set RTC 24/12 hour setting and Day of the Week */
/*-----------------------------------------------------------------------------------------------------*/
RTC_WaitAccessEnable();
if(sPt->u32TimeScale == (uint32_t)RTC_CLOCK_12)
{
pRTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;
/*-------------------------------------------------------------------------------------------------*/
/* Important, range of 12-hour PM mode is 21 up to 32 */
/*-------------------------------------------------------------------------------------------------*/
if(sPt->u32AmPm == (uint32_t)RTC_PM)
{
sPt->u32Hour += 20UL;
}
}
else
{
pRTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;
}
/*-----------------------------------------------------------------------------------------------------*/
/* Set RTC Alarm Date and Time */
/*-----------------------------------------------------------------------------------------------------*/
u32RegCALM = ((sPt->u32Year - (uint32_t)RTC_YEAR2000) / 10UL) << 20;
u32RegCALM |= (((sPt->u32Year - (uint32_t)RTC_YEAR2000) % 10UL) << 16);
u32RegCALM |= ((sPt->u32Month / 10UL) << 12);
u32RegCALM |= ((sPt->u32Month % 10UL) << 8);
u32RegCALM |= ((sPt->u32Day / 10UL) << 4);
u32RegCALM |= (sPt->u32Day % 10UL);
u32RegTALM = ((sPt->u32Hour / 10UL) << 20);
u32RegTALM |= ((sPt->u32Hour % 10UL) << 16);
u32RegTALM |= ((sPt->u32Minute / 10UL) << 12);
u32RegTALM |= ((sPt->u32Minute % 10UL) << 8);
u32RegTALM |= ((sPt->u32Second / 10UL) << 4);
u32RegTALM |= (sPt->u32Second % 10UL);
RTC_WaitAccessEnable();
pRTC->CALM = (uint32_t)u32RegCALM;
RTC_WaitAccessEnable();
pRTC->TALM = (uint32_t)u32RegTALM;
}
}
/**
* @brief Get RTC Alarm Date and Time
*
* @param[out] sPt The returned pointer is specified the RTC alarm value. It includes: \n
* u32Year: Year value \n
* u32Month: Month value \n
* u32Day: Day value \n
* u32DayOfWeek: Day of week \n
* u32Hour: Hour value \n
* u32Minute: Minute value \n
* u32Second: Second value \n
* u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24] \n
* u8AmPm: [RTC_AM / RTC_PM] \n
*
* @return None
*
* @details This API is used to get the RTC alarm date and time setting.
*/
void RTC_GetAlarmDateAndTime(S_RTC_TIME_DATA_T *sPt)
{
uint32_t u32Tmp;
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
sPt->u32TimeScale = pRTC->CLKFMT & RTC_CLKFMT_24HEN_Msk; /* 12/24-hour */
sPt->u32DayOfWeek = pRTC->WEEKDAY & RTC_WEEKDAY_WEEKDAY_Msk; /* Day of the week */
/* Get alarm [Date digit] data */
RTC_WaitAccessEnable();
g_u32hiYear = (pRTC->CALM & RTC_CALM_TENYEAR_Msk) >> RTC_CALM_TENYEAR_Pos;
g_u32loYear = (pRTC->CALM & RTC_CALM_YEAR_Msk) >> RTC_CALM_YEAR_Pos;
g_u32hiMonth = (pRTC->CALM & RTC_CALM_TENMON_Msk) >> RTC_CALM_TENMON_Pos;
g_u32loMonth = (pRTC->CALM & RTC_CALM_MON_Msk) >> RTC_CALM_MON_Pos;
g_u32hiDay = (pRTC->CALM & RTC_CALM_TENDAY_Msk) >> RTC_CALM_TENDAY_Pos;
g_u32loDay = (pRTC->CALM & RTC_CALM_DAY_Msk) >> RTC_CALM_DAY_Pos;
/* Get alarm [Time digit] data */
RTC_WaitAccessEnable();
g_u32hiHour = (pRTC->TALM & RTC_TALM_TENHR_Msk) >> RTC_TALM_TENHR_Pos;
g_u32loHour = (pRTC->TALM & RTC_TALM_HR_Msk) >> RTC_TALM_HR_Pos;
g_u32hiMin = (pRTC->TALM & RTC_TALM_TENMIN_Msk) >> RTC_TALM_TENMIN_Pos;
g_u32loMin = (pRTC->TALM & RTC_TALM_MIN_Msk) >> RTC_TALM_MIN_Pos;
g_u32hiSec = (pRTC->TALM & RTC_TALM_TENSEC_Msk) >> RTC_TALM_TENSEC_Pos;
g_u32loSec = (pRTC->TALM & RTC_TALM_SEC_Msk) >> RTC_TALM_SEC_Pos;
/* Compute to 20XX year */
u32Tmp = (g_u32hiYear * 10UL);
u32Tmp += g_u32loYear;
sPt->u32Year = u32Tmp + (uint32_t)RTC_YEAR2000;
/* Compute 0~12 month */
u32Tmp = (g_u32hiMonth * 10UL);
sPt->u32Month = u32Tmp + g_u32loMonth;
/* Compute 0~31 day */
u32Tmp = (g_u32hiDay * 10UL);
sPt->u32Day = u32Tmp + g_u32loDay;
/* Compute 12/24 hour */
if(sPt->u32TimeScale == (uint32_t)RTC_CLOCK_12)
{
u32Tmp = (g_u32hiHour * 10UL);
u32Tmp += g_u32loHour;
sPt->u32Hour = u32Tmp; /* AM: 1~12. PM: 21~32. */
if(sPt->u32Hour >= 21UL)
{
sPt->u32AmPm = (uint32_t)RTC_PM;
sPt->u32Hour -= 20UL;
}
else
{
sPt->u32AmPm = (uint32_t)RTC_AM;
}
u32Tmp = (g_u32hiMin * 10UL);
u32Tmp += g_u32loMin;
sPt->u32Minute = u32Tmp;
u32Tmp = (g_u32hiSec * 10UL);
u32Tmp += g_u32loSec;
sPt->u32Second = u32Tmp;
}
else
{
u32Tmp = (g_u32hiHour * 10UL);
u32Tmp += g_u32loHour;
sPt->u32Hour = u32Tmp;
u32Tmp = (g_u32hiMin * 10UL);
u32Tmp += g_u32loMin;
sPt->u32Minute = u32Tmp;
u32Tmp = (g_u32hiSec * 10UL);
u32Tmp += g_u32loSec;
sPt->u32Second = u32Tmp;
}
}
/*---------------------------------------------------------------------------------------------------------*/
void RTC_AlarmAndWakeupTest(void)
{
printf("# Set RTC Current Date/Time is: 2012/07/10 13:10:55. \n");
printf("# Set RTC Alarm Date/Time is: 2012/07/10 13:11:07. \n");
printf("# System enter to Power Down on RTC Date/Time 2012/07/10 13:10:55; \n");
printf(" and waken-up on RTC Date/Time 2012/07/10 13:11:07. \n");
printf("Press any key to start test ... \n\n");
getchar();
/* Wait RTC Register Access Enable */
RTC_WaitAccessEnable();
/* Set RTC Current Date/Time */
RTC_SetCurrentCalendar(12, 7, 10);
RTC_SetCurrentTime(13, 10, 55);
_RTC_SET_DWR(RTC_DWR_TUESDAY);
/* Set RTC Alarm Date/Time */
RTC_SetAlarmCalendar(12, 7, 10);
RTC_SetAlarmTime(13, 11, 7);
/* Wait RTC Register Access Enable */
RTC_WaitAccessEnable();
/* Check if RTC Current Date/Time are ok except [SEC] data */
if ((_RTC_GET_YEAR() != 12) || (_RTC_GET_MON() != 7) || (_RTC_GET_DAY() != 10) ||
(_RTC_GET_HOUR() != 13) || (_RTC_GET_MIN() != 10))
{
printf("Set RTC Current Date/Time fail. \n\n");
return ;
}
/* Check if RTC current Date/Time are ok */
if ((_RTC_GET_ALARM_YEAR() != 12) || (_RTC_GET_ALARM_MON() != 7) || (_RTC_GET_ALARM_DAY() != 10) ||
(_RTC_GET_ALARM_HOUR() != 13) || (_RTC_GET_ALARM_MIN() != 11) || (_RTC_GET_ALARM_SEC() != 7))
{
printf("Set RTC Alarm Date/Time fail. \n\n");
return ;
}
/* Enable RTC NVIC */
NVIC_EnableIRQ(RTC_IRQn);
/* Enable RTC Alarm Interrupt */
_RTC_ALARM_INT_ENABLE();
printf("Cunnret Date/Time is 2012/07/10 13:10:55 and system enter to Power Down. \n");
g_u8IsRTCAlarmINT = 0;
/* System enter to Power Down */
PowerDownFunction();
while (g_u8IsRTCAlarmINT == 0);
printf("System waken-up and current Date/Time is %d/%02d/%02d %02d:%02d:%02d. \n",
(2000+_RTC_GET_YEAR()), _RTC_GET_MON(), _RTC_GET_DAY(), _RTC_GET_HOUR(), _RTC_GET_MIN(), _RTC_GET_SEC());
/* Disable RTC NVIC */
NVIC_DisableIRQ(RTC_IRQn);
/* Disable RTC Alarm Interrupt */
_RTC_ALARM_INT_DISABLE();
printf("\n");
}
/**
* @brief Get RTC Alarm Date and Time
*
* @param[out] sPt The returned pointer is specified the RTC alarm value. It includes: \n
* u32Year: Year value \n
* u32Month: Month value \n
* u32Day: Day value \n
* u32DayOfWeek: Day of week \n
* u32Hour: Hour value \n
* u32Minute: Minute value \n
* u32Second: Second value \n
* u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24] \n
* u8AmPm: [RTC_AM / RTC_PM] \n
*
* @return None
*
* @details This API is used to get the RTC alarm date and time setting.
*/
void RTC_GetAlarmDateAndTime(S_RTC_TIME_DATA_T *sPt)
{
uint32_t u32Tmp;
sPt->u32TimeScale = RTC->TSSR & RTC_TSSR_24H_12H_Msk; /* 12/24-hour */
sPt->u32DayOfWeek = RTC->DWR & RTC_DWR_DWR_Msk; /* Day of the week */
/* Get alarm [Date digit] data */
RTC_WaitAccessEnable();
g_u32hiYear = (RTC->CAR & RTC_CAR_10YEAR_Msk) >> RTC_CAR_10YEAR_Pos;
g_u32loYear = (RTC->CAR & RTC_CAR_1YEAR_Msk) >> RTC_CAR_1YEAR_Pos;
g_u32hiMonth = (RTC->CAR & RTC_CAR_10MON_Msk) >> RTC_CAR_10MON_Pos;
g_u32loMonth = (RTC->CAR & RTC_CAR_1MON_Msk) >> RTC_CAR_1MON_Pos;
g_u32hiDay = (RTC->CAR & RTC_CAR_10DAY_Msk) >> RTC_CAR_10DAY_Pos;
g_u32loDay = (RTC->CAR & RTC_CAR_1DAY_Msk);
/* Get alarm [Time digit] data */
RTC_WaitAccessEnable();
g_u32hiHour = (RTC->TAR & RTC_TAR_10HR_Msk) >> RTC_TAR_10HR_Pos;
g_u32loHour = (RTC->TAR & RTC_TAR_1HR_Msk) >> RTC_TAR_1HR_Pos;
g_u32hiMin = (RTC->TAR & RTC_TAR_10MIN_Msk) >> RTC_TAR_10MIN_Pos;
g_u32loMin = (RTC->TAR & RTC_TAR_1MIN_Msk) >> RTC_TAR_1MIN_Pos;
g_u32hiSec = (RTC->TAR & RTC_TAR_10SEC_Msk) >> RTC_TAR_10SEC_Pos;
g_u32loSec = (RTC->TAR & RTC_TAR_1SEC_Msk);
/* Compute to 20XX year */
u32Tmp = (g_u32hiYear * 10);
u32Tmp += g_u32loYear;
sPt->u32Year = u32Tmp + RTC_YEAR2000;
/* Compute 0~12 month */
u32Tmp = (g_u32hiMonth * 10);
sPt->u32Month = u32Tmp + g_u32loMonth;
/* Compute 0~31 day */
u32Tmp = (g_u32hiDay * 10);
sPt->u32Day = u32Tmp + g_u32loDay;
/* Compute 12/24 hour */
if(sPt->u32TimeScale == RTC_CLOCK_12)
{
u32Tmp = (g_u32hiHour * 10);
u32Tmp += g_u32loHour;
sPt->u32Hour = u32Tmp; /* AM: 1~12. PM: 21~32. */
if(sPt->u32Hour >= 21)
{
sPt->u32AmPm = RTC_PM;
sPt->u32Hour -= 20;
}
else
{
sPt->u32AmPm = RTC_AM;
}
u32Tmp = (g_u32hiMin * 10);
u32Tmp += g_u32loMin;
sPt->u32Minute = u32Tmp;
u32Tmp = (g_u32hiSec * 10);
u32Tmp += g_u32loSec;
sPt->u32Second = u32Tmp;
}
else
{
u32Tmp = (g_u32hiHour * 10);
u32Tmp += g_u32loHour;
sPt->u32Hour = u32Tmp;
u32Tmp = (g_u32hiMin * 10);
u32Tmp += g_u32loMin;
sPt->u32Minute = u32Tmp;
u32Tmp = (g_u32hiSec * 10);
u32Tmp += g_u32loSec;
sPt->u32Second = u32Tmp;
}
}
/**
* @brief Dynamic Tamper Detect
*
* @param[in] u32PairSel Tamper pin detection enable. Possible options are
* - \ref RTC_PAIR0_SELECT
* - \ref RTC_PAIR1_SELECT
* - \ref RTC_PAIR2_SELECT
*
* @param[in] u32DebounceEn Tamper pin de-bounce enable
* - \ref RTC_TAMPER_DEBOUNCE_ENABLE
* - \ref RTC_TAMPER_DEBOUNCE_DISABLE
*
* @param[in] u32Pair1Source Dynamic Pair 1 Input Source Select
* 0: Pair 1 source select tamper 2
* 1: Pair 1 source select tamper 0
*
* @param[in] u32Pair2Source Dynamic Pair 2 Input Source Select
* 0: Pair 2 source select tamper 4
* 1: Pair 2 source select tamper 0
*
* @return None
*
* @details This API is used to enable the dynamic tamper.
*/
void RTC_DynamicTamperEnable(uint32_t u32PairSel, uint32_t u32DebounceEn, uint32_t u32Pair1Source, uint32_t u32Pair2Source)
{
uint32_t i;
uint32_t u32Reg;
uint32_t u32TmpReg;
uint32_t u32Tamper2Debounce, u32Tamper4Debounce;
RTC_T *pRTC;
if((__PC()&NS_OFFSET) == NS_OFFSET)
{
pRTC = RTC_NS;
}
else
{
pRTC = RTC;
}
RTC_WaitAccessEnable();
u32Reg = pRTC->TAMPCTL;
u32Reg &= ~(RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk | RTC_TAMPCTL_TAMP2EN_Msk |
RTC_TAMPCTL_TAMP3EN_Msk | RTC_TAMPCTL_TAMP4EN_Msk | RTC_TAMPCTL_TAMP5EN_Msk);
u32Tamper2Debounce = u32Reg & RTC_TAMPCTL_TAMP2DBEN_Msk;
u32Tamper4Debounce = u32Reg & RTC_TAMPCTL_TAMP4DBEN_Msk;
u32Reg &= ~(RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk | RTC_TAMPCTL_TAMP2EN_Msk |
RTC_TAMPCTL_TAMP3EN_Msk | RTC_TAMPCTL_TAMP4EN_Msk | RTC_TAMPCTL_TAMP5EN_Msk);
u32Reg &= ~(RTC_TAMPCTL_DYN1ISS_Msk | RTC_TAMPCTL_DYN2ISS_Msk);
u32Reg |= ((u32Pair1Source & 0x1UL) << RTC_TAMPCTL_DYN1ISS_Pos) | ((u32Pair2Source & 0x1UL) << RTC_TAMPCTL_DYN2ISS_Pos);
if(u32DebounceEn)
{
u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk |
RTC_TAMPCTL_TAMP0DBEN_Msk | RTC_TAMPCTL_TAMP1DBEN_Msk | RTC_TAMPCTL_DYNPR0EN_Msk);
}
else
{
u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk | RTC_TAMPCTL_DYNPR0EN_Msk);
}
for(i = 0UL; i < (uint32_t)MAX_PAIR_NUM; i++)
{
if(u32PairSel & (0x1UL << i))
{
u32Reg &= ~((RTC_TAMPCTL_TAMP0DBEN_Msk | RTC_TAMPCTL_TAMP1DBEN_Msk) << (i * 8UL));
u32Reg |= (u32TmpReg << (i * 8UL));
}
}
if((u32Pair1Source) && (u32PairSel & (uint32_t)RTC_PAIR1_SELECT))
{
u32Reg &= ~RTC_TAMPCTL_TAMP2EN_Msk;
u32Reg |= u32Tamper2Debounce;
}
if((u32Pair2Source) && (u32PairSel & (uint32_t)RTC_PAIR2_SELECT))
{
u32Reg &= ~RTC_TAMPCTL_TAMP4EN_Msk;
u32Reg |= u32Tamper4Debounce;
}
RTC_WaitAccessEnable();
pRTC->TAMPCTL = u32Reg;
}
