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@149:156823d33999, 2016-10-28 (annotated)

Committer:
<>
Date:
Fri Oct 28 11:17:30 2016 +0100
Revision:
149:156823d33999
Parent:
targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_rtc_ex.c@144:ef7eb2e8f9f7
Child:
156:95d6b41a828b
This updates the lib to the mbed lib v128



NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

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
<> 144:ef7eb2e8f9f7 5 * @version V1.4.0
<> 144:ef7eb2e8f9f7 6 * @date 27-May-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 {
<> 144:ef7eb2e8f9f7 154 uint32_t tmpreg = 0;
<> 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 {
<> 144:ef7eb2e8f9f7 208 uint32_t tmpreg = 0;
<> 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 {
<> 144:ef7eb2e8f9f7 258 uint32_t tmpreg = 0;
<> 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 {
<> 144:ef7eb2e8f9f7 302 uint32_t tmptime = 0, tmpdate = 0;
<> 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 */
<> 144:ef7eb2e8f9f7 312 sTimeStamp->Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16);
<> 144:ef7eb2e8f9f7 313 sTimeStamp->Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8);
<> 144:ef7eb2e8f9f7 314 sTimeStamp->Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU));
<> 144:ef7eb2e8f9f7 315 sTimeStamp->TimeFormat = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16);
<> 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;
<> 144:ef7eb2e8f9f7 320 sTimeStampDate->Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8);
<> 144:ef7eb2e8f9f7 321 sTimeStampDate->Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU));
<> 144:ef7eb2e8f9f7 322 sTimeStampDate->WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13);
<> 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 {
<> 144:ef7eb2e8f9f7 353 uint32_t tmpreg = 0;
<> 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 {
<> 144:ef7eb2e8f9f7 371 sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1);
<> 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
<> 144:ef7eb2e8f9f7 378 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (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 {
<> 144:ef7eb2e8f9f7 402 uint32_t tmpreg = 0;
<> 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 {
<> 144:ef7eb2e8f9f7 421 sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1);
<> 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
<> 144:ef7eb2e8f9f7 428 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (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 {
<> 144:ef7eb2e8f9f7 636 if((Timeout == 0) || ((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 {
<> 144:ef7eb2e8f9f7 665 if((Timeout == 0) || ((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 {
<> 144:ef7eb2e8f9f7 697 if((Timeout == 0) || ((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 {
<> 144:ef7eb2e8f9f7 730 if((Timeout == 0) || ((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 {
<> 144:ef7eb2e8f9f7 776 uint32_t tickstart = 0;
<> 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 {
<> 144:ef7eb2e8f9f7 865 uint32_t tickstart = 0;
<> 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
<> 144:ef7eb2e8f9f7 901 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 902
<> 144:ef7eb2e8f9f7 903 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 904
<> 144:ef7eb2e8f9f7 905 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
<> 144:ef7eb2e8f9f7 906 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
<> 144:ef7eb2e8f9f7 907 {
<> 144:ef7eb2e8f9f7 908 if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 909 {
<> 144:ef7eb2e8f9f7 910 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 911 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 912
<> 144:ef7eb2e8f9f7 913 hrtc->State = HAL_RTC_STATE_TIMEOUT;
<> 144:ef7eb2e8f9f7 914
<> 144:ef7eb2e8f9f7 915 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 916 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 917
<> 144:ef7eb2e8f9f7 918 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 919 }
<> 144:ef7eb2e8f9f7 920 }
<> 144:ef7eb2e8f9f7 921
<> 144:ef7eb2e8f9f7 922 /* Configure the Wakeup Timer counter */
<> 144:ef7eb2e8f9f7 923 hrtc->Instance->WUTR = (uint32_t)WakeUpCounter;
<> 144:ef7eb2e8f9f7 924
<> 144:ef7eb2e8f9f7 925 /* Clear the Wakeup Timer clock source bits in CR register */
<> 144:ef7eb2e8f9f7 926 hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;
<> 144:ef7eb2e8f9f7 927
<> 144:ef7eb2e8f9f7 928 /* Configure the clock source */
<> 144:ef7eb2e8f9f7 929 hrtc->Instance->CR |= (uint32_t)WakeUpClock;
<> 144:ef7eb2e8f9f7 930
<> 144:ef7eb2e8f9f7 931 /* RTC WakeUpTimer Interrupt Configuration: EXTI configuration */
<> 144:ef7eb2e8f9f7 932 __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_IT();
<> 144:ef7eb2e8f9f7 933
<> 144:ef7eb2e8f9f7 934 __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_RISING_EDGE();
<> 144:ef7eb2e8f9f7 935
<> 144:ef7eb2e8f9f7 936 /* Configure the Interrupt in the RTC_CR register */
<> 144:ef7eb2e8f9f7 937 __HAL_RTC_WAKEUPTIMER_ENABLE_IT(hrtc,RTC_IT_WUT);
<> 144:ef7eb2e8f9f7 938
<> 144:ef7eb2e8f9f7 939 /* Enable the Wakeup Timer */
<> 144:ef7eb2e8f9f7 940 __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 941
<> 144:ef7eb2e8f9f7 942 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 943 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 944
<> 144:ef7eb2e8f9f7 945 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 946
<> 144:ef7eb2e8f9f7 947 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 948 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 949
<> 144:ef7eb2e8f9f7 950 return HAL_OK;
<> 144:ef7eb2e8f9f7 951 }
<> 144:ef7eb2e8f9f7 952
<> 144:ef7eb2e8f9f7 953 /**
<> 144:ef7eb2e8f9f7 954 * @brief Deactivate wake up timer counter.
<> 144:ef7eb2e8f9f7 955 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 956 * @retval HAL status
<> 144:ef7eb2e8f9f7 957 */
<> 144:ef7eb2e8f9f7 958 uint32_t HAL_RTCEx_DeactivateWakeUpTimer(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 959 {
<> 144:ef7eb2e8f9f7 960 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 961
<> 144:ef7eb2e8f9f7 962 /* Process Locked */
<> 144:ef7eb2e8f9f7 963 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 964
<> 144:ef7eb2e8f9f7 965 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 966
<> 144:ef7eb2e8f9f7 967 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 968 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 969
<> 144:ef7eb2e8f9f7 970 /* Disable the Wakeup Timer */
<> 144:ef7eb2e8f9f7 971 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 972
<> 144:ef7eb2e8f9f7 973 /* In case of interrupt mode is used, the interrupt source must disabled */
<> 144:ef7eb2e8f9f7 974 __HAL_RTC_WAKEUPTIMER_DISABLE_IT(hrtc,RTC_IT_WUT);
<> 144:ef7eb2e8f9f7 975
<> 144:ef7eb2e8f9f7 976 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 977 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
<> 144:ef7eb2e8f9f7 978 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
<> 144:ef7eb2e8f9f7 979 {
<> 144:ef7eb2e8f9f7 980 if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 981 {
<> 144:ef7eb2e8f9f7 982 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 983 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 984
<> 144:ef7eb2e8f9f7 985 hrtc->State = HAL_RTC_STATE_TIMEOUT;
<> 144:ef7eb2e8f9f7 986
<> 144:ef7eb2e8f9f7 987 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 988 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 989
<> 144:ef7eb2e8f9f7 990 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 991 }
<> 144:ef7eb2e8f9f7 992 }
<> 144:ef7eb2e8f9f7 993
<> 144:ef7eb2e8f9f7 994 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 995 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 996
<> 144:ef7eb2e8f9f7 997 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 998
<> 144:ef7eb2e8f9f7 999 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1000 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1001
<> 144:ef7eb2e8f9f7 1002 return HAL_OK;
<> 144:ef7eb2e8f9f7 1003 }
<> 144:ef7eb2e8f9f7 1004
<> 144:ef7eb2e8f9f7 1005 /**
<> 144:ef7eb2e8f9f7 1006 * @brief Get wake up timer counter.
<> 144:ef7eb2e8f9f7 1007 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1008 * @retval Counter value
<> 144:ef7eb2e8f9f7 1009 */
<> 144:ef7eb2e8f9f7 1010 uint32_t HAL_RTCEx_GetWakeUpTimer(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 1011 {
<> 144:ef7eb2e8f9f7 1012 /* Get the counter value */
<> 144:ef7eb2e8f9f7 1013 return ((uint32_t)(hrtc->Instance->WUTR & RTC_WUTR_WUT));
<> 144:ef7eb2e8f9f7 1014 }
<> 144:ef7eb2e8f9f7 1015
<> 144:ef7eb2e8f9f7 1016 /**
<> 144:ef7eb2e8f9f7 1017 * @brief Handle Wake Up Timer interrupt request.
<> 144:ef7eb2e8f9f7 1018 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1019 * @retval None
<> 144:ef7eb2e8f9f7 1020 */
<> 144:ef7eb2e8f9f7 1021 void HAL_RTCEx_WakeUpTimerIRQHandler(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 1022 {
<> 144:ef7eb2e8f9f7 1023 /* Get the WAKEUPTIMER interrupt source enable status */
<> 144:ef7eb2e8f9f7 1024 if(__HAL_RTC_WAKEUPTIMER_GET_IT_SOURCE(hrtc, RTC_IT_WUT) != RESET)
<> 144:ef7eb2e8f9f7 1025 {
<> 144:ef7eb2e8f9f7 1026 /* Get the pending status of the WAKEUPTIMER Interrupt */
<> 144:ef7eb2e8f9f7 1027 if(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) != RESET)
<> 144:ef7eb2e8f9f7 1028 {
<> 144:ef7eb2e8f9f7 1029 /* WAKEUPTIMER callback */
<> 144:ef7eb2e8f9f7 1030 HAL_RTCEx_WakeUpTimerEventCallback(hrtc);
<> 144:ef7eb2e8f9f7 1031
<> 144:ef7eb2e8f9f7 1032 /* Clear the WAKEUPTIMER interrupt pending bit */
<> 144:ef7eb2e8f9f7 1033 __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
<> 144:ef7eb2e8f9f7 1034 }
<> 144:ef7eb2e8f9f7 1035 }
<> 144:ef7eb2e8f9f7 1036
<> 144:ef7eb2e8f9f7 1037 /* Clear the EXTI's line Flag for RTC WakeUpTimer */
<> 144:ef7eb2e8f9f7 1038 __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();
<> 144:ef7eb2e8f9f7 1039
<> 144:ef7eb2e8f9f7 1040 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1041 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1042 }
<> 144:ef7eb2e8f9f7 1043
<> 144:ef7eb2e8f9f7 1044 /**
<> 144:ef7eb2e8f9f7 1045 * @brief Wake Up Timer callback.
<> 144:ef7eb2e8f9f7 1046 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1047 * @retval None
<> 144:ef7eb2e8f9f7 1048 */
<> 144:ef7eb2e8f9f7 1049 __weak void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 1050 {
<> 144:ef7eb2e8f9f7 1051 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1052 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 1053
<> 144:ef7eb2e8f9f7 1054 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1055 the HAL_RTCEx_WakeUpTimerEventCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1056 */
<> 144:ef7eb2e8f9f7 1057 }
<> 144:ef7eb2e8f9f7 1058
<> 144:ef7eb2e8f9f7 1059
<> 144:ef7eb2e8f9f7 1060 /**
<> 144:ef7eb2e8f9f7 1061 * @brief Handle Wake Up Timer Polling.
<> 144:ef7eb2e8f9f7 1062 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1063 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 1064 * @retval HAL status
<> 144:ef7eb2e8f9f7 1065 */
<> 144:ef7eb2e8f9f7 1066 HAL_StatusTypeDef HAL_RTCEx_PollForWakeUpTimerEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 1067 {
<> 144:ef7eb2e8f9f7 1068 uint32_t tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1069
<> 144:ef7eb2e8f9f7 1070 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) == RESET)
<> 144:ef7eb2e8f9f7 1071 {
<> 144:ef7eb2e8f9f7 1072 if(Timeout != HAL_MAX_DELAY)
<> 144:ef7eb2e8f9f7 1073 {
<> 144:ef7eb2e8f9f7 1074 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
<> 144:ef7eb2e8f9f7 1075 {
<> 144:ef7eb2e8f9f7 1076 hrtc->State = HAL_RTC_STATE_TIMEOUT;
<> 144:ef7eb2e8f9f7 1077
<> 144:ef7eb2e8f9f7 1078 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1079 }
<> 144:ef7eb2e8f9f7 1080 }
<> 144:ef7eb2e8f9f7 1081 }
<> 144:ef7eb2e8f9f7 1082
<> 144:ef7eb2e8f9f7 1083 /* Clear the WAKEUPTIMER Flag */
<> 144:ef7eb2e8f9f7 1084 __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
<> 144:ef7eb2e8f9f7 1085
<> 144:ef7eb2e8f9f7 1086 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1087 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1088
<> 144:ef7eb2e8f9f7 1089 return HAL_OK;
<> 144:ef7eb2e8f9f7 1090 }
<> 144:ef7eb2e8f9f7 1091
<> 144:ef7eb2e8f9f7 1092 /**
<> 144:ef7eb2e8f9f7 1093 * @}
<> 144:ef7eb2e8f9f7 1094 */
<> 144:ef7eb2e8f9f7 1095 #endif /* defined(STM32F070xB) || defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx) | defined(STM32F030xC) */
<> 144:ef7eb2e8f9f7 1096
<> 144:ef7eb2e8f9f7 1097 /** @addtogroup RTCEx_Exported_Functions_Group3
<> 144:ef7eb2e8f9f7 1098 * @brief Extended Peripheral Control functions
<> 144:ef7eb2e8f9f7 1099 *
<> 144:ef7eb2e8f9f7 1100 @verbatim
<> 144:ef7eb2e8f9f7 1101 ===============================================================================
<> 144:ef7eb2e8f9f7 1102 ##### Extended Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 1103 ===============================================================================
<> 144:ef7eb2e8f9f7 1104 [..]
<> 144:ef7eb2e8f9f7 1105 This subsection provides functions allowing to
<> 144:ef7eb2e8f9f7 1106 (+) Write a data in a specified RTC Backup data register
<> 144:ef7eb2e8f9f7 1107 (+) Read a data in a specified RTC Backup data register
<> 144:ef7eb2e8f9f7 1108 (+) Set the Coarse calibration parameters.
<> 144:ef7eb2e8f9f7 1109 (+) Deactivate the Coarse calibration parameters
<> 144:ef7eb2e8f9f7 1110 (+) Set the Smooth calibration parameters.
<> 144:ef7eb2e8f9f7 1111 (+) Configure the Synchronization Shift Control Settings.
<> 144:ef7eb2e8f9f7 1112 (+) Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
<> 144:ef7eb2e8f9f7 1113 (+) Deactivate the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
<> 144:ef7eb2e8f9f7 1114 (+) Enable the RTC reference clock detection.
<> 144:ef7eb2e8f9f7 1115 (+) Disable the RTC reference clock detection.
<> 144:ef7eb2e8f9f7 1116 (+) Enable the Bypass Shadow feature.
<> 144:ef7eb2e8f9f7 1117 (+) Disable the Bypass Shadow feature.
<> 144:ef7eb2e8f9f7 1118
<> 144:ef7eb2e8f9f7 1119 @endverbatim
<> 144:ef7eb2e8f9f7 1120 * @{
<> 144:ef7eb2e8f9f7 1121 */
<> 144:ef7eb2e8f9f7 1122
<> 144:ef7eb2e8f9f7 1123 #if !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC)
<> 144:ef7eb2e8f9f7 1124 /**
<> 144:ef7eb2e8f9f7 1125 * @brief Write a data in a specified RTC Backup data register.
<> 144:ef7eb2e8f9f7 1126 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1127 * @param BackupRegister: RTC Backup data Register number.
<> 144:ef7eb2e8f9f7 1128 * This parameter can be: RTC_BKP_DRx where x can be from 0 to 4 to
<> 144:ef7eb2e8f9f7 1129 * specify the register.
<> 144:ef7eb2e8f9f7 1130 * @param Data: Data to be written in the specified RTC Backup data register.
<> 144:ef7eb2e8f9f7 1131 * @retval None
<> 144:ef7eb2e8f9f7 1132 */
<> 144:ef7eb2e8f9f7 1133 void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)
<> 144:ef7eb2e8f9f7 1134 {
<> 144:ef7eb2e8f9f7 1135 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 1136
<> 144:ef7eb2e8f9f7 1137 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1138 assert_param(IS_RTC_BKP(BackupRegister));
<> 144:ef7eb2e8f9f7 1139
<> 144:ef7eb2e8f9f7 1140 tmp = (uint32_t)&(hrtc->Instance->BKP0R);
<> 144:ef7eb2e8f9f7 1141 tmp += (BackupRegister * 4);
<> 144:ef7eb2e8f9f7 1142
<> 144:ef7eb2e8f9f7 1143 /* Write the specified register */
<> 144:ef7eb2e8f9f7 1144 *(__IO uint32_t *)tmp = (uint32_t)Data;
<> 144:ef7eb2e8f9f7 1145 }
<> 144:ef7eb2e8f9f7 1146
<> 144:ef7eb2e8f9f7 1147 /**
<> 144:ef7eb2e8f9f7 1148 * @brief Reads data from the specified RTC Backup data Register.
<> 144:ef7eb2e8f9f7 1149 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1150 * @param BackupRegister: RTC Backup data Register number.
<> 144:ef7eb2e8f9f7 1151 * This parameter can be: RTC_BKP_DRx where x can be from 0 to 4 to
<> 144:ef7eb2e8f9f7 1152 * specify the register.
<> 144:ef7eb2e8f9f7 1153 * @retval Read value
<> 144:ef7eb2e8f9f7 1154 */
<> 144:ef7eb2e8f9f7 1155 uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)
<> 144:ef7eb2e8f9f7 1156 {
<> 144:ef7eb2e8f9f7 1157 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 1158
<> 144:ef7eb2e8f9f7 1159 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1160 assert_param(IS_RTC_BKP(BackupRegister));
<> 144:ef7eb2e8f9f7 1161
<> 144:ef7eb2e8f9f7 1162 tmp = (uint32_t)&(hrtc->Instance->BKP0R);
<> 144:ef7eb2e8f9f7 1163 tmp += (BackupRegister * 4);
<> 144:ef7eb2e8f9f7 1164
<> 144:ef7eb2e8f9f7 1165 /* Read the specified register */
<> 144:ef7eb2e8f9f7 1166 return (*(__IO uint32_t *)tmp);
<> 144:ef7eb2e8f9f7 1167 }
<> 144:ef7eb2e8f9f7 1168 #endif /* !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC) */
<> 144:ef7eb2e8f9f7 1169
<> 144:ef7eb2e8f9f7 1170 /**
<> 144:ef7eb2e8f9f7 1171 * @brief Set the Smooth calibration parameters.
<> 144:ef7eb2e8f9f7 1172 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1173 * @param SmoothCalibPeriod: Select the Smooth Calibration Period.
<> 144:ef7eb2e8f9f7 1174 * This parameter can be can be one of the following values :
<> 144:ef7eb2e8f9f7 1175 * @arg RTC_SMOOTHCALIB_PERIOD_32SEC: The smooth calibration period is 32s.
<> 144:ef7eb2e8f9f7 1176 * @arg RTC_SMOOTHCALIB_PERIOD_16SEC: The smooth calibration period is 16s.
<> 144:ef7eb2e8f9f7 1177 * @arg RTC_SMOOTHCALIB_PERIOD_8SEC: The smooth calibration period is 8s.
<> 144:ef7eb2e8f9f7 1178 * @param SmoothCalibPlusPulses: Select to Set or reset the CALP bit.
<> 144:ef7eb2e8f9f7 1179 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1180 * @arg RTC_SMOOTHCALIB_PLUSPULSES_SET: Add one RTCCLK pulse every 2*11 pulses.
<> 144:ef7eb2e8f9f7 1181 * @arg RTC_SMOOTHCALIB_PLUSPULSES_RESET: No RTCCLK pulses are added.
<> 144:ef7eb2e8f9f7 1182 * @param SmoothCalibMinusPulsesValue: Select the value of CALM[8:0] bits.
<> 144:ef7eb2e8f9f7 1183 * This parameter can be one any value from 0 to 0x000001FF.
<> 144:ef7eb2e8f9f7 1184 * @note To deactivate the smooth calibration, the field SmoothCalibPlusPulses
<> 144:ef7eb2e8f9f7 1185 * must be equal to SMOOTHCALIB_PLUSPULSES_RESET and the field
<> 144:ef7eb2e8f9f7 1186 * SmoothCalibMinusPulsesValue mut be equal to 0.
<> 144:ef7eb2e8f9f7 1187 * @retval HAL status
<> 144:ef7eb2e8f9f7 1188 */
<> 144:ef7eb2e8f9f7 1189 HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef* hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmoothCalibMinusPulsesValue)
<> 144:ef7eb2e8f9f7 1190 {
<> 144:ef7eb2e8f9f7 1191 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1192
<> 144:ef7eb2e8f9f7 1193 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1194 assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(SmoothCalibPeriod));
<> 144:ef7eb2e8f9f7 1195 assert_param(IS_RTC_SMOOTH_CALIB_PLUS(SmoothCalibPlusPulses));
<> 144:ef7eb2e8f9f7 1196 assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmoothCalibMinusPulsesValue));
<> 144:ef7eb2e8f9f7 1197
<> 144:ef7eb2e8f9f7 1198 /* Process Locked */
<> 144:ef7eb2e8f9f7 1199 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1200
<> 144:ef7eb2e8f9f7 1201 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1202
<> 144:ef7eb2e8f9f7 1203 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1204 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1205
<> 144:ef7eb2e8f9f7 1206 /* check if a calibration is pending*/
<> 144:ef7eb2e8f9f7 1207 if((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)
<> 144:ef7eb2e8f9f7 1208 {
<> 144:ef7eb2e8f9f7 1209 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1210
<> 144:ef7eb2e8f9f7 1211 /* check if a calibration is pending*/
<> 144:ef7eb2e8f9f7 1212 while((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)
<> 144:ef7eb2e8f9f7 1213 {
<> 144:ef7eb2e8f9f7 1214 if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1215 {
<> 144:ef7eb2e8f9f7 1216 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1217 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1218
<> 144:ef7eb2e8f9f7 1219 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1220 hrtc->State = HAL_RTC_STATE_TIMEOUT;
<> 144:ef7eb2e8f9f7 1221
<> 144:ef7eb2e8f9f7 1222 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1223 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1224
<> 144:ef7eb2e8f9f7 1225 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1226 }
<> 144:ef7eb2e8f9f7 1227 }
<> 144:ef7eb2e8f9f7 1228 }
<> 144:ef7eb2e8f9f7 1229
<> 144:ef7eb2e8f9f7 1230 /* Configure the Smooth calibration settings */
<> 144:ef7eb2e8f9f7 1231 hrtc->Instance->CALR = (uint32_t)((uint32_t)SmoothCalibPeriod | (uint32_t)SmoothCalibPlusPulses | (uint32_t)SmoothCalibMinusPulsesValue);
<> 144:ef7eb2e8f9f7 1232
<> 144:ef7eb2e8f9f7 1233 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1234 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1235
<> 144:ef7eb2e8f9f7 1236 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1237 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1238
<> 144:ef7eb2e8f9f7 1239 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1240 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1241
<> 144:ef7eb2e8f9f7 1242 return HAL_OK;
<> 144:ef7eb2e8f9f7 1243 }
<> 144:ef7eb2e8f9f7 1244
<> 144:ef7eb2e8f9f7 1245 /**
<> 144:ef7eb2e8f9f7 1246 * @brief Configure the Synchronization Shift Control Settings.
<> 144:ef7eb2e8f9f7 1247 * @note When REFCKON is set, firmware must not write to Shift control register.
<> 144:ef7eb2e8f9f7 1248 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1249 * @param ShiftAdd1S: Select to add or not 1 second to the time calendar.
<> 144:ef7eb2e8f9f7 1250 * This parameter can be one of the following values :
<> 144:ef7eb2e8f9f7 1251 * @arg RTC_SHIFTADD1S_SET: Add one second to the clock calendar.
<> 144:ef7eb2e8f9f7 1252 * @arg RTC_SHIFTADD1S_RESET: No effect.
<> 144:ef7eb2e8f9f7 1253 * @param ShiftSubFS: Select the number of Second Fractions to substitute.
<> 144:ef7eb2e8f9f7 1254 * This parameter can be one any value from 0 to 0x7FFF.
<> 144:ef7eb2e8f9f7 1255 * @retval HAL status
<> 144:ef7eb2e8f9f7 1256 */
<> 144:ef7eb2e8f9f7 1257 HAL_StatusTypeDef HAL_RTCEx_SetSynchroShift(RTC_HandleTypeDef* hrtc, uint32_t ShiftAdd1S, uint32_t ShiftSubFS)
<> 144:ef7eb2e8f9f7 1258 {
<> 144:ef7eb2e8f9f7 1259 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1260
<> 144:ef7eb2e8f9f7 1261 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1262 assert_param(IS_RTC_SHIFT_ADD1S(ShiftAdd1S));
<> 144:ef7eb2e8f9f7 1263 assert_param(IS_RTC_SHIFT_SUBFS(ShiftSubFS));
<> 144:ef7eb2e8f9f7 1264
<> 144:ef7eb2e8f9f7 1265 /* Process Locked */
<> 144:ef7eb2e8f9f7 1266 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1267
<> 144:ef7eb2e8f9f7 1268 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1269
<> 144:ef7eb2e8f9f7 1270 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1271 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1272
<> 144:ef7eb2e8f9f7 1273 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1274
<> 144:ef7eb2e8f9f7 1275 /* Wait until the shift is completed*/
<> 144:ef7eb2e8f9f7 1276 while((hrtc->Instance->ISR & RTC_ISR_SHPF) != RESET)
<> 144:ef7eb2e8f9f7 1277 {
<> 144:ef7eb2e8f9f7 1278 if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1279 {
<> 144:ef7eb2e8f9f7 1280 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1281 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1282
<> 144:ef7eb2e8f9f7 1283 hrtc->State = HAL_RTC_STATE_TIMEOUT;
<> 144:ef7eb2e8f9f7 1284
<> 144:ef7eb2e8f9f7 1285 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1286 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1287
<> 144:ef7eb2e8f9f7 1288 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1289 }
<> 144:ef7eb2e8f9f7 1290 }
<> 144:ef7eb2e8f9f7 1291
<> 144:ef7eb2e8f9f7 1292 /* Check if the reference clock detection is disabled */
<> 144:ef7eb2e8f9f7 1293 if((hrtc->Instance->CR & RTC_CR_REFCKON) == RESET)
<> 144:ef7eb2e8f9f7 1294 {
<> 144:ef7eb2e8f9f7 1295 /* Configure the Shift settings */
<> 144:ef7eb2e8f9f7 1296 hrtc->Instance->SHIFTR = (uint32_t)(uint32_t)(ShiftSubFS) | (uint32_t)(ShiftAdd1S);
<> 144:ef7eb2e8f9f7 1297
<> 144:ef7eb2e8f9f7 1298 /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
<> 144:ef7eb2e8f9f7 1299 if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
<> 144:ef7eb2e8f9f7 1300 {
<> 144:ef7eb2e8f9f7 1301 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1302 {
<> 144:ef7eb2e8f9f7 1303 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1304 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1305
<> 144:ef7eb2e8f9f7 1306 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 1307
<> 144:ef7eb2e8f9f7 1308 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1309 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1310
<> 144:ef7eb2e8f9f7 1311 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1312 }
<> 144:ef7eb2e8f9f7 1313 }
<> 144:ef7eb2e8f9f7 1314 }
<> 144:ef7eb2e8f9f7 1315 else
<> 144:ef7eb2e8f9f7 1316 {
<> 144:ef7eb2e8f9f7 1317 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1318 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1319
<> 144:ef7eb2e8f9f7 1320 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1321 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 1322
<> 144:ef7eb2e8f9f7 1323 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1324 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1325
<> 144:ef7eb2e8f9f7 1326 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1327 }
<> 144:ef7eb2e8f9f7 1328
<> 144:ef7eb2e8f9f7 1329 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1330 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1331
<> 144:ef7eb2e8f9f7 1332 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1333 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1334
<> 144:ef7eb2e8f9f7 1335 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1336 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1337
<> 144:ef7eb2e8f9f7 1338 return HAL_OK;
<> 144:ef7eb2e8f9f7 1339 }
<> 144:ef7eb2e8f9f7 1340
<> 144:ef7eb2e8f9f7 1341 /**
<> 144:ef7eb2e8f9f7 1342 * @brief Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
<> 144:ef7eb2e8f9f7 1343 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1344 * @param CalibOutput : Select the Calibration output Selection .
<> 144:ef7eb2e8f9f7 1345 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1346 * @arg RTC_CALIBOUTPUT_512HZ: A signal has a regular waveform at 512Hz.
<> 144:ef7eb2e8f9f7 1347 * @arg RTC_CALIBOUTPUT_1HZ: A signal has a regular waveform at 1Hz.
<> 144:ef7eb2e8f9f7 1348 * @retval HAL status
<> 144:ef7eb2e8f9f7 1349 */
<> 144:ef7eb2e8f9f7 1350 HAL_StatusTypeDef HAL_RTCEx_SetCalibrationOutPut(RTC_HandleTypeDef* hrtc, uint32_t CalibOutput)
<> 144:ef7eb2e8f9f7 1351 {
<> 144:ef7eb2e8f9f7 1352 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1353 assert_param(IS_RTC_CALIB_OUTPUT(CalibOutput));
<> 144:ef7eb2e8f9f7 1354
<> 144:ef7eb2e8f9f7 1355 /* Process Locked */
<> 144:ef7eb2e8f9f7 1356 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1357
<> 144:ef7eb2e8f9f7 1358 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1359
<> 144:ef7eb2e8f9f7 1360 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1361 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1362
<> 144:ef7eb2e8f9f7 1363 /* Clear flags before config */
<> 144:ef7eb2e8f9f7 1364 hrtc->Instance->CR &= (uint32_t)~RTC_CR_COSEL;
<> 144:ef7eb2e8f9f7 1365
<> 144:ef7eb2e8f9f7 1366 /* Configure the RTC_CR register */
<> 144:ef7eb2e8f9f7 1367 hrtc->Instance->CR |= (uint32_t)CalibOutput;
<> 144:ef7eb2e8f9f7 1368
<> 144:ef7eb2e8f9f7 1369 __HAL_RTC_CALIBRATION_OUTPUT_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1370
<> 144:ef7eb2e8f9f7 1371 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1372 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1373
<> 144:ef7eb2e8f9f7 1374 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1375 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1376
<> 144:ef7eb2e8f9f7 1377 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1378 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1379
<> 144:ef7eb2e8f9f7 1380 return HAL_OK;
<> 144:ef7eb2e8f9f7 1381 }
<> 144:ef7eb2e8f9f7 1382
<> 144:ef7eb2e8f9f7 1383 /**
<> 144:ef7eb2e8f9f7 1384 * @brief Deactivate the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
<> 144:ef7eb2e8f9f7 1385 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1386 * @retval HAL status
<> 144:ef7eb2e8f9f7 1387 */
<> 144:ef7eb2e8f9f7 1388 HAL_StatusTypeDef HAL_RTCEx_DeactivateCalibrationOutPut(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1389 {
<> 144:ef7eb2e8f9f7 1390 /* Process Locked */
<> 144:ef7eb2e8f9f7 1391 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1392
<> 144:ef7eb2e8f9f7 1393 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1394
<> 144:ef7eb2e8f9f7 1395 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1396 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1397
<> 144:ef7eb2e8f9f7 1398 __HAL_RTC_CALIBRATION_OUTPUT_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1399
<> 144:ef7eb2e8f9f7 1400 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1401 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1402
<> 144:ef7eb2e8f9f7 1403 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1404 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1405
<> 144:ef7eb2e8f9f7 1406 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1407 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1408
<> 144:ef7eb2e8f9f7 1409 return HAL_OK;
<> 144:ef7eb2e8f9f7 1410 }
<> 144:ef7eb2e8f9f7 1411
<> 144:ef7eb2e8f9f7 1412 /**
<> 144:ef7eb2e8f9f7 1413 * @brief Enable the RTC reference clock detection.
<> 144:ef7eb2e8f9f7 1414 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1415 * @retval HAL status
<> 144:ef7eb2e8f9f7 1416 */
<> 144:ef7eb2e8f9f7 1417 HAL_StatusTypeDef HAL_RTCEx_SetRefClock(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1418 {
<> 144:ef7eb2e8f9f7 1419 /* Process Locked */
<> 144:ef7eb2e8f9f7 1420 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1421
<> 144:ef7eb2e8f9f7 1422 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1423
<> 144:ef7eb2e8f9f7 1424 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1425 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1426
<> 144:ef7eb2e8f9f7 1427 /* Set Initialization mode */
<> 144:ef7eb2e8f9f7 1428 if(RTC_EnterInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1429 {
<> 144:ef7eb2e8f9f7 1430 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1431 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1432
<> 144:ef7eb2e8f9f7 1433 /* Set RTC state*/
<> 144:ef7eb2e8f9f7 1434 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 1435
<> 144:ef7eb2e8f9f7 1436 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1437 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1438
<> 144:ef7eb2e8f9f7 1439 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1440 }
<> 144:ef7eb2e8f9f7 1441 else
<> 144:ef7eb2e8f9f7 1442 {
<> 144:ef7eb2e8f9f7 1443 __HAL_RTC_CLOCKREF_DETECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1444
<> 144:ef7eb2e8f9f7 1445 /* Exit Initialization mode */
<> 144:ef7eb2e8f9f7 1446 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
<> 144:ef7eb2e8f9f7 1447 }
<> 144:ef7eb2e8f9f7 1448
<> 144:ef7eb2e8f9f7 1449 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1450 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1451
<> 144:ef7eb2e8f9f7 1452 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1453 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1454
<> 144:ef7eb2e8f9f7 1455 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1456 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1457
<> 144:ef7eb2e8f9f7 1458 return HAL_OK;
<> 144:ef7eb2e8f9f7 1459 }
<> 144:ef7eb2e8f9f7 1460
<> 144:ef7eb2e8f9f7 1461 /**
<> 144:ef7eb2e8f9f7 1462 * @brief Disable the RTC reference clock detection.
<> 144:ef7eb2e8f9f7 1463 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1464 * @retval HAL status
<> 144:ef7eb2e8f9f7 1465 */
<> 144:ef7eb2e8f9f7 1466 HAL_StatusTypeDef HAL_RTCEx_DeactivateRefClock(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1467 {
<> 144:ef7eb2e8f9f7 1468 /* Process Locked */
<> 144:ef7eb2e8f9f7 1469 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1470
<> 144:ef7eb2e8f9f7 1471 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1472
<> 144:ef7eb2e8f9f7 1473 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1474 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1475
<> 144:ef7eb2e8f9f7 1476 /* Set Initialization mode */
<> 144:ef7eb2e8f9f7 1477 if(RTC_EnterInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1478 {
<> 144:ef7eb2e8f9f7 1479 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1480 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1481
<> 144:ef7eb2e8f9f7 1482 /* Set RTC state*/
<> 144:ef7eb2e8f9f7 1483 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 1484
<> 144:ef7eb2e8f9f7 1485 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1486 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1487
<> 144:ef7eb2e8f9f7 1488 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1489 }
<> 144:ef7eb2e8f9f7 1490 else
<> 144:ef7eb2e8f9f7 1491 {
<> 144:ef7eb2e8f9f7 1492 __HAL_RTC_CLOCKREF_DETECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1493
<> 144:ef7eb2e8f9f7 1494 /* Exit Initialization mode */
<> 144:ef7eb2e8f9f7 1495 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
<> 144:ef7eb2e8f9f7 1496 }
<> 144:ef7eb2e8f9f7 1497
<> 144:ef7eb2e8f9f7 1498 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1499 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1500
<> 144:ef7eb2e8f9f7 1501 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1502 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1503
<> 144:ef7eb2e8f9f7 1504 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1505 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1506
<> 144:ef7eb2e8f9f7 1507 return HAL_OK;
<> 144:ef7eb2e8f9f7 1508 }
<> 144:ef7eb2e8f9f7 1509
<> 144:ef7eb2e8f9f7 1510 /**
<> 144:ef7eb2e8f9f7 1511 * @brief Enable the Bypass Shadow feature.
<> 144:ef7eb2e8f9f7 1512 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1513 * @note When the Bypass Shadow is enabled the calendar value are taken
<> 144:ef7eb2e8f9f7 1514 * directly from the Calendar counter.
<> 144:ef7eb2e8f9f7 1515 * @retval HAL status
<> 144:ef7eb2e8f9f7 1516 */
<> 144:ef7eb2e8f9f7 1517 HAL_StatusTypeDef HAL_RTCEx_EnableBypassShadow(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1518 {
<> 144:ef7eb2e8f9f7 1519 /* Process Locked */
<> 144:ef7eb2e8f9f7 1520 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1521
<> 144:ef7eb2e8f9f7 1522 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1523
<> 144:ef7eb2e8f9f7 1524 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1525 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1526
<> 144:ef7eb2e8f9f7 1527 /* Set the BYPSHAD bit */
<> 144:ef7eb2e8f9f7 1528 hrtc->Instance->CR |= (uint8_t)RTC_CR_BYPSHAD;
<> 144:ef7eb2e8f9f7 1529
<> 144:ef7eb2e8f9f7 1530 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1531 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1532
<> 144:ef7eb2e8f9f7 1533 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1534 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1535
<> 144:ef7eb2e8f9f7 1536 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1537 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1538
<> 144:ef7eb2e8f9f7 1539 return HAL_OK;
<> 144:ef7eb2e8f9f7 1540 }
<> 144:ef7eb2e8f9f7 1541
<> 144:ef7eb2e8f9f7 1542 /**
<> 144:ef7eb2e8f9f7 1543 * @brief Disable the Bypass Shadow feature.
<> 144:ef7eb2e8f9f7 1544 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 1545 * @note When the Bypass Shadow is enabled the calendar value are taken
<> 144:ef7eb2e8f9f7 1546 * directly from the Calendar counter.
<> 144:ef7eb2e8f9f7 1547 * @retval HAL status
<> 144:ef7eb2e8f9f7 1548 */
<> 144:ef7eb2e8f9f7 1549 HAL_StatusTypeDef HAL_RTCEx_DisableBypassShadow(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1550 {
<> 144:ef7eb2e8f9f7 1551 /* Process Locked */
<> 144:ef7eb2e8f9f7 1552 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1553
<> 144:ef7eb2e8f9f7 1554 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1555
<> 144:ef7eb2e8f9f7 1556 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1557 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1558
<> 144:ef7eb2e8f9f7 1559 /* Reset the BYPSHAD bit */
<> 144:ef7eb2e8f9f7 1560 hrtc->Instance->CR &= ((uint8_t)~RTC_CR_BYPSHAD);
<> 144:ef7eb2e8f9f7 1561
<> 144:ef7eb2e8f9f7 1562 /* Enable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1563 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1564
<> 144:ef7eb2e8f9f7 1565 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1566 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1567
<> 144:ef7eb2e8f9f7 1568 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1569 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1570
<> 144:ef7eb2e8f9f7 1571 return HAL_OK;
<> 144:ef7eb2e8f9f7 1572 }
<> 144:ef7eb2e8f9f7 1573
<> 144:ef7eb2e8f9f7 1574 /**
<> 144:ef7eb2e8f9f7 1575 * @}
<> 144:ef7eb2e8f9f7 1576 */
<> 144:ef7eb2e8f9f7 1577
<> 144:ef7eb2e8f9f7 1578 /**
<> 144:ef7eb2e8f9f7 1579 * @}
<> 144:ef7eb2e8f9f7 1580 */
<> 144:ef7eb2e8f9f7 1581
<> 144:ef7eb2e8f9f7 1582 #endif /* HAL_RTC_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 1583
<> 144:ef7eb2e8f9f7 1584 /**
<> 144:ef7eb2e8f9f7 1585 * @}
<> 144:ef7eb2e8f9f7 1586 */
<> 144:ef7eb2e8f9f7 1587
<> 144:ef7eb2e8f9f7 1588 /**
<> 144:ef7eb2e8f9f7 1589 * @}
<> 144:ef7eb2e8f9f7 1590 */
<> 144:ef7eb2e8f9f7 1591
<> 144:ef7eb2e8f9f7 1592 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/