Subversion Repositories FuelGauge

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f0xx_hal_rtc_ex.c
  4.   * @author  MCD Application Team
  5.   * @brief   Extended RTC HAL module driver.
  6.   *          This file provides firmware functions to manage the following
  7.   *          functionalities of the Real Time Clock (RTC) Extended peripheral:
  8.   *           + RTC Time Stamp functions
  9.   *           + RTC Tamper functions
  10.   *           + RTC Wake-up functions
  11.   *           + Extended Control functions
  12.   *           + Extended RTC features functions
  13.   *
  14.   @verbatim
  15.   ==============================================================================
  16.                   ##### How to use this driver #####
  17.   ==============================================================================
  18.   [..]
  19.     (+) Enable the RTC domain access.
  20.         (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and RTC hour
  21.             format using the HAL_RTC_Init() function.
  22.  
  23.     *** RTC Wake-up configuration ***
  24.     ================================
  25.     [..]
  26.     (+) To configure the RTC Wakeup Clock source and Counter use the HAL_RTCEx_SetWakeUpTimer()
  27.         function. You can also configure the RTC Wakeup timer with interrupt mode
  28.             using the HAL_RTCEx_SetWakeUpTimer_IT() function.
  29.     (+) To read the RTC WakeUp Counter register, use the HAL_RTCEx_GetWakeUpTimer()
  30.             function.
  31.         (@) Not available on F030x4/x6/x8 and F070x6
  32.  
  33.     *** TimeStamp configuration ***
  34.     ===============================
  35.     [..]
  36.         (+) Configure the RTC_AF trigger and enable the RTC TimeStamp using the
  37.             HAL_RTCEx_SetTimeStamp() function. You can also configure the RTC TimeStamp with
  38.             interrupt mode using the HAL_RTCEx_SetTimeStamp_IT() function.
  39.         (+) To read the RTC TimeStamp Time and Date register, use the HAL_RTCEx_GetTimeStamp()
  40.             function.
  41.  
  42.     *** Tamper configuration ***
  43.     ============================
  44.     [..]
  45.         (+) Enable the RTC Tamper and configure the Tamper filter count, trigger Edge
  46.             or Level according to the Tamper filter (if equal to 0 Edge else Level)
  47.             value, sampling frequency, precharge or discharge and Pull-UP using the
  48.             HAL_RTCEx_SetTamper() function. You can configure RTC Tamper in interrupt
  49.             mode using HAL_RTCEx_SetTamper_IT() function.
  50.  
  51.     *** Backup Data Registers configuration ***
  52.     ===========================================
  53.     [..]
  54.         (+) To write to the RTC Backup Data registers, use the HAL_RTCEx_BKUPWrite()
  55.             function.
  56.         (+) To read the RTC Backup Data registers, use the HAL_RTCEx_BKUPRead()
  57.             function.
  58.         (@) Not available on F030x6/x8/xC and F070x6/xB (F0xx Value Line devices)
  59.  
  60.  
  61.    @endverbatim
  62.   ******************************************************************************
  63.   * @attention
  64.   *
  65.   * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
  66.   * All rights reserved.</center></h2>
  67.   *
  68.   * This software component is licensed by ST under BSD 3-Clause license,
  69.   * the "License"; You may not use this file except in compliance with the
  70.   * License. You may obtain a copy of the License at:
  71.   *                        opensource.org/licenses/BSD-3-Clause
  72.   *
  73.   ******************************************************************************
  74.   */
  75.  
  76. /* Includes ------------------------------------------------------------------*/
  77. #include "stm32f0xx_hal.h"
  78.  
  79. /** @addtogroup STM32F0xx_HAL_Driver
  80.   * @{
  81.   */
  82.  
  83.  
  84.  
  85. /** @addtogroup RTCEx
  86.   * @brief RTC Extended HAL module driver
  87.   * @{
  88.   */
  89.  
  90. #ifdef HAL_RTC_MODULE_ENABLED
  91.  
  92. /* Private typedef -----------------------------------------------------------*/
  93. /* Private define ------------------------------------------------------------*/
  94. /* Private macro -------------------------------------------------------------*/
  95. /* Private variables ---------------------------------------------------------*/
  96. /* Private function prototypes -----------------------------------------------*/
  97. /* Exported functions ---------------------------------------------------------*/
  98.  
  99. /** @addtogroup RTCEx_Exported_Functions
  100.   * @{
  101.   */
  102.  
  103.  
  104. /** @addtogroup RTCEx_Exported_Functions_Group1
  105.  *  @brief   RTC TimeStamp and Tamper functions
  106.  *
  107. @verbatim
  108.  ===============================================================================
  109.                  ##### RTC TimeStamp and Tamper functions #####
  110.  ===============================================================================
  111.  
  112.  [..] This section provides functions allowing to configure TimeStamp feature
  113.  
  114. @endverbatim
  115.   * @{
  116.   */
  117.  
  118. /**
  119.   * @brief  Set TimeStamp.
  120.   * @note   This API must be called before enabling the TimeStamp feature.
  121.   * @param  hrtc RTC handle
  122.   * @param  TimeStampEdge Specifies the pin edge on which the TimeStamp is
  123.   *         activated.
  124.   *          This parameter can be one of the following values:
  125.   *             @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the
  126.   *                                        rising edge of the related pin.
  127.   *             @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the
  128.   *                                         falling edge of the related pin.
  129.   * @param  RTC_TimeStampPin specifies the RTC TimeStamp Pin.
  130.   *          This parameter can be one of the following values:
  131.   *             @arg RTC_TIMESTAMPPIN_DEFAULT: PC13 is selected as RTC TimeStamp Pin.
  132.   * @retval HAL status
  133.   */
  134. HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge, uint32_t RTC_TimeStampPin)
  135. {
  136.   uint32_t tmpreg = 0U;
  137.  
  138.   /* Check the parameters */
  139.   assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge));
  140.   assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin));
  141.  
  142.   /* Process Locked */
  143.   __HAL_LOCK(hrtc);
  144.  
  145.   hrtc->State = HAL_RTC_STATE_BUSY;
  146.  
  147.   /* Get the RTC_CR register and clear the bits to be configured */
  148.   tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
  149.  
  150.   tmpreg |= TimeStampEdge;
  151.  
  152.   /* Disable the write protection for RTC registers */
  153.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  154.  
  155.   /* Configure the Time Stamp TSEDGE and Enable bits */
  156.   hrtc->Instance->CR = (uint32_t)tmpreg;
  157.  
  158.   __HAL_RTC_TIMESTAMP_ENABLE(hrtc);
  159.  
  160.   /* Enable the write protection for RTC registers */
  161.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  162.  
  163.   /* Change RTC state */
  164.   hrtc->State = HAL_RTC_STATE_READY;
  165.  
  166.   /* Process Unlocked */
  167.   __HAL_UNLOCK(hrtc);
  168.  
  169.   return HAL_OK;
  170. }
  171.  
  172. /**
  173.   * @brief  Set TimeStamp with Interrupt.
  174.   * @param  hrtc RTC handle
  175.   * @note   This API must be called before enabling the TimeStamp feature.
  176.   * @param  TimeStampEdge Specifies the pin edge on which the TimeStamp is
  177.   *         activated.
  178.   *          This parameter can be one of the following values:
  179.   *             @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the
  180.   *                                        rising edge of the related pin.
  181.   *             @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the
  182.   *                                         falling edge of the related pin.
  183.   * @param  RTC_TimeStampPin Specifies the RTC TimeStamp Pin.
  184.   *          This parameter can be one of the following values:
  185.   *             @arg RTC_TIMESTAMPPIN_DEFAULT: PC13 is selected as RTC TimeStamp Pin.
  186.   * @retval HAL status
  187.   */
  188. HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp_IT(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge, uint32_t RTC_TimeStampPin)
  189. {
  190.   uint32_t tmpreg = 0U;
  191.  
  192.   /* Check the parameters */
  193.   assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge));
  194.   assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin));
  195.  
  196.   /* Process Locked */
  197.   __HAL_LOCK(hrtc);
  198.  
  199.   hrtc->State = HAL_RTC_STATE_BUSY;
  200.  
  201.   /* Get the RTC_CR register and clear the bits to be configured */
  202.   tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
  203.  
  204.   tmpreg |= TimeStampEdge;
  205.  
  206.   /* Disable the write protection for RTC registers */
  207.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  208.  
  209.   /* Configure the Time Stamp TSEDGE and Enable bits */
  210.   hrtc->Instance->CR = (uint32_t)tmpreg;
  211.  
  212.   __HAL_RTC_TIMESTAMP_ENABLE(hrtc);
  213.  
  214.   /* Enable IT timestamp */
  215.   __HAL_RTC_TIMESTAMP_ENABLE_IT(hrtc, RTC_IT_TS);
  216.  
  217.   /* RTC timestamp Interrupt Configuration: EXTI configuration */
  218.   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_IT();
  219.  
  220.   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_RISING_EDGE();
  221.  
  222.   /* Enable the write protection for RTC registers */
  223.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  224.  
  225.   hrtc->State = HAL_RTC_STATE_READY;
  226.  
  227.   /* Process Unlocked */
  228.   __HAL_UNLOCK(hrtc);
  229.  
  230.   return HAL_OK;
  231. }
  232.  
  233. /**
  234.   * @brief  Deactivate TimeStamp.
  235.   * @param  hrtc RTC handle
  236.   * @retval HAL status
  237.   */
  238. HAL_StatusTypeDef HAL_RTCEx_DeactivateTimeStamp(RTC_HandleTypeDef *hrtc)
  239. {
  240.   uint32_t tmpreg = 0U;
  241.  
  242.   /* Process Locked */
  243.   __HAL_LOCK(hrtc);
  244.  
  245.   hrtc->State = HAL_RTC_STATE_BUSY;
  246.  
  247.   /* Disable the write protection for RTC registers */
  248.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  249.  
  250.   /* In case of interrupt mode is used, the interrupt source must disabled */
  251.   __HAL_RTC_TIMESTAMP_DISABLE_IT(hrtc, RTC_IT_TS);
  252.  
  253.   /* Get the RTC_CR register and clear the bits to be configured */
  254.   tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
  255.  
  256.   /* Configure the Time Stamp TSEDGE and Enable bits */
  257.   hrtc->Instance->CR = (uint32_t)tmpreg;
  258.  
  259.   /* Enable the write protection for RTC registers */
  260.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  261.  
  262.   hrtc->State = HAL_RTC_STATE_READY;
  263.  
  264.   /* Process Unlocked */
  265.   __HAL_UNLOCK(hrtc);
  266.  
  267.   return HAL_OK;
  268. }
  269.  
  270. /**
  271.   * @brief  Get the RTC TimeStamp value.
  272.   * @param  hrtc RTC handle
  273.  
  274.   * @param  sTimeStamp Pointer to Time structure
  275.   * @param  sTimeStampDate Pointer to Date structure
  276.   * @param  Format specifies the format of the entered parameters.
  277.   *          This parameter can be one of the following values:
  278.   *             @arg RTC_FORMAT_BIN: Binary data format
  279.   *             @arg RTC_FORMAT_BCD: BCD data format
  280.   * @retval HAL status
  281.   */
  282. HAL_StatusTypeDef HAL_RTCEx_GetTimeStamp(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTimeStamp, RTC_DateTypeDef *sTimeStampDate, uint32_t Format)
  283. {
  284.   uint32_t tmptime = 0U, tmpdate = 0U;
  285.  
  286.   /* Check the parameters */
  287.   assert_param(IS_RTC_FORMAT(Format));
  288.  
  289.   /* Get the TimeStamp time and date registers values */
  290.   tmptime = (uint32_t)(hrtc->Instance->TSTR & RTC_TR_RESERVED_MASK);
  291.   tmpdate = (uint32_t)(hrtc->Instance->TSDR & RTC_DR_RESERVED_MASK);
  292.  
  293.   /* Fill the Time structure fields with the read parameters */
  294.   sTimeStamp->Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16U);
  295.   sTimeStamp->Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8U);
  296.   sTimeStamp->Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU));
  297.   sTimeStamp->TimeFormat = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16U);
  298.   sTimeStamp->SubSeconds = (uint32_t) hrtc->Instance->TSSSR;
  299.  
  300.   /* Fill the Date structure fields with the read parameters */
  301.   sTimeStampDate->Year = 0;
  302.   sTimeStampDate->Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8U);
  303.   sTimeStampDate->Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU));
  304.   sTimeStampDate->WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13U);
  305.  
  306.   /* Check the input parameters format */
  307.   if (Format == RTC_FORMAT_BIN)
  308.   {
  309.     /* Convert the TimeStamp structure parameters to Binary format */
  310.     sTimeStamp->Hours = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Hours);
  311.     sTimeStamp->Minutes = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Minutes);
  312.     sTimeStamp->Seconds = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Seconds);
  313.  
  314.     /* Convert the DateTimeStamp structure parameters to Binary format */
  315.     sTimeStampDate->Month = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Month);
  316.     sTimeStampDate->Date = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Date);
  317.     sTimeStampDate->WeekDay = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->WeekDay);
  318.   }
  319.  
  320.   /* Clear the TIMESTAMP Flag */
  321.   __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSF);
  322.  
  323.   return HAL_OK;
  324. }
  325.  
  326. /**
  327.   * @brief  Set Tamper
  328.   * @note   By calling this API we disable the tamper interrupt for all tampers.
  329.   * @param  hrtc RTC handle
  330.   * @param  sTamper Pointer to Tamper Structure.
  331.   * @retval HAL status
  332.   */
  333. HAL_StatusTypeDef HAL_RTCEx_SetTamper(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef *sTamper)
  334. {
  335.   uint32_t tmpreg = 0U;
  336.  
  337.   /* Check the parameters */
  338.   assert_param(IS_RTC_TAMPER(sTamper->Tamper));
  339.   assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
  340.   assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter));
  341.   assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency));
  342.   assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration));
  343.   assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp));
  344.   assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection));
  345.  
  346.   /* Process Locked */
  347.   __HAL_LOCK(hrtc);
  348.  
  349.   hrtc->State = HAL_RTC_STATE_BUSY;
  350.  
  351.   if (sTamper->Trigger != RTC_TAMPERTRIGGER_RISINGEDGE)
  352.   {
  353.     sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1U);
  354.   }
  355.  
  356.   tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->Trigger | (uint32_t)sTamper->Filter | \
  357.             (uint32_t)sTamper->SamplingFrequency | (uint32_t)sTamper->PrechargeDuration | \
  358.             (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection);
  359.  
  360.   hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1U) | (uint32_t)RTC_TAFCR_TAMPTS | \
  361.                                        (uint32_t)RTC_TAFCR_TAMPFREQ | (uint32_t)RTC_TAFCR_TAMPFLT | (uint32_t)RTC_TAFCR_TAMPPRCH | \
  362.                                        (uint32_t)RTC_TAFCR_TAMPPUDIS | (uint32_t)RTC_TAFCR_TAMPIE);
  363.  
  364.   hrtc->Instance->TAFCR |= tmpreg;
  365.  
  366.   hrtc->State = HAL_RTC_STATE_READY;
  367.  
  368.   /* Process Unlocked */
  369.   __HAL_UNLOCK(hrtc);
  370.  
  371.   return HAL_OK;
  372. }
  373.  
  374. /**
  375.   * @brief  Sets Tamper with interrupt.
  376.   * @note   By calling this API we force the tamper interrupt for all tampers.
  377.   * @param  hrtc pointer to a RTC_HandleTypeDef structure that contains
  378.   *                the configuration information for RTC.
  379.   * @param  sTamper Pointer to RTC Tamper.
  380.   * @retval HAL status
  381.   */
  382. HAL_StatusTypeDef HAL_RTCEx_SetTamper_IT(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef *sTamper)
  383. {
  384.   uint32_t tmpreg = 0U;
  385.  
  386.   /* Check the parameters */
  387.   assert_param(IS_RTC_TAMPER(sTamper->Tamper));
  388.   assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
  389.   assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter));
  390.   assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency));
  391.   assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration));
  392.   assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp));
  393.   assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection));
  394.  
  395.   /* Process Locked */
  396.   __HAL_LOCK(hrtc);
  397.  
  398.   hrtc->State = HAL_RTC_STATE_BUSY;
  399.  
  400.   /* Configure the tamper trigger */
  401.   if (sTamper->Trigger != RTC_TAMPERTRIGGER_RISINGEDGE)
  402.   {
  403.     sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1U);
  404.   }
  405.  
  406.   tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->Trigger | (uint32_t)sTamper->Filter | \
  407.             (uint32_t)sTamper->SamplingFrequency | (uint32_t)sTamper->PrechargeDuration | \
  408.             (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection);
  409.  
  410.   hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1U) | (uint32_t)RTC_TAFCR_TAMPTS | \
  411.                                        (uint32_t)RTC_TAFCR_TAMPFREQ | (uint32_t)RTC_TAFCR_TAMPFLT | (uint32_t)RTC_TAFCR_TAMPPRCH | \
  412.                                        (uint32_t)RTC_TAFCR_TAMPPUDIS);
  413.  
  414.   hrtc->Instance->TAFCR |= tmpreg;
  415.  
  416.   /* Configure the Tamper Interrupt in the RTC_TAFCR */
  417.   hrtc->Instance->TAFCR |= (uint32_t)RTC_TAFCR_TAMPIE;
  418.  
  419.   /* RTC Tamper Interrupt Configuration: EXTI configuration */
  420.   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_IT();
  421.  
  422.   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_RISING_EDGE();
  423.  
  424.   hrtc->State = HAL_RTC_STATE_READY;
  425.  
  426.   /* Process Unlocked */
  427.   __HAL_UNLOCK(hrtc);
  428.  
  429.   return HAL_OK;
  430. }
  431.  
  432. /**
  433.   * @brief  Deactivate Tamper.
  434.   * @param  hrtc RTC handle
  435.   * @param  Tamper Selected tamper pin.
  436.   *          This parameter can be any combination of RTC_TAMPER_1, RTC_TAMPER_2 and RTC_TAMPER_3.
  437.   * @retval HAL status
  438.   */
  439. HAL_StatusTypeDef HAL_RTCEx_DeactivateTamper(RTC_HandleTypeDef *hrtc, uint32_t Tamper)
  440. {
  441.   assert_param(IS_RTC_TAMPER(Tamper));
  442.  
  443.   /* Process Locked */
  444.   __HAL_LOCK(hrtc);
  445.  
  446.   hrtc->State = HAL_RTC_STATE_BUSY;
  447.  
  448.   /* Disable the selected Tamper pin */
  449.   hrtc->Instance->TAFCR &= (uint32_t)~Tamper;
  450.  
  451.   hrtc->State = HAL_RTC_STATE_READY;
  452.  
  453.   /* Process Unlocked */
  454.   __HAL_UNLOCK(hrtc);
  455.  
  456.   return HAL_OK;
  457. }
  458.  
  459. /**
  460.   * @brief  Handle TimeStamp interrupt request.
  461.   * @param  hrtc RTC handle
  462.   * @retval None
  463.   */
  464. void HAL_RTCEx_TamperTimeStampIRQHandler(RTC_HandleTypeDef *hrtc)
  465. {
  466.   /* Get the TimeStamp interrupt source enable status */
  467.   if (__HAL_RTC_TIMESTAMP_GET_IT_SOURCE(hrtc, RTC_IT_TS) != RESET)
  468.   {
  469.     /* Get the pending status of the TIMESTAMP Interrupt */
  470.     if (__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSF) != RESET)
  471.     {
  472.       /* TIMESTAMP callback */
  473. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  474.       hrtc->TimeStampEventCallback(hrtc);
  475. #else
  476.       HAL_RTCEx_TimeStampEventCallback(hrtc);
  477. #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */
  478.  
  479.       /* Clear the TIMESTAMP interrupt pending bit */
  480.       __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSF);
  481.     }
  482.   }
  483.  
  484.   /* Get the Tamper interrupts source enable status */
  485.   if (__HAL_RTC_TAMPER_GET_IT_SOURCE(hrtc, RTC_IT_TAMP))
  486.   {
  487.     /* Get the pending status of the Tamper1 Interrupt */
  488.     if (__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F) != RESET)
  489.     {
  490.       /* Tamper1 callback */
  491. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  492.       hrtc->Tamper1EventCallback(hrtc);
  493. #else
  494.       HAL_RTCEx_Tamper1EventCallback(hrtc);
  495. #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */
  496.  
  497.       /* Clear the Tamper1 interrupt pending bit */
  498.       __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP1F);
  499.     }
  500.   }
  501.  
  502.   /* Get the Tamper interrupts source enable status */
  503.   if (__HAL_RTC_TAMPER_GET_IT_SOURCE(hrtc, RTC_IT_TAMP))
  504.   {
  505.     /* Get the pending status of the Tamper2 Interrupt */
  506.     if (__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP2F) != RESET)
  507.     {
  508.       /* Tamper2 callback */
  509. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  510.       hrtc->Tamper2EventCallback(hrtc);
  511. #else
  512.       HAL_RTCEx_Tamper2EventCallback(hrtc);
  513. #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */
  514.  
  515.       /* Clear the Tamper2 interrupt pending bit */
  516.       __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP2F);
  517.     }
  518.   }
  519.  
  520. #if defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx)
  521.   /* Get the Tamper interrupts source enable status */
  522.   if (__HAL_RTC_TAMPER_GET_IT_SOURCE(hrtc, RTC_IT_TAMP))
  523.   {
  524.     /* Get the pending status of the Tamper3 Interrupt */
  525.     if (__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP3F) != RESET)
  526.     {
  527.       /* Tamper3 callback */
  528. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  529.       hrtc->Tamper3EventCallback(hrtc);
  530. #else
  531.       HAL_RTCEx_Tamper3EventCallback(hrtc);
  532. #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */
  533.  
  534.       /* Clear the Tamper3 interrupt pending bit */
  535.       __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP3F);
  536.     }
  537.   }
  538. #endif
  539.  
  540.   /* Clear the EXTI's Flag for RTC TimeStamp and Tamper */
  541.   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_CLEAR_FLAG();
  542.  
  543.   /* Change RTC state */
  544.   hrtc->State = HAL_RTC_STATE_READY;
  545. }
  546.  
  547. /**
  548.   * @brief  TimeStamp callback.
  549.   * @param  hrtc RTC handle
  550.   * @retval None
  551.   */
  552. __weak void HAL_RTCEx_TimeStampEventCallback(RTC_HandleTypeDef *hrtc)
  553. {
  554.   /* Prevent unused argument(s) compilation warning */
  555.   UNUSED(hrtc);
  556.  
  557.   /* NOTE : This function should not be modified, when the callback is needed,
  558.             the HAL_RTCEx_TimeStampEventCallback could be implemented in the user file
  559.   */
  560. }
  561.  
  562. /**
  563.   * @brief  Tamper 1 callback.
  564.   * @param  hrtc RTC handle
  565.   * @retval None
  566.   */
  567. __weak void HAL_RTCEx_Tamper1EventCallback(RTC_HandleTypeDef *hrtc)
  568. {
  569.   /* Prevent unused argument(s) compilation warning */
  570.   UNUSED(hrtc);
  571.  
  572.   /* NOTE : This function should not be modified, when the callback is needed,
  573.             the HAL_RTCEx_Tamper1EventCallback could be implemented in the user file
  574.    */
  575. }
  576.  
  577. /**
  578.   * @brief  Tamper 2 callback.
  579.   * @param  hrtc RTC handle
  580.   * @retval None
  581.   */
  582. __weak void HAL_RTCEx_Tamper2EventCallback(RTC_HandleTypeDef *hrtc)
  583. {
  584.   /* Prevent unused argument(s) compilation warning */
  585.   UNUSED(hrtc);
  586.  
  587.   /* NOTE : This function should not be modified, when the callback is needed,
  588.             the HAL_RTCEx_Tamper2EventCallback could be implemented in the user file
  589.    */
  590. }
  591.  
  592. #if defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx)
  593. /**
  594.   * @brief  Tamper 3 callback.
  595.   * @param  hrtc RTC handle
  596.   * @retval None
  597.   */
  598. __weak void HAL_RTCEx_Tamper3EventCallback(RTC_HandleTypeDef *hrtc)
  599. {
  600.   /* Prevent unused argument(s) compilation warning */
  601.   UNUSED(hrtc);
  602.  
  603.   /* NOTE : This function should not be modified, when the callback is needed,
  604.             the HAL_RTCEx_Tamper3EventCallback could be implemented in the user file
  605.    */
  606. }
  607. #endif
  608.  
  609. /**
  610.   * @brief  Handle TimeStamp polling request.
  611.   * @param  hrtc RTC handle
  612.   * @param  Timeout Timeout duration
  613.   * @retval HAL status
  614.   */
  615. HAL_StatusTypeDef HAL_RTCEx_PollForTimeStampEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
  616. {
  617.   uint32_t tickstart = HAL_GetTick();
  618.  
  619.   while (__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSF) == RESET)
  620.   {
  621.     if (__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSOVF) != RESET)
  622.     {
  623.       /* Clear the TIMESTAMP OverRun Flag */
  624.       __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSOVF);
  625.  
  626.       /* Change TIMESTAMP state */
  627.       hrtc->State = HAL_RTC_STATE_ERROR;
  628.  
  629.       return HAL_ERROR;
  630.     }
  631.  
  632.     if (Timeout != HAL_MAX_DELAY)
  633.     {
  634.       if ((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
  635.       {
  636.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  637.         return HAL_TIMEOUT;
  638.       }
  639.     }
  640.   }
  641.  
  642.   /* Change RTC state */
  643.   hrtc->State = HAL_RTC_STATE_READY;
  644.  
  645.   return HAL_OK;
  646. }
  647.  
  648. /**
  649.   * @brief  Handle Tamper 1 Polling.
  650.   * @param  hrtc RTC handle
  651.   * @param  Timeout Timeout duration
  652.   * @retval HAL status
  653.   */
  654. HAL_StatusTypeDef HAL_RTCEx_PollForTamper1Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
  655. {
  656.   uint32_t tickstart = HAL_GetTick();
  657.  
  658.   /* Get the status of the Interrupt */
  659.   while (__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F) == RESET)
  660.   {
  661.     if (Timeout != HAL_MAX_DELAY)
  662.     {
  663.       if ((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
  664.       {
  665.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  666.         return HAL_TIMEOUT;
  667.       }
  668.     }
  669.   }
  670.  
  671.   /* Clear the Tamper Flag */
  672.   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP1F);
  673.  
  674.   /* Change RTC state */
  675.   hrtc->State = HAL_RTC_STATE_READY;
  676.  
  677.   return HAL_OK;
  678. }
  679.  
  680. /**
  681.   * @brief  Handle Tamper 2 Polling.
  682.   * @param  hrtc RTC handle
  683.   * @param  Timeout Timeout duration
  684.   * @retval HAL status
  685.   */
  686. HAL_StatusTypeDef HAL_RTCEx_PollForTamper2Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
  687. {
  688.   uint32_t tickstart = HAL_GetTick();
  689.  
  690.   /* Get the status of the Interrupt */
  691.   while (__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP2F) == RESET)
  692.   {
  693.     if (Timeout != HAL_MAX_DELAY)
  694.     {
  695.       if ((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
  696.       {
  697.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  698.         return HAL_TIMEOUT;
  699.       }
  700.     }
  701.   }
  702.  
  703.   /* Clear the Tamper Flag */
  704.   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP2F);
  705.  
  706.   /* Change RTC state */
  707.   hrtc->State = HAL_RTC_STATE_READY;
  708.  
  709.   return HAL_OK;
  710. }
  711.  
  712. #if defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx)
  713. /**
  714.   * @brief  Handle Tamper 3 Polling.
  715.   * @param  hrtc RTC handle
  716.   * @param  Timeout Timeout duration
  717.   * @retval HAL status
  718.   */
  719. HAL_StatusTypeDef HAL_RTCEx_PollForTamper3Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
  720. {
  721.   uint32_t tickstart = HAL_GetTick();
  722.  
  723.   /* Get the status of the Interrupt */
  724.   while (__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP3F) == RESET)
  725.   {
  726.     if (Timeout != HAL_MAX_DELAY)
  727.     {
  728.       if ((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
  729.       {
  730.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  731.         return HAL_TIMEOUT;
  732.       }
  733.     }
  734.   }
  735.  
  736.   /* Clear the Tamper Flag */
  737.   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP3F);
  738.  
  739.   /* Change RTC state */
  740.   hrtc->State = HAL_RTC_STATE_READY;
  741.  
  742.   return HAL_OK;
  743. }
  744. #endif
  745.  
  746. /**
  747.   * @}
  748.   */
  749.  
  750. #if defined(STM32F070xB) || defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx) || defined(STM32F030xC)
  751. /** @addtogroup RTCEx_Exported_Functions_Group2
  752.   * @brief    RTC Wake-up functions
  753.   *
  754. @verbatim
  755.  ===============================================================================
  756.                         ##### RTC Wake-up functions #####
  757.  ===============================================================================
  758.  
  759.  [..] This section provides functions allowing to configure Wake-up feature
  760.  
  761. @endverbatim
  762.   * @{
  763.   */
  764.  
  765. /**
  766.   * @brief  Set wake up timer.
  767.   * @param  hrtc RTC handle
  768.   * @param  WakeUpCounter Wake up counter
  769.   * @param  WakeUpClock Wake up clock
  770.   * @retval HAL status
  771.   */
  772. HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock)
  773. {
  774.   uint32_t tickstart = 0U;
  775.  
  776.   /* Check the parameters */
  777.   assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock));
  778.   assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter));
  779.  
  780.   /* Process Locked */
  781.   __HAL_LOCK(hrtc);
  782.  
  783.   hrtc->State = HAL_RTC_STATE_BUSY;
  784.  
  785.   /* Disable the write protection for RTC registers */
  786.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  787.  
  788.   /*Check RTC WUTWF flag is reset only when wake up timer enabled*/
  789.   if ((hrtc->Instance->CR & RTC_CR_WUTE) != RESET)
  790.   {
  791.     tickstart = HAL_GetTick();
  792.  
  793.     /* Wait till RTC WUTWF flag is reset and if Time out is reached exit */
  794.     while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == SET)
  795.     {
  796.       if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
  797.       {
  798.         /* Enable the write protection for RTC registers */
  799.         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  800.  
  801.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  802.  
  803.         /* Process Unlocked */
  804.         __HAL_UNLOCK(hrtc);
  805.  
  806.         return HAL_TIMEOUT;
  807.       }
  808.     }
  809.   }
  810.  
  811.   __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
  812.  
  813.   tickstart = HAL_GetTick();
  814.  
  815.   /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
  816.   while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
  817.   {
  818.     if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
  819.     {
  820.       /* Enable the write protection for RTC registers */
  821.       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  822.  
  823.       hrtc->State = HAL_RTC_STATE_TIMEOUT;
  824.  
  825.       /* Process Unlocked */
  826.       __HAL_UNLOCK(hrtc);
  827.  
  828.       return HAL_TIMEOUT;
  829.     }
  830.   }
  831.  
  832.   /* Clear the Wakeup Timer clock source bits in CR register */
  833.   hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;
  834.  
  835.   /* Configure the clock source */
  836.   hrtc->Instance->CR |= (uint32_t)WakeUpClock;
  837.  
  838.   /* Configure the Wakeup Timer counter */
  839.   hrtc->Instance->WUTR = (uint32_t)WakeUpCounter;
  840.  
  841.   /* Enable the Wakeup Timer */
  842.   __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc);
  843.  
  844.   /* Enable the write protection for RTC registers */
  845.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  846.  
  847.   hrtc->State = HAL_RTC_STATE_READY;
  848.  
  849.   /* Process Unlocked */
  850.   __HAL_UNLOCK(hrtc);
  851.  
  852.   return HAL_OK;
  853. }
  854.  
  855. /**
  856.   * @brief  Set wake up timer with interrupt.
  857.   * @param  hrtc RTC handle
  858.   * @param  WakeUpCounter Wake up counter
  859.   * @param  WakeUpClock Wake up clock
  860.   * @retval HAL status
  861.   */
  862. HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer_IT(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock)
  863. {
  864.   uint32_t tickstart = 0U;
  865.  
  866.   /* Check the parameters */
  867.   assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock));
  868.   assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter));
  869.  
  870.   /* Process Locked */
  871.   __HAL_LOCK(hrtc);
  872.  
  873.   hrtc->State = HAL_RTC_STATE_BUSY;
  874.  
  875.   /* Disable the write protection for RTC registers */
  876.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  877.  
  878.   /*Check RTC WUTWF flag is reset only when wake up timer enabled*/
  879.   if ((hrtc->Instance->CR & RTC_CR_WUTE) != RESET)
  880.   {
  881.     tickstart = HAL_GetTick();
  882.  
  883.     /* Wait till RTC WUTWF flag is reset and if Time out is reached exit */
  884.     while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == SET)
  885.     {
  886.       if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
  887.       {
  888.         /* Enable the write protection for RTC registers */
  889.         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  890.  
  891.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  892.  
  893.         /* Process Unlocked */
  894.         __HAL_UNLOCK(hrtc);
  895.  
  896.         return HAL_TIMEOUT;
  897.       }
  898.     }
  899.   }
  900.  
  901.   /* Disable the Wake-Up timer */
  902.   __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
  903.  
  904.   /* Clear flag Wake-Up */
  905.   __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
  906.  
  907.   tickstart = HAL_GetTick();
  908.  
  909.   /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
  910.   while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
  911.   {
  912.     if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
  913.     {
  914.       /* Enable the write protection for RTC registers */
  915.       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  916.  
  917.       hrtc->State = HAL_RTC_STATE_TIMEOUT;
  918.  
  919.       /* Process Unlocked */
  920.       __HAL_UNLOCK(hrtc);
  921.  
  922.       return HAL_TIMEOUT;
  923.     }
  924.   }
  925.  
  926.   /* Configure the Wakeup Timer counter */
  927.   hrtc->Instance->WUTR = (uint32_t)WakeUpCounter;
  928.  
  929.   /* Clear the Wakeup Timer clock source bits in CR register */
  930.   hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;
  931.  
  932.   /* Configure the clock source */
  933.   hrtc->Instance->CR |= (uint32_t)WakeUpClock;
  934.  
  935.   /* RTC WakeUpTimer Interrupt Configuration: EXTI configuration */
  936.   __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_IT();
  937.  
  938.   __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_RISING_EDGE();
  939.  
  940.   /* Configure the Interrupt in the RTC_CR register */
  941.   __HAL_RTC_WAKEUPTIMER_ENABLE_IT(hrtc, RTC_IT_WUT);
  942.  
  943.   /* Enable the Wakeup Timer */
  944.   __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc);
  945.  
  946.   /* Enable the write protection for RTC registers */
  947.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  948.  
  949.   hrtc->State = HAL_RTC_STATE_READY;
  950.  
  951.   /* Process Unlocked */
  952.   __HAL_UNLOCK(hrtc);
  953.  
  954.   return HAL_OK;
  955. }
  956.  
  957. /**
  958.   * @brief  Deactivate wake up timer counter.
  959.   * @param  hrtc RTC handle
  960.   * @retval HAL status
  961.   */
  962. uint32_t HAL_RTCEx_DeactivateWakeUpTimer(RTC_HandleTypeDef *hrtc)
  963. {
  964.   uint32_t tickstart = 0U;
  965.  
  966.   /* Process Locked */
  967.   __HAL_LOCK(hrtc);
  968.  
  969.   hrtc->State = HAL_RTC_STATE_BUSY;
  970.  
  971.   /* Disable the write protection for RTC registers */
  972.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  973.  
  974.   /* Disable the Wakeup Timer */
  975.   __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
  976.  
  977.   /* In case of interrupt mode is used, the interrupt source must disabled */
  978.   __HAL_RTC_WAKEUPTIMER_DISABLE_IT(hrtc, RTC_IT_WUT);
  979.  
  980.   tickstart = HAL_GetTick();
  981.   /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
  982.   while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
  983.   {
  984.     if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
  985.     {
  986.       /* Enable the write protection for RTC registers */
  987.       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  988.  
  989.       hrtc->State = HAL_RTC_STATE_TIMEOUT;
  990.  
  991.       /* Process Unlocked */
  992.       __HAL_UNLOCK(hrtc);
  993.  
  994.       return HAL_TIMEOUT;
  995.     }
  996.   }
  997.  
  998.   /* Enable the write protection for RTC registers */
  999.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1000.  
  1001.   hrtc->State = HAL_RTC_STATE_READY;
  1002.  
  1003.   /* Process Unlocked */
  1004.   __HAL_UNLOCK(hrtc);
  1005.  
  1006.   return HAL_OK;
  1007. }
  1008.  
  1009. /**
  1010.   * @brief  Get wake up timer counter.
  1011.   * @param  hrtc RTC handle
  1012.   * @retval Counter value
  1013.   */
  1014. uint32_t HAL_RTCEx_GetWakeUpTimer(RTC_HandleTypeDef *hrtc)
  1015. {
  1016.   /* Get the counter value */
  1017.   return ((uint32_t)(hrtc->Instance->WUTR & RTC_WUTR_WUT));
  1018. }
  1019.  
  1020. /**
  1021.   * @brief  Handle Wake Up Timer interrupt request.
  1022.   * @param  hrtc RTC handle
  1023.   * @retval None
  1024.   */
  1025. void HAL_RTCEx_WakeUpTimerIRQHandler(RTC_HandleTypeDef *hrtc)
  1026. {
  1027.   /* Get the WAKEUPTIMER interrupt source enable status */
  1028.   if (__HAL_RTC_WAKEUPTIMER_GET_IT_SOURCE(hrtc, RTC_IT_WUT) != RESET)
  1029.   {
  1030.     /* Get the pending status of the WAKEUPTIMER Interrupt */
  1031.     if (__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) != RESET)
  1032.     {
  1033.       /* WAKEUPTIMER callback */
  1034. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  1035.       hrtc->WakeUpTimerEventCallback(hrtc);
  1036. #else
  1037.       HAL_RTCEx_WakeUpTimerEventCallback(hrtc);
  1038. #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */
  1039.  
  1040.       /* Clear the WAKEUPTIMER interrupt pending bit */
  1041.       __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
  1042.     }
  1043.   }
  1044.  
  1045.   /* Clear the EXTI's line Flag for RTC WakeUpTimer */
  1046.   __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();
  1047.  
  1048.   /* Change RTC state */
  1049.   hrtc->State = HAL_RTC_STATE_READY;
  1050. }
  1051.  
  1052. /**
  1053.   * @brief  Wake Up Timer callback.
  1054.   * @param  hrtc RTC handle
  1055.   * @retval None
  1056.   */
  1057. __weak void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
  1058. {
  1059.   /* Prevent unused argument(s) compilation warning */
  1060.   UNUSED(hrtc);
  1061.  
  1062.   /* NOTE : This function should not be modified, when the callback is needed,
  1063.             the HAL_RTCEx_WakeUpTimerEventCallback could be implemented in the user file
  1064.    */
  1065. }
  1066.  
  1067.  
  1068. /**
  1069.   * @brief  Handle Wake Up Timer Polling.
  1070.   * @param  hrtc RTC handle
  1071.   * @param  Timeout Timeout duration
  1072.   * @retval HAL status
  1073.   */
  1074. HAL_StatusTypeDef HAL_RTCEx_PollForWakeUpTimerEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
  1075. {
  1076.   uint32_t tickstart = HAL_GetTick();
  1077.  
  1078.   while (__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) == RESET)
  1079.   {
  1080.     if (Timeout != HAL_MAX_DELAY)
  1081.     {
  1082.       if ((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
  1083.       {
  1084.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  1085.  
  1086.         return HAL_TIMEOUT;
  1087.       }
  1088.     }
  1089.   }
  1090.  
  1091.   /* Clear the WAKEUPTIMER Flag */
  1092.   __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
  1093.  
  1094.   /* Change RTC state */
  1095.   hrtc->State = HAL_RTC_STATE_READY;
  1096.  
  1097.   return HAL_OK;
  1098. }
  1099.  
  1100. /**
  1101.   * @}
  1102.   */
  1103. #endif /* defined(STM32F070xB) || defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx) | defined(STM32F030xC)  */
  1104.  
  1105. /** @addtogroup RTCEx_Exported_Functions_Group3
  1106.   * @brief    Extended Peripheral Control functions
  1107.   *
  1108. @verbatim
  1109.  ===============================================================================
  1110.               ##### Extended Peripheral Control functions #####
  1111.  ===============================================================================
  1112.     [..]
  1113.     This subsection provides functions allowing to
  1114.       (+) Write a data in a specified RTC Backup data register
  1115.       (+) Read a data in a specified RTC Backup data register
  1116.       (+) Set the Coarse calibration parameters.
  1117.       (+) Deactivate the Coarse calibration parameters
  1118.       (+) Set the Smooth calibration parameters.
  1119.       (+) Configure the Synchronization Shift Control Settings.
  1120.       (+) Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
  1121.       (+) Deactivate the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
  1122.       (+) Enable the RTC reference clock detection.
  1123.       (+) Disable the RTC reference clock detection.
  1124.       (+) Enable the Bypass Shadow feature.
  1125.       (+) Disable the Bypass Shadow feature.
  1126.  
  1127. @endverbatim
  1128.   * @{
  1129.   */
  1130.  
  1131. #if !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC)
  1132. /**
  1133.   * @brief  Write a data in a specified RTC Backup data register.
  1134.   * @param  hrtc RTC handle
  1135.   * @param  BackupRegister RTC Backup data Register number.
  1136.   *          This parameter can be: RTC_BKP_DRx where x can be from 0 to 4 to
  1137.   *                                 specify the register.
  1138.   * @param  Data Data to be written in the specified RTC Backup data register.
  1139.   * @retval None
  1140.   */
  1141. void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)
  1142. {
  1143.   uint32_t tmp = 0U;
  1144.  
  1145.   /* Check the parameters */
  1146.   assert_param(IS_RTC_BKP(BackupRegister));
  1147.  
  1148.   tmp = (uint32_t) & (hrtc->Instance->BKP0R);
  1149.   tmp += (BackupRegister * 4U);
  1150.  
  1151.   /* Write the specified register */
  1152.   *(__IO uint32_t *)tmp = (uint32_t)Data;
  1153. }
  1154.  
  1155. /**
  1156.   * @brief  Reads data from the specified RTC Backup data Register.
  1157.   * @param  hrtc RTC handle
  1158.   * @param  BackupRegister RTC Backup data Register number.
  1159.   *          This parameter can be: RTC_BKP_DRx where x can be from 0 to 4 to
  1160.   *                                 specify the register.
  1161.   * @retval Read value
  1162.   */
  1163. uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)
  1164. {
  1165.   uint32_t tmp = 0U;
  1166.  
  1167.   /* Check the parameters */
  1168.   assert_param(IS_RTC_BKP(BackupRegister));
  1169.  
  1170.   tmp = (uint32_t) & (hrtc->Instance->BKP0R);
  1171.   tmp += (BackupRegister * 4U);
  1172.  
  1173.   /* Read the specified register */
  1174.   return (*(__IO uint32_t *)tmp);
  1175. }
  1176. #endif /* !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC) */
  1177.  
  1178. /**
  1179.   * @brief  Set the Smooth calibration parameters.
  1180.   * @param  hrtc RTC handle
  1181.   * @param  SmoothCalibPeriod Select the Smooth Calibration Period.
  1182.   *          This parameter can be can be one of the following values :
  1183.   *             @arg RTC_SMOOTHCALIB_PERIOD_32SEC: The smooth calibration period is 32s.
  1184.   *             @arg RTC_SMOOTHCALIB_PERIOD_16SEC: The smooth calibration period is 16s.
  1185.   *             @arg RTC_SMOOTHCALIB_PERIOD_8SEC: The smooth calibration period is 8s.
  1186.   * @param  SmoothCalibPlusPulses Select to Set or reset the CALP bit.
  1187.   *          This parameter can be one of the following values:
  1188.   *             @arg RTC_SMOOTHCALIB_PLUSPULSES_SET: Add one RTCCLK pulse every 2*11 pulses.
  1189.   *             @arg RTC_SMOOTHCALIB_PLUSPULSES_RESET: No RTCCLK pulses are added.
  1190.   * @param  SmoothCalibMinusPulsesValue Select the value of CALM[8:0] bits.
  1191.   *          This parameter can be one any value from 0 to 0x000001FF.
  1192.   * @note   To deactivate the smooth calibration, the field SmoothCalibPlusPulses
  1193.   *         must be equal to SMOOTHCALIB_PLUSPULSES_RESET and the field
  1194.   *         SmoothCalibMinusPulsesValue mut be equal to 0.
  1195.   * @retval HAL status
  1196.   */
  1197. HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef *hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmoothCalibMinusPulsesValue)
  1198. {
  1199.   uint32_t tickstart = 0U;
  1200.  
  1201.   /* Check the parameters */
  1202.   assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(SmoothCalibPeriod));
  1203.   assert_param(IS_RTC_SMOOTH_CALIB_PLUS(SmoothCalibPlusPulses));
  1204.   assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmoothCalibMinusPulsesValue));
  1205.  
  1206.   /* Process Locked */
  1207.   __HAL_LOCK(hrtc);
  1208.  
  1209.   hrtc->State = HAL_RTC_STATE_BUSY;
  1210.  
  1211.   /* Disable the write protection for RTC registers */
  1212.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1213.  
  1214.   /* check if a calibration is pending*/
  1215.   if ((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)
  1216.   {
  1217.     tickstart = HAL_GetTick();
  1218.  
  1219.     /* check if a calibration is pending*/
  1220.     while ((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)
  1221.     {
  1222.       if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
  1223.       {
  1224.         /* Enable the write protection for RTC registers */
  1225.         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1226.  
  1227.         /* Change RTC state */
  1228.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  1229.  
  1230.         /* Process Unlocked */
  1231.         __HAL_UNLOCK(hrtc);
  1232.  
  1233.         return HAL_TIMEOUT;
  1234.       }
  1235.     }
  1236.   }
  1237.  
  1238.   /* Configure the Smooth calibration settings */
  1239.   hrtc->Instance->CALR = (uint32_t)((uint32_t)SmoothCalibPeriod | (uint32_t)SmoothCalibPlusPulses | (uint32_t)SmoothCalibMinusPulsesValue);
  1240.  
  1241.   /* Enable the write protection for RTC registers */
  1242.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1243.  
  1244.   /* Change RTC state */
  1245.   hrtc->State = HAL_RTC_STATE_READY;
  1246.  
  1247.   /* Process Unlocked */
  1248.   __HAL_UNLOCK(hrtc);
  1249.  
  1250.   return HAL_OK;
  1251. }
  1252.  
  1253. /**
  1254.   * @brief  Configure the Synchronization Shift Control Settings.
  1255.   * @note   When REFCKON is set, firmware must not write to Shift control register.
  1256.   * @param  hrtc RTC handle
  1257.   * @param  ShiftAdd1S Select to add or not 1 second to the time calendar.
  1258.   *          This parameter can be one of the following values :
  1259.   *             @arg RTC_SHIFTADD1S_SET: Add one second to the clock calendar.
  1260.   *             @arg RTC_SHIFTADD1S_RESET: No effect.
  1261.   * @param  ShiftSubFS Select the number of Second Fractions to substitute.
  1262.   *          This parameter can be one any value from 0 to 0x7FFF.
  1263.   * @retval HAL status
  1264.   */
  1265. HAL_StatusTypeDef HAL_RTCEx_SetSynchroShift(RTC_HandleTypeDef *hrtc, uint32_t ShiftAdd1S, uint32_t ShiftSubFS)
  1266. {
  1267.   uint32_t tickstart = 0U;
  1268.  
  1269.   /* Check the parameters */
  1270.   assert_param(IS_RTC_SHIFT_ADD1S(ShiftAdd1S));
  1271.   assert_param(IS_RTC_SHIFT_SUBFS(ShiftSubFS));
  1272.  
  1273.   /* Process Locked */
  1274.   __HAL_LOCK(hrtc);
  1275.  
  1276.   hrtc->State = HAL_RTC_STATE_BUSY;
  1277.  
  1278.   /* Disable the write protection for RTC registers */
  1279.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1280.  
  1281.   tickstart = HAL_GetTick();
  1282.  
  1283.   /* Wait until the shift is completed*/
  1284.   while ((hrtc->Instance->ISR & RTC_ISR_SHPF) != RESET)
  1285.   {
  1286.     if ((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
  1287.     {
  1288.       /* Enable the write protection for RTC registers */
  1289.       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1290.  
  1291.       hrtc->State = HAL_RTC_STATE_TIMEOUT;
  1292.  
  1293.       /* Process Unlocked */
  1294.       __HAL_UNLOCK(hrtc);
  1295.  
  1296.       return HAL_TIMEOUT;
  1297.     }
  1298.   }
  1299.  
  1300.   /* Check if the reference clock detection is disabled */
  1301.   if ((hrtc->Instance->CR & RTC_CR_REFCKON) == RESET)
  1302.   {
  1303.     /* Configure the Shift settings */
  1304.     hrtc->Instance->SHIFTR = (uint32_t)(uint32_t)(ShiftSubFS) | (uint32_t)(ShiftAdd1S);
  1305.  
  1306.     /* If  RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
  1307.     if ((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
  1308.     {
  1309.       if (HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
  1310.       {
  1311.         /* Enable the write protection for RTC registers */
  1312.         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1313.  
  1314.         hrtc->State = HAL_RTC_STATE_ERROR;
  1315.  
  1316.         /* Process Unlocked */
  1317.         __HAL_UNLOCK(hrtc);
  1318.  
  1319.         return HAL_ERROR;
  1320.       }
  1321.     }
  1322.   }
  1323.   else
  1324.   {
  1325.     /* Enable the write protection for RTC registers */
  1326.     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1327.  
  1328.     /* Change RTC state */
  1329.     hrtc->State = HAL_RTC_STATE_ERROR;
  1330.  
  1331.     /* Process Unlocked */
  1332.     __HAL_UNLOCK(hrtc);
  1333.  
  1334.     return HAL_ERROR;
  1335.   }
  1336.  
  1337.   /* Enable the write protection for RTC registers */
  1338.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1339.  
  1340.   /* Change RTC state */
  1341.   hrtc->State = HAL_RTC_STATE_READY;
  1342.  
  1343.   /* Process Unlocked */
  1344.   __HAL_UNLOCK(hrtc);
  1345.  
  1346.   return HAL_OK;
  1347. }
  1348.  
  1349. /**
  1350.   * @brief  Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
  1351.   * @param  hrtc RTC handle
  1352.   * @param  CalibOutput Select the Calibration output Selection .
  1353.   *          This parameter can be one of the following values:
  1354.   *             @arg RTC_CALIBOUTPUT_512HZ: A signal has a regular waveform at 512Hz.
  1355.   *             @arg RTC_CALIBOUTPUT_1HZ: A signal has a regular waveform at 1Hz.
  1356.   * @retval HAL status
  1357.   */
  1358. HAL_StatusTypeDef HAL_RTCEx_SetCalibrationOutPut(RTC_HandleTypeDef *hrtc, uint32_t CalibOutput)
  1359. {
  1360.   /* Check the parameters */
  1361.   assert_param(IS_RTC_CALIB_OUTPUT(CalibOutput));
  1362.  
  1363.   /* Process Locked */
  1364.   __HAL_LOCK(hrtc);
  1365.  
  1366.   hrtc->State = HAL_RTC_STATE_BUSY;
  1367.  
  1368.   /* Disable the write protection for RTC registers */
  1369.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1370.  
  1371.   /* Clear flags before config */
  1372.   hrtc->Instance->CR &= (uint32_t)~RTC_CR_COSEL;
  1373.  
  1374.   /* Configure the RTC_CR register */
  1375.   hrtc->Instance->CR |= (uint32_t)CalibOutput;
  1376.  
  1377.   __HAL_RTC_CALIBRATION_OUTPUT_ENABLE(hrtc);
  1378.  
  1379.   /* Enable the write protection for RTC registers */
  1380.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1381.  
  1382.   /* Change RTC state */
  1383.   hrtc->State = HAL_RTC_STATE_READY;
  1384.  
  1385.   /* Process Unlocked */
  1386.   __HAL_UNLOCK(hrtc);
  1387.  
  1388.   return HAL_OK;
  1389. }
  1390.  
  1391. /**
  1392.   * @brief  Deactivate the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
  1393.   * @param  hrtc RTC handle
  1394.   * @retval HAL status
  1395.   */
  1396. HAL_StatusTypeDef HAL_RTCEx_DeactivateCalibrationOutPut(RTC_HandleTypeDef *hrtc)
  1397. {
  1398.   /* Process Locked */
  1399.   __HAL_LOCK(hrtc);
  1400.  
  1401.   hrtc->State = HAL_RTC_STATE_BUSY;
  1402.  
  1403.   /* Disable the write protection for RTC registers */
  1404.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1405.  
  1406.   __HAL_RTC_CALIBRATION_OUTPUT_DISABLE(hrtc);
  1407.  
  1408.   /* Enable the write protection for RTC registers */
  1409.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1410.  
  1411.   /* Change RTC state */
  1412.   hrtc->State = HAL_RTC_STATE_READY;
  1413.  
  1414.   /* Process Unlocked */
  1415.   __HAL_UNLOCK(hrtc);
  1416.  
  1417.   return HAL_OK;
  1418. }
  1419.  
  1420. /**
  1421.   * @brief  Enable the RTC reference clock detection.
  1422.   * @param  hrtc RTC handle
  1423.   * @retval HAL status
  1424.   */
  1425. HAL_StatusTypeDef HAL_RTCEx_SetRefClock(RTC_HandleTypeDef *hrtc)
  1426. {
  1427.   /* Process Locked */
  1428.   __HAL_LOCK(hrtc);
  1429.  
  1430.   hrtc->State = HAL_RTC_STATE_BUSY;
  1431.  
  1432.   /* Disable the write protection for RTC registers */
  1433.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1434.  
  1435.   /* Set Initialization mode */
  1436.   if (RTC_EnterInitMode(hrtc) != HAL_OK)
  1437.   {
  1438.     /* Enable the write protection for RTC registers */
  1439.     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1440.  
  1441.     /* Set RTC state*/
  1442.     hrtc->State = HAL_RTC_STATE_ERROR;
  1443.  
  1444.     /* Process Unlocked */
  1445.     __HAL_UNLOCK(hrtc);
  1446.  
  1447.     return HAL_ERROR;
  1448.   }
  1449.   else
  1450.   {
  1451.     __HAL_RTC_CLOCKREF_DETECTION_ENABLE(hrtc);
  1452.  
  1453.     /* Exit Initialization mode */
  1454.     hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
  1455.   }
  1456.  
  1457.   /* Enable the write protection for RTC registers */
  1458.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1459.  
  1460.   /* Change RTC state */
  1461.   hrtc->State = HAL_RTC_STATE_READY;
  1462.  
  1463.   /* Process Unlocked */
  1464.   __HAL_UNLOCK(hrtc);
  1465.  
  1466.   return HAL_OK;
  1467. }
  1468.  
  1469. /**
  1470.   * @brief  Disable the RTC reference clock detection.
  1471.   * @param  hrtc RTC handle
  1472.   * @retval HAL status
  1473.   */
  1474. HAL_StatusTypeDef HAL_RTCEx_DeactivateRefClock(RTC_HandleTypeDef *hrtc)
  1475. {
  1476.   /* Process Locked */
  1477.   __HAL_LOCK(hrtc);
  1478.  
  1479.   hrtc->State = HAL_RTC_STATE_BUSY;
  1480.  
  1481.   /* Disable the write protection for RTC registers */
  1482.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1483.  
  1484.   /* Set Initialization mode */
  1485.   if (RTC_EnterInitMode(hrtc) != HAL_OK)
  1486.   {
  1487.     /* Enable the write protection for RTC registers */
  1488.     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1489.  
  1490.     /* Set RTC state*/
  1491.     hrtc->State = HAL_RTC_STATE_ERROR;
  1492.  
  1493.     /* Process Unlocked */
  1494.     __HAL_UNLOCK(hrtc);
  1495.  
  1496.     return HAL_ERROR;
  1497.   }
  1498.   else
  1499.   {
  1500.     __HAL_RTC_CLOCKREF_DETECTION_DISABLE(hrtc);
  1501.  
  1502.     /* Exit Initialization mode */
  1503.     hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
  1504.   }
  1505.  
  1506.   /* Enable the write protection for RTC registers */
  1507.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1508.  
  1509.   /* Change RTC state */
  1510.   hrtc->State = HAL_RTC_STATE_READY;
  1511.  
  1512.   /* Process Unlocked */
  1513.   __HAL_UNLOCK(hrtc);
  1514.  
  1515.   return HAL_OK;
  1516. }
  1517.  
  1518. /**
  1519.   * @brief  Enable the Bypass Shadow feature.
  1520.   * @param  hrtc RTC handle
  1521.   * @note   When the Bypass Shadow is enabled the calendar value are taken
  1522.   *         directly from the Calendar counter.
  1523.   * @retval HAL status
  1524.   */
  1525. HAL_StatusTypeDef HAL_RTCEx_EnableBypassShadow(RTC_HandleTypeDef *hrtc)
  1526. {
  1527.   /* Process Locked */
  1528.   __HAL_LOCK(hrtc);
  1529.  
  1530.   hrtc->State = HAL_RTC_STATE_BUSY;
  1531.  
  1532.   /* Disable the write protection for RTC registers */
  1533.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1534.  
  1535.   /* Set the BYPSHAD bit */
  1536.   hrtc->Instance->CR |= (uint8_t)RTC_CR_BYPSHAD;
  1537.  
  1538.   /* Enable the write protection for RTC registers */
  1539.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1540.  
  1541.   /* Change RTC state */
  1542.   hrtc->State = HAL_RTC_STATE_READY;
  1543.  
  1544.   /* Process Unlocked */
  1545.   __HAL_UNLOCK(hrtc);
  1546.  
  1547.   return HAL_OK;
  1548. }
  1549.  
  1550. /**
  1551.   * @brief  Disable the Bypass Shadow feature.
  1552.   * @param  hrtc RTC handle
  1553.   * @note   When the Bypass Shadow is enabled the calendar value are taken
  1554.   *         directly from the Calendar counter.
  1555.   * @retval HAL status
  1556.   */
  1557. HAL_StatusTypeDef HAL_RTCEx_DisableBypassShadow(RTC_HandleTypeDef *hrtc)
  1558. {
  1559.   /* Process Locked */
  1560.   __HAL_LOCK(hrtc);
  1561.  
  1562.   hrtc->State = HAL_RTC_STATE_BUSY;
  1563.  
  1564.   /* Disable the write protection for RTC registers */
  1565.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1566.  
  1567.   /* Reset the BYPSHAD bit */
  1568.   hrtc->Instance->CR &= ((uint8_t)~RTC_CR_BYPSHAD);
  1569.  
  1570.   /* Enable the write protection for RTC registers */
  1571.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1572.  
  1573.   /* Change RTC state */
  1574.   hrtc->State = HAL_RTC_STATE_READY;
  1575.  
  1576.   /* Process Unlocked */
  1577.   __HAL_UNLOCK(hrtc);
  1578.  
  1579.   return HAL_OK;
  1580. }
  1581.  
  1582. /**
  1583.   * @}
  1584.   */
  1585.  
  1586. /**
  1587.   * @}
  1588.   */
  1589.  
  1590. #endif /* HAL_RTC_MODULE_ENABLED */
  1591.  
  1592. /**
  1593.   * @}
  1594.   */
  1595.  
  1596. /**
  1597.   * @}
  1598.   */
  1599.  
  1600. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  1601.