AMiRo-OS

/**

  ******************************************************************************

  * @file    stm32f4xx_rtc.c

  * @author  MCD Application Team

  * @version V1.1.0

  * @date    11-January-2013

  * @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

  *           + Shift control synchronisation    

  *           + RTC Tamper and TimeStamp Pins Selection and Output Type Config configuration

  *           + Interrupts and flags management

  *

@verbatim

 ===================================================================

              ##### Backup Domain Operating Condition #####

 ===================================================================

 [..] The real-time clock (RTC), the RTC backup registers, and the backup 

      SRAM (BKP SRAM) can be powered from the VBAT voltage when the main 

      VDD supply is powered off.

      To retain the content of the RTC backup registers, backup SRAM, and supply 

      the RTC when VDD is turned off, VBAT pin can be connected to an optional 

      standby voltage supplied by a battery or by another source.

 [..] To allow the RTC to operate even when the main digital supply (VDD) is turned

      off, the VBAT pin powers the following blocks:

   (#) The RTC

   (#) The LSE oscillator

   (#) The backup SRAM when the low power backup regulator is enabled

   (#) PC13 to PC15 I/Os, plus PI8 I/O (when available)

 [..] When the backup domain is supplied by VDD (analog switch connected to VDD),

      the following functions are available:

   (#) PC14 and PC15 can be used as either GPIO or LSE pins

   (#) PC13 can be used as a GPIO or as the RTC_AF1 pin

   (#) PI8 can be used as a GPIO or as the RTC_AF2 pin

 [..] When the backup domain is supplied by VBAT (analog switch connected to VBAT 

      because VDD is not present), the following functions are available:

   (#) PC14 and PC15 can be used as LSE pins only

   (#) PC13 can be used as the RTC_AF1 pin 

   (#) PI8 can be used as the RTC_AF2 pin

                   ##### Backup Domain Reset #####

 ===================================================================

 [..] The backup domain reset sets all RTC registers and the RCC_BDCR register 

      to their reset values. The BKPSRAM is not affected by this reset. The only

      way of resetting the BKPSRAM is through the Flash interface by requesting 

      a protection level change from 1 to 0.

 [..] A backup domain reset is generated when one of the following events occurs:

   (#) Software reset, triggered by setting the BDRST bit in the 

       RCC Backup domain control register (RCC_BDCR). You can use the

       RCC_BackupResetCmd().

   (#) VDD or VBAT power on, if both supplies have previously been powered off.

                   ##### Backup Domain Access #####

 ===================================================================

 [..] After reset, the backup domain (RTC registers, RTC backup data 

      registers and backup SRAM) is protected against possible unwanted 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_BackupAccessCmd() function.

   (+) Select the RTC clock source using the RCC_RTCCLKConfig() function.

   (+) Enable RTC Clock using the RCC_RTCCLKCmd() function.

                  ##### How to use RTC 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.

   (+) 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.

   (+) The TAMPER1 alternate function can be mapped either to RTC_AF1(PC13)

       or RTC_AF2 (PI8) depending on the value of TAMP1INSEL bit in 

       RTC_TAFCR register. You can use the  RTC_TamperPinSelection() function to

       select the corresponding pin.     

 *** Tamper configuration ***

 ============================

 [..]

   (+) Enable the RTC Tamper using the RTC_TamperCmd() function.

   (+) 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 Time stamp on Tamper detection event using  

       TC_TSOnTamperDetecCmd() function.

   (+) The TIMESTAMP alternate function can be mapped to either RTC_AF1 

       or RTC_AF2 depending on the value of the TSINSEL bit in the RTC_TAFCR 

       register. You can use the  RTC_TimeStampPinSelection() function to select 

       the corresponding pin. 

 *** 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:

   (+) AFO_ALARM output

   (+) AFO_CALIB output

   (+) AFI_TAMPER

   (+) AFI_TIMESTAMP

 [..]   

   +-------------------------------------------------------------------------------------------------------------+

   |     Pin         |AFO_ALARM |AFO_CALIB |AFI_TAMPER |AFI_TIMESTAMP | TAMP1INSEL |   TSINSEL    |ALARMOUTTYPE  |

   |  configuration  | ENABLED  | ENABLED  |  ENABLED  |   ENABLED    |TAMPER1 pin |TIMESTAMP pin |  AFO_ALARM   |

   |  and function   |          |          |           |              | selection  |  selection   |Configuration |

   |-----------------|----------|----------|-----------|--------------|------------|--------------|--------------|

   |   Alarm out     |          |          |           |              |    Don't   |     Don't    |              |

   |   output OD     |     1    |Don't care|Don't care | Don't care   |    care    |     care     |      0       |

   |-----------------|----------|----------|-----------|--------------|------------|--------------|--------------|

   |   Alarm out     |          |          |           |              |    Don't   |     Don't    |              |

   |   output PP     |     1    |Don't care|Don't care | Don't care   |    care    |     care     |      1       |

   |-----------------|----------|----------|-----------|--------------|------------|--------------|--------------|

   | Calibration out |          |          |           |              |    Don't   |     Don't    |              |

   |   output PP     |     0    |    1     |Don't care | Don't care   |    care    |     care     |  Don't care  |

   |-----------------|----------|----------|-----------|--------------|------------|--------------|--------------|

   |  TAMPER input   |          |          |           |              |            |     Don't    |              |

   |   floating      |     0    |    0     |     1     |      0       |      0     |     care     |  Don't care  |

   |-----------------|----------|----------|-----------|--------------|------------|--------------|--------------|

   |  TIMESTAMP and  |          |          |           |              |            |              |              |

   |  TAMPER input   |     0    |    0     |     1     |      1       |      0     |      0       |  Don't care  |

   |   floating      |          |          |           |              |            |              |              |

   |-----------------|----------|----------|-----------|--------------|------------|--------------|--------------|

   | TIMESTAMP input |          |          |           |              |    Don't   |              |              |

   |    floating     |     0    |    0     |     0     |      1       |    care    |      0       |  Don't care  |

   |-----------------|----------|----------|-----------|--------------|------------|--------------|--------------|

   |  Standard GPIO  |     0    |    0     |     0     |      0       | Don't care |  Don't care  |  Don't care  |

   +-------------------------------------------------------------------------------------------------------------+

        #####  Selection of RTC_AF2 alternate functions #####

 ===================================================================

 [..] The RTC_AF2 pin (PI8) can be used for the following purposes:

   (+) AFI_TAMPER

   (+) AFI_TIMESTAMP

 [..]

   +---------------------------------------------------------------------------------------+

   |     Pin         |AFI_TAMPER |AFI_TIMESTAMP | TAMP1INSEL |   TSINSEL    |ALARMOUTTYPE  |

   |  configuration  |  ENABLED  |   ENABLED    |TAMPER1 pin |TIMESTAMP pin |  AFO_ALARM   |

   |  and function   |           |              | selection  |  selection   |Configuration |

   |-----------------|-----------|--------------|------------|--------------|--------------|

   |  TAMPER input   |           |              |            |     Don't    |              |

   |   floating      |     1     |      0       |      1     |     care     |  Don't care  |

   |-----------------|-----------|--------------|------------|--------------|--------------|

   |  TIMESTAMP and  |           |              |            |              |              |

   |  TAMPER input   |     1     |      1       |      1     |      1       |  Don't care  |

   |   floating      |           |              |            |              |              |

   |-----------------|-----------|--------------|------------|--------------|--------------|

   | TIMESTAMP input |           |              |    Don't   |              |              |

   |    floating     |     0     |      1       |    care    |      1       |  Don't care  |

   |-----------------|-----------|--------------|------------|--------------|--------------|

   |  Standard GPIO  |     0     |      0       | Don't care |  Don't care  |  Don't care  |

   +---------------------------------------------------------------------------------------+   

@endverbatim

  ******************************************************************************

  * @attention

  *

  * <h2><center>&copy; COPYRIGHT 2013 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 "stm32f4xx_rtc.h"

/** @addtogroup STM32F4xx_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_RECALPF | RTC_FLAG_SHPF))

#define INITMODE_TIMEOUT         ((uint32_t) 0x00010000)

#define SYNCHRO_TIMEOUT          ((uint32_t) 0x00020000)

#define RECALPF_TIMEOUT          ((uint32_t) 0x00020000)

#define SHPF_TIMEOUT             ((uint32_t) 0x00001000)

/* 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;

      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 Sub seconds value.

  * @note   This function freeze the Time and Date registers after reading the 

  *         SSR register.

  * @param  None

  * @retval RTC current Calendar Sub seconds value.

  */

uint32_t RTC_GetSubSecond(void)

{

  uint32_t tmpreg = 0;

  /* Get sub seconds 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;

}