mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F3/stm32f3xx_hal_rtc_ex.c@634:ac7d6880524d, 2015-09-28 (annotated)

Committer:
mbed_official
Date:
Mon Sep 28 20:15:09 2015 +0100
Revision:
634:ac7d6880524d
Parent:
632:7687fb9c4f91 
Synchronized with git revision 9b7d23d47153c298a6d24de9a415202705889d11



Full URL: https://github.com/mbedmicro/mbed/commit/9b7d23d47153c298a6d24de9a415202705889d11/



Revert "[NUCLEO_F303K8] add support of the STM32F303K8"

Who changed what in which revision?

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