/** | |
****************************************************************************** | |
* @file stm32l1xx_rtc.c | |
* @author MCD Application Team | |
* @version V1.1.1 | |
* @date 05-March-2012 | |
* @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 and Alarm B) configuration | |
* + WakeUp Timer configuration | |
* + Daylight Saving configuration | |
* + Output pin Configuration | |
* + Coarse digital Calibration configuration | |
* + Smooth digital Calibration configuration | |
* + TimeStamp configuration | |
* + Tampers configuration | |
* + Backup Data Registers configuration | |
* + Output Type Config configuration | |
* + Shift control synchronisation | |
* + Interrupts and flags management | |
* | |
@verbatim | |
=============================================================================== | |
##### RTC Domain Reset ##### | |
=============================================================================== | |
[..] After power-on reset, the RTC domain (RTC clock source configuration, | |
RTC registers and RTC Backup data registers) is reset. You can also | |
reset this domain by software using the RCC_RTCResetCmd() function. | |
##### RTC Operating Condition ##### | |
=============================================================================== | |
[..] As long as the supply voltage remains in the operating range, | |
the RTC never stops, regardless of the device status (Run mode, | |
low power modes or under reset). | |
##### RTC Domain Access ##### | |
=============================================================================== | |
[..] After reset, the RTC domain (RTC clock source configuration, | |
RTC registers and RTC Backup data registers) are protected against | |
possible stray write accesses. | |
[..] To enable access to the RTC Domain and RTC registers, proceed as follows: | |
(+) Enable the Power Controller (PWR) APB1 interface clock using the | |
RCC_APB1PeriphClockCmd() function. | |
(+) Enable access to RTC domain using the PWR_RTCAccessCmd() function. | |
(+) Select the RTC clock source using the RCC_RTCCLKConfig() function. | |
(+) Enable RTC Clock using the RCC_RTCCLKCmd() function. | |
##### How to use this driver ##### | |
=============================================================================== | |
[..] | |
(+) Enable the RTC domain access (see description in the section above) | |
(+) Configure the RTC Prescaler (Asynchronous and Synchronous) and | |
RTC hour format using the RTC_Init() function. | |
***Time and Date configuration *** | |
================================== | |
[..] | |
(+) To configure the RTC Calendar (Time and Date) use the RTC_SetTime() | |
and RTC_SetDate() functions. | |
(+) To read the RTC Calendar, use the RTC_GetTime() and RTC_GetDate() | |
functions. | |
(+) To read the RTC subsecond, use the RTC_GetSubSecond() function. | |
(+) Use the RTC_DayLightSavingConfig() function to add or sub one | |
hour to the RTC Calendar. | |
***Alarm configuration *** | |
========================== | |
[..] | |
(+) To configure the RTC Alarm use the RTC_SetAlarm() function. | |
(+) Enable the selected RTC Alarm using the RTC_AlarmCmd() function | |
(+) To read the RTC Alarm, use the RTC_GetAlarm() function. | |
(+) To read the RTC alarm SubSecond, use the RTC_GetAlarmSubSecond() function. | |
***RTC Wakeup configuration *** | |
=============================== | |
[..] | |
(+) Configure the RTC Wakeup Clock source use the RTC_WakeUpClockConfig() | |
function. | |
(+) Configure the RTC WakeUp Counter using the RTC_SetWakeUpCounter() | |
function. | |
(+) Enable the RTC WakeUp using the RTC_WakeUpCmd() function | |
(+) To read the RTC WakeUp Counter register, use the RTC_GetWakeUpCounter() | |
function. | |
***Outputs configuration *** | |
============================ | |
[..] The RTC has 2 different outputs: | |
(+) AFO_ALARM: this output is used to manage the RTC Alarm A, Alarm B | |
and WaKeUp signals. | |
To output the selected RTC signal on RTC_AF1 pin, use the | |
RTC_OutputConfig() function. | |
(+) AFO_CALIB: this output is 512Hz signal or 1Hz. | |
To output the RTC Clock on RTC_AF1 pin, use the RTC_CalibOutputCmd() | |
function. | |
***Smooth digital Calibration configuration *** | |
=============================================== | |
[..] | |
(+) Configure the RTC Original Digital Calibration Value and the corresponding | |
calibration cycle period (32s,16s and 8s) using the RTC_SmoothCalibConfig() | |
function. | |
***Coarse digital Calibration configuration *** | |
=============================================== | |
[..] | |
(+) Configure the RTC Coarse Calibration Value and the corresponding | |
sign using the RTC_CoarseCalibConfig() function. | |
(+) Enable the RTC Coarse Calibration using the RTC_CoarseCalibCmd() | |
function. | |
***TimeStamp configuration *** | |
============================== | |
[..] | |
(+) Configure the RTC_AF1 trigger and enables the RTC TimeStamp | |
using the RTC_TimeStampCmd() function. | |
(+) To read the RTC TimeStamp Time and Date register, use the | |
RTC_GetTimeStamp() function. | |
(+) To read the RTC TimeStamp SubSecond register, use the | |
RTC_GetTimeStampSubSecond() function. | |
***Tamper configuration *** | |
=========================== | |
[..] | |
(+) Configure the Tamper filter count using RTC_TamperFilterConfig() | |
function. | |
(+) Configure the RTC Tamper trigger Edge or Level according to the Tamper | |
filter (if equal to 0 Edge else Level) value using the RTC_TamperConfig() | |
function. | |
(+) Configure the Tamper sampling frequency using RTC_TamperSamplingFreqConfig() | |
function. | |
(+) Configure the Tamper precharge or discharge duration using | |
RTC_TamperPinsPrechargeDuration() function. | |
(+) Enable the Tamper Pull-UP using RTC_TamperPullUpDisableCmd() function. | |
(+) Enable the RTC Tamper using the RTC_TamperCmd() function. | |
(+) Enable the Time stamp on Tamper detection event using | |
RTC_TSOnTamperDetecCmd() function. | |
***Backup Data Registers configuration *** | |
========================================== | |
[..] | |
(+) To write to the RTC Backup Data registers, use the RTC_WriteBackupRegister() | |
function. | |
(+) To read the RTC Backup Data registers, use the RTC_ReadBackupRegister() | |
function. | |
##### RTC and low power modes ##### | |
=============================================================================== | |
[..] The MCU can be woken up from a low power mode by an RTC alternate | |
function. | |
[..] The RTC alternate functions are the RTC alarms (Alarm A and Alarm B), | |
RTC wakeup, RTC tamper event detection and RTC time stamp event detection. | |
These RTC alternate functions can wake up the system from the Stop | |
and Standby lowpower modes. | |
The system can also wake up from low power modes without depending | |
on an external interrupt (Auto-wakeup mode), by using the RTC alarm | |
or the RTC wakeup events. | |
[..] The RTC provides a programmable time base for waking up from the | |
Stop or Standby mode at regular intervals. | |
Wakeup from STOP and Standby modes is possible only when the RTC | |
clock source is LSE or LSI. | |
##### Selection of RTC_AF1 alternate functions ##### | |
=============================================================================== | |
[..] The RTC_AF1 pin (PC13) can be used for the following purposes: | |
(+) Wakeup pin 2 (WKUP2) using the PWR_WakeUpPinCmd() function. | |
(+) AFO_ALARM output. | |
(+) AFO_CALIB output. | |
(+) AFI_TAMPER. | |
(+) AFI_TIMESTAMP. | |
+------------------------------------------------------------------------------------------+ | |
| Pin |AFO_ALARM |AFO_CALIB |AFI_TAMPER |AFI_TIMESTAMP | WKUP2 |ALARMOUTTYPE | | |
| configuration | ENABLED | ENABLED | ENABLED | ENABLED |ENABLED | AFO_ALARM | | |
| and function | | | | | |Configuration | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| Alarm out | | | | | Don't | | | |
| output OD | 1 | 0 |Don't care | Don't care | care | 0 | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| Alarm out | | | | | Don't | | | |
| output PP | 1 | 0 |Don't care | Don't care | care | 1 | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| Calibration out | | | | | Don't | | | |
| output PP | 0 | 1 |Don't care | Don't care | care | Don't care | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| TAMPER input | | | | | Don't | | | |
| floating | 0 | 0 | 1 | 0 | care | Don't care | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| TIMESTAMP and | | | | | Don't | | | |
| TAMPER input | 0 | 0 | 1 | 1 | care | Don't care | | |
| floating | | | | | | | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| TIMESTAMP input | | | | | Don't | | | |
| floating | 0 | 0 | 0 | 1 | care | Don't care | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| Wakeup Pin 2 | 0 | 0 | 0 | 0 | 1 | Don't care | | |
|-----------------|----------|----------|-----------|--------------|--------|--------------| | |
| Standard GPIO | 0 | 0 | 0 | 0 | 0 | Don't care | | |
+------------------------------------------------------------------------------------------+ | |
@endverbatim | |
****************************************************************************** | |
* @attention | |
* | |
* <h2><center>© COPYRIGHT 2012 STMicroelectronics</center></h2> | |
* | |
* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); | |
* You may not use this file except in compliance with the License. | |
* You may obtain a copy of the License at: | |
* | |
* http://www.st.com/software_license_agreement_liberty_v2 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
* | |
****************************************************************************** | |
*/ | |
/* Includes ------------------------------------------------------------------*/ | |
#include "stm32l1xx_rtc.h" | |
#include "stm32l1xx_rcc.h" | |
/** @addtogroup STM32L1xx_StdPeriph_Driver | |
* @{ | |
*/ | |
/** @defgroup RTC | |
* @brief RTC driver modules | |
* @{ | |
*/ | |
/* Private typedef -----------------------------------------------------------*/ | |
/* Private define ------------------------------------------------------------*/ | |
/* 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_WUTF | \ | |
RTC_FLAG_ALRBF | RTC_FLAG_ALRAF | RTC_FLAG_INITF | \ | |
RTC_FLAG_RSF | RTC_FLAG_INITS | RTC_FLAG_WUTWF | \ | |
RTC_FLAG_ALRBWF | RTC_FLAG_ALRAWF | RTC_FLAG_TAMP1F | \ | |
RTC_FLAG_TAMP2F | RTC_FLAG_TAMP3F | RTC_FLAG_RECALPF | \ | |
RTC_FLAG_SHPF)) | |
#define INITMODE_TIMEOUT ((uint32_t) 0x00002000) | |
#define SYNCHRO_TIMEOUT ((uint32_t) 0x00008000) | |
#define RECALPF_TIMEOUT ((uint32_t) 0x00001000) | |
#define SHPF_TIMEOUT ((uint32_t) 0x00002000) | |
/* Private macro -------------------------------------------------------------*/ | |
/* Private variables ---------------------------------------------------------*/ | |
/* Private function prototypes -----------------------------------------------*/ | |
static uint8_t RTC_ByteToBcd2(uint8_t Value); | |
static uint8_t RTC_Bcd2ToByte(uint8_t Value); | |
/* Private functions ---------------------------------------------------------*/ | |
/** @defgroup RTC_Private_Functions | |
* @{ | |
*/ | |
/** @defgroup RTC_Group1 Initialization and Configuration functions | |
* @brief Initialization and Configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Initialization and Configuration functions ##### | |
=============================================================================== | |
[..] This section provide functions allowing to initialize and configure the | |
RTC Prescaler (Synchronous and Asynchronous), RTC Hour format, disable | |
RTC registers Write protection, enter and exit the RTC initialization mode, | |
RTC registers synchronization check and reference clock detection enable. | |
(#) The RTC Prescaler is programmed to generate the RTC 1Hz time base. | |
It is split into 2 programmable prescalers to minimize power consumption. | |
(++) A 7-bit asynchronous prescaler and A 13-bit synchronous prescaler. | |
(++) When both prescalers are used, it is recommended to configure the | |
asynchronous prescaler to a high value to minimize consumption. | |
(#) All RTC registers are Write protected. Writing to the RTC registers | |
is enabled by writing a key into the Write Protection register, RTC_WPR. | |
(#) To Configure the RTC Calendar, user application should enter | |
initialization mode. In this mode, the calendar counter is stopped | |
and its value can be updated. When the initialization sequence is | |
complete, the calendar restarts counting after 4 RTCCLK cycles. | |
(#) 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.The RTC_WaitForSynchro() function | |
implements the above software sequence (RSF clear and RSF check). | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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) | |
{ | |
__IO uint32_t wutcounter = 0x00; | |
uint32_t wutwfstatus = 0x00; | |
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; | |
/* Reset All CR bits except CR[2:0] */ | |
RTC->CR &= (uint32_t)0x00000007; | |
/* Wait till RTC WUTWF flag is set and if Time out is reached exit */ | |
do | |
{ | |
wutwfstatus = RTC->ISR & RTC_ISR_WUTWF; | |
wutcounter++; | |
} while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00)); | |
if ((RTC->ISR & RTC_ISR_WUTWF) == RESET) | |
{ | |
status = ERROR; | |
} | |
else | |
{ | |
/* Reset all RTC CR register bits */ | |
RTC->CR &= (uint32_t)0x00000000; | |
RTC->WUTR = (uint32_t)0x0000FFFF; | |
RTC->PRER = (uint32_t)0x007F00FF; | |
RTC->CALIBR = (uint32_t)0x00000000; | |
RTC->ALRMAR = (uint32_t)0x00000000; | |
RTC->ALRMBR = (uint32_t)0x00000000; | |
RTC->SHIFTR = (uint32_t)0x00000000; | |
RTC->CALR = (uint32_t)0x00000000; | |
RTC->ALRMASSR = (uint32_t)0x00000000; | |
RTC->ALRMBSSR = (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; | |
} | |
/** | |
* @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; | |
/* 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; | |
} | |
/* Enable 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; | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group2 Time and Date configuration functions | |
* @brief Time and Date configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Time and Date configuration functions ##### | |
=============================================================================== | |
[..] This section provide functions allowing to program and read the RTC | |
Calendar (Time and Date). | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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); | |
} | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group3 Alarms configuration functions | |
* @brief Alarms (Alarm A and Alarm B) configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Alarms (Alarm A and Alarm B) configuration functions ##### | |
=============================================================================== | |
[..] This section provide functions allowing to program and read the RTC | |
Alarms. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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. | |
* @arg RTC_Alarm_B: to select Alarm B. | |
* @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_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 */ | |
if (RTC_Alarm == RTC_Alarm_A) | |
{ | |
RTC->ALRMAR = (uint32_t)tmpreg; | |
} | |
else | |
{ | |
RTC->ALRMBR = (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. | |
* @arg RTC_Alarm_B: to select Alarm B. | |
* @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_ALRMxR register */ | |
if (RTC_Alarm == RTC_Alarm_A) | |
{ | |
tmpreg = (uint32_t)(RTC->ALRMAR); | |
} | |
else | |
{ | |
tmpreg = (uint32_t)(RTC->ALRMBR); | |
} | |
/* 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. | |
* @arg RTC_Alarm_B: to select Alarm B. | |
* @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. | |
* @arg RTC_Alarm_B: to select Alarm B. | |
* @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, uint32_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); | |
if (RTC_Alarm == RTC_Alarm_A) | |
{ | |
/* Configure the AlarmA SubSecond register */ | |
RTC->ALRMASSR = tmpreg; | |
} | |
else | |
{ | |
/* Configure the Alarm B SubSecond register */ | |
RTC->ALRMBSSR = 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. | |
* @arg RTC_Alarm_B: to select Alarm B. | |
* @param None | |
* @retval RTC Alarm Subseconds value. | |
*/ | |
uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm) | |
{ | |
uint32_t tmpreg = 0; | |
/* Get the RTC_ALRMxR register */ | |
if (RTC_Alarm == RTC_Alarm_A) | |
{ | |
tmpreg = (uint32_t)((RTC->ALRMASSR) & RTC_ALRMASSR_SS); | |
} | |
else | |
{ | |
tmpreg = (uint32_t)((RTC->ALRMBSSR) & RTC_ALRMBSSR_SS); | |
} | |
return (tmpreg); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group4 WakeUp Timer configuration functions | |
* @brief WakeUp Timer configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### WakeUp Timer configuration functions ##### | |
=============================================================================== | |
[..] This section provide functions allowing to program and read the RTC WakeUp. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief Configures the RTC Wakeup clock source. | |
* @note The WakeUp Clock source can only be changed when the RTC WakeUp | |
* is disabled (Use the RTC_WakeUpCmd(DISABLE)). | |
* @param RTC_WakeUpClock: Wakeup Clock source. | |
* This parameter can be one of the following values: | |
* @arg RTC_WakeUpClock_RTCCLK_Div16: RTC Wakeup Counter Clock = RTCCLK/16. | |
* @arg RTC_WakeUpClock_RTCCLK_Div8: RTC Wakeup Counter Clock = RTCCLK/8. | |
* @arg RTC_WakeUpClock_RTCCLK_Div4: RTC Wakeup Counter Clock = RTCCLK/4. | |
* @arg RTC_WakeUpClock_RTCCLK_Div2: RTC Wakeup Counter Clock = RTCCLK/2. | |
* @arg RTC_WakeUpClock_CK_SPRE_16bits: RTC Wakeup Counter Clock = CK_SPRE. | |
* @arg RTC_WakeUpClock_CK_SPRE_17bits: RTC Wakeup Counter Clock = CK_SPRE. | |
* @retval None | |
*/ | |
void RTC_WakeUpClockConfig(uint32_t RTC_WakeUpClock) | |
{ | |
/* Check the parameters */ | |
assert_param(IS_RTC_WAKEUP_CLOCK(RTC_WakeUpClock)); | |
/* Disable the write protection for RTC registers */ | |
RTC->WPR = 0xCA; | |
RTC->WPR = 0x53; | |
/* Clear the Wakeup Timer clock source bits in CR register */ | |
RTC->CR &= (uint32_t)~RTC_CR_WUCKSEL; | |
/* Configure the clock source */ | |
RTC->CR |= (uint32_t)RTC_WakeUpClock; | |
/* Enable the write protection for RTC registers */ | |
RTC->WPR = 0xFF; | |
} | |
/** | |
* @brief Configures the RTC Wakeup counter. | |
* @note The RTC WakeUp counter can only be written when the RTC WakeUp. | |
* is disabled (Use the RTC_WakeUpCmd(DISABLE)). | |
* @param RTC_WakeUpCounter: specifies the WakeUp counter. | |
* This parameter can be a value from 0x0000 to 0xFFFF. | |
* @retval None | |
*/ | |
void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter) | |
{ | |
/* Check the parameters */ | |
assert_param(IS_RTC_WAKEUP_COUNTER(RTC_WakeUpCounter)); | |
/* Disable the write protection for RTC registers */ | |
RTC->WPR = 0xCA; | |
RTC->WPR = 0x53; | |
/* Configure the Wakeup Timer counter */ | |
RTC->WUTR = (uint32_t)RTC_WakeUpCounter; | |
/* Enable the write protection for RTC registers */ | |
RTC->WPR = 0xFF; | |
} | |
/** | |
* @brief Returns the RTC WakeUp timer counter value. | |
* @param None | |
* @retval The RTC WakeUp Counter value. | |
*/ | |
uint32_t RTC_GetWakeUpCounter(void) | |
{ | |
/* Get the counter value */ | |
return ((uint32_t)(RTC->WUTR & RTC_WUTR_WUT)); | |
} | |
/** | |
* @brief Enables or Disables the RTC WakeUp timer. | |
* @param NewState: new state of the WakeUp timer. | |
* This parameter can be: ENABLE or DISABLE. | |
* @retval None | |
*/ | |
ErrorStatus RTC_WakeUpCmd(FunctionalState NewState) | |
{ | |
__IO uint32_t wutcounter = 0x00; | |
uint32_t wutwfstatus = 0x00; | |
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; | |
if (NewState != DISABLE) | |
{ | |
/* Enable the Wakeup Timer */ | |
RTC->CR |= (uint32_t)RTC_CR_WUTE; | |
status = SUCCESS; | |
} | |
else | |
{ | |
/* Disable the Wakeup Timer */ | |
RTC->CR &= (uint32_t)~RTC_CR_WUTE; | |
/* Wait till RTC WUTWF flag is set and if Time out is reached exit */ | |
do | |
{ | |
wutwfstatus = RTC->ISR & RTC_ISR_WUTWF; | |
wutcounter++; | |
} while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00)); | |
if ((RTC->ISR & RTC_ISR_WUTWF) == RESET) | |
{ | |
status = ERROR; | |
} | |
else | |
{ | |
status = SUCCESS; | |
} | |
} | |
/* Enable the write protection for RTC registers */ | |
RTC->WPR = 0xFF; | |
return status; | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group5 Daylight Saving configuration functions | |
* @brief Daylight Saving configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Daylight Saving configuration functions ##### | |
=============================================================================== | |
[..] This section provide functions allowing to configure the RTC DayLight Saving. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group6 Output pin Configuration function | |
* @brief Output pin Configuration function | |
* | |
@verbatim | |
=============================================================================== | |
##### Output pin Configuration function ##### | |
=============================================================================== | |
[..] This section provide functions allowing to configure the RTC Output source. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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_AlarmB: signal of AlarmB 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/ALRBF/WUTF is high (depending on OSEL). | |
* @arg RTC_OutputPolarity_Low: The output pin is low when the | |
* ALRAF/ALRBF/WUTF 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; | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group7 Coarse and Smooth Calibrations configuration functions | |
* @brief Coarse and Smooth Calibrations configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Coarse and Smooth Calibrations configuration functions ##### | |
=============================================================================== | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief Configures the Coarse Calibration parameters. | |
* @param RTC_CalibSign: specifies the sign of the calibration value. | |
* This parameter can be one of the following values: | |
* @arg RTC_CalibSign_Positive: The value sign is positive. | |
* @arg RTC_CalibSign_Negative: The value sign is negative. | |
* @param Value: value of calibration expressed in ppm (coded on 5 bits) | |
* This value should be between 0 and 63 when using negative sign | |
* with a 2-ppm step. | |
* This value should be between 0 and 126 when using positive sign | |
* with a 4-ppm step. | |
* @retval An ErrorStatus enumeration value: | |
* - SUCCESS: RTC Coarse calibration are initialized | |
* - ERROR: RTC Coarse calibration are not initialized | |
*/ | |
ErrorStatus RTC_CoarseCalibConfig(uint32_t RTC_CalibSign, uint32_t Value) | |
{ | |
ErrorStatus status = ERROR; | |
/* Check the parameters */ | |
assert_param(IS_RTC_CALIB_SIGN(RTC_CalibSign)); | |
assert_param(IS_RTC_CALIB_VALUE(Value)); | |
/* 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 coarse calibration value */ | |
RTC->CALIBR = (uint32_t)(RTC_CalibSign | Value); | |
/* Exit Initialization mode */ | |
RTC_ExitInitMode(); | |
status = SUCCESS; | |
} | |
/* Enable the write protection for RTC registers */ | |
RTC->WPR = 0xFF; | |
return status; | |
} | |
/** | |
* @brief Enables or disables the Coarse calibration process. | |
* @param NewState: new state of the Coarse calibration. | |
* This parameter can be: ENABLE or DISABLE. | |
* @retval An ErrorStatus enumeration value: | |
* - SUCCESS: RTC Coarse calibration are enabled/disabled | |
* - ERROR: RTC Coarse calibration are not enabled/disabled | |
*/ | |
ErrorStatus RTC_CoarseCalibCmd(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 Coarse Calibration */ | |
RTC->CR |= (uint32_t)RTC_CR_DCE; | |
} | |
else | |
{ | |
/* Disable the Coarse Calibration */ | |
RTC->CR &= (uint32_t)~RTC_CR_DCE; | |
} | |
/* Exit Initialization mode */ | |
RTC_ExitInitMode(); | |
status = SUCCESS; | |
} | |
/* Enable the write protection for RTC registers */ | |
RTC->WPR = 0xFF; | |
return status; | |
} | |
/** | |
* @brief Enables or disables the RTC clock to be output through the relative | |
* pin. | |
* @param NewState: new state of the coarse 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_COSEL); | |
/* 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); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group8 TimeStamp configuration functions | |
* @brief TimeStamp configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### TimeStamp configuration functions ##### | |
=============================================================================== | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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; | |
/* 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); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group9 Tampers configuration functions | |
* @brief Tampers configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Tampers configuration functions ##### | |
=============================================================================== | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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. | |
* @arg RTC_Tamper_3: Select Tamper 3. | |
* @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)); | |
/* Check if the active level for Tamper is rising edge (Low level)*/ | |
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. | |
* @arg RTC_Tamper_3: Select Tamper 3. | |
* @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; | |
} | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group10 Backup Data Registers configuration functions | |
* @brief Backup Data Registers configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Backup Data Registers configuration functions ##### | |
=============================================================================== | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief Writes a data in a specified RTC Backup data register. | |
* @param RTC_BKP_DR: RTC Backup data Register number. | |
* This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to | |
* specify the register. | |
* @param Data: Data to be written in the specified RTC Backup data register. | |
* @retval None | |
*/ | |
void RTC_WriteBackupRegister(uint32_t RTC_BKP_DR, uint32_t Data) | |
{ | |
__IO uint32_t tmp = 0; | |
/* Check the parameters */ | |
assert_param(IS_RTC_BKP(RTC_BKP_DR)); | |
tmp = RTC_BASE + 0x50; | |
tmp += (RTC_BKP_DR * 4); | |
/* Write the specified register */ | |
*(__IO uint32_t *)tmp = (uint32_t)Data; | |
} | |
/** | |
* @brief Reads data from the specified RTC Backup data Register. | |
* @param RTC_BKP_DR: RTC Backup data Register number. | |
* This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to | |
* specify the register. | |
* @retval None | |
*/ | |
uint32_t RTC_ReadBackupRegister(uint32_t RTC_BKP_DR) | |
{ | |
__IO uint32_t tmp = 0; | |
/* Check the parameters */ | |
assert_param(IS_RTC_BKP(RTC_BKP_DR)); | |
tmp = RTC_BASE + 0x50; | |
tmp += (RTC_BKP_DR * 4); | |
/* Read the specified register */ | |
return (*(__IO uint32_t *)tmp); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group11 Output Type Config configuration functions | |
* @brief Output Type Config configuration functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Output Type Config configuration functions ##### | |
=============================================================================== | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group12 Shift control synchronisation functions | |
* @brief Shift control synchronisation functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Shift control synchronisation functions ##### | |
=============================================================================== | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup RTC_Group13 Interrupts and flags management functions | |
* @brief Interrupts and flags management functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Interrupts and flags management functions ##### | |
=============================================================================== | |
[..] All RTC interrupts are connected to the EXTI controller. | |
(+) To enable the RTC Alarm interrupt, the following sequence is required: | |
(+) Configure and enable the EXTI Line 17 in interrupt mode and select | |
the rising edge sensitivity using the EXTI_Init() function. | |
(+) Configure and enable the RTC_Alarm IRQ channel in the NVIC using | |
the NVIC_Init() function. | |
(+) Configure the RTC to generate RTC alarms (Alarm A and/or Alarm B) | |
using the RTC_SetAlarm() and RTC_AlarmCmd() functions. | |
(+) To enable the RTC Wakeup interrupt, the following sequence is required: | |
(+) Configure and enable the EXTI Line 20 in interrupt mode and select | |
the rising edge sensitivity using the EXTI_Init() function. | |
(+) Configure and enable the RTC_WKUP IRQ channel in the NVIC using the | |
NVIC_Init() function. | |
(+) Configure the RTC to generate the RTC wakeup timer event using the | |
RTC_WakeUpClockConfig(), RTC_SetWakeUpCounter() and RTC_WakeUpCmd() | |
functions. | |
(+) To enable the RTC Tamper interrupt, the following sequence is required: | |
(+) Configure and enable the EXTI Line 19 in interrupt mode and select | |
the rising edge sensitivity using the EXTI_Init() function. | |
(+) Configure and enable the TAMP_STAMP IRQ channel in the NVIC using | |
the NVIC_Init() function. | |
(+) Configure the RTC to detect the RTC tamper event using the | |
RTC_TamperTriggerConfig() and RTC_TamperCmd() functions. | |
(+) To enable the RTC TimeStamp interrupt, the following sequence is | |
required: | |
(+) Configure and enable the EXTI Line 19 in interrupt mode and select | |
the rising edge sensitivity using the EXTI_Init() function. | |
(+) Configure and enable the TAMP_STAMP IRQ channel in the NVIC using | |
the NVIC_Init() function. | |
(+) Configure the RTC to detect the RTC time-stamp event using the | |
RTC_TimeStampCmd() functions. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @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_ALRB: Alarm B 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_TAMP3F: Tamper 3 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_ALRBF: Alarm B 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. | |
* @argRTC_FLAG_SHPF: Shift operation pending flag. | |
* @arg RTC_FLAG_WUTWF: WakeUp Timer Write flag. | |
* @arg RTC_FLAG_ALRBWF: Alarm B Write flag. | |
* @arg RTC_FLAG_ALRAWF: Alarm A write 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_TAMP3F: Tamper 3 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_ALRBF: Alarm B 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_ALRB: Alarm B interrupt. | |
* @arg RTC_IT_ALRA: Alarm A interrupt. | |
* @arg RTC_IT_TAMP1: Tamper1 event interrupt. | |
* @arg RTC_IT_TAMP2: Tamper2 event interrupt. | |
* @arg RTC_IT_TAMP3: Tamper3 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_ALRB: Alarm B interrupt | |
* @arg RTC_IT_ALRA: Alarm A interrupt | |
* @arg RTC_IT_TAMP1: Tamper1 event interrupt | |
* @arg RTC_IT_TAMP2: Tamper2 event interrupt | |
* @arg RTC_IT_TAMP3: Tamper3 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 STMicroelectronics *****END OF FILE****/ |