Flotsam / mbed-modifed

Modified version of the mbed library for use with the Nucleo boards.

Dependents:   EEPROMWrite Full-Project

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_rtc_ex.c@630:825f75ca301e, 2015-09-28 (annotated)

Committer:
mbed_official
Date:
Mon Sep 28 10:45:10 2015 +0100
Revision:
630:825f75ca301e
Parent:
441:d2c15dda23c1 
Synchronized with git revision 54fbe4144faf309c37205a5d39fa665daa919f10



Full URL: https://github.com/mbedmicro/mbed/commit/54fbe4144faf309c37205a5d39fa665daa919f10/



NUCLEO_F031K6 : Add new target

Who changed what in which revision?

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