/** ****************************************************************************** * @file ft32f0xx_rtc.c * @author FMD AE * @brief This file provides firmware functions to manage the following * functionalities of the Real-Time Clock (RTC) peripheral: * + Initialization * + Calendar (Time and Date) configuration * + Alarms (Alarm A) configuration * + Daylight Saving configuration * + Output pin Configuration * + Digital Calibration configuration * + TimeStamp configuration * + Tampers configuration * + Backup Data Registers configuration * + Output Type Config configuration * + Shift control synchronisation * + Interrupts and flags management * @version V1.0.0 * @data 2021-07-01 ****************************************************************************** */ /* Includes ------------------------------------------------------------------*/ #include "ft32f0xx_rtc.h" /* Masks Definition */ #define RTC_TR_RESERVED_MASK ((uint32_t)0x007F7F7F) #define RTC_DR_RESERVED_MASK ((uint32_t)0x00FFFF3F) #define RTC_INIT_MASK ((uint32_t)0xFFFFFFFF) #define RTC_RSF_MASK ((uint32_t)0xFFFFFF5F) #define RTC_FLAGS_MASK ((uint32_t)(RTC_FLAG_TSOVF | RTC_FLAG_TSF | RTC_FLAG_ALRAF | \ RTC_FLAG_RSF | RTC_FLAG_INITS |RTC_FLAG_INITF | \ RTC_FLAG_TAMP1F | RTC_FLAG_TAMP2F | RTC_FLAG_RECALPF | \ RTC_FLAG_SHPF)) #define INITMODE_TIMEOUT ((uint32_t) 0x00004000) #define SYNCHRO_TIMEOUT ((uint32_t) 0x00008000) #define RECALPF_TIMEOUT ((uint32_t) 0x00001000) #define SHPF_TIMEOUT ((uint32_t) 0x00001000) static uint8_t RTC_ByteToBcd2(uint8_t Value); static uint8_t RTC_Bcd2ToByte(uint8_t Value); /** * @brief Deinitializes the RTC registers to their default reset values. * @note This function doesn't reset the RTC Clock source and RTC Backup Data * registers. * @param None * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC registers are deinitialized * - ERROR: RTC registers are not deinitialized */ ErrorStatus RTC_DeInit(void) { ErrorStatus status = ERROR; /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Set Initialization mode */ if (RTC_EnterInitMode() == ERROR) { status = ERROR; } else { /* Reset TR, DR and CR registers */ RTC->TR = (uint32_t)0x00000000; RTC->DR = (uint32_t)0x00002101; RTC->CR &= (uint32_t)0x00000000; RTC->PRER = (uint32_t)0x007F00FF; RTC->ALRMAR = (uint32_t)0x00000000; RTC->SHIFTR = (uint32_t)0x00000000; RTC->CALR = (uint32_t)0x00000000; RTC->ALRMASSR = (uint32_t)0x00000000; /* Reset ISR register and exit initialization mode */ RTC->ISR = (uint32_t)0x00000000; /* Reset Tamper and alternate functions configuration register */ RTC->TAFCR = 0x00000000; /* Wait till the RTC RSF flag is set */ if (RTC_WaitForSynchro() == ERROR) { status = ERROR; } else { status = SUCCESS; } } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return status; } /** * @brief Initializes the RTC registers according to the specified parameters * in RTC_InitStruct. * @param RTC_InitStruct: pointer to a RTC_InitTypeDef structure that contains * the configuration information for the RTC peripheral. * @note The RTC Prescaler register is write protected and can be written in * initialization mode only. * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC registers are initialized * - ERROR: RTC registers are not initialized */ ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct) { ErrorStatus status = ERROR; /* Check the parameters */ assert_param(IS_RTC_HOUR_FORMAT(RTC_InitStruct->RTC_HourFormat)); assert_param(IS_RTC_ASYNCH_PREDIV(RTC_InitStruct->RTC_AsynchPrediv)); assert_param(IS_RTC_SYNCH_PREDIV(RTC_InitStruct->RTC_SynchPrediv)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Set Initialization mode */ if (RTC_EnterInitMode() == ERROR) { status = ERROR; } else { /* Clear RTC CR FMT Bit */ RTC->CR &= ((uint32_t)~(RTC_CR_FMT)); /* Set RTC_CR register */ RTC->CR |= ((uint32_t)(RTC_InitStruct->RTC_HourFormat)); /* Configure the RTC PRER */ RTC->PRER = (uint32_t)(RTC_InitStruct->RTC_SynchPrediv); RTC->PRER |= (uint32_t)(RTC_InitStruct->RTC_AsynchPrediv << 16); /* Exit Initialization mode */ RTC_ExitInitMode(); status = SUCCESS; } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return status; } /** * @brief Fills each RTC_InitStruct member with its default value. * @param RTC_InitStruct: pointer to a RTC_InitTypeDef structure which will be * initialized. * @retval None */ void RTC_StructInit(RTC_InitTypeDef* RTC_InitStruct) { /* Initialize the RTC_HourFormat member */ RTC_InitStruct->RTC_HourFormat = RTC_HourFormat_24; /* Initialize the RTC_AsynchPrediv member */ RTC_InitStruct->RTC_AsynchPrediv = (uint32_t)0x7F; /* Initialize the RTC_SynchPrediv member */ RTC_InitStruct->RTC_SynchPrediv = (uint32_t)0xFF; } /** * @brief Enables or disables the RTC registers write protection. * @note All the RTC registers are write protected except for RTC_ISR[13:8], * RTC_TAFCR and RTC_BKPxR. * @note Writing a wrong key reactivates the write protection. * @note The protection mechanism is not affected by system reset. * @param NewState: new state of the write protection. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_WriteProtectionCmd(FunctionalState NewState) { /* Check the parameters */ assert_param(IS_FUNCTIONAL_STATE(NewState)); if (NewState != DISABLE) { /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } else { /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; } } /** * @brief Enters the RTC Initialization mode. * @note The RTC Initialization mode is write protected, use the * RTC_WriteProtectionCmd(DISABLE) before calling this function. * @param None * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC is in Init mode * - ERROR: RTC is not in Init mode */ ErrorStatus RTC_EnterInitMode(void) { __IO uint32_t initcounter = 0x00; ErrorStatus status = ERROR; uint32_t initstatus = 0x00; /* Check if the Initialization mode is set */ if ((RTC->ISR & RTC_ISR_INITF) == (uint32_t)RESET) { /* Set the Initialization mode */ RTC->ISR = (uint32_t)RTC_INIT_MASK; /* Wait till RTC is in INIT state and if Time out is reached exit */ do { initstatus = RTC->ISR & RTC_ISR_INITF; initcounter++; } while((initcounter != INITMODE_TIMEOUT) && (initstatus == 0x00)); if ((RTC->ISR & RTC_ISR_INITF) != RESET) { status = SUCCESS; } else { status = ERROR; } } else { status = SUCCESS; } return (status); } /** * @brief Exits the RTC Initialization mode. * @note When the initialization sequence is complete, the calendar restarts * counting after 4 RTCCLK cycles. * @note The RTC Initialization mode is write protected, use the * RTC_WriteProtectionCmd(DISABLE) before calling this function. * @param None * @retval None */ void RTC_ExitInitMode(void) { /* Exit Initialization mode */ RTC->ISR &= (uint32_t)~RTC_ISR_INIT; /*when BypassShadow is enable,this bit should wait to clear zero.edit:2020.5.23*/ while((RTC->ISR & RTC_ISR_INITF) != RESET) { ; } } /** * @brief Waits until the RTC Time and Date registers (RTC_TR and RTC_DR) are * synchronized with RTC APB clock. * @note The RTC Resynchronization mode is write protected, use the * RTC_WriteProtectionCmd(DISABLE) before calling this function. * @note To read the calendar through the shadow registers after Calendar * initialization, calendar update or after wakeup from low power modes * the software must first clear the RSF flag. * The software must then wait until it is set again before reading * the calendar, which means that the calendar registers have been * correctly copied into the RTC_TR and RTC_DR shadow registers. * @param None * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC registers are synchronised * - ERROR: RTC registers are not synchronised */ ErrorStatus RTC_WaitForSynchro(void) { __IO uint32_t synchrocounter = 0; ErrorStatus status = ERROR; uint32_t synchrostatus = 0x00; if ((RTC->CR & RTC_CR_BYPSHAD) != RESET) { /* Bypass shadow mode */ status = SUCCESS; } else { /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Clear RSF flag */ RTC->ISR &= (uint32_t)RTC_RSF_MASK; /* Wait the registers to be synchronised */ do { synchrostatus = RTC->ISR & RTC_ISR_RSF; synchrocounter++; } while((synchrocounter != SYNCHRO_TIMEOUT) && (synchrostatus == 0x00)); if ((RTC->ISR & RTC_ISR_RSF) != RESET) { status = SUCCESS; } else { status = ERROR; } /* Disable the write protection for RTC registers */ RTC->WPR = 0xFF; } return (status); } /** * @brief Enables or disables the RTC reference clock detection. * @param NewState: new state of the RTC reference clock. * This parameter can be: ENABLE or DISABLE. * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC reference clock detection is enabled * - ERROR: RTC reference clock detection is disabled */ ErrorStatus RTC_RefClockCmd(FunctionalState NewState) { ErrorStatus status = ERROR; /* Check the parameters */ assert_param(IS_FUNCTIONAL_STATE(NewState)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Set Initialization mode */ if (RTC_EnterInitMode() == ERROR) { status = ERROR; } else { if (NewState != DISABLE) { /* Enable the RTC reference clock detection */ RTC->CR |= RTC_CR_REFCKON; } else { /* Disable the RTC reference clock detection */ RTC->CR &= ~RTC_CR_REFCKON; } /* Exit Initialization mode */ RTC_ExitInitMode(); status = SUCCESS; } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return status; } /** * @brief Enables or Disables the Bypass Shadow feature. * @note When the Bypass Shadow is enabled the calendar value are taken * directly from the Calendar counter. * @param NewState: new state of the Bypass Shadow feature. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_BypassShadowCmd(FunctionalState NewState) { /* Check the parameters */ assert_param(IS_FUNCTIONAL_STATE(NewState)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; if (NewState != DISABLE) { /* Set the BYPSHAD bit */ RTC->CR |= (uint8_t)RTC_CR_BYPSHAD; } else { /* Reset the BYPSHAD bit */ RTC->CR &= (uint8_t)~RTC_CR_BYPSHAD; } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @} */ /** * @brief Set the RTC current time. * @param RTC_Format: specifies the format of the entered parameters. * This parameter can be one of the following values: * @arg RTC_Format_BIN: Binary data format * @arg RTC_Format_BCD: BCD data format * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure that contains * the time configuration information for the RTC. * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC Time register is configured * - ERROR: RTC Time register is not configured */ ErrorStatus RTC_SetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct) { uint32_t tmpreg = 0; ErrorStatus status = ERROR; /* Check the parameters */ assert_param(IS_RTC_FORMAT(RTC_Format)); if (RTC_Format == RTC_Format_BIN) { if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) { assert_param(IS_RTC_HOUR12(RTC_TimeStruct->RTC_Hours)); assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); } else { RTC_TimeStruct->RTC_H12 = 0x00; assert_param(IS_RTC_HOUR24(RTC_TimeStruct->RTC_Hours)); } assert_param(IS_RTC_MINUTES(RTC_TimeStruct->RTC_Minutes)); assert_param(IS_RTC_SECONDS(RTC_TimeStruct->RTC_Seconds)); } else { if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) { tmpreg = RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours); assert_param(IS_RTC_HOUR12(tmpreg)); assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); } else { RTC_TimeStruct->RTC_H12 = 0x00; assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours))); } assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes))); assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds))); } /* Check the input parameters format */ if (RTC_Format != RTC_Format_BIN) { tmpreg = (((uint32_t)(RTC_TimeStruct->RTC_Hours) << 16) | \ ((uint32_t)(RTC_TimeStruct->RTC_Minutes) << 8) | \ ((uint32_t)RTC_TimeStruct->RTC_Seconds) | \ ((uint32_t)(RTC_TimeStruct->RTC_H12) << 16)); } else { tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Hours) << 16) | \ ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Minutes) << 8) | \ ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Seconds)) | \ (((uint32_t)RTC_TimeStruct->RTC_H12) << 16)); } /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Set Initialization mode */ if (RTC_EnterInitMode() == ERROR) { status = ERROR; } else { /* Set the RTC_TR register */ RTC->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK); /* Exit Initialization mode */ RTC_ExitInitMode(); /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */ if ((RTC->CR & RTC_CR_BYPSHAD) == RESET) { if (RTC_WaitForSynchro() == ERROR) { status = ERROR; } else { status = SUCCESS; } } else { status = SUCCESS; } } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return status; } /** * @brief Fills each RTC_TimeStruct member with its default value * (Time = 00h:00min:00sec). * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure which will be * initialized. * @retval None */ void RTC_TimeStructInit(RTC_TimeTypeDef* RTC_TimeStruct) { /* Time = 00h:00min:00sec */ RTC_TimeStruct->RTC_H12 = RTC_H12_AM; RTC_TimeStruct->RTC_Hours = 0; RTC_TimeStruct->RTC_Minutes = 0; RTC_TimeStruct->RTC_Seconds = 0; } /** * @brief Get the RTC current Time. * @param RTC_Format: specifies the format of the returned parameters. * This parameter can be one of the following values: * @arg RTC_Format_BIN: Binary data format * @arg RTC_Format_BCD: BCD data format * @param RTC_TimeStruct: pointer to a RTC_TimeTypeDef structure that will * contain the returned current time configuration. * @retval None */ void RTC_GetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct) { uint32_t tmpreg = 0; /* Check the parameters */ assert_param(IS_RTC_FORMAT(RTC_Format)); /* Get the RTC_TR register */ tmpreg = (uint32_t)(RTC->TR & RTC_TR_RESERVED_MASK); /* Fill the structure fields with the read parameters */ RTC_TimeStruct->RTC_Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16); RTC_TimeStruct->RTC_Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8); RTC_TimeStruct->RTC_Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU)); RTC_TimeStruct->RTC_H12 = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16); /* Check the input parameters format */ if (RTC_Format == RTC_Format_BIN) { /* Convert the structure parameters to Binary format */ RTC_TimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours); RTC_TimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes); RTC_TimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds); } } /** * @brief Gets the RTC current Calendar Subseconds value. * @note This function freeze the Time and Date registers after reading the * SSR register. * @param None * @retval RTC current Calendar Subseconds value. */ uint32_t RTC_GetSubSecond(void) { uint32_t tmpreg = 0; /* Get subseconds values from the correspondent registers*/ tmpreg = (uint32_t)(RTC->SSR); /* Read DR register to unfroze calendar registers */ (void) (RTC->DR); return (tmpreg); } /** * @brief Set the RTC current date. * @param RTC_Format: specifies the format of the entered parameters. * This parameter can be one of the following values: * @arg RTC_Format_BIN: Binary data format * @arg RTC_Format_BCD: BCD data format * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure that contains * the date configuration information for the RTC. * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC Date register is configured * - ERROR: RTC Date register is not configured */ ErrorStatus RTC_SetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct) { uint32_t tmpreg = 0; ErrorStatus status = ERROR; /* Check the parameters */ assert_param(IS_RTC_FORMAT(RTC_Format)); if ((RTC_Format == RTC_Format_BIN) && ((RTC_DateStruct->RTC_Month & 0x10) == 0x10)) { RTC_DateStruct->RTC_Month = (RTC_DateStruct->RTC_Month & (uint32_t)~(0x10)) + 0x0A; } if (RTC_Format == RTC_Format_BIN) { assert_param(IS_RTC_YEAR(RTC_DateStruct->RTC_Year)); assert_param(IS_RTC_MONTH(RTC_DateStruct->RTC_Month)); assert_param(IS_RTC_DATE(RTC_DateStruct->RTC_Date)); } else { assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year))); tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month); assert_param(IS_RTC_MONTH(tmpreg)); tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date); assert_param(IS_RTC_DATE(tmpreg)); } assert_param(IS_RTC_WEEKDAY(RTC_DateStruct->RTC_WeekDay)); /* Check the input parameters format */ if (RTC_Format != RTC_Format_BIN) { tmpreg = ((((uint32_t)RTC_DateStruct->RTC_Year) << 16) | \ (((uint32_t)RTC_DateStruct->RTC_Month) << 8) | \ ((uint32_t)RTC_DateStruct->RTC_Date) | \ (((uint32_t)RTC_DateStruct->RTC_WeekDay) << 13)); } else { tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Year) << 16) | \ ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Month) << 8) | \ ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Date)) | \ ((uint32_t)RTC_DateStruct->RTC_WeekDay << 13)); } /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Set Initialization mode */ if (RTC_EnterInitMode() == ERROR) { status = ERROR; } else { /* Set the RTC_DR register */ RTC->DR = (uint32_t)(tmpreg & RTC_DR_RESERVED_MASK); /* Exit Initialization mode */ RTC_ExitInitMode(); /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */ if ((RTC->CR & RTC_CR_BYPSHAD) == RESET) { if (RTC_WaitForSynchro() == ERROR) { status = ERROR; } else { status = SUCCESS; } } else { status = SUCCESS; } } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return status; } /** * @brief Fills each RTC_DateStruct member with its default value * (Monday, January 01 xx00). * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure which will be * initialized. * @retval None */ void RTC_DateStructInit(RTC_DateTypeDef* RTC_DateStruct) { /* Monday, January 01 xx00 */ RTC_DateStruct->RTC_WeekDay = RTC_Weekday_Monday; RTC_DateStruct->RTC_Date = 1; RTC_DateStruct->RTC_Month = RTC_Month_January; RTC_DateStruct->RTC_Year = 0; } /** * @brief Get the RTC current date. * @param RTC_Format: specifies the format of the returned parameters. * This parameter can be one of the following values: * @arg RTC_Format_BIN: Binary data format * @arg RTC_Format_BCD: BCD data format * @param RTC_DateStruct: pointer to a RTC_DateTypeDef structure that will * contain the returned current date configuration. * @retval None */ void RTC_GetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct) { uint32_t tmpreg = 0; /* Check the parameters */ assert_param(IS_RTC_FORMAT(RTC_Format)); /* Get the RTC_TR register */ tmpreg = (uint32_t)(RTC->DR & RTC_DR_RESERVED_MASK); /* Fill the structure fields with the read parameters */ RTC_DateStruct->RTC_Year = (uint8_t)((tmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16); RTC_DateStruct->RTC_Month = (uint8_t)((tmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8); RTC_DateStruct->RTC_Date = (uint8_t)(tmpreg & (RTC_DR_DT | RTC_DR_DU)); RTC_DateStruct->RTC_WeekDay = (uint8_t)((tmpreg & (RTC_DR_WDU)) >> 13); /* Check the input parameters format */ if (RTC_Format == RTC_Format_BIN) { /* Convert the structure parameters to Binary format */ RTC_DateStruct->RTC_Year = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year); RTC_DateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month); RTC_DateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date); RTC_DateStruct->RTC_WeekDay = (uint8_t)(RTC_DateStruct->RTC_WeekDay); } } /** * @} */ /** * @brief Set the specified RTC Alarm. * @note The Alarm register can only be written when the corresponding Alarm * is disabled (Use the RTC_AlarmCmd(DISABLE)). * @param RTC_Format: specifies the format of the returned parameters. * This parameter can be one of the following values: * @arg RTC_Format_BIN: Binary data format * @arg RTC_Format_BCD: BCD data format * @param RTC_Alarm: specifies the alarm to be configured. * This parameter can be one of the following values: * @arg RTC_Alarm_A: to select Alarm A * @param RTC_AlarmStruct: pointer to a RTC_AlarmTypeDef structure that * contains the alarm configuration parameters. * @retval None */ void RTC_SetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct) { uint32_t tmpreg = 0; /* Check the parameters */ assert_param(IS_RTC_FORMAT(RTC_Format)); assert_param(IS_RTC_ALARM(RTC_Alarm)); assert_param(IS_RTC_ALARM_MASK(RTC_AlarmStruct->RTC_AlarmMask)); assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel)); if (RTC_Format == RTC_Format_BIN) { if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) { assert_param(IS_RTC_HOUR12(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)); assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12)); } else { RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00; assert_param(IS_RTC_HOUR24(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)); } assert_param(IS_RTC_MINUTES(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes)); assert_param(IS_RTC_SECONDS(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)); if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date) { assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(RTC_AlarmStruct->RTC_AlarmDateWeekDay)); } else { assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(RTC_AlarmStruct->RTC_AlarmDateWeekDay)); } } else { if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET) { tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours); assert_param(IS_RTC_HOUR12(tmpreg)); assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12)); } else { RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00; assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours))); } assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes))); assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds))); if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date) { tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg)); } else { tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg)); } } /* Check the input parameters format */ if (RTC_Format != RTC_Format_BIN) { tmpreg = (((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \ ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \ ((uint32_t)RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds) | \ ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \ ((uint32_t)(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \ ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \ ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); } else { tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \ ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \ ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)) | \ ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \ ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \ ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \ ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); } /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Configure the Alarm register */ RTC->ALRMAR = (uint32_t)tmpreg; /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @brief Fills each RTC_AlarmStruct member with its default value * (Time = 00h:00mn:00sec / Date = 1st day of the month/Mask = * all fields are masked). * @param RTC_AlarmStruct: pointer to a @ref RTC_AlarmTypeDef structure which * will be initialized. * @retval None */ void RTC_AlarmStructInit(RTC_AlarmTypeDef* RTC_AlarmStruct) { /* Alarm Time Settings : Time = 00h:00mn:00sec */ RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = RTC_H12_AM; RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = 0; RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = 0; RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = 0; /* Alarm Date Settings : Date = 1st day of the month */ RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date; RTC_AlarmStruct->RTC_AlarmDateWeekDay = 1; /* Alarm Masks Settings : Mask = all fields are not masked */ RTC_AlarmStruct->RTC_AlarmMask = RTC_AlarmMask_None; } /** * @brief Get the RTC Alarm value and masks. * @param RTC_Format: specifies the format of the output parameters. * This parameter can be one of the following values: * @arg RTC_Format_BIN: Binary data format * @arg RTC_Format_BCD: BCD data format * @param RTC_Alarm: specifies the alarm to be read. * This parameter can be one of the following values: * @arg RTC_Alarm_A: to select Alarm A * @param RTC_AlarmStruct: pointer to a RTC_AlarmTypeDef structure that will * contains the output alarm configuration values. * @retval None */ void RTC_GetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct) { uint32_t tmpreg = 0; /* Check the parameters */ assert_param(IS_RTC_FORMAT(RTC_Format)); assert_param(IS_RTC_ALARM(RTC_Alarm)); /* Get the RTC_ALRMAR register */ tmpreg = (uint32_t)(RTC->ALRMAR); /* Fill the structure with the read parameters */ RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | \ RTC_ALRMAR_HU)) >> 16); RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | \ RTC_ALRMAR_MNU)) >> 8); RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | \ RTC_ALRMAR_SU)); RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16); RTC_AlarmStruct->RTC_AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24); RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL); RTC_AlarmStruct->RTC_AlarmMask = (uint32_t)(tmpreg & RTC_AlarmMask_All); if (RTC_Format == RTC_Format_BIN) { RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ RTC_AlarmTime.RTC_Hours); RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ RTC_AlarmTime.RTC_Minutes); RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = RTC_Bcd2ToByte(RTC_AlarmStruct-> \ RTC_AlarmTime.RTC_Seconds); RTC_AlarmStruct->RTC_AlarmDateWeekDay = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay); } } /** * @brief Enables or disables the specified RTC Alarm. * @param RTC_Alarm: specifies the alarm to be configured. * This parameter can be any combination of the following values: * @arg RTC_Alarm_A: to select Alarm A * @param NewState: new state of the specified alarm. * This parameter can be: ENABLE or DISABLE. * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC Alarm is enabled/disabled * - ERROR: RTC Alarm is not enabled/disabled */ ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm, FunctionalState NewState) { __IO uint32_t alarmcounter = 0x00; uint32_t alarmstatus = 0x00; ErrorStatus status = ERROR; /* Check the parameters */ assert_param(IS_RTC_CMD_ALARM(RTC_Alarm)); assert_param(IS_FUNCTIONAL_STATE(NewState)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Configure the Alarm state */ if (NewState != DISABLE) { RTC->CR |= (uint32_t)RTC_Alarm; status = SUCCESS; } else { /* Disable the Alarm in RTC_CR register */ RTC->CR &= (uint32_t)~RTC_Alarm; /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */ do { alarmstatus = RTC->ISR & (RTC_Alarm >> 8); alarmcounter++; } while((alarmcounter != INITMODE_TIMEOUT) && (alarmstatus == 0x00)); if ((RTC->ISR & (RTC_Alarm >> 8)) == RESET) { status = ERROR; } else { status = SUCCESS; } } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return status; } /** * @brief Configure the RTC AlarmA/B Subseconds value and mask. * @note This function is performed only when the Alarm is disabled. * @param RTC_Alarm: specifies the alarm to be configured. * This parameter can be one of the following values: * @arg RTC_Alarm_A: to select Alarm A * @param RTC_AlarmSubSecondValue: specifies the Subseconds value. * This parameter can be a value from 0 to 0x00007FFF. * @param RTC_AlarmSubSecondMask: specifies the Subseconds Mask. * This parameter can be any combination of the following values: * @arg RTC_AlarmSubSecondMask_All: All Alarm SS fields are masked. * There is no comparison on sub seconds for Alarm. * @arg RTC_AlarmSubSecondMask_SS14_1: SS[14:1] are don't care in Alarm comparison. * Only SS[0] is compared * @arg RTC_AlarmSubSecondMask_SS14_2: SS[14:2] are don't care in Alarm comparison. * Only SS[1:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_3: SS[14:3] are don't care in Alarm comparison. * Only SS[2:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_4: SS[14:4] are don't care in Alarm comparison. * Only SS[3:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_5: SS[14:5] are don't care in Alarm comparison. * Only SS[4:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_6: SS[14:6] are don't care in Alarm comparison. * Only SS[5:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_7: SS[14:7] are don't care in Alarm comparison. * Only SS[6:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_8: SS[14:8] are don't care in Alarm comparison. * Only SS[7:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_9: SS[14:9] are don't care in Alarm comparison. * Only SS[8:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_10: SS[14:10] are don't care in Alarm comparison. * Only SS[9:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_11: SS[14:11] are don't care in Alarm comparison. * Only SS[10:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_12: SS[14:12] are don't care in Alarm comparison. * Only SS[11:0] are compared * @arg RTC_AlarmSubSecondMask_SS14_13: SS[14:13] are don't care in Alarm comparison. * Only SS[12:0] are compared * @arg RTC_AlarmSubSecondMask_SS14: SS[14] is don't care in Alarm comparison. * Only SS[13:0] are compared * @arg RTC_AlarmSubSecondMask_None: SS[14:0] are compared and must match to activate alarm * @retval None */ void RTC_AlarmSubSecondConfig(uint32_t RTC_Alarm, uint32_t RTC_AlarmSubSecondValue, uint8_t RTC_AlarmSubSecondMask) { uint32_t tmpreg = 0; /* Check the parameters */ assert_param(IS_RTC_ALARM(RTC_Alarm)); assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(RTC_AlarmSubSecondValue)); assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(RTC_AlarmSubSecondMask)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Configure the Alarm A or Alarm B SubSecond registers */ tmpreg = (uint32_t) (((uint32_t)(RTC_AlarmSubSecondValue)) | ((uint32_t)(RTC_AlarmSubSecondMask) << 24)); /* Configure the AlarmA SubSecond register */ RTC->ALRMASSR = tmpreg; /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @brief Gets the RTC Alarm Subseconds value. * @param RTC_Alarm: specifies the alarm to be read. * This parameter can be one of the following values: * @arg RTC_Alarm_A: to select Alarm A * @param None * @retval RTC Alarm Subseconds value. */ uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm) { uint32_t tmpreg = 0; /* Get the RTC_ALRMAR register */ tmpreg = (uint32_t)((RTC->ALRMASSR) & RTC_ALRMASSR_SS); return (tmpreg); } /** * @} */ /** * @brief Adds or substract one hour from the current time. * @param RTC_DayLightSaveOperation: the value of hour adjustment. * This parameter can be one of the following values: * @arg RTC_DayLightSaving_SUB1H: Substract one hour (winter time) * @arg RTC_DayLightSaving_ADD1H: Add one hour (summer time) * @param RTC_StoreOperation: Specifies the value to be written in the BCK bit * in CR register to store the operation. * This parameter can be one of the following values: * @arg RTC_StoreOperation_Reset: BCK Bit Reset * @arg RTC_StoreOperation_Set: BCK Bit Set * @retval None */ void RTC_DayLightSavingConfig(uint32_t RTC_DayLightSaving, uint32_t RTC_StoreOperation) { /* Check the parameters */ assert_param(IS_RTC_DAYLIGHT_SAVING(RTC_DayLightSaving)); assert_param(IS_RTC_STORE_OPERATION(RTC_StoreOperation)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Clear the bits to be configured */ RTC->CR &= (uint32_t)~(RTC_CR_BCK); /* Configure the RTC_CR register */ RTC->CR |= (uint32_t)(RTC_DayLightSaving | RTC_StoreOperation); /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @brief Returns the RTC Day Light Saving stored operation. * @param None * @retval RTC Day Light Saving stored operation. * - RTC_StoreOperation_Reset * - RTC_StoreOperation_Set */ uint32_t RTC_GetStoreOperation(void) { return (RTC->CR & RTC_CR_BCK); } /** * @} */ /** * @brief Configures the RTC output source (AFO_ALARM). * @param RTC_Output: Specifies which signal will be routed to the RTC output. * This parameter can be one of the following values: * @arg RTC_Output_Disable: No output selected * @arg RTC_Output_AlarmA: signal of AlarmA mapped to output * @arg RTC_Output_WakeUp: signal of WakeUp mapped to output * @param RTC_OutputPolarity: Specifies the polarity of the output signal. * This parameter can be one of the following: * @arg RTC_OutputPolarity_High: The output pin is high when the * ALRAF is high (depending on OSEL) * @arg RTC_OutputPolarity_Low: The output pin is low when the * ALRAF is high (depending on OSEL) * @retval None */ void RTC_OutputConfig(uint32_t RTC_Output, uint32_t RTC_OutputPolarity) { /* Check the parameters */ assert_param(IS_RTC_OUTPUT(RTC_Output)); assert_param(IS_RTC_OUTPUT_POL(RTC_OutputPolarity)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Clear the bits to be configured */ RTC->CR &= (uint32_t)~(RTC_CR_OSEL | RTC_CR_POL); /* Configure the output selection and polarity */ RTC->CR |= (uint32_t)(RTC_Output | RTC_OutputPolarity); /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @} */ /** * @brief Enables or disables the RTC clock to be output through the relative pin. * @param NewState: new state of the digital calibration Output. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_CalibOutputCmd(FunctionalState NewState) { /* Check the parameters */ assert_param(IS_FUNCTIONAL_STATE(NewState)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; if (NewState != DISABLE) { /* Enable the RTC clock output */ RTC->CR |= (uint32_t)RTC_CR_COE; } else { /* Disable the RTC clock output */ RTC->CR &= (uint32_t)~RTC_CR_COE; } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @brief Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz). * @param RTC_CalibOutput: Select the Calibration output Selection . * This parameter can be one of the following values: * @arg RTC_CalibOutput_512Hz: A signal has a regular waveform at 512Hz. * @arg RTC_CalibOutput_1Hz: A signal has a regular waveform at 1Hz. * @retval None */ void RTC_CalibOutputConfig(uint32_t RTC_CalibOutput) { /* Check the parameters */ assert_param(IS_RTC_CALIB_OUTPUT(RTC_CalibOutput)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /*clear flags before config*/ RTC->CR &= (uint32_t)~(RTC_CR_CALSEL); /* Configure the RTC_CR register */ RTC->CR |= (uint32_t)RTC_CalibOutput; /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @brief Configures the Smooth Calibration Settings. * @param RTC_SmoothCalibPeriod: Select the Smooth Calibration Period. * This parameter can be can be one of the following values: * @arg RTC_SmoothCalibPeriod_32sec: The smooth calibration periode is 32s. * @arg RTC_SmoothCalibPeriod_16sec: The smooth calibration periode is 16s. * @arg RTC_SmoothCalibPeriod_8sec: The smooth calibartion periode is 8s. * @param RTC_SmoothCalibPlusPulses: Select to Set or reset the CALP bit. * This parameter can be one of the following values: * @arg RTC_SmoothCalibPlusPulses_Set: Add one RTCCLK puls every 2**11 pulses. * @arg RTC_SmoothCalibPlusPulses_Reset: No RTCCLK pulses are added. * @param RTC_SmouthCalibMinusPulsesValue: Select the value of CALM[8:0] bits. * This parameter can be one any value from 0 to 0x000001FF. * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC Calib registers are configured * - ERROR: RTC Calib registers are not configured */ ErrorStatus RTC_SmoothCalibConfig(uint32_t RTC_SmoothCalibPeriod, uint32_t RTC_SmoothCalibPlusPulses, uint32_t RTC_SmouthCalibMinusPulsesValue) { ErrorStatus status = ERROR; uint32_t recalpfcount = 0; /* Check the parameters */ assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(RTC_SmoothCalibPeriod)); assert_param(IS_RTC_SMOOTH_CALIB_PLUS(RTC_SmoothCalibPlusPulses)); assert_param(IS_RTC_SMOOTH_CALIB_MINUS(RTC_SmouthCalibMinusPulsesValue)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* check if a calibration is pending*/ if ((RTC->ISR & RTC_ISR_RECALPF) != RESET) { /* wait until the Calibration is completed*/ while (((RTC->ISR & RTC_ISR_RECALPF) != RESET) && (recalpfcount != RECALPF_TIMEOUT)) { recalpfcount++; } } /* check if the calibration pending is completed or if there is no calibration operation at all*/ if ((RTC->ISR & RTC_ISR_RECALPF) == RESET) { /* Configure the Smooth calibration settings */ RTC->CALR = (uint32_t)((uint32_t)RTC_SmoothCalibPeriod | (uint32_t)RTC_SmoothCalibPlusPulses | (uint32_t)RTC_SmouthCalibMinusPulsesValue); status = SUCCESS; } else { status = ERROR; } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return (ErrorStatus)(status); } /** * @} */ /** * @brief Enables or Disables the RTC TimeStamp functionality with the * specified time stamp pin stimulating edge. * @param RTC_TimeStampEdge: Specifies the pin edge on which the TimeStamp is * activated. * This parameter can be one of the following: * @arg RTC_TimeStampEdge_Rising: the Time stamp event occurs on the rising * edge of the related pin. * @arg RTC_TimeStampEdge_Falling: the Time stamp event occurs on the * falling edge of the related pin. * @param NewState: new state of the TimeStamp. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_TimeStampCmd(uint32_t RTC_TimeStampEdge, FunctionalState NewState) { uint32_t tmpreg = 0; /*��Edge�ĸ��û�д�λ�Ķ���*/ /* Check the parameters */ assert_param(IS_RTC_TIMESTAMP_EDGE(RTC_TimeStampEdge)); assert_param(IS_FUNCTIONAL_STATE(NewState)); /* Get the RTC_CR register and clear the bits to be configured */ tmpreg = (uint32_t)(RTC->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE)); /* Get the new configuration */ if (NewState != DISABLE) { tmpreg |= (uint32_t)(RTC_TimeStampEdge | RTC_CR_TSE); } else { tmpreg |= (uint32_t)(RTC_TimeStampEdge); } /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Configure the Time Stamp TSEDGE and Enable bits */ RTC->CR = (uint32_t)tmpreg; /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @brief Get the RTC TimeStamp value and masks. * @param RTC_Format: specifies the format of the output parameters. * This parameter can be one of the following values: * @arg RTC_Format_BIN: Binary data format * @arg RTC_Format_BCD: BCD data format * @param RTC_StampTimeStruct: pointer to a RTC_TimeTypeDef structure that will * contains the TimeStamp time values. * @param RTC_StampDateStruct: pointer to a RTC_DateTypeDef structure that will * contains the TimeStamp date values. * @retval None */ void RTC_GetTimeStamp(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_StampTimeStruct, RTC_DateTypeDef* RTC_StampDateStruct) { uint32_t tmptime = 0, tmpdate = 0; /* Check the parameters */ assert_param(IS_RTC_FORMAT(RTC_Format)); /* Get the TimeStamp time and date registers values */ tmptime = (uint32_t)(RTC->TSTR & RTC_TR_RESERVED_MASK); tmpdate = (uint32_t)(RTC->TSDR & RTC_DR_RESERVED_MASK); /* Fill the Time structure fields with the read parameters */ RTC_StampTimeStruct->RTC_Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16); RTC_StampTimeStruct->RTC_Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8); RTC_StampTimeStruct->RTC_Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU)); RTC_StampTimeStruct->RTC_H12 = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16); /* Fill the Date structure fields with the read parameters */ RTC_StampDateStruct->RTC_Year = 0; RTC_StampDateStruct->RTC_Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8); RTC_StampDateStruct->RTC_Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU)); RTC_StampDateStruct->RTC_WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13); /* Check the input parameters format */ if (RTC_Format == RTC_Format_BIN) { /* Convert the Time structure parameters to Binary format */ RTC_StampTimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Hours); RTC_StampTimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Minutes); RTC_StampTimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Seconds); /* Convert the Date structure parameters to Binary format */ RTC_StampDateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Month); RTC_StampDateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Date); RTC_StampDateStruct->RTC_WeekDay = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_WeekDay); } } /** * @brief Get the RTC timestamp Subseconds value. * @param None * @retval RTC current timestamp Subseconds value. */ uint32_t RTC_GetTimeStampSubSecond(void) { /* Get timestamp subseconds values from the correspondent registers */ return (uint32_t)(RTC->TSSSR); } /** * @} */ /** * @brief Configures the select Tamper pin edge. * @param RTC_Tamper: Selected tamper pin. * This parameter can be any combination of the following values: * @arg RTC_Tamper_1: Select Tamper 1. * @arg RTC_Tamper_2: Select Tamper 2. * @param RTC_TamperTrigger: Specifies the trigger on the tamper pin that * stimulates tamper event. * This parameter can be one of the following values: * @arg RTC_TamperTrigger_RisingEdge: Rising Edge of the tamper pin causes tamper event. * @arg RTC_TamperTrigger_FallingEdge: Falling Edge of the tamper pin causes tamper event. * @arg RTC_TamperTrigger_LowLevel: Low Level of the tamper pin causes tamper event. * @arg RTC_TamperTrigger_HighLevel: High Level of the tamper pin causes tamper event. * @retval None */ void RTC_TamperTriggerConfig(uint32_t RTC_Tamper, uint32_t RTC_TamperTrigger) { /* Check the parameters */ assert_param(IS_RTC_TAMPER(RTC_Tamper)); assert_param(IS_RTC_TAMPER_TRIGGER(RTC_TamperTrigger)); if (RTC_TamperTrigger == RTC_TamperTrigger_RisingEdge) { /* Configure the RTC_TAFCR register */ RTC->TAFCR &= (uint32_t)((uint32_t)~(RTC_Tamper << 1)); } else { /* Configure the RTC_TAFCR register */ RTC->TAFCR |= (uint32_t)(RTC_Tamper << 1); } } /** * @brief Enables or Disables the Tamper detection. * @param RTC_Tamper: Selected tamper pin. * This parameter can be any combination of the following values: * @arg RTC_Tamper_1: Select Tamper 1. * @arg RTC_Tamper_2: Select Tamper 2. * @param NewState: new state of the tamper pin. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_TamperCmd(uint32_t RTC_Tamper, FunctionalState NewState) { /* Check the parameters */ assert_param(IS_RTC_TAMPER(RTC_Tamper)); assert_param(IS_FUNCTIONAL_STATE(NewState)); if (NewState != DISABLE) { /* Enable the selected Tamper pin */ RTC->TAFCR |= (uint32_t)RTC_Tamper; } else { /* Disable the selected Tamper pin */ RTC->TAFCR &= (uint32_t)~RTC_Tamper; } } /** * @brief Configures the Tampers Filter. * @param RTC_TamperFilter: Specifies the tampers filter. * This parameter can be one of the following values: * @arg RTC_TamperFilter_Disable: Tamper filter is disabled. * @arg RTC_TamperFilter_2Sample: Tamper is activated after 2 consecutive * samples at the active level * @arg RTC_TamperFilter_4Sample: Tamper is activated after 4 consecutive * samples at the active level * @arg RTC_TamperFilter_8Sample: Tamper is activated after 8 consecutive * samples at the active level * @retval None */ void RTC_TamperFilterConfig(uint32_t RTC_TamperFilter) { /* Check the parameters */ assert_param(IS_RTC_TAMPER_FILTER(RTC_TamperFilter)); /* Clear TAMPFLT[1:0] bits in the RTC_TAFCR register */ RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFLT); /* Configure the RTC_TAFCR register */ RTC->TAFCR |= (uint32_t)RTC_TamperFilter; } /** * @brief Configures the Tampers Sampling Frequency. * @param RTC_TamperSamplingFreq: Specifies the tampers Sampling Frequency. * This parameter can be one of the following values: * @arg RTC_TamperSamplingFreq_RTCCLK_Div32768: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 32768 * @arg RTC_TamperSamplingFreq_RTCCLK_Div16384: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 16384 * @arg RTC_TamperSamplingFreq_RTCCLK_Div8192: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 8192 * @arg RTC_TamperSamplingFreq_RTCCLK_Div4096: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 4096 * @arg RTC_TamperSamplingFreq_RTCCLK_Div2048: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 2048 * @arg RTC_TamperSamplingFreq_RTCCLK_Div1024: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 1024 * @arg RTC_TamperSamplingFreq_RTCCLK_Div512: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 512 * @arg RTC_TamperSamplingFreq_RTCCLK_Div256: Each of the tamper inputs are sampled * with a frequency = RTCCLK / 256 * @retval None */ void RTC_TamperSamplingFreqConfig(uint32_t RTC_TamperSamplingFreq) { /* Check the parameters */ assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(RTC_TamperSamplingFreq)); /* Clear TAMPFREQ[2:0] bits in the RTC_TAFCR register */ RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFREQ); /* Configure the RTC_TAFCR register */ RTC->TAFCR |= (uint32_t)RTC_TamperSamplingFreq; } /** * @brief Configures the Tampers Pins input Precharge Duration. * @param RTC_TamperPrechargeDuration: Specifies the Tampers Pins input * Precharge Duration. * This parameter can be one of the following values: * @arg RTC_TamperPrechargeDuration_1RTCCLK: Tamper pins are pre-charged before sampling during 1 RTCCLK cycle * @arg RTC_TamperPrechargeDuration_2RTCCLK: Tamper pins are pre-charged before sampling during 2 RTCCLK cycle * @arg RTC_TamperPrechargeDuration_4RTCCLK: Tamper pins are pre-charged before sampling during 4 RTCCLK cycle * @arg RTC_TamperPrechargeDuration_8RTCCLK: Tamper pins are pre-charged before sampling during 8 RTCCLK cycle * @retval None */ void RTC_TamperPinsPrechargeDuration(uint32_t RTC_TamperPrechargeDuration) { /* Check the parameters */ assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(RTC_TamperPrechargeDuration)); /* Clear TAMPPRCH[1:0] bits in the RTC_TAFCR register */ RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPPRCH); /* Configure the RTC_TAFCR register */ RTC->TAFCR |= (uint32_t)RTC_TamperPrechargeDuration; } /** * @brief Enables or Disables the TimeStamp on Tamper Detection Event. * @note The timestamp is valid even the TSE bit in tamper control register * is reset. * @param NewState: new state of the timestamp on tamper event. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_TimeStampOnTamperDetectionCmd(FunctionalState NewState) { /* Check the parameters */ assert_param(IS_FUNCTIONAL_STATE(NewState)); if (NewState != DISABLE) { /* Save timestamp on tamper detection event */ RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPTS; } else { /* Tamper detection does not cause a timestamp to be saved */ RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPTS; } } /** * @brief Enables or Disables the Precharge of Tamper pin. * @param NewState: new state of tamper pull up. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_TamperPullUpCmd(FunctionalState NewState) { /* Check the parameters */ assert_param(IS_FUNCTIONAL_STATE(NewState)); if (NewState != DISABLE) { /* Enable precharge of the selected Tamper pin */ RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPPUDIS; } else { /* Disable precharge of the selected Tamper pin */ RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPPUDIS; } } /** * @} */ /** * @brief Configures the RTC Output Pin mode. * @param RTC_OutputType: specifies the RTC Output (PC13) pin mode. * This parameter can be one of the following values: * @arg RTC_OutputType_OpenDrain: RTC Output (PC13) is configured in * Open Drain mode. * @arg RTC_OutputType_PushPull: RTC Output (PC13) is configured in * Push Pull mode. * @retval None */ void RTC_OutputTypeConfig(uint32_t RTC_OutputType) { /* Check the parameters */ assert_param(IS_RTC_OUTPUT_TYPE(RTC_OutputType)); RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_ALARMOUTTYPE); RTC->TAFCR |= (uint32_t)(RTC_OutputType); } /** * @} */ /** * @brief Configures the Synchronization Shift Control Settings. * @note When REFCKON is set, firmware must not write to Shift control register * @param RTC_ShiftAdd1S: Select to add or not 1 second to the time Calendar. * This parameter can be one of the following values : * @arg RTC_ShiftAdd1S_Set: Add one second to the clock calendar. * @arg RTC_ShiftAdd1S_Reset: No effect. * @param RTC_ShiftSubFS: Select the number of Second Fractions to Substitute. * This parameter can be one any value from 0 to 0x7FFF. * @retval An ErrorStatus enumeration value: * - SUCCESS: RTC Shift registers are configured * - ERROR: RTC Shift registers are not configured */ ErrorStatus RTC_SynchroShiftConfig(uint32_t RTC_ShiftAdd1S, uint32_t RTC_ShiftSubFS) { ErrorStatus status = ERROR; uint32_t shpfcount = 0; /* Check the parameters */ assert_param(IS_RTC_SHIFT_ADD1S(RTC_ShiftAdd1S)); assert_param(IS_RTC_SHIFT_SUBFS(RTC_ShiftSubFS)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; /* Check if a Shift is pending*/ if ((RTC->ISR & RTC_ISR_SHPF) != RESET) { /* Wait until the shift is completed*/ while (((RTC->ISR & RTC_ISR_SHPF) != RESET) && (shpfcount != SHPF_TIMEOUT)) { shpfcount++; } } /* Check if the Shift pending is completed or if there is no Shift operation at all*/ if ((RTC->ISR & RTC_ISR_SHPF) == RESET) { /* check if the reference clock detection is disabled */ if((RTC->CR & RTC_CR_REFCKON) == RESET) { /* Configure the Shift settings */ RTC->SHIFTR = (uint32_t)(uint32_t)(RTC_ShiftSubFS) | (uint32_t)(RTC_ShiftAdd1S); if(RTC_WaitForSynchro() == ERROR) { status = ERROR; } else { status = SUCCESS; } } else { status = ERROR; } } else { status = ERROR; } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; return (ErrorStatus)(status); } /** * @} */ /** * @brief Enables or disables the specified RTC interrupts. * @param RTC_IT: specifies the RTC interrupt sources to be enabled or disabled. * This parameter can be any combination of the following values: * @arg RTC_IT_TS: Time Stamp interrupt mask * @arg RTC_IT_WUT: WakeUp Timer interrupt mask * @arg RTC_IT_ALRA: Alarm A interrupt mask * @arg RTC_IT_TAMP: Tamper event interrupt mask * @param NewState: new state of the specified RTC interrupts. * This parameter can be: ENABLE or DISABLE. * @retval None */ void RTC_ITConfig(uint32_t RTC_IT, FunctionalState NewState) { /* Check the parameters */ assert_param(IS_RTC_CONFIG_IT(RTC_IT)); assert_param(IS_FUNCTIONAL_STATE(NewState)); /* Disable the write protection for RTC registers */ RTC->WPR = 0xCA; RTC->WPR = 0x53; if (NewState != DISABLE) { /* Configure the Interrupts in the RTC_CR register */ RTC->CR |= (uint32_t)(RTC_IT & ~RTC_TAFCR_TAMPIE); /* Configure the Tamper Interrupt in the RTC_TAFCR */ RTC->TAFCR |= (uint32_t)(RTC_IT & RTC_TAFCR_TAMPIE); } else { /* Configure the Interrupts in the RTC_CR register */ RTC->CR &= (uint32_t)~(RTC_IT & (uint32_t)~RTC_TAFCR_TAMPIE); /* Configure the Tamper Interrupt in the RTC_TAFCR */ RTC->TAFCR &= (uint32_t)~(RTC_IT & RTC_TAFCR_TAMPIE); } /* Enable the write protection for RTC registers */ RTC->WPR = 0xFF; } /** * @brief Checks whether the specified RTC flag is set or not. * @param RTC_FLAG: specifies the flag to check. * This parameter can be one of the following values: * @arg RTC_FLAG_RECALPF: RECALPF event flag * @arg RTC_FLAG_TAMP2F: Tamper 2 event flag * @arg RTC_FLAG_TAMP1F: Tamper 1 event flag * @arg RTC_FLAG_TSOVF: Time Stamp OverFlow flag * @arg RTC_FLAG_TSF: Time Stamp event flag * @arg RTC_FLAG_WUTF: WakeUp Timer flag * @arg RTC_FLAG_ALRAF: Alarm A flag * @arg RTC_FLAG_INITF: Initialization mode flag * @arg RTC_FLAG_RSF: Registers Synchronized flag * @arg RTC_FLAG_INITS: Registers Configured flag * @retval The new state of RTC_FLAG (SET or RESET). */ FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG) { FlagStatus bitstatus = RESET; uint32_t tmpreg = 0; /* Check the parameters */ assert_param(IS_RTC_GET_FLAG(RTC_FLAG)); /* Get all the flags */ tmpreg = (uint32_t)(RTC->ISR & RTC_FLAGS_MASK); /* Return the status of the flag */ if ((tmpreg & RTC_FLAG) != (uint32_t)RESET) { bitstatus = SET; } else { bitstatus = RESET; } return bitstatus; } /** * @brief Clears the RTC's pending flags. * @param RTC_FLAG: specifies the RTC flag to clear. * This parameter can be any combination of the following values: * @arg RTC_FLAG_TAMP2F: Tamper 2 event flag * @arg RTC_FLAG_TAMP1F: Tamper 1 event flag * @arg RTC_FLAG_TSOVF: Time Stamp Overflow flag * @arg RTC_FLAG_TSF: Time Stamp event flag * @arg RTC_FLAG_WUTF: WakeUp Timer flag * @arg RTC_FLAG_ALRAF: Alarm A flag * @arg RTC_FLAG_RSF: Registers Synchronized flag * @retval None */ void RTC_ClearFlag(uint32_t RTC_FLAG) { /* Check the parameters */ assert_param(IS_RTC_CLEAR_FLAG(RTC_FLAG)); /* Clear the Flags in the RTC_ISR register */ RTC->ISR = (uint32_t)((uint32_t)(~((RTC_FLAG | RTC_ISR_INIT)& 0x0001FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); } /** * @brief Checks whether the specified RTC interrupt has occurred or not. * @param RTC_IT: specifies the RTC interrupt source to check. * This parameter can be one of the following values: * @arg RTC_IT_TS: Time Stamp interrupt * @arg RTC_IT_WUT: WakeUp Timer interrupt * @arg RTC_IT_ALRA: Alarm A interrupt * @arg RTC_IT_TAMP1: Tamper1 event interrupt * @arg RTC_IT_TAMP2: Tamper2 event interrupt * @retval The new state of RTC_IT (SET or RESET). */ ITStatus RTC_GetITStatus(uint32_t RTC_IT) { ITStatus bitstatus = RESET; uint32_t tmpreg = 0, enablestatus = 0; /* Check the parameters */ assert_param(IS_RTC_GET_IT(RTC_IT)); /* Get the TAMPER Interrupt enable bit and pending bit */ tmpreg = (uint32_t)(RTC->TAFCR & (RTC_TAFCR_TAMPIE)); /* Get the Interrupt enable Status */ enablestatus = (uint32_t)((RTC->CR & RTC_IT) | (tmpreg & ((RTC_IT >> (RTC_IT >> 18)) >> 15))); /* Get the Interrupt pending bit */ tmpreg = (uint32_t)((RTC->ISR & (uint32_t)(RTC_IT >> 4))); /* Get the status of the Interrupt */ if ((enablestatus != (uint32_t)RESET) && ((tmpreg & 0x0000FFFF) != (uint32_t)RESET)) { bitstatus = SET; } else { bitstatus = RESET; } return bitstatus; } /** * @brief Clears the RTC's interrupt pending bits. * @param RTC_IT: specifies the RTC interrupt pending bit to clear. * This parameter can be any combination of the following values: * @arg RTC_IT_TS: Time Stamp interrupt * @arg RTC_IT_WUT: WakeUp Timer interrupt * @arg RTC_IT_ALRA: Alarm A interrupt * @arg RTC_IT_TAMP1: Tamper1 event interrupt * @arg RTC_IT_TAMP2: Tamper2 event interrupt * @retval None */ void RTC_ClearITPendingBit(uint32_t RTC_IT) { uint32_t tmpreg = 0; /* Check the parameters */ assert_param(IS_RTC_CLEAR_IT(RTC_IT)); /* Get the RTC_ISR Interrupt pending bits mask */ tmpreg = (uint32_t)(RTC_IT >> 4); /* Clear the interrupt pending bits in the RTC_ISR register */ RTC->ISR = (uint32_t)((uint32_t)(~((tmpreg | RTC_ISR_INIT)& 0x0000FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); } /** * @} */ /** * @brief Converts a 2 digit decimal to BCD format. * @param Value: Byte to be converted. * @retval Converted byte */ static uint8_t RTC_ByteToBcd2(uint8_t Value) { uint8_t bcdhigh = 0; while (Value >= 10) { bcdhigh++; Value -= 10; } return ((uint8_t)(bcdhigh << 4) | Value); } /** * @brief Convert from 2 digit BCD to Binary. * @param Value: BCD value to be converted. * @retval Converted word */ static uint8_t RTC_Bcd2ToByte(uint8_t Value) { uint8_t tmp = 0; tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10; return (tmp + (Value & (uint8_t)0x0F)); } /** * @} */ /** * @} */ /** * @} */ /************************ (C) COPYRIGHT FMD *****END OF FILE****/