mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F0/device/stm32f0xx_hal_rtc_ex.c@156:95d6b41a828b, 2017-01-16 (annotated)

Committer:
<>
Date:
Mon Jan 16 15:03:32 2017 +0000
Revision:
156:95d6b41a828b
Parent:
149:156823d33999
Child:
180:96ed750bd169
This updates the lib to the mbed lib v134

Who changed what in which revision?

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