GameOpener / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_rtc.c@603:f00c7e78e8b4, 2015-08-09 (annotated)

Committer:
HiAlgoBoost
Date:
Sun Aug 09 05:18:54 2015 +0000
Revision:
603:f00c7e78e8b4
Parent:
573:ad23fe03a082 
Evening of August 8th version

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 573:ad23fe03a082 1 /**
mbed_official 573:ad23fe03a082 2 ******************************************************************************
mbed_official 573:ad23fe03a082 3 * @file stm32f7xx_hal_rtc.c
mbed_official 573:ad23fe03a082 4 * @author MCD Application Team
mbed_official 573:ad23fe03a082 5 * @version V1.0.0
mbed_official 573:ad23fe03a082 6 * @date 12-May-2015
mbed_official 573:ad23fe03a082 7 * @brief RTC HAL module driver.
mbed_official 573:ad23fe03a082 8 * This file provides firmware functions to manage the following
mbed_official 573:ad23fe03a082 9 * functionalities of the Real Time Clock (RTC) peripheral:
mbed_official 573:ad23fe03a082 10 * + Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 11 * + RTC Time and Date functions
mbed_official 573:ad23fe03a082 12 * + RTC Alarm functions
mbed_official 573:ad23fe03a082 13 * + Peripheral Control functions
mbed_official 573:ad23fe03a082 14 * + Peripheral State functions
mbed_official 573:ad23fe03a082 15 *
mbed_official 573:ad23fe03a082 16 @verbatim
mbed_official 573:ad23fe03a082 17 ==============================================================================
mbed_official 573:ad23fe03a082 18 ##### Backup Domain Operating Condition #####
mbed_official 573:ad23fe03a082 19 ==============================================================================
mbed_official 573:ad23fe03a082 20 [..] The real-time clock (RTC), the RTC backup registers, and the backup
mbed_official 573:ad23fe03a082 21 SRAM (BKP SRAM) can be powered from the VBAT voltage when the main
mbed_official 573:ad23fe03a082 22 VDD supply is powered off.
mbed_official 573:ad23fe03a082 23 To retain the content of the RTC backup registers, backup SRAM, and supply
mbed_official 573:ad23fe03a082 24 the RTC when VDD is turned off, VBAT pin can be connected to an optional
mbed_official 573:ad23fe03a082 25 standby voltage supplied by a battery or by another source.
mbed_official 573:ad23fe03a082 26
mbed_official 573:ad23fe03a082 27 [..] To allow the RTC operating even when the main digital supply (VDD) is turned
mbed_official 573:ad23fe03a082 28 off, the VBAT pin powers the following blocks:
mbed_official 573:ad23fe03a082 29 (#) The RTC
mbed_official 573:ad23fe03a082 30 (#) The LSE oscillator
mbed_official 573:ad23fe03a082 31 (#) The backup SRAM when the low power backup regulator is enabled
mbed_official 573:ad23fe03a082 32 (#) PC13 to PC15 I/Os, plus PI8 I/O (when available)
mbed_official 573:ad23fe03a082 33
mbed_official 573:ad23fe03a082 34 [..] When the backup domain is supplied by VDD (analog switch connected to VDD),
mbed_official 573:ad23fe03a082 35 the following pins are available:
mbed_official 573:ad23fe03a082 36 (#) PC14 and PC15 can be used as either GPIO or LSE pins
mbed_official 573:ad23fe03a082 37 (#) PC13 can be used as a GPIO or as the RTC_AF1 pin
mbed_official 573:ad23fe03a082 38 (#) PI8 can be used as a GPIO or as the RTC_AF2 pin
mbed_official 573:ad23fe03a082 39
mbed_official 573:ad23fe03a082 40 [..] When the backup domain is supplied by VBAT (analog switch connected to VBAT
mbed_official 573:ad23fe03a082 41 because VDD is not present), the following pins are available:
mbed_official 573:ad23fe03a082 42 (#) PC14 and PC15 can be used as LSE pins only
mbed_official 573:ad23fe03a082 43 (#) PC13 can be used as the RTC_AF1 pin
mbed_official 573:ad23fe03a082 44 (#) PI8 can be used as the RTC_AF2 pin
mbed_official 573:ad23fe03a082 45 (#) PC1 can be used as the RTC_AF3 pin
mbed_official 573:ad23fe03a082 46
mbed_official 573:ad23fe03a082 47 ##### Backup Domain Reset #####
mbed_official 573:ad23fe03a082 48 ==================================================================
mbed_official 573:ad23fe03a082 49 [..] The backup domain reset sets all RTC registers and the RCC_BDCR register
mbed_official 573:ad23fe03a082 50 to their reset values. The BKPSRAM is not affected by this reset. The only
mbed_official 573:ad23fe03a082 51 way to reset the BKPSRAM is through the Flash interface by requesting
mbed_official 573:ad23fe03a082 52 a protection level change from 1 to 0.
mbed_official 573:ad23fe03a082 53 [..] A backup domain reset is generated when one of the following events occurs:
mbed_official 573:ad23fe03a082 54 (#) Software reset, triggered by setting the BDRST bit in the
mbed_official 573:ad23fe03a082 55 RCC Backup domain control register (RCC_BDCR).
mbed_official 573:ad23fe03a082 56 (#) VDD or VBAT power on, if both supplies have previously been powered off.
mbed_official 573:ad23fe03a082 57
mbed_official 573:ad23fe03a082 58 ##### Backup Domain Access #####
mbed_official 573:ad23fe03a082 59 ==================================================================
mbed_official 573:ad23fe03a082 60 [..] After reset, the backup domain (RTC registers, RTC backup data
mbed_official 573:ad23fe03a082 61 registers and backup SRAM) is protected against possible unwanted write
mbed_official 573:ad23fe03a082 62 accesses.
mbed_official 573:ad23fe03a082 63 [..] To enable access to the RTC Domain and RTC registers, proceed as follows:
mbed_official 573:ad23fe03a082 64 (+) Enable the Power Controller (PWR) APB1 interface clock using the
mbed_official 573:ad23fe03a082 65 __PWR_CLK_ENABLE() function.
mbed_official 573:ad23fe03a082 66 (+) Enable access to RTC domain using the HAL_PWR_EnableBkUpAccess() function.
mbed_official 573:ad23fe03a082 67 (+) Select the RTC clock source using the __HAL_RCC_RTC_CONFIG() function.
mbed_official 573:ad23fe03a082 68 (+) Enable RTC Clock using the __HAL_RCC_RTC_ENABLE() function.
mbed_official 573:ad23fe03a082 69
mbed_official 573:ad23fe03a082 70
mbed_official 573:ad23fe03a082 71 ##### How to use this driver #####
mbed_official 573:ad23fe03a082 72 ==================================================================
mbed_official 573:ad23fe03a082 73 [..]
mbed_official 573:ad23fe03a082 74 (+) Enable the RTC domain access (see description in the section above).
mbed_official 573:ad23fe03a082 75 (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and RTC hour
mbed_official 573:ad23fe03a082 76 format using the HAL_RTC_Init() function.
mbed_official 573:ad23fe03a082 77
mbed_official 573:ad23fe03a082 78 *** Time and Date configuration ***
mbed_official 573:ad23fe03a082 79 ===================================
mbed_official 573:ad23fe03a082 80 [..]
mbed_official 573:ad23fe03a082 81 (+) To configure the RTC Calendar (Time and Date) use the HAL_RTC_SetTime()
mbed_official 573:ad23fe03a082 82 and HAL_RTC_SetDate() functions.
mbed_official 573:ad23fe03a082 83 (+) To read the RTC Calendar, use the HAL_RTC_GetTime() and HAL_RTC_GetDate() functions.
mbed_official 573:ad23fe03a082 84
mbed_official 573:ad23fe03a082 85 *** Alarm configuration ***
mbed_official 573:ad23fe03a082 86 ===========================
mbed_official 573:ad23fe03a082 87 [..]
mbed_official 573:ad23fe03a082 88 (+) To configure the RTC Alarm use the HAL_RTC_SetAlarm() function.
mbed_official 573:ad23fe03a082 89 You can also configure the RTC Alarm with interrupt mode using the HAL_RTC_SetAlarm_IT() function.
mbed_official 573:ad23fe03a082 90 (+) To read the RTC Alarm, use the HAL_RTC_GetAlarm() function.
mbed_official 573:ad23fe03a082 91
mbed_official 573:ad23fe03a082 92 ##### RTC and low power modes #####
mbed_official 573:ad23fe03a082 93 ==================================================================
mbed_official 573:ad23fe03a082 94 [..] The MCU can be woken up from a low power mode by an RTC alternate
mbed_official 573:ad23fe03a082 95 function.
mbed_official 573:ad23fe03a082 96 [..] The RTC alternate functions are the RTC alarms (Alarm A and Alarm B),
mbed_official 573:ad23fe03a082 97 RTC wakeup, RTC tamper event detection and RTC time stamp event detection.
mbed_official 573:ad23fe03a082 98 These RTC alternate functions can wake up the system from the Stop and
mbed_official 573:ad23fe03a082 99 Standby low power modes.
mbed_official 573:ad23fe03a082 100 [..] The system can also wake up from low power modes without depending
mbed_official 573:ad23fe03a082 101 on an external interrupt (Auto-wakeup mode), by using the RTC alarm
mbed_official 573:ad23fe03a082 102 or the RTC wakeup events.
mbed_official 573:ad23fe03a082 103 [..] The RTC provides a programmable time base for waking up from the
mbed_official 573:ad23fe03a082 104 Stop or Standby mode at regular intervals.
mbed_official 573:ad23fe03a082 105 Wakeup from STOP and STANDBY modes is possible only when the RTC clock source
mbed_official 573:ad23fe03a082 106 is LSE or LSI.
mbed_official 573:ad23fe03a082 107
mbed_official 573:ad23fe03a082 108 @endverbatim
mbed_official 573:ad23fe03a082 109 ******************************************************************************
mbed_official 573:ad23fe03a082 110 * @attention
mbed_official 573:ad23fe03a082 111 *
mbed_official 573:ad23fe03a082 112 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 573:ad23fe03a082 113 *
mbed_official 573:ad23fe03a082 114 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 573:ad23fe03a082 115 * are permitted provided that the following conditions are met:
mbed_official 573:ad23fe03a082 116 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 573:ad23fe03a082 117 * this list of conditions and the following disclaimer.
mbed_official 573:ad23fe03a082 118 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 573:ad23fe03a082 119 * this list of conditions and the following disclaimer in the documentation
mbed_official 573:ad23fe03a082 120 * and/or other materials provided with the distribution.
mbed_official 573:ad23fe03a082 121 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 573:ad23fe03a082 122 * may be used to endorse or promote products derived from this software
mbed_official 573:ad23fe03a082 123 * without specific prior written permission.
mbed_official 573:ad23fe03a082 124 *
mbed_official 573:ad23fe03a082 125 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 573:ad23fe03a082 126 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 573:ad23fe03a082 127 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 573:ad23fe03a082 128 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 573:ad23fe03a082 129 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 573:ad23fe03a082 130 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 573:ad23fe03a082 131 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 573:ad23fe03a082 132 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 573:ad23fe03a082 133 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 573:ad23fe03a082 134 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 573:ad23fe03a082 135 *
mbed_official 573:ad23fe03a082 136 ******************************************************************************
mbed_official 573:ad23fe03a082 137 */
mbed_official 573:ad23fe03a082 138
mbed_official 573:ad23fe03a082 139 /* Includes ------------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 140 #include "stm32f7xx_hal.h"
mbed_official 573:ad23fe03a082 141
mbed_official 573:ad23fe03a082 142 /** @addtogroup STM32F7xx_HAL_Driver
mbed_official 573:ad23fe03a082 143 * @{
mbed_official 573:ad23fe03a082 144 */
mbed_official 573:ad23fe03a082 145
mbed_official 573:ad23fe03a082 146 /** @defgroup RTC RTC
mbed_official 573:ad23fe03a082 147 * @brief RTC HAL module driver
mbed_official 573:ad23fe03a082 148 * @{
mbed_official 573:ad23fe03a082 149 */
mbed_official 573:ad23fe03a082 150
mbed_official 573:ad23fe03a082 151 #ifdef HAL_RTC_MODULE_ENABLED
mbed_official 573:ad23fe03a082 152
mbed_official 573:ad23fe03a082 153 /* Private typedef -----------------------------------------------------------*/
mbed_official 573:ad23fe03a082 154 /* Private define ------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 155 /* Private macro -------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 156 /* Private variables ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 157 /* Private function prototypes -----------------------------------------------*/
mbed_official 573:ad23fe03a082 158 /* Private functions ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 159
mbed_official 573:ad23fe03a082 160 /** @defgroup RTC_Exported_Functions RTC Exported Functions
mbed_official 573:ad23fe03a082 161 * @{
mbed_official 573:ad23fe03a082 162 */
mbed_official 573:ad23fe03a082 163
mbed_official 573:ad23fe03a082 164 /** @defgroup RTC_Group1 Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 165 * @brief Initialization and Configuration functions
mbed_official 573:ad23fe03a082 166 *
mbed_official 573:ad23fe03a082 167 @verbatim
mbed_official 573:ad23fe03a082 168 ===============================================================================
mbed_official 573:ad23fe03a082 169 ##### Initialization and de-initialization functions #####
mbed_official 573:ad23fe03a082 170 ===============================================================================
mbed_official 573:ad23fe03a082 171 [..] This section provides functions allowing to initialize and configure the
mbed_official 573:ad23fe03a082 172 RTC Prescaler (Synchronous and Asynchronous), RTC Hour format, disable
mbed_official 573:ad23fe03a082 173 RTC registers Write protection, enter and exit the RTC initialization mode,
mbed_official 573:ad23fe03a082 174 RTC registers synchronization check and reference clock detection enable.
mbed_official 573:ad23fe03a082 175 (#) The RTC Prescaler is programmed to generate the RTC 1Hz time base.
mbed_official 573:ad23fe03a082 176 It is split into 2 programmable prescalers to minimize power consumption.
mbed_official 573:ad23fe03a082 177 (++) A 7-bit asynchronous prescaler and a 13-bit synchronous prescaler.
mbed_official 573:ad23fe03a082 178 (++) When both prescalers are used, it is recommended to configure the
mbed_official 573:ad23fe03a082 179 asynchronous prescaler to a high value to minimize power consumption.
mbed_official 573:ad23fe03a082 180 (#) All RTC registers are Write protected. Writing to the RTC registers
mbed_official 573:ad23fe03a082 181 is enabled by writing a key into the Write Protection register, RTC_WPR.
mbed_official 573:ad23fe03a082 182 (#) To configure the RTC Calendar, user application should enter
mbed_official 573:ad23fe03a082 183 initialization mode. In this mode, the calendar counter is stopped
mbed_official 573:ad23fe03a082 184 and its value can be updated. When the initialization sequence is
mbed_official 573:ad23fe03a082 185 complete, the calendar restarts counting after 4 RTCCLK cycles.
mbed_official 573:ad23fe03a082 186 (#) To read the calendar through the shadow registers after Calendar
mbed_official 573:ad23fe03a082 187 initialization, calendar update or after wakeup from low power modes
mbed_official 573:ad23fe03a082 188 the software must first clear the RSF flag. The software must then
mbed_official 573:ad23fe03a082 189 wait until it is set again before reading the calendar, which means
mbed_official 573:ad23fe03a082 190 that the calendar registers have been correctly copied into the
mbed_official 573:ad23fe03a082 191 RTC_TR and RTC_DR shadow registers.The HAL_RTC_WaitForSynchro() function
mbed_official 573:ad23fe03a082 192 implements the above software sequence (RSF clear and RSF check).
mbed_official 573:ad23fe03a082 193
mbed_official 573:ad23fe03a082 194 @endverbatim
mbed_official 573:ad23fe03a082 195 * @{
mbed_official 573:ad23fe03a082 196 */
mbed_official 573:ad23fe03a082 197
mbed_official 573:ad23fe03a082 198 /**
mbed_official 573:ad23fe03a082 199 * @brief Initializes the RTC peripheral
mbed_official 573:ad23fe03a082 200 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 201 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 202 * @retval HAL status
mbed_official 573:ad23fe03a082 203 */
mbed_official 573:ad23fe03a082 204 HAL_StatusTypeDef HAL_RTC_Init(RTC_HandleTypeDef *hrtc)
mbed_official 573:ad23fe03a082 205 {
mbed_official 573:ad23fe03a082 206 /* Check the RTC peripheral state */
mbed_official 573:ad23fe03a082 207 if(hrtc == NULL)
mbed_official 573:ad23fe03a082 208 {
mbed_official 573:ad23fe03a082 209 return HAL_ERROR;
mbed_official 573:ad23fe03a082 210 }
mbed_official 573:ad23fe03a082 211
mbed_official 573:ad23fe03a082 212 /* Check the parameters */
mbed_official 573:ad23fe03a082 213 assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
mbed_official 573:ad23fe03a082 214 assert_param(IS_RTC_HOUR_FORMAT(hrtc->Init.HourFormat));
mbed_official 573:ad23fe03a082 215 assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv));
mbed_official 573:ad23fe03a082 216 assert_param(IS_RTC_SYNCH_PREDIV(hrtc->Init.SynchPrediv));
mbed_official 573:ad23fe03a082 217 assert_param (IS_RTC_OUTPUT(hrtc->Init.OutPut));
mbed_official 573:ad23fe03a082 218 assert_param (IS_RTC_OUTPUT_POL(hrtc->Init.OutPutPolarity));
mbed_official 573:ad23fe03a082 219 assert_param(IS_RTC_OUTPUT_TYPE(hrtc->Init.OutPutType));
mbed_official 573:ad23fe03a082 220
mbed_official 573:ad23fe03a082 221 if(hrtc->State == HAL_RTC_STATE_RESET)
mbed_official 573:ad23fe03a082 222 {
mbed_official 573:ad23fe03a082 223 /* Allocate lock resource and initialize it */
mbed_official 573:ad23fe03a082 224 hrtc->Lock = HAL_UNLOCKED;
mbed_official 573:ad23fe03a082 225 /* Initialize RTC MSP */
mbed_official 573:ad23fe03a082 226 HAL_RTC_MspInit(hrtc);
mbed_official 573:ad23fe03a082 227 }
mbed_official 573:ad23fe03a082 228
mbed_official 573:ad23fe03a082 229 /* Set RTC state */
mbed_official 573:ad23fe03a082 230 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 231
mbed_official 573:ad23fe03a082 232 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 233 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 234
mbed_official 573:ad23fe03a082 235 /* Set Initialization mode */
mbed_official 573:ad23fe03a082 236 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 237 {
mbed_official 573:ad23fe03a082 238 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 239 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 240
mbed_official 573:ad23fe03a082 241 /* Set RTC state */
mbed_official 573:ad23fe03a082 242 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 243
mbed_official 573:ad23fe03a082 244 return HAL_ERROR;
mbed_official 573:ad23fe03a082 245 }
mbed_official 573:ad23fe03a082 246 else
mbed_official 573:ad23fe03a082 247 {
mbed_official 573:ad23fe03a082 248 /* Clear RTC_CR FMT, OSEL and POL Bits */
mbed_official 573:ad23fe03a082 249 hrtc->Instance->CR &= ((uint32_t)~(RTC_CR_FMT | RTC_CR_OSEL | RTC_CR_POL));
mbed_official 573:ad23fe03a082 250 /* Set RTC_CR register */
mbed_official 573:ad23fe03a082 251 hrtc->Instance->CR |= (uint32_t)(hrtc->Init.HourFormat | hrtc->Init.OutPut | hrtc->Init.OutPutPolarity);
mbed_official 573:ad23fe03a082 252
mbed_official 573:ad23fe03a082 253 /* Configure the RTC PRER */
mbed_official 573:ad23fe03a082 254 hrtc->Instance->PRER = (uint32_t)(hrtc->Init.SynchPrediv);
mbed_official 573:ad23fe03a082 255 hrtc->Instance->PRER |= (uint32_t)(hrtc->Init.AsynchPrediv << 16);
mbed_official 573:ad23fe03a082 256
mbed_official 573:ad23fe03a082 257 /* Exit Initialization mode */
mbed_official 573:ad23fe03a082 258 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 573:ad23fe03a082 259
mbed_official 573:ad23fe03a082 260 hrtc->Instance->OR &= (uint32_t)~RTC_OR_ALARMTYPE;
mbed_official 573:ad23fe03a082 261 hrtc->Instance->OR |= (uint32_t)(hrtc->Init.OutPutType);
mbed_official 573:ad23fe03a082 262
mbed_official 573:ad23fe03a082 263 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 264 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 265
mbed_official 573:ad23fe03a082 266 /* Set RTC state */
mbed_official 573:ad23fe03a082 267 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 268
mbed_official 573:ad23fe03a082 269 return HAL_OK;
mbed_official 573:ad23fe03a082 270 }
mbed_official 573:ad23fe03a082 271 }
mbed_official 573:ad23fe03a082 272
mbed_official 573:ad23fe03a082 273 /**
mbed_official 573:ad23fe03a082 274 * @brief DeInitializes the RTC peripheral
mbed_official 573:ad23fe03a082 275 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 276 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 277 * @note This function doesn't reset the RTC Backup Data registers.
mbed_official 573:ad23fe03a082 278 * @retval HAL status
mbed_official 573:ad23fe03a082 279 */
mbed_official 573:ad23fe03a082 280 HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)
mbed_official 573:ad23fe03a082 281 {
mbed_official 573:ad23fe03a082 282 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 283
mbed_official 573:ad23fe03a082 284 /* Check the parameters */
mbed_official 573:ad23fe03a082 285 assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
mbed_official 573:ad23fe03a082 286
mbed_official 573:ad23fe03a082 287 /* Set RTC state */
mbed_official 573:ad23fe03a082 288 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 289
mbed_official 573:ad23fe03a082 290 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 291 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 292
mbed_official 573:ad23fe03a082 293 /* Set Initialization mode */
mbed_official 573:ad23fe03a082 294 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 295 {
mbed_official 573:ad23fe03a082 296 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 297 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 298
mbed_official 573:ad23fe03a082 299 /* Set RTC state */
mbed_official 573:ad23fe03a082 300 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 301
mbed_official 573:ad23fe03a082 302 return HAL_ERROR;
mbed_official 573:ad23fe03a082 303 }
mbed_official 573:ad23fe03a082 304 else
mbed_official 573:ad23fe03a082 305 {
mbed_official 573:ad23fe03a082 306 /* Reset TR, DR and CR registers */
mbed_official 573:ad23fe03a082 307 hrtc->Instance->TR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 308 hrtc->Instance->DR = (uint32_t)0x00002101;
mbed_official 573:ad23fe03a082 309 /* Reset All CR bits except CR[2:0] */
mbed_official 573:ad23fe03a082 310 hrtc->Instance->CR &= (uint32_t)0x00000007;
mbed_official 573:ad23fe03a082 311
mbed_official 573:ad23fe03a082 312 /* Get tick */
mbed_official 573:ad23fe03a082 313 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 314
mbed_official 573:ad23fe03a082 315 /* Wait till WUTWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 316 while(((hrtc->Instance->ISR) & RTC_ISR_WUTWF) == (uint32_t)RESET)
mbed_official 573:ad23fe03a082 317 {
mbed_official 573:ad23fe03a082 318 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 319 {
mbed_official 573:ad23fe03a082 320 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 321 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 322
mbed_official 573:ad23fe03a082 323 /* Set RTC state */
mbed_official 573:ad23fe03a082 324 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 325
mbed_official 573:ad23fe03a082 326 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 327 }
mbed_official 573:ad23fe03a082 328 }
mbed_official 573:ad23fe03a082 329
mbed_official 573:ad23fe03a082 330 /* Reset all RTC CR register bits */
mbed_official 573:ad23fe03a082 331 hrtc->Instance->CR &= (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 332 hrtc->Instance->WUTR = (uint32_t)0x0000FFFF;
mbed_official 573:ad23fe03a082 333 hrtc->Instance->PRER = (uint32_t)0x007F00FF;
mbed_official 573:ad23fe03a082 334 hrtc->Instance->ALRMAR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 335 hrtc->Instance->ALRMBR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 336 hrtc->Instance->SHIFTR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 337 hrtc->Instance->CALR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 338 hrtc->Instance->ALRMASSR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 339 hrtc->Instance->ALRMBSSR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 340
mbed_official 573:ad23fe03a082 341 /* Reset ISR register and exit initialization mode */
mbed_official 573:ad23fe03a082 342 hrtc->Instance->ISR = (uint32_t)0x00000000;
mbed_official 573:ad23fe03a082 343
mbed_official 573:ad23fe03a082 344 /* Reset Tamper and alternate functions configuration register */
mbed_official 573:ad23fe03a082 345 hrtc->Instance->TAMPCR = 0x00000000;
mbed_official 573:ad23fe03a082 346
mbed_official 573:ad23fe03a082 347 /* Reset Option register */
mbed_official 573:ad23fe03a082 348 hrtc->Instance->OR = 0x00000000;
mbed_official 573:ad23fe03a082 349
mbed_official 573:ad23fe03a082 350 /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
mbed_official 573:ad23fe03a082 351 if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
mbed_official 573:ad23fe03a082 352 {
mbed_official 573:ad23fe03a082 353 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 354 {
mbed_official 573:ad23fe03a082 355 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 356 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 357
mbed_official 573:ad23fe03a082 358 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 359
mbed_official 573:ad23fe03a082 360 return HAL_ERROR;
mbed_official 573:ad23fe03a082 361 }
mbed_official 573:ad23fe03a082 362 }
mbed_official 573:ad23fe03a082 363 }
mbed_official 573:ad23fe03a082 364
mbed_official 573:ad23fe03a082 365 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 366 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 367
mbed_official 573:ad23fe03a082 368 /* De-Initialize RTC MSP */
mbed_official 573:ad23fe03a082 369 HAL_RTC_MspDeInit(hrtc);
mbed_official 573:ad23fe03a082 370
mbed_official 573:ad23fe03a082 371 hrtc->State = HAL_RTC_STATE_RESET;
mbed_official 573:ad23fe03a082 372
mbed_official 573:ad23fe03a082 373 /* Release Lock */
mbed_official 573:ad23fe03a082 374 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 375
mbed_official 573:ad23fe03a082 376 return HAL_OK;
mbed_official 573:ad23fe03a082 377 }
mbed_official 573:ad23fe03a082 378
mbed_official 573:ad23fe03a082 379 /**
mbed_official 573:ad23fe03a082 380 * @brief Initializes the RTC MSP.
mbed_official 573:ad23fe03a082 381 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 382 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 383 * @retval None
mbed_official 573:ad23fe03a082 384 */
mbed_official 573:ad23fe03a082 385 __weak void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 386 {
mbed_official 573:ad23fe03a082 387 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 388 the HAL_RTC_MspInit could be implemented in the user file
mbed_official 573:ad23fe03a082 389 */
mbed_official 573:ad23fe03a082 390 }
mbed_official 573:ad23fe03a082 391
mbed_official 573:ad23fe03a082 392 /**
mbed_official 573:ad23fe03a082 393 * @brief DeInitializes the RTC MSP.
mbed_official 573:ad23fe03a082 394 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 395 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 396 * @retval None
mbed_official 573:ad23fe03a082 397 */
mbed_official 573:ad23fe03a082 398 __weak void HAL_RTC_MspDeInit(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 399 {
mbed_official 573:ad23fe03a082 400 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 401 the HAL_RTC_MspDeInit could be implemented in the user file
mbed_official 573:ad23fe03a082 402 */
mbed_official 573:ad23fe03a082 403 }
mbed_official 573:ad23fe03a082 404
mbed_official 573:ad23fe03a082 405 /**
mbed_official 573:ad23fe03a082 406 * @}
mbed_official 573:ad23fe03a082 407 */
mbed_official 573:ad23fe03a082 408
mbed_official 573:ad23fe03a082 409 /** @defgroup RTC_Group2 RTC Time and Date functions
mbed_official 573:ad23fe03a082 410 * @brief RTC Time and Date functions
mbed_official 573:ad23fe03a082 411 *
mbed_official 573:ad23fe03a082 412 @verbatim
mbed_official 573:ad23fe03a082 413 ===============================================================================
mbed_official 573:ad23fe03a082 414 ##### RTC Time and Date functions #####
mbed_official 573:ad23fe03a082 415 ===============================================================================
mbed_official 573:ad23fe03a082 416
mbed_official 573:ad23fe03a082 417 [..] This section provides functions allowing to configure Time and Date features
mbed_official 573:ad23fe03a082 418
mbed_official 573:ad23fe03a082 419 @endverbatim
mbed_official 573:ad23fe03a082 420 * @{
mbed_official 573:ad23fe03a082 421 */
mbed_official 573:ad23fe03a082 422
mbed_official 573:ad23fe03a082 423 /**
mbed_official 573:ad23fe03a082 424 * @brief Sets RTC current time.
mbed_official 573:ad23fe03a082 425 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 426 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 427 * @param sTime: Pointer to Time structure
mbed_official 573:ad23fe03a082 428 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 429 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 430 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 431 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 432 * @retval HAL status
mbed_official 573:ad23fe03a082 433 */
mbed_official 573:ad23fe03a082 434 HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
mbed_official 573:ad23fe03a082 435 {
mbed_official 573:ad23fe03a082 436 uint32_t tmpreg = 0;
mbed_official 573:ad23fe03a082 437
mbed_official 573:ad23fe03a082 438 /* Check the parameters */
mbed_official 573:ad23fe03a082 439 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 440 assert_param(IS_RTC_DAYLIGHT_SAVING(sTime->DayLightSaving));
mbed_official 573:ad23fe03a082 441 assert_param(IS_RTC_STORE_OPERATION(sTime->StoreOperation));
mbed_official 573:ad23fe03a082 442
mbed_official 573:ad23fe03a082 443 /* Process Locked */
mbed_official 573:ad23fe03a082 444 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 445
mbed_official 573:ad23fe03a082 446 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 447
mbed_official 573:ad23fe03a082 448 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 449 {
mbed_official 573:ad23fe03a082 450 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 451 {
mbed_official 573:ad23fe03a082 452 assert_param(IS_RTC_HOUR12(sTime->Hours));
mbed_official 573:ad23fe03a082 453 assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat));
mbed_official 573:ad23fe03a082 454 }
mbed_official 573:ad23fe03a082 455 else
mbed_official 573:ad23fe03a082 456 {
mbed_official 573:ad23fe03a082 457 sTime->TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 458 assert_param(IS_RTC_HOUR24(sTime->Hours));
mbed_official 573:ad23fe03a082 459 }
mbed_official 573:ad23fe03a082 460 assert_param(IS_RTC_MINUTES(sTime->Minutes));
mbed_official 573:ad23fe03a082 461 assert_param(IS_RTC_SECONDS(sTime->Seconds));
mbed_official 573:ad23fe03a082 462
mbed_official 573:ad23fe03a082 463 tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(sTime->Hours) << 16) | \
mbed_official 573:ad23fe03a082 464 ((uint32_t)RTC_ByteToBcd2(sTime->Minutes) << 8) | \
mbed_official 573:ad23fe03a082 465 ((uint32_t)RTC_ByteToBcd2(sTime->Seconds)) | \
mbed_official 573:ad23fe03a082 466 (((uint32_t)sTime->TimeFormat) << 16));
mbed_official 573:ad23fe03a082 467 }
mbed_official 573:ad23fe03a082 468 else
mbed_official 573:ad23fe03a082 469 {
mbed_official 573:ad23fe03a082 470 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 471 {
mbed_official 573:ad23fe03a082 472 tmpreg = RTC_Bcd2ToByte(sTime->Hours);
mbed_official 573:ad23fe03a082 473 assert_param(IS_RTC_HOUR12(tmpreg));
mbed_official 573:ad23fe03a082 474 assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat));
mbed_official 573:ad23fe03a082 475 }
mbed_official 573:ad23fe03a082 476 else
mbed_official 573:ad23fe03a082 477 {
mbed_official 573:ad23fe03a082 478 sTime->TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 479 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours)));
mbed_official 573:ad23fe03a082 480 }
mbed_official 573:ad23fe03a082 481 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes)));
mbed_official 573:ad23fe03a082 482 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds)));
mbed_official 573:ad23fe03a082 483 tmpreg = (((uint32_t)(sTime->Hours) << 16) | \
mbed_official 573:ad23fe03a082 484 ((uint32_t)(sTime->Minutes) << 8) | \
mbed_official 573:ad23fe03a082 485 ((uint32_t)sTime->Seconds) | \
mbed_official 573:ad23fe03a082 486 ((uint32_t)(sTime->TimeFormat) << 16));
mbed_official 573:ad23fe03a082 487 }
mbed_official 573:ad23fe03a082 488
mbed_official 573:ad23fe03a082 489 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 490 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 491
mbed_official 573:ad23fe03a082 492 /* Set Initialization mode */
mbed_official 573:ad23fe03a082 493 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 494 {
mbed_official 573:ad23fe03a082 495 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 496 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 497
mbed_official 573:ad23fe03a082 498 /* Set RTC state */
mbed_official 573:ad23fe03a082 499 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 500
mbed_official 573:ad23fe03a082 501 /* Process Unlocked */
mbed_official 573:ad23fe03a082 502 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 503
mbed_official 573:ad23fe03a082 504 return HAL_ERROR;
mbed_official 573:ad23fe03a082 505 }
mbed_official 573:ad23fe03a082 506 else
mbed_official 573:ad23fe03a082 507 {
mbed_official 573:ad23fe03a082 508 /* Set the RTC_TR register */
mbed_official 573:ad23fe03a082 509 hrtc->Instance->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK);
mbed_official 573:ad23fe03a082 510
mbed_official 573:ad23fe03a082 511 /* Clear the bits to be configured */
mbed_official 573:ad23fe03a082 512 hrtc->Instance->CR &= (uint32_t)~RTC_CR_BCK;
mbed_official 573:ad23fe03a082 513
mbed_official 573:ad23fe03a082 514 /* Configure the RTC_CR register */
mbed_official 573:ad23fe03a082 515 hrtc->Instance->CR |= (uint32_t)(sTime->DayLightSaving | sTime->StoreOperation);
mbed_official 573:ad23fe03a082 516
mbed_official 573:ad23fe03a082 517 /* Exit Initialization mode */
mbed_official 573:ad23fe03a082 518 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 573:ad23fe03a082 519
mbed_official 573:ad23fe03a082 520 /* If CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
mbed_official 573:ad23fe03a082 521 if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
mbed_official 573:ad23fe03a082 522 {
mbed_official 573:ad23fe03a082 523 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 524 {
mbed_official 573:ad23fe03a082 525 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 526 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 527
mbed_official 573:ad23fe03a082 528 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 529
mbed_official 573:ad23fe03a082 530 /* Process Unlocked */
mbed_official 573:ad23fe03a082 531 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 532
mbed_official 573:ad23fe03a082 533 return HAL_ERROR;
mbed_official 573:ad23fe03a082 534 }
mbed_official 573:ad23fe03a082 535 }
mbed_official 573:ad23fe03a082 536
mbed_official 573:ad23fe03a082 537 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 538 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 539
mbed_official 573:ad23fe03a082 540 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 541
mbed_official 573:ad23fe03a082 542 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 543
mbed_official 573:ad23fe03a082 544 return HAL_OK;
mbed_official 573:ad23fe03a082 545 }
mbed_official 573:ad23fe03a082 546 }
mbed_official 573:ad23fe03a082 547
mbed_official 573:ad23fe03a082 548 /**
mbed_official 573:ad23fe03a082 549 * @brief Gets RTC current time.
mbed_official 573:ad23fe03a082 550 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 551 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 552 * @param sTime: Pointer to Time structure
mbed_official 573:ad23fe03a082 553 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 554 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 555 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 556 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 557 * @note You must call HAL_RTC_GetDate() after HAL_RTC_GetTime() to unlock the values
mbed_official 573:ad23fe03a082 558 * in the higher-order calendar shadow registers to ensure consistency between the time and date values.
mbed_official 573:ad23fe03a082 559 * Reading RTC current time locks the values in calendar shadow registers until Current date is read.
mbed_official 573:ad23fe03a082 560 * @retval HAL status
mbed_official 573:ad23fe03a082 561 */
mbed_official 573:ad23fe03a082 562 HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
mbed_official 573:ad23fe03a082 563 {
mbed_official 573:ad23fe03a082 564 uint32_t tmpreg = 0;
mbed_official 573:ad23fe03a082 565
mbed_official 573:ad23fe03a082 566 /* Check the parameters */
mbed_official 573:ad23fe03a082 567 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 568
mbed_official 573:ad23fe03a082 569 /* Get subseconds values from the correspondent registers*/
mbed_official 573:ad23fe03a082 570 sTime->SubSeconds = (uint32_t)(hrtc->Instance->SSR);
mbed_official 573:ad23fe03a082 571
mbed_official 573:ad23fe03a082 572 /* Get the TR register */
mbed_official 573:ad23fe03a082 573 tmpreg = (uint32_t)(hrtc->Instance->TR & RTC_TR_RESERVED_MASK);
mbed_official 573:ad23fe03a082 574
mbed_official 573:ad23fe03a082 575 /* Fill the structure fields with the read parameters */
mbed_official 573:ad23fe03a082 576 sTime->Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16);
mbed_official 573:ad23fe03a082 577 sTime->Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8);
mbed_official 573:ad23fe03a082 578 sTime->Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU));
mbed_official 573:ad23fe03a082 579 sTime->TimeFormat = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16);
mbed_official 573:ad23fe03a082 580
mbed_official 573:ad23fe03a082 581 /* Check the input parameters format */
mbed_official 573:ad23fe03a082 582 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 583 {
mbed_official 573:ad23fe03a082 584 /* Convert the time structure parameters to Binary format */
mbed_official 573:ad23fe03a082 585 sTime->Hours = (uint8_t)RTC_Bcd2ToByte(sTime->Hours);
mbed_official 573:ad23fe03a082 586 sTime->Minutes = (uint8_t)RTC_Bcd2ToByte(sTime->Minutes);
mbed_official 573:ad23fe03a082 587 sTime->Seconds = (uint8_t)RTC_Bcd2ToByte(sTime->Seconds);
mbed_official 573:ad23fe03a082 588 }
mbed_official 573:ad23fe03a082 589
mbed_official 573:ad23fe03a082 590 return HAL_OK;
mbed_official 573:ad23fe03a082 591 }
mbed_official 573:ad23fe03a082 592
mbed_official 573:ad23fe03a082 593 /**
mbed_official 573:ad23fe03a082 594 * @brief Sets RTC current date.
mbed_official 573:ad23fe03a082 595 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 596 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 597 * @param sDate: Pointer to date structure
mbed_official 573:ad23fe03a082 598 * @param Format: specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 599 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 600 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 601 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 602 * @retval HAL status
mbed_official 573:ad23fe03a082 603 */
mbed_official 573:ad23fe03a082 604 HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
mbed_official 573:ad23fe03a082 605 {
mbed_official 573:ad23fe03a082 606 uint32_t datetmpreg = 0;
mbed_official 573:ad23fe03a082 607
mbed_official 573:ad23fe03a082 608 /* Check the parameters */
mbed_official 573:ad23fe03a082 609 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 610
mbed_official 573:ad23fe03a082 611 /* Process Locked */
mbed_official 573:ad23fe03a082 612 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 613
mbed_official 573:ad23fe03a082 614 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 615
mbed_official 573:ad23fe03a082 616 if((Format == RTC_FORMAT_BIN) && ((sDate->Month & 0x10) == 0x10))
mbed_official 573:ad23fe03a082 617 {
mbed_official 573:ad23fe03a082 618 sDate->Month = (uint8_t)((sDate->Month & (uint8_t)~(0x10)) + (uint8_t)0x0A);
mbed_official 573:ad23fe03a082 619 }
mbed_official 573:ad23fe03a082 620
mbed_official 573:ad23fe03a082 621 assert_param(IS_RTC_WEEKDAY(sDate->WeekDay));
mbed_official 573:ad23fe03a082 622
mbed_official 573:ad23fe03a082 623 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 624 {
mbed_official 573:ad23fe03a082 625 assert_param(IS_RTC_YEAR(sDate->Year));
mbed_official 573:ad23fe03a082 626 assert_param(IS_RTC_MONTH(sDate->Month));
mbed_official 573:ad23fe03a082 627 assert_param(IS_RTC_DATE(sDate->Date));
mbed_official 573:ad23fe03a082 628
mbed_official 573:ad23fe03a082 629 datetmpreg = (((uint32_t)RTC_ByteToBcd2(sDate->Year) << 16) | \
mbed_official 573:ad23fe03a082 630 ((uint32_t)RTC_ByteToBcd2(sDate->Month) << 8) | \
mbed_official 573:ad23fe03a082 631 ((uint32_t)RTC_ByteToBcd2(sDate->Date)) | \
mbed_official 573:ad23fe03a082 632 ((uint32_t)sDate->WeekDay << 13));
mbed_official 573:ad23fe03a082 633 }
mbed_official 573:ad23fe03a082 634 else
mbed_official 573:ad23fe03a082 635 {
mbed_official 573:ad23fe03a082 636 assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year)));
mbed_official 573:ad23fe03a082 637 datetmpreg = RTC_Bcd2ToByte(sDate->Month);
mbed_official 573:ad23fe03a082 638 assert_param(IS_RTC_MONTH(datetmpreg));
mbed_official 573:ad23fe03a082 639 datetmpreg = RTC_Bcd2ToByte(sDate->Date);
mbed_official 573:ad23fe03a082 640 assert_param(IS_RTC_DATE(datetmpreg));
mbed_official 573:ad23fe03a082 641
mbed_official 573:ad23fe03a082 642 datetmpreg = ((((uint32_t)sDate->Year) << 16) | \
mbed_official 573:ad23fe03a082 643 (((uint32_t)sDate->Month) << 8) | \
mbed_official 573:ad23fe03a082 644 ((uint32_t)sDate->Date) | \
mbed_official 573:ad23fe03a082 645 (((uint32_t)sDate->WeekDay) << 13));
mbed_official 573:ad23fe03a082 646 }
mbed_official 573:ad23fe03a082 647
mbed_official 573:ad23fe03a082 648 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 649 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 650
mbed_official 573:ad23fe03a082 651 /* Set Initialization mode */
mbed_official 573:ad23fe03a082 652 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 653 {
mbed_official 573:ad23fe03a082 654 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 655 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 656
mbed_official 573:ad23fe03a082 657 /* Set RTC state*/
mbed_official 573:ad23fe03a082 658 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 659
mbed_official 573:ad23fe03a082 660 /* Process Unlocked */
mbed_official 573:ad23fe03a082 661 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 662
mbed_official 573:ad23fe03a082 663 return HAL_ERROR;
mbed_official 573:ad23fe03a082 664 }
mbed_official 573:ad23fe03a082 665 else
mbed_official 573:ad23fe03a082 666 {
mbed_official 573:ad23fe03a082 667 /* Set the RTC_DR register */
mbed_official 573:ad23fe03a082 668 hrtc->Instance->DR = (uint32_t)(datetmpreg & RTC_DR_RESERVED_MASK);
mbed_official 573:ad23fe03a082 669
mbed_official 573:ad23fe03a082 670 /* Exit Initialization mode */
mbed_official 573:ad23fe03a082 671 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 573:ad23fe03a082 672
mbed_official 573:ad23fe03a082 673 /* If CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
mbed_official 573:ad23fe03a082 674 if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
mbed_official 573:ad23fe03a082 675 {
mbed_official 573:ad23fe03a082 676 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 677 {
mbed_official 573:ad23fe03a082 678 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 679 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 680
mbed_official 573:ad23fe03a082 681 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 682
mbed_official 573:ad23fe03a082 683 /* Process Unlocked */
mbed_official 573:ad23fe03a082 684 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 685
mbed_official 573:ad23fe03a082 686 return HAL_ERROR;
mbed_official 573:ad23fe03a082 687 }
mbed_official 573:ad23fe03a082 688 }
mbed_official 573:ad23fe03a082 689
mbed_official 573:ad23fe03a082 690 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 691 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 692
mbed_official 573:ad23fe03a082 693 hrtc->State = HAL_RTC_STATE_READY ;
mbed_official 573:ad23fe03a082 694
mbed_official 573:ad23fe03a082 695 /* Process Unlocked */
mbed_official 573:ad23fe03a082 696 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 697
mbed_official 573:ad23fe03a082 698 return HAL_OK;
mbed_official 573:ad23fe03a082 699 }
mbed_official 573:ad23fe03a082 700 }
mbed_official 573:ad23fe03a082 701
mbed_official 573:ad23fe03a082 702 /**
mbed_official 573:ad23fe03a082 703 * @brief Gets RTC current date.
mbed_official 573:ad23fe03a082 704 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 705 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 706 * @param sDate: Pointer to Date structure
mbed_official 573:ad23fe03a082 707 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 708 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 709 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 710 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 711 * @retval HAL status
mbed_official 573:ad23fe03a082 712 */
mbed_official 573:ad23fe03a082 713 HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
mbed_official 573:ad23fe03a082 714 {
mbed_official 573:ad23fe03a082 715 uint32_t datetmpreg = 0;
mbed_official 573:ad23fe03a082 716
mbed_official 573:ad23fe03a082 717 /* Check the parameters */
mbed_official 573:ad23fe03a082 718 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 719
mbed_official 573:ad23fe03a082 720 /* Get the DR register */
mbed_official 573:ad23fe03a082 721 datetmpreg = (uint32_t)(hrtc->Instance->DR & RTC_DR_RESERVED_MASK);
mbed_official 573:ad23fe03a082 722
mbed_official 573:ad23fe03a082 723 /* Fill the structure fields with the read parameters */
mbed_official 573:ad23fe03a082 724 sDate->Year = (uint8_t)((datetmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16);
mbed_official 573:ad23fe03a082 725 sDate->Month = (uint8_t)((datetmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8);
mbed_official 573:ad23fe03a082 726 sDate->Date = (uint8_t)(datetmpreg & (RTC_DR_DT | RTC_DR_DU));
mbed_official 573:ad23fe03a082 727 sDate->WeekDay = (uint8_t)((datetmpreg & (RTC_DR_WDU)) >> 13);
mbed_official 573:ad23fe03a082 728
mbed_official 573:ad23fe03a082 729 /* Check the input parameters format */
mbed_official 573:ad23fe03a082 730 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 731 {
mbed_official 573:ad23fe03a082 732 /* Convert the date structure parameters to Binary format */
mbed_official 573:ad23fe03a082 733 sDate->Year = (uint8_t)RTC_Bcd2ToByte(sDate->Year);
mbed_official 573:ad23fe03a082 734 sDate->Month = (uint8_t)RTC_Bcd2ToByte(sDate->Month);
mbed_official 573:ad23fe03a082 735 sDate->Date = (uint8_t)RTC_Bcd2ToByte(sDate->Date);
mbed_official 573:ad23fe03a082 736 }
mbed_official 573:ad23fe03a082 737 return HAL_OK;
mbed_official 573:ad23fe03a082 738 }
mbed_official 573:ad23fe03a082 739
mbed_official 573:ad23fe03a082 740 /**
mbed_official 573:ad23fe03a082 741 * @}
mbed_official 573:ad23fe03a082 742 */
mbed_official 573:ad23fe03a082 743
mbed_official 573:ad23fe03a082 744 /** @defgroup RTC_Group3 RTC Alarm functions
mbed_official 573:ad23fe03a082 745 * @brief RTC Alarm functions
mbed_official 573:ad23fe03a082 746 *
mbed_official 573:ad23fe03a082 747 @verbatim
mbed_official 573:ad23fe03a082 748 ===============================================================================
mbed_official 573:ad23fe03a082 749 ##### RTC Alarm functions #####
mbed_official 573:ad23fe03a082 750 ===============================================================================
mbed_official 573:ad23fe03a082 751
mbed_official 573:ad23fe03a082 752 [..] This section provides functions allowing to configure Alarm feature
mbed_official 573:ad23fe03a082 753
mbed_official 573:ad23fe03a082 754 @endverbatim
mbed_official 573:ad23fe03a082 755 * @{
mbed_official 573:ad23fe03a082 756 */
mbed_official 573:ad23fe03a082 757 /**
mbed_official 573:ad23fe03a082 758 * @brief Sets the specified RTC Alarm.
mbed_official 573:ad23fe03a082 759 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 760 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 761 * @param sAlarm: Pointer to Alarm structure
mbed_official 573:ad23fe03a082 762 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 763 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 764 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 765 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 766 * @retval HAL status
mbed_official 573:ad23fe03a082 767 */
mbed_official 573:ad23fe03a082 768 HAL_StatusTypeDef HAL_RTC_SetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
mbed_official 573:ad23fe03a082 769 {
mbed_official 573:ad23fe03a082 770 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 771 uint32_t tmpreg = 0, subsecondtmpreg = 0;
mbed_official 573:ad23fe03a082 772
mbed_official 573:ad23fe03a082 773 /* Check the parameters */
mbed_official 573:ad23fe03a082 774 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 775 assert_param(IS_RTC_ALARM(sAlarm->Alarm));
mbed_official 573:ad23fe03a082 776 assert_param(IS_RTC_ALARM_MASK(sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 777 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
mbed_official 573:ad23fe03a082 778 assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
mbed_official 573:ad23fe03a082 779 assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 780
mbed_official 573:ad23fe03a082 781 /* Process Locked */
mbed_official 573:ad23fe03a082 782 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 783
mbed_official 573:ad23fe03a082 784 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 785
mbed_official 573:ad23fe03a082 786 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 787 {
mbed_official 573:ad23fe03a082 788 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 789 {
mbed_official 573:ad23fe03a082 790 assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 791 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 792 }
mbed_official 573:ad23fe03a082 793 else
mbed_official 573:ad23fe03a082 794 {
mbed_official 573:ad23fe03a082 795 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 796 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 797 }
mbed_official 573:ad23fe03a082 798 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
mbed_official 573:ad23fe03a082 799 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
mbed_official 573:ad23fe03a082 800
mbed_official 573:ad23fe03a082 801 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 802 {
mbed_official 573:ad23fe03a082 803 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 804 }
mbed_official 573:ad23fe03a082 805 else
mbed_official 573:ad23fe03a082 806 {
mbed_official 573:ad23fe03a082 807 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 808 }
mbed_official 573:ad23fe03a082 809
mbed_official 573:ad23fe03a082 810 tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 811 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 812 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
mbed_official 573:ad23fe03a082 813 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 814 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 815 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 816 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 817 }
mbed_official 573:ad23fe03a082 818 else
mbed_official 573:ad23fe03a082 819 {
mbed_official 573:ad23fe03a082 820 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 821 {
mbed_official 573:ad23fe03a082 822 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 573:ad23fe03a082 823 assert_param(IS_RTC_HOUR12(tmpreg));
mbed_official 573:ad23fe03a082 824 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 825 }
mbed_official 573:ad23fe03a082 826 else
mbed_official 573:ad23fe03a082 827 {
mbed_official 573:ad23fe03a082 828 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 829 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
mbed_official 573:ad23fe03a082 830 }
mbed_official 573:ad23fe03a082 831
mbed_official 573:ad23fe03a082 832 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
mbed_official 573:ad23fe03a082 833 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
mbed_official 573:ad23fe03a082 834
mbed_official 573:ad23fe03a082 835 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 836 {
mbed_official 573:ad23fe03a082 837 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 838 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
mbed_official 573:ad23fe03a082 839 }
mbed_official 573:ad23fe03a082 840 else
mbed_official 573:ad23fe03a082 841 {
mbed_official 573:ad23fe03a082 842 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 843 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
mbed_official 573:ad23fe03a082 844 }
mbed_official 573:ad23fe03a082 845
mbed_official 573:ad23fe03a082 846 tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 847 ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 848 ((uint32_t) sAlarm->AlarmTime.Seconds) | \
mbed_official 573:ad23fe03a082 849 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 850 ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 851 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 852 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 853 }
mbed_official 573:ad23fe03a082 854
mbed_official 573:ad23fe03a082 855 /* Configure the Alarm A or Alarm B Sub Second registers */
mbed_official 573:ad23fe03a082 856 subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 857
mbed_official 573:ad23fe03a082 858 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 859 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 860
mbed_official 573:ad23fe03a082 861 /* Configure the Alarm register */
mbed_official 573:ad23fe03a082 862 if(sAlarm->Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 863 {
mbed_official 573:ad23fe03a082 864 /* Disable the Alarm A interrupt */
mbed_official 573:ad23fe03a082 865 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 866
mbed_official 573:ad23fe03a082 867 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 868 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
mbed_official 573:ad23fe03a082 869
mbed_official 573:ad23fe03a082 870 /* Get tick */
mbed_official 573:ad23fe03a082 871 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 872
mbed_official 573:ad23fe03a082 873 /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 874 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 573:ad23fe03a082 875 {
mbed_official 573:ad23fe03a082 876 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 877 {
mbed_official 573:ad23fe03a082 878 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 879 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 880
mbed_official 573:ad23fe03a082 881 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 882
mbed_official 573:ad23fe03a082 883 /* Process Unlocked */
mbed_official 573:ad23fe03a082 884 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 885
mbed_official 573:ad23fe03a082 886 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 887 }
mbed_official 573:ad23fe03a082 888 }
mbed_official 573:ad23fe03a082 889
mbed_official 573:ad23fe03a082 890 hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 891 /* Configure the Alarm A Sub Second register */
mbed_official 573:ad23fe03a082 892 hrtc->Instance->ALRMASSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 893 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 894 __HAL_RTC_ALARMA_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 895 }
mbed_official 573:ad23fe03a082 896 else
mbed_official 573:ad23fe03a082 897 {
mbed_official 573:ad23fe03a082 898 /* Disable the Alarm B interrupt */
mbed_official 573:ad23fe03a082 899 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 900
mbed_official 573:ad23fe03a082 901 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 902 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRB);
mbed_official 573:ad23fe03a082 903
mbed_official 573:ad23fe03a082 904 /* Get tick */
mbed_official 573:ad23fe03a082 905 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 906
mbed_official 573:ad23fe03a082 907 /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 908 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 573:ad23fe03a082 909 {
mbed_official 573:ad23fe03a082 910 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 911 {
mbed_official 573:ad23fe03a082 912 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 913 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 914
mbed_official 573:ad23fe03a082 915 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 916
mbed_official 573:ad23fe03a082 917 /* Process Unlocked */
mbed_official 573:ad23fe03a082 918 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 919
mbed_official 573:ad23fe03a082 920 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 921 }
mbed_official 573:ad23fe03a082 922 }
mbed_official 573:ad23fe03a082 923
mbed_official 573:ad23fe03a082 924 hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 925 /* Configure the Alarm B Sub Second register */
mbed_official 573:ad23fe03a082 926 hrtc->Instance->ALRMBSSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 927 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 928 __HAL_RTC_ALARMB_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 929 }
mbed_official 573:ad23fe03a082 930
mbed_official 573:ad23fe03a082 931 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 932 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 933
mbed_official 573:ad23fe03a082 934 /* Change RTC state */
mbed_official 573:ad23fe03a082 935 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 936
mbed_official 573:ad23fe03a082 937 /* Process Unlocked */
mbed_official 573:ad23fe03a082 938 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 939
mbed_official 573:ad23fe03a082 940 return HAL_OK;
mbed_official 573:ad23fe03a082 941 }
mbed_official 573:ad23fe03a082 942
mbed_official 573:ad23fe03a082 943 /**
mbed_official 573:ad23fe03a082 944 * @brief Sets the specified RTC Alarm with Interrupt
mbed_official 573:ad23fe03a082 945 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 946 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 947 * @param sAlarm: Pointer to Alarm structure
mbed_official 573:ad23fe03a082 948 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 949 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 950 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 951 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 952 * @note The Alarm register can only be written when the corresponding Alarm
mbed_official 573:ad23fe03a082 953 * is disabled (Use the HAL_RTC_DeactivateAlarm()).
mbed_official 573:ad23fe03a082 954 * @note The HAL_RTC_SetTime() must be called before enabling the Alarm feature.
mbed_official 573:ad23fe03a082 955 * @retval HAL status
mbed_official 573:ad23fe03a082 956 */
mbed_official 573:ad23fe03a082 957 HAL_StatusTypeDef HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
mbed_official 573:ad23fe03a082 958 {
mbed_official 573:ad23fe03a082 959 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 960 uint32_t tmpreg = 0, subsecondtmpreg = 0;
mbed_official 573:ad23fe03a082 961
mbed_official 573:ad23fe03a082 962 /* Check the parameters */
mbed_official 573:ad23fe03a082 963 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 964 assert_param(IS_RTC_ALARM(sAlarm->Alarm));
mbed_official 573:ad23fe03a082 965 assert_param(IS_RTC_ALARM_MASK(sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 966 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
mbed_official 573:ad23fe03a082 967 assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
mbed_official 573:ad23fe03a082 968 assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 969
mbed_official 573:ad23fe03a082 970 /* Process Locked */
mbed_official 573:ad23fe03a082 971 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 972
mbed_official 573:ad23fe03a082 973 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 974
mbed_official 573:ad23fe03a082 975 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 976 {
mbed_official 573:ad23fe03a082 977 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 978 {
mbed_official 573:ad23fe03a082 979 assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 980 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 981 }
mbed_official 573:ad23fe03a082 982 else
mbed_official 573:ad23fe03a082 983 {
mbed_official 573:ad23fe03a082 984 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 985 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 986 }
mbed_official 573:ad23fe03a082 987 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
mbed_official 573:ad23fe03a082 988 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
mbed_official 573:ad23fe03a082 989
mbed_official 573:ad23fe03a082 990 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 991 {
mbed_official 573:ad23fe03a082 992 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 993 }
mbed_official 573:ad23fe03a082 994 else
mbed_official 573:ad23fe03a082 995 {
mbed_official 573:ad23fe03a082 996 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 997 }
mbed_official 573:ad23fe03a082 998 tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 999 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 1000 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
mbed_official 573:ad23fe03a082 1001 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 1002 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 1003 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 1004 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 1005 }
mbed_official 573:ad23fe03a082 1006 else
mbed_official 573:ad23fe03a082 1007 {
mbed_official 573:ad23fe03a082 1008 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1009 {
mbed_official 573:ad23fe03a082 1010 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 573:ad23fe03a082 1011 assert_param(IS_RTC_HOUR12(tmpreg));
mbed_official 573:ad23fe03a082 1012 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 1013 }
mbed_official 573:ad23fe03a082 1014 else
mbed_official 573:ad23fe03a082 1015 {
mbed_official 573:ad23fe03a082 1016 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 1017 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
mbed_official 573:ad23fe03a082 1018 }
mbed_official 573:ad23fe03a082 1019
mbed_official 573:ad23fe03a082 1020 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
mbed_official 573:ad23fe03a082 1021 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
mbed_official 573:ad23fe03a082 1022
mbed_official 573:ad23fe03a082 1023 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 1024 {
mbed_official 573:ad23fe03a082 1025 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 1026 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
mbed_official 573:ad23fe03a082 1027 }
mbed_official 573:ad23fe03a082 1028 else
mbed_official 573:ad23fe03a082 1029 {
mbed_official 573:ad23fe03a082 1030 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 1031 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
mbed_official 573:ad23fe03a082 1032 }
mbed_official 573:ad23fe03a082 1033 tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 1034 ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 1035 ((uint32_t) sAlarm->AlarmTime.Seconds) | \
mbed_official 573:ad23fe03a082 1036 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 1037 ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 1038 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 1039 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 1040 }
mbed_official 573:ad23fe03a082 1041 /* Configure the Alarm A or Alarm B Sub Second registers */
mbed_official 573:ad23fe03a082 1042 subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 1043
mbed_official 573:ad23fe03a082 1044 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1045 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1046
mbed_official 573:ad23fe03a082 1047 /* Configure the Alarm register */
mbed_official 573:ad23fe03a082 1048 if(sAlarm->Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 1049 {
mbed_official 573:ad23fe03a082 1050 /* Disable the Alarm A interrupt */
mbed_official 573:ad23fe03a082 1051 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1052
mbed_official 573:ad23fe03a082 1053 /* Clear flag alarm A */
mbed_official 573:ad23fe03a082 1054 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
mbed_official 573:ad23fe03a082 1055
mbed_official 573:ad23fe03a082 1056 /* Get tick */
mbed_official 573:ad23fe03a082 1057 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1058
mbed_official 573:ad23fe03a082 1059 /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1060 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 573:ad23fe03a082 1061 {
mbed_official 573:ad23fe03a082 1062 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1063 {
mbed_official 573:ad23fe03a082 1064 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1065 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1066
mbed_official 573:ad23fe03a082 1067 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1068
mbed_official 573:ad23fe03a082 1069 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1070 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1071
mbed_official 573:ad23fe03a082 1072 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1073 }
mbed_official 573:ad23fe03a082 1074 }
mbed_official 573:ad23fe03a082 1075
mbed_official 573:ad23fe03a082 1076 hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 1077 /* Configure the Alarm A Sub Second register */
mbed_official 573:ad23fe03a082 1078 hrtc->Instance->ALRMASSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 1079 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 1080 __HAL_RTC_ALARMA_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1081 /* Configure the Alarm interrupt */
mbed_official 573:ad23fe03a082 1082 __HAL_RTC_ALARM_ENABLE_IT(hrtc,RTC_IT_ALRA);
mbed_official 573:ad23fe03a082 1083 }
mbed_official 573:ad23fe03a082 1084 else
mbed_official 573:ad23fe03a082 1085 {
mbed_official 573:ad23fe03a082 1086 /* Disable the Alarm B interrupt */
mbed_official 573:ad23fe03a082 1087 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1088
mbed_official 573:ad23fe03a082 1089 /* Clear flag alarm B */
mbed_official 573:ad23fe03a082 1090 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRBF);
mbed_official 573:ad23fe03a082 1091
mbed_official 573:ad23fe03a082 1092 /* Get tick */
mbed_official 573:ad23fe03a082 1093 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1094
mbed_official 573:ad23fe03a082 1095 /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1096 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 573:ad23fe03a082 1097 {
mbed_official 573:ad23fe03a082 1098 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1099 {
mbed_official 573:ad23fe03a082 1100 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1101 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1102
mbed_official 573:ad23fe03a082 1103 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1104
mbed_official 573:ad23fe03a082 1105 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1106 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1107
mbed_official 573:ad23fe03a082 1108 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1109 }
mbed_official 573:ad23fe03a082 1110 }
mbed_official 573:ad23fe03a082 1111
mbed_official 573:ad23fe03a082 1112 hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 1113 /* Configure the Alarm B Sub Second register */
mbed_official 573:ad23fe03a082 1114 hrtc->Instance->ALRMBSSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 1115 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 1116 __HAL_RTC_ALARMB_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1117 /* Configure the Alarm interrupt */
mbed_official 573:ad23fe03a082 1118 __HAL_RTC_ALARM_ENABLE_IT(hrtc, RTC_IT_ALRB);
mbed_official 573:ad23fe03a082 1119 }
mbed_official 573:ad23fe03a082 1120
mbed_official 573:ad23fe03a082 1121 /* RTC Alarm Interrupt Configuration: EXTI configuration */
mbed_official 573:ad23fe03a082 1122 __HAL_RTC_ALARM_EXTI_ENABLE_IT();
mbed_official 573:ad23fe03a082 1123
mbed_official 573:ad23fe03a082 1124 EXTI->RTSR |= RTC_EXTI_LINE_ALARM_EVENT;
mbed_official 573:ad23fe03a082 1125
mbed_official 573:ad23fe03a082 1126 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1127 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1128
mbed_official 573:ad23fe03a082 1129 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1130
mbed_official 573:ad23fe03a082 1131 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1132 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1133
mbed_official 573:ad23fe03a082 1134 return HAL_OK;
mbed_official 573:ad23fe03a082 1135 }
mbed_official 573:ad23fe03a082 1136
mbed_official 573:ad23fe03a082 1137 /**
mbed_official 573:ad23fe03a082 1138 * @brief Deactive the specified RTC Alarm
mbed_official 573:ad23fe03a082 1139 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1140 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1141 * @param Alarm: Specifies the Alarm.
mbed_official 573:ad23fe03a082 1142 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 1143 * @arg RTC_ALARM_A: AlarmA
mbed_official 573:ad23fe03a082 1144 * @arg RTC_ALARM_B: AlarmB
mbed_official 573:ad23fe03a082 1145 * @retval HAL status
mbed_official 573:ad23fe03a082 1146 */
mbed_official 573:ad23fe03a082 1147 HAL_StatusTypeDef HAL_RTC_DeactivateAlarm(RTC_HandleTypeDef *hrtc, uint32_t Alarm)
mbed_official 573:ad23fe03a082 1148 {
mbed_official 573:ad23fe03a082 1149 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1150
mbed_official 573:ad23fe03a082 1151 /* Check the parameters */
mbed_official 573:ad23fe03a082 1152 assert_param(IS_RTC_ALARM(Alarm));
mbed_official 573:ad23fe03a082 1153
mbed_official 573:ad23fe03a082 1154 /* Process Locked */
mbed_official 573:ad23fe03a082 1155 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 1156
mbed_official 573:ad23fe03a082 1157 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 1158
mbed_official 573:ad23fe03a082 1159 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1160 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1161
mbed_official 573:ad23fe03a082 1162 if(Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 1163 {
mbed_official 573:ad23fe03a082 1164 /* AlarmA */
mbed_official 573:ad23fe03a082 1165 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1166
mbed_official 573:ad23fe03a082 1167 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 1168 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
mbed_official 573:ad23fe03a082 1169
mbed_official 573:ad23fe03a082 1170 /* Get tick */
mbed_official 573:ad23fe03a082 1171 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1172
mbed_official 573:ad23fe03a082 1173 /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1174 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 573:ad23fe03a082 1175 {
mbed_official 573:ad23fe03a082 1176 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1177 {
mbed_official 573:ad23fe03a082 1178 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1179 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1180
mbed_official 573:ad23fe03a082 1181 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1182
mbed_official 573:ad23fe03a082 1183 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1184 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1185
mbed_official 573:ad23fe03a082 1186 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1187 }
mbed_official 573:ad23fe03a082 1188 }
mbed_official 573:ad23fe03a082 1189 }
mbed_official 573:ad23fe03a082 1190 else
mbed_official 573:ad23fe03a082 1191 {
mbed_official 573:ad23fe03a082 1192 /* AlarmB */
mbed_official 573:ad23fe03a082 1193 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1194
mbed_official 573:ad23fe03a082 1195 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 1196 __HAL_RTC_ALARM_DISABLE_IT(hrtc,RTC_IT_ALRB);
mbed_official 573:ad23fe03a082 1197
mbed_official 573:ad23fe03a082 1198 /* Get tick */
mbed_official 573:ad23fe03a082 1199 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1200
mbed_official 573:ad23fe03a082 1201 /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1202 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 573:ad23fe03a082 1203 {
mbed_official 573:ad23fe03a082 1204 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1205 {
mbed_official 573:ad23fe03a082 1206 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1207 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1208
mbed_official 573:ad23fe03a082 1209 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1210
mbed_official 573:ad23fe03a082 1211 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1212 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1213
mbed_official 573:ad23fe03a082 1214 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1215 }
mbed_official 573:ad23fe03a082 1216 }
mbed_official 573:ad23fe03a082 1217 }
mbed_official 573:ad23fe03a082 1218 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1219 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1220
mbed_official 573:ad23fe03a082 1221 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1222
mbed_official 573:ad23fe03a082 1223 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1224 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1225
mbed_official 573:ad23fe03a082 1226 return HAL_OK;
mbed_official 573:ad23fe03a082 1227 }
mbed_official 573:ad23fe03a082 1228
mbed_official 573:ad23fe03a082 1229 /**
mbed_official 573:ad23fe03a082 1230 * @brief Gets the RTC Alarm value and masks.
mbed_official 573:ad23fe03a082 1231 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1232 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1233 * @param sAlarm: Pointer to Date structure
mbed_official 573:ad23fe03a082 1234 * @param Alarm: Specifies the Alarm.
mbed_official 573:ad23fe03a082 1235 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 1236 * @arg RTC_ALARM_A: AlarmA
mbed_official 573:ad23fe03a082 1237 * @arg RTC_ALARM_B: AlarmB
mbed_official 573:ad23fe03a082 1238 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 1239 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 1240 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 1241 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 1242 * @retval HAL status
mbed_official 573:ad23fe03a082 1243 */
mbed_official 573:ad23fe03a082 1244 HAL_StatusTypeDef HAL_RTC_GetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Alarm, uint32_t Format)
mbed_official 573:ad23fe03a082 1245 {
mbed_official 573:ad23fe03a082 1246 uint32_t tmpreg = 0, subsecondtmpreg = 0;
mbed_official 573:ad23fe03a082 1247
mbed_official 573:ad23fe03a082 1248 /* Check the parameters */
mbed_official 573:ad23fe03a082 1249 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 1250 assert_param(IS_RTC_ALARM(Alarm));
mbed_official 573:ad23fe03a082 1251
mbed_official 573:ad23fe03a082 1252 if(Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 1253 {
mbed_official 573:ad23fe03a082 1254 /* AlarmA */
mbed_official 573:ad23fe03a082 1255 sAlarm->Alarm = RTC_ALARM_A;
mbed_official 573:ad23fe03a082 1256
mbed_official 573:ad23fe03a082 1257 tmpreg = (uint32_t)(hrtc->Instance->ALRMAR);
mbed_official 573:ad23fe03a082 1258 subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMASSR ) & RTC_ALRMASSR_SS);
mbed_official 573:ad23fe03a082 1259 }
mbed_official 573:ad23fe03a082 1260 else
mbed_official 573:ad23fe03a082 1261 {
mbed_official 573:ad23fe03a082 1262 sAlarm->Alarm = RTC_ALARM_B;
mbed_official 573:ad23fe03a082 1263
mbed_official 573:ad23fe03a082 1264 tmpreg = (uint32_t)(hrtc->Instance->ALRMBR);
mbed_official 573:ad23fe03a082 1265 subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMBSSR) & RTC_ALRMBSSR_SS);
mbed_official 573:ad23fe03a082 1266 }
mbed_official 573:ad23fe03a082 1267
mbed_official 573:ad23fe03a082 1268 /* Fill the structure with the read parameters */
mbed_official 573:ad23fe03a082 1269 sAlarm->AlarmTime.Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | RTC_ALRMAR_HU)) >> 16);
mbed_official 573:ad23fe03a082 1270 sAlarm->AlarmTime.Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | RTC_ALRMAR_MNU)) >> 8);
mbed_official 573:ad23fe03a082 1271 sAlarm->AlarmTime.Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | RTC_ALRMAR_SU));
mbed_official 573:ad23fe03a082 1272 sAlarm->AlarmTime.TimeFormat = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16);
mbed_official 573:ad23fe03a082 1273 sAlarm->AlarmTime.SubSeconds = (uint32_t) subsecondtmpreg;
mbed_official 573:ad23fe03a082 1274 sAlarm->AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24);
mbed_official 573:ad23fe03a082 1275 sAlarm->AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL);
mbed_official 573:ad23fe03a082 1276 sAlarm->AlarmMask = (uint32_t)(tmpreg & RTC_ALARMMASK_ALL);
mbed_official 573:ad23fe03a082 1277
mbed_official 573:ad23fe03a082 1278 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 1279 {
mbed_official 573:ad23fe03a082 1280 sAlarm->AlarmTime.Hours = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 573:ad23fe03a082 1281 sAlarm->AlarmTime.Minutes = RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes);
mbed_official 573:ad23fe03a082 1282 sAlarm->AlarmTime.Seconds = RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds);
mbed_official 573:ad23fe03a082 1283 sAlarm->AlarmDateWeekDay = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 1284 }
mbed_official 573:ad23fe03a082 1285
mbed_official 573:ad23fe03a082 1286 return HAL_OK;
mbed_official 573:ad23fe03a082 1287 }
mbed_official 573:ad23fe03a082 1288
mbed_official 573:ad23fe03a082 1289 /**
mbed_official 573:ad23fe03a082 1290 * @brief This function handles Alarm interrupt request.
mbed_official 573:ad23fe03a082 1291 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1292 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1293 * @retval None
mbed_official 573:ad23fe03a082 1294 */
mbed_official 573:ad23fe03a082 1295 void HAL_RTC_AlarmIRQHandler(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1296 {
mbed_official 573:ad23fe03a082 1297 if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRA))
mbed_official 573:ad23fe03a082 1298 {
mbed_official 573:ad23fe03a082 1299 /* Get the status of the Interrupt */
mbed_official 573:ad23fe03a082 1300 if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRA) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1301 {
mbed_official 573:ad23fe03a082 1302 /* AlarmA callback */
mbed_official 573:ad23fe03a082 1303 HAL_RTC_AlarmAEventCallback(hrtc);
mbed_official 573:ad23fe03a082 1304
mbed_official 573:ad23fe03a082 1305 /* Clear the Alarm interrupt pending bit */
mbed_official 573:ad23fe03a082 1306 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRAF);
mbed_official 573:ad23fe03a082 1307 }
mbed_official 573:ad23fe03a082 1308 }
mbed_official 573:ad23fe03a082 1309
mbed_official 573:ad23fe03a082 1310 if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRB))
mbed_official 573:ad23fe03a082 1311 {
mbed_official 573:ad23fe03a082 1312 /* Get the status of the Interrupt */
mbed_official 573:ad23fe03a082 1313 if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRB) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1314 {
mbed_official 573:ad23fe03a082 1315 /* AlarmB callback */
mbed_official 573:ad23fe03a082 1316 HAL_RTCEx_AlarmBEventCallback(hrtc);
mbed_official 573:ad23fe03a082 1317
mbed_official 573:ad23fe03a082 1318 /* Clear the Alarm interrupt pending bit */
mbed_official 573:ad23fe03a082 1319 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRBF);
mbed_official 573:ad23fe03a082 1320 }
mbed_official 573:ad23fe03a082 1321 }
mbed_official 573:ad23fe03a082 1322
mbed_official 573:ad23fe03a082 1323 /* Clear the EXTI's line Flag for RTC Alarm */
mbed_official 573:ad23fe03a082 1324 __HAL_RTC_ALARM_EXTI_CLEAR_FLAG();
mbed_official 573:ad23fe03a082 1325
mbed_official 573:ad23fe03a082 1326 /* Change RTC state */
mbed_official 573:ad23fe03a082 1327 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1328 }
mbed_official 573:ad23fe03a082 1329
mbed_official 573:ad23fe03a082 1330 /**
mbed_official 573:ad23fe03a082 1331 * @brief Alarm A callback.
mbed_official 573:ad23fe03a082 1332 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1333 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1334 * @retval None
mbed_official 573:ad23fe03a082 1335 */
mbed_official 573:ad23fe03a082 1336 __weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 573:ad23fe03a082 1337 {
mbed_official 573:ad23fe03a082 1338 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1339 the HAL_RTC_AlarmAEventCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 1340 */
mbed_official 573:ad23fe03a082 1341 }
mbed_official 573:ad23fe03a082 1342
mbed_official 573:ad23fe03a082 1343 /**
mbed_official 573:ad23fe03a082 1344 * @brief This function handles AlarmA Polling request.
mbed_official 573:ad23fe03a082 1345 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1346 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1347 * @param Timeout: Timeout duration
mbed_official 573:ad23fe03a082 1348 * @retval HAL status
mbed_official 573:ad23fe03a082 1349 */
mbed_official 573:ad23fe03a082 1350 HAL_StatusTypeDef HAL_RTC_PollForAlarmAEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 573:ad23fe03a082 1351 {
mbed_official 573:ad23fe03a082 1352 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1353
mbed_official 573:ad23fe03a082 1354 /* Get tick */
mbed_official 573:ad23fe03a082 1355 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1356
mbed_official 573:ad23fe03a082 1357 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) == RESET)
mbed_official 573:ad23fe03a082 1358 {
mbed_official 573:ad23fe03a082 1359 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 1360 {
mbed_official 573:ad23fe03a082 1361 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 573:ad23fe03a082 1362 {
mbed_official 573:ad23fe03a082 1363 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1364 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1365 }
mbed_official 573:ad23fe03a082 1366 }
mbed_official 573:ad23fe03a082 1367 }
mbed_official 573:ad23fe03a082 1368
mbed_official 573:ad23fe03a082 1369 /* Clear the Alarm interrupt pending bit */
mbed_official 573:ad23fe03a082 1370 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
mbed_official 573:ad23fe03a082 1371
mbed_official 573:ad23fe03a082 1372 /* Change RTC state */
mbed_official 573:ad23fe03a082 1373 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1374
mbed_official 573:ad23fe03a082 1375 return HAL_OK;
mbed_official 573:ad23fe03a082 1376 }
mbed_official 573:ad23fe03a082 1377
mbed_official 573:ad23fe03a082 1378 /**
mbed_official 573:ad23fe03a082 1379 * @}
mbed_official 573:ad23fe03a082 1380 */
mbed_official 573:ad23fe03a082 1381
mbed_official 573:ad23fe03a082 1382 /** @defgroup RTC_Group4 Peripheral Control functions
mbed_official 573:ad23fe03a082 1383 * @brief Peripheral Control functions
mbed_official 573:ad23fe03a082 1384 *
mbed_official 573:ad23fe03a082 1385 @verbatim
mbed_official 573:ad23fe03a082 1386 ===============================================================================
mbed_official 573:ad23fe03a082 1387 ##### Peripheral Control functions #####
mbed_official 573:ad23fe03a082 1388 ===============================================================================
mbed_official 573:ad23fe03a082 1389 [..]
mbed_official 573:ad23fe03a082 1390 This subsection provides functions allowing to
mbed_official 573:ad23fe03a082 1391 (+) Wait for RTC Time and Date Synchronization
mbed_official 573:ad23fe03a082 1392
mbed_official 573:ad23fe03a082 1393 @endverbatim
mbed_official 573:ad23fe03a082 1394 * @{
mbed_official 573:ad23fe03a082 1395 */
mbed_official 573:ad23fe03a082 1396
mbed_official 573:ad23fe03a082 1397 /**
mbed_official 573:ad23fe03a082 1398 * @brief Waits until the RTC Time and Date registers (RTC_TR and RTC_DR) are
mbed_official 573:ad23fe03a082 1399 * synchronized with RTC APB clock.
mbed_official 573:ad23fe03a082 1400 * @note The RTC Resynchronization mode is write protected, use the
mbed_official 573:ad23fe03a082 1401 * __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function.
mbed_official 573:ad23fe03a082 1402 * @note To read the calendar through the shadow registers after Calendar
mbed_official 573:ad23fe03a082 1403 * initialization, calendar update or after wakeup from low power modes
mbed_official 573:ad23fe03a082 1404 * the software must first clear the RSF flag.
mbed_official 573:ad23fe03a082 1405 * The software must then wait until it is set again before reading
mbed_official 573:ad23fe03a082 1406 * the calendar, which means that the calendar registers have been
mbed_official 573:ad23fe03a082 1407 * correctly copied into the RTC_TR and RTC_DR shadow registers.
mbed_official 573:ad23fe03a082 1408 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1409 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1410 * @retval HAL status
mbed_official 573:ad23fe03a082 1411 */
mbed_official 573:ad23fe03a082 1412 HAL_StatusTypeDef HAL_RTC_WaitForSynchro(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1413 {
mbed_official 573:ad23fe03a082 1414 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1415
mbed_official 573:ad23fe03a082 1416 /* Clear RSF flag */
mbed_official 573:ad23fe03a082 1417 hrtc->Instance->ISR &= (uint32_t)RTC_RSF_MASK;
mbed_official 573:ad23fe03a082 1418
mbed_official 573:ad23fe03a082 1419 /* Get tick */
mbed_official 573:ad23fe03a082 1420 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1421
mbed_official 573:ad23fe03a082 1422 /* Wait the registers to be synchronised */
mbed_official 573:ad23fe03a082 1423 while((hrtc->Instance->ISR & RTC_ISR_RSF) == (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1424 {
mbed_official 573:ad23fe03a082 1425 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1426 {
mbed_official 573:ad23fe03a082 1427 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1428 }
mbed_official 573:ad23fe03a082 1429 }
mbed_official 573:ad23fe03a082 1430
mbed_official 573:ad23fe03a082 1431 return HAL_OK;
mbed_official 573:ad23fe03a082 1432 }
mbed_official 573:ad23fe03a082 1433
mbed_official 573:ad23fe03a082 1434 /**
mbed_official 573:ad23fe03a082 1435 * @}
mbed_official 573:ad23fe03a082 1436 */
mbed_official 573:ad23fe03a082 1437
mbed_official 573:ad23fe03a082 1438 /** @defgroup RTC_Group5 Peripheral State functions
mbed_official 573:ad23fe03a082 1439 * @brief Peripheral State functions
mbed_official 573:ad23fe03a082 1440 *
mbed_official 573:ad23fe03a082 1441 @verbatim
mbed_official 573:ad23fe03a082 1442 ===============================================================================
mbed_official 573:ad23fe03a082 1443 ##### Peripheral State functions #####
mbed_official 573:ad23fe03a082 1444 ===============================================================================
mbed_official 573:ad23fe03a082 1445 [..]
mbed_official 573:ad23fe03a082 1446 This subsection provides functions allowing to
mbed_official 573:ad23fe03a082 1447 (+) Get RTC state
mbed_official 573:ad23fe03a082 1448
mbed_official 573:ad23fe03a082 1449 @endverbatim
mbed_official 573:ad23fe03a082 1450 * @{
mbed_official 573:ad23fe03a082 1451 */
mbed_official 573:ad23fe03a082 1452 /**
mbed_official 573:ad23fe03a082 1453 * @brief Returns the RTC state.
mbed_official 573:ad23fe03a082 1454 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1455 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1456 * @retval HAL state
mbed_official 573:ad23fe03a082 1457 */
mbed_official 573:ad23fe03a082 1458 HAL_RTCStateTypeDef HAL_RTC_GetState(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1459 {
mbed_official 573:ad23fe03a082 1460 return hrtc->State;
mbed_official 573:ad23fe03a082 1461 }
mbed_official 573:ad23fe03a082 1462
mbed_official 573:ad23fe03a082 1463 /**
mbed_official 573:ad23fe03a082 1464 * @}
mbed_official 573:ad23fe03a082 1465 */
mbed_official 573:ad23fe03a082 1466
mbed_official 573:ad23fe03a082 1467 /**
mbed_official 573:ad23fe03a082 1468 * @brief Enters the RTC Initialization mode.
mbed_official 573:ad23fe03a082 1469 * @note The RTC Initialization mode is write protected, use the
mbed_official 573:ad23fe03a082 1470 * __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function.
mbed_official 573:ad23fe03a082 1471 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1472 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1473 * @retval HAL status
mbed_official 573:ad23fe03a082 1474 */
mbed_official 573:ad23fe03a082 1475 HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1476 {
mbed_official 573:ad23fe03a082 1477 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1478
mbed_official 573:ad23fe03a082 1479 /* Check if the Initialization mode is set */
mbed_official 573:ad23fe03a082 1480 if((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1481 {
mbed_official 573:ad23fe03a082 1482 /* Set the Initialization mode */
mbed_official 573:ad23fe03a082 1483 hrtc->Instance->ISR = (uint32_t)RTC_INIT_MASK;
mbed_official 573:ad23fe03a082 1484
mbed_official 573:ad23fe03a082 1485 /* Get tick */
mbed_official 573:ad23fe03a082 1486 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1487
mbed_official 573:ad23fe03a082 1488 /* Wait till RTC is in INIT state and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1489 while((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1490 {
mbed_official 573:ad23fe03a082 1491 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1492 {
mbed_official 573:ad23fe03a082 1493 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1494 }
mbed_official 573:ad23fe03a082 1495 }
mbed_official 573:ad23fe03a082 1496 }
mbed_official 573:ad23fe03a082 1497
mbed_official 573:ad23fe03a082 1498 return HAL_OK;
mbed_official 573:ad23fe03a082 1499 }
mbed_official 573:ad23fe03a082 1500
mbed_official 573:ad23fe03a082 1501
mbed_official 573:ad23fe03a082 1502 /**
mbed_official 573:ad23fe03a082 1503 * @brief Converts a 2 digit decimal to BCD format.
mbed_official 573:ad23fe03a082 1504 * @param Value: Byte to be converted
mbed_official 573:ad23fe03a082 1505 * @retval Converted byte
mbed_official 573:ad23fe03a082 1506 */
mbed_official 573:ad23fe03a082 1507 uint8_t RTC_ByteToBcd2(uint8_t Value)
mbed_official 573:ad23fe03a082 1508 {
mbed_official 573:ad23fe03a082 1509 uint32_t bcdhigh = 0;
mbed_official 573:ad23fe03a082 1510
mbed_official 573:ad23fe03a082 1511 while(Value >= 10)
mbed_official 573:ad23fe03a082 1512 {
mbed_official 573:ad23fe03a082 1513 bcdhigh++;
mbed_official 573:ad23fe03a082 1514 Value -= 10;
mbed_official 573:ad23fe03a082 1515 }
mbed_official 573:ad23fe03a082 1516
mbed_official 573:ad23fe03a082 1517 return ((uint8_t)(bcdhigh << 4) | Value);
mbed_official 573:ad23fe03a082 1518 }
mbed_official 573:ad23fe03a082 1519
mbed_official 573:ad23fe03a082 1520 /**
mbed_official 573:ad23fe03a082 1521 * @brief Converts from 2 digit BCD to Binary.
mbed_official 573:ad23fe03a082 1522 * @param Value: BCD value to be converted
mbed_official 573:ad23fe03a082 1523 * @retval Converted word
mbed_official 573:ad23fe03a082 1524 */
mbed_official 573:ad23fe03a082 1525 uint8_t RTC_Bcd2ToByte(uint8_t Value)
mbed_official 573:ad23fe03a082 1526 {
mbed_official 573:ad23fe03a082 1527 uint32_t tmp = 0;
mbed_official 573:ad23fe03a082 1528 tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10;
mbed_official 573:ad23fe03a082 1529 return (tmp + (Value & (uint8_t)0x0F));
mbed_official 573:ad23fe03a082 1530 }
mbed_official 573:ad23fe03a082 1531
mbed_official 573:ad23fe03a082 1532 /**
mbed_official 573:ad23fe03a082 1533 * @}
mbed_official 573:ad23fe03a082 1534 */
mbed_official 573:ad23fe03a082 1535
mbed_official 573:ad23fe03a082 1536 #endif /* HAL_RTC_MODULE_ENABLED */
mbed_official 573:ad23fe03a082 1537 /**
mbed_official 573:ad23fe03a082 1538 * @}
mbed_official 573:ad23fe03a082 1539 */
mbed_official 573:ad23fe03a082 1540
mbed_official 573:ad23fe03a082 1541 /**
mbed_official 573:ad23fe03a082 1542 * @}
mbed_official 573:ad23fe03a082 1543 */
mbed_official 573:ad23fe03a082 1544
mbed_official 573:ad23fe03a082 1545 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/