Joris Aerts / mbed-src

mbed library sources

Dependents:   Marvino mbot

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_rtc.c@637:ed69428d4850, 2015-12-22 (annotated)

Committer:
jaerts
Date:
Tue Dec 22 13:22:16 2015 +0000
Revision:
637:ed69428d4850
Parent:
610:813dcc80987e 
Add very shady LPC1768 CAN Filter implementation

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 610:813dcc80987e 5 * @version V1.0.1
mbed_official 610:813dcc80987e 6 * @date 25-June-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 610:813dcc80987e 65 __HAL_RCC_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 610:813dcc80987e 550 * @param hrtc: RTC handle
mbed_official 610:813dcc80987e 551 * @param sTime: Pointer to Time structure with Hours, Minutes and Seconds fields returned
mbed_official 610:813dcc80987e 552 * with input format (BIN or BCD), also SubSeconds field returning the
mbed_official 610:813dcc80987e 553 * RTC_SSR register content and SecondFraction field the Synchronous pre-scaler
mbed_official 610:813dcc80987e 554 * factor to be used for second fraction ratio computation.
mbed_official 573:ad23fe03a082 555 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 556 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 557 * @arg RTC_FORMAT_BIN: Binary data format
mbed_official 610:813dcc80987e 558 * @arg RTC_FORMAT_BCD: BCD data format
mbed_official 610:813dcc80987e 559 * @note You can use SubSeconds and SecondFraction (sTime structure fields returned) to convert SubSeconds
mbed_official 610:813dcc80987e 560 * value in second fraction ratio with time unit following generic formula:
mbed_official 610:813dcc80987e 561 * Second fraction ratio * time_unit= [(SecondFraction-SubSeconds)/(SecondFraction+1)] * time_unit
mbed_official 610:813dcc80987e 562 * This conversion can be performed only if no shift operation is pending (ie. SHFP=0) when PREDIV_S >= SS
mbed_official 610:813dcc80987e 563 * @note You must call HAL_RTC_GetDate() after HAL_RTC_GetTime() to unlock the values
mbed_official 610:813dcc80987e 564 * in the higher-order calendar shadow registers to ensure consistency between the time and date values.
mbed_official 610:813dcc80987e 565 * Reading RTC current time locks the values in calendar shadow registers until Current date is read
mbed_official 610:813dcc80987e 566 * to ensure consistency between the time and date values.
mbed_official 573:ad23fe03a082 567 * @retval HAL status
mbed_official 573:ad23fe03a082 568 */
mbed_official 573:ad23fe03a082 569 HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
mbed_official 573:ad23fe03a082 570 {
mbed_official 573:ad23fe03a082 571 uint32_t tmpreg = 0;
mbed_official 573:ad23fe03a082 572
mbed_official 573:ad23fe03a082 573 /* Check the parameters */
mbed_official 573:ad23fe03a082 574 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 575
mbed_official 573:ad23fe03a082 576 /* Get subseconds values from the correspondent registers*/
mbed_official 573:ad23fe03a082 577 sTime->SubSeconds = (uint32_t)(hrtc->Instance->SSR);
mbed_official 573:ad23fe03a082 578
mbed_official 573:ad23fe03a082 579 /* Get the TR register */
mbed_official 573:ad23fe03a082 580 tmpreg = (uint32_t)(hrtc->Instance->TR & RTC_TR_RESERVED_MASK);
mbed_official 573:ad23fe03a082 581
mbed_official 573:ad23fe03a082 582 /* Fill the structure fields with the read parameters */
mbed_official 573:ad23fe03a082 583 sTime->Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16);
mbed_official 573:ad23fe03a082 584 sTime->Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8);
mbed_official 573:ad23fe03a082 585 sTime->Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU));
mbed_official 573:ad23fe03a082 586 sTime->TimeFormat = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16);
mbed_official 573:ad23fe03a082 587
mbed_official 573:ad23fe03a082 588 /* Check the input parameters format */
mbed_official 573:ad23fe03a082 589 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 590 {
mbed_official 573:ad23fe03a082 591 /* Convert the time structure parameters to Binary format */
mbed_official 573:ad23fe03a082 592 sTime->Hours = (uint8_t)RTC_Bcd2ToByte(sTime->Hours);
mbed_official 573:ad23fe03a082 593 sTime->Minutes = (uint8_t)RTC_Bcd2ToByte(sTime->Minutes);
mbed_official 573:ad23fe03a082 594 sTime->Seconds = (uint8_t)RTC_Bcd2ToByte(sTime->Seconds);
mbed_official 573:ad23fe03a082 595 }
mbed_official 573:ad23fe03a082 596
mbed_official 573:ad23fe03a082 597 return HAL_OK;
mbed_official 573:ad23fe03a082 598 }
mbed_official 573:ad23fe03a082 599
mbed_official 573:ad23fe03a082 600 /**
mbed_official 573:ad23fe03a082 601 * @brief Sets RTC current date.
mbed_official 573:ad23fe03a082 602 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 603 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 604 * @param sDate: Pointer to date structure
mbed_official 573:ad23fe03a082 605 * @param Format: specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 606 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 607 * @arg RTC_FORMAT_BIN: Binary data format
mbed_official 610:813dcc80987e 608 * @arg RTC_FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 609 * @retval HAL status
mbed_official 573:ad23fe03a082 610 */
mbed_official 573:ad23fe03a082 611 HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
mbed_official 573:ad23fe03a082 612 {
mbed_official 573:ad23fe03a082 613 uint32_t datetmpreg = 0;
mbed_official 573:ad23fe03a082 614
mbed_official 573:ad23fe03a082 615 /* Check the parameters */
mbed_official 573:ad23fe03a082 616 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 617
mbed_official 573:ad23fe03a082 618 /* Process Locked */
mbed_official 573:ad23fe03a082 619 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 620
mbed_official 573:ad23fe03a082 621 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 622
mbed_official 573:ad23fe03a082 623 if((Format == RTC_FORMAT_BIN) && ((sDate->Month & 0x10) == 0x10))
mbed_official 573:ad23fe03a082 624 {
mbed_official 573:ad23fe03a082 625 sDate->Month = (uint8_t)((sDate->Month & (uint8_t)~(0x10)) + (uint8_t)0x0A);
mbed_official 573:ad23fe03a082 626 }
mbed_official 573:ad23fe03a082 627
mbed_official 573:ad23fe03a082 628 assert_param(IS_RTC_WEEKDAY(sDate->WeekDay));
mbed_official 573:ad23fe03a082 629
mbed_official 573:ad23fe03a082 630 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 631 {
mbed_official 573:ad23fe03a082 632 assert_param(IS_RTC_YEAR(sDate->Year));
mbed_official 573:ad23fe03a082 633 assert_param(IS_RTC_MONTH(sDate->Month));
mbed_official 573:ad23fe03a082 634 assert_param(IS_RTC_DATE(sDate->Date));
mbed_official 573:ad23fe03a082 635
mbed_official 573:ad23fe03a082 636 datetmpreg = (((uint32_t)RTC_ByteToBcd2(sDate->Year) << 16) | \
mbed_official 573:ad23fe03a082 637 ((uint32_t)RTC_ByteToBcd2(sDate->Month) << 8) | \
mbed_official 573:ad23fe03a082 638 ((uint32_t)RTC_ByteToBcd2(sDate->Date)) | \
mbed_official 573:ad23fe03a082 639 ((uint32_t)sDate->WeekDay << 13));
mbed_official 573:ad23fe03a082 640 }
mbed_official 573:ad23fe03a082 641 else
mbed_official 573:ad23fe03a082 642 {
mbed_official 573:ad23fe03a082 643 assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year)));
mbed_official 573:ad23fe03a082 644 datetmpreg = RTC_Bcd2ToByte(sDate->Month);
mbed_official 573:ad23fe03a082 645 assert_param(IS_RTC_MONTH(datetmpreg));
mbed_official 573:ad23fe03a082 646 datetmpreg = RTC_Bcd2ToByte(sDate->Date);
mbed_official 573:ad23fe03a082 647 assert_param(IS_RTC_DATE(datetmpreg));
mbed_official 573:ad23fe03a082 648
mbed_official 573:ad23fe03a082 649 datetmpreg = ((((uint32_t)sDate->Year) << 16) | \
mbed_official 573:ad23fe03a082 650 (((uint32_t)sDate->Month) << 8) | \
mbed_official 573:ad23fe03a082 651 ((uint32_t)sDate->Date) | \
mbed_official 573:ad23fe03a082 652 (((uint32_t)sDate->WeekDay) << 13));
mbed_official 573:ad23fe03a082 653 }
mbed_official 573:ad23fe03a082 654
mbed_official 573:ad23fe03a082 655 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 656 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 657
mbed_official 573:ad23fe03a082 658 /* Set Initialization mode */
mbed_official 573:ad23fe03a082 659 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 660 {
mbed_official 573:ad23fe03a082 661 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 662 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 663
mbed_official 573:ad23fe03a082 664 /* Set RTC state*/
mbed_official 573:ad23fe03a082 665 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 666
mbed_official 573:ad23fe03a082 667 /* Process Unlocked */
mbed_official 573:ad23fe03a082 668 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 669
mbed_official 573:ad23fe03a082 670 return HAL_ERROR;
mbed_official 573:ad23fe03a082 671 }
mbed_official 573:ad23fe03a082 672 else
mbed_official 573:ad23fe03a082 673 {
mbed_official 573:ad23fe03a082 674 /* Set the RTC_DR register */
mbed_official 573:ad23fe03a082 675 hrtc->Instance->DR = (uint32_t)(datetmpreg & RTC_DR_RESERVED_MASK);
mbed_official 573:ad23fe03a082 676
mbed_official 573:ad23fe03a082 677 /* Exit Initialization mode */
mbed_official 573:ad23fe03a082 678 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 573:ad23fe03a082 679
mbed_official 573:ad23fe03a082 680 /* If CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
mbed_official 573:ad23fe03a082 681 if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
mbed_official 573:ad23fe03a082 682 {
mbed_official 573:ad23fe03a082 683 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
mbed_official 573:ad23fe03a082 684 {
mbed_official 573:ad23fe03a082 685 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 686 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 687
mbed_official 573:ad23fe03a082 688 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 573:ad23fe03a082 689
mbed_official 573:ad23fe03a082 690 /* Process Unlocked */
mbed_official 573:ad23fe03a082 691 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 692
mbed_official 573:ad23fe03a082 693 return HAL_ERROR;
mbed_official 573:ad23fe03a082 694 }
mbed_official 573:ad23fe03a082 695 }
mbed_official 573:ad23fe03a082 696
mbed_official 573:ad23fe03a082 697 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 698 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 699
mbed_official 573:ad23fe03a082 700 hrtc->State = HAL_RTC_STATE_READY ;
mbed_official 573:ad23fe03a082 701
mbed_official 573:ad23fe03a082 702 /* Process Unlocked */
mbed_official 573:ad23fe03a082 703 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 704
mbed_official 573:ad23fe03a082 705 return HAL_OK;
mbed_official 573:ad23fe03a082 706 }
mbed_official 573:ad23fe03a082 707 }
mbed_official 573:ad23fe03a082 708
mbed_official 573:ad23fe03a082 709 /**
mbed_official 573:ad23fe03a082 710 * @brief Gets RTC current date.
mbed_official 573:ad23fe03a082 711 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 712 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 713 * @param sDate: Pointer to Date structure
mbed_official 573:ad23fe03a082 714 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 715 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 716 * @arg RTC_FORMAT_BIN: Binary data format
mbed_official 610:813dcc80987e 717 * @arg RTC_FORMAT_BCD: BCD data format
mbed_official 610:813dcc80987e 718 * @note You must call HAL_RTC_GetDate() after HAL_RTC_GetTime() to unlock the values
mbed_official 610:813dcc80987e 719 * in the higher-order calendar shadow registers to ensure consistency between the time and date values.
mbed_official 610:813dcc80987e 720 * Reading RTC current time locks the values in calendar shadow registers until Current date is read.
mbed_official 573:ad23fe03a082 721 * @retval HAL status
mbed_official 573:ad23fe03a082 722 */
mbed_official 573:ad23fe03a082 723 HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
mbed_official 573:ad23fe03a082 724 {
mbed_official 573:ad23fe03a082 725 uint32_t datetmpreg = 0;
mbed_official 573:ad23fe03a082 726
mbed_official 573:ad23fe03a082 727 /* Check the parameters */
mbed_official 573:ad23fe03a082 728 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 729
mbed_official 573:ad23fe03a082 730 /* Get the DR register */
mbed_official 573:ad23fe03a082 731 datetmpreg = (uint32_t)(hrtc->Instance->DR & RTC_DR_RESERVED_MASK);
mbed_official 573:ad23fe03a082 732
mbed_official 573:ad23fe03a082 733 /* Fill the structure fields with the read parameters */
mbed_official 573:ad23fe03a082 734 sDate->Year = (uint8_t)((datetmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16);
mbed_official 573:ad23fe03a082 735 sDate->Month = (uint8_t)((datetmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8);
mbed_official 573:ad23fe03a082 736 sDate->Date = (uint8_t)(datetmpreg & (RTC_DR_DT | RTC_DR_DU));
mbed_official 573:ad23fe03a082 737 sDate->WeekDay = (uint8_t)((datetmpreg & (RTC_DR_WDU)) >> 13);
mbed_official 573:ad23fe03a082 738
mbed_official 573:ad23fe03a082 739 /* Check the input parameters format */
mbed_official 573:ad23fe03a082 740 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 741 {
mbed_official 573:ad23fe03a082 742 /* Convert the date structure parameters to Binary format */
mbed_official 573:ad23fe03a082 743 sDate->Year = (uint8_t)RTC_Bcd2ToByte(sDate->Year);
mbed_official 573:ad23fe03a082 744 sDate->Month = (uint8_t)RTC_Bcd2ToByte(sDate->Month);
mbed_official 573:ad23fe03a082 745 sDate->Date = (uint8_t)RTC_Bcd2ToByte(sDate->Date);
mbed_official 573:ad23fe03a082 746 }
mbed_official 573:ad23fe03a082 747 return HAL_OK;
mbed_official 573:ad23fe03a082 748 }
mbed_official 573:ad23fe03a082 749
mbed_official 573:ad23fe03a082 750 /**
mbed_official 573:ad23fe03a082 751 * @}
mbed_official 573:ad23fe03a082 752 */
mbed_official 573:ad23fe03a082 753
mbed_official 573:ad23fe03a082 754 /** @defgroup RTC_Group3 RTC Alarm functions
mbed_official 573:ad23fe03a082 755 * @brief RTC Alarm functions
mbed_official 573:ad23fe03a082 756 *
mbed_official 573:ad23fe03a082 757 @verbatim
mbed_official 573:ad23fe03a082 758 ===============================================================================
mbed_official 573:ad23fe03a082 759 ##### RTC Alarm functions #####
mbed_official 573:ad23fe03a082 760 ===============================================================================
mbed_official 573:ad23fe03a082 761
mbed_official 573:ad23fe03a082 762 [..] This section provides functions allowing to configure Alarm feature
mbed_official 573:ad23fe03a082 763
mbed_official 573:ad23fe03a082 764 @endverbatim
mbed_official 573:ad23fe03a082 765 * @{
mbed_official 573:ad23fe03a082 766 */
mbed_official 573:ad23fe03a082 767 /**
mbed_official 573:ad23fe03a082 768 * @brief Sets the specified RTC Alarm.
mbed_official 573:ad23fe03a082 769 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 770 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 771 * @param sAlarm: Pointer to Alarm structure
mbed_official 573:ad23fe03a082 772 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 773 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 774 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 775 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 776 * @retval HAL status
mbed_official 573:ad23fe03a082 777 */
mbed_official 573:ad23fe03a082 778 HAL_StatusTypeDef HAL_RTC_SetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
mbed_official 573:ad23fe03a082 779 {
mbed_official 573:ad23fe03a082 780 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 781 uint32_t tmpreg = 0, subsecondtmpreg = 0;
mbed_official 573:ad23fe03a082 782
mbed_official 573:ad23fe03a082 783 /* Check the parameters */
mbed_official 573:ad23fe03a082 784 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 785 assert_param(IS_RTC_ALARM(sAlarm->Alarm));
mbed_official 573:ad23fe03a082 786 assert_param(IS_RTC_ALARM_MASK(sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 787 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
mbed_official 573:ad23fe03a082 788 assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
mbed_official 573:ad23fe03a082 789 assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 790
mbed_official 573:ad23fe03a082 791 /* Process Locked */
mbed_official 573:ad23fe03a082 792 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 793
mbed_official 573:ad23fe03a082 794 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 795
mbed_official 573:ad23fe03a082 796 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 797 {
mbed_official 573:ad23fe03a082 798 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 799 {
mbed_official 573:ad23fe03a082 800 assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 801 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 802 }
mbed_official 573:ad23fe03a082 803 else
mbed_official 573:ad23fe03a082 804 {
mbed_official 573:ad23fe03a082 805 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 806 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 807 }
mbed_official 573:ad23fe03a082 808 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
mbed_official 573:ad23fe03a082 809 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
mbed_official 573:ad23fe03a082 810
mbed_official 573:ad23fe03a082 811 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 812 {
mbed_official 573:ad23fe03a082 813 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 814 }
mbed_official 573:ad23fe03a082 815 else
mbed_official 573:ad23fe03a082 816 {
mbed_official 573:ad23fe03a082 817 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 818 }
mbed_official 573:ad23fe03a082 819
mbed_official 573:ad23fe03a082 820 tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 821 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 822 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
mbed_official 573:ad23fe03a082 823 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 824 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 825 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 826 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 827 }
mbed_official 573:ad23fe03a082 828 else
mbed_official 573:ad23fe03a082 829 {
mbed_official 573:ad23fe03a082 830 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 831 {
mbed_official 573:ad23fe03a082 832 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 573:ad23fe03a082 833 assert_param(IS_RTC_HOUR12(tmpreg));
mbed_official 573:ad23fe03a082 834 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 835 }
mbed_official 573:ad23fe03a082 836 else
mbed_official 573:ad23fe03a082 837 {
mbed_official 573:ad23fe03a082 838 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 839 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
mbed_official 573:ad23fe03a082 840 }
mbed_official 573:ad23fe03a082 841
mbed_official 573:ad23fe03a082 842 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
mbed_official 573:ad23fe03a082 843 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
mbed_official 573:ad23fe03a082 844
mbed_official 573:ad23fe03a082 845 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 846 {
mbed_official 573:ad23fe03a082 847 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 848 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
mbed_official 573:ad23fe03a082 849 }
mbed_official 573:ad23fe03a082 850 else
mbed_official 573:ad23fe03a082 851 {
mbed_official 573:ad23fe03a082 852 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 853 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
mbed_official 573:ad23fe03a082 854 }
mbed_official 573:ad23fe03a082 855
mbed_official 573:ad23fe03a082 856 tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 857 ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 858 ((uint32_t) sAlarm->AlarmTime.Seconds) | \
mbed_official 573:ad23fe03a082 859 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 860 ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 861 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 862 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 863 }
mbed_official 573:ad23fe03a082 864
mbed_official 573:ad23fe03a082 865 /* Configure the Alarm A or Alarm B Sub Second registers */
mbed_official 573:ad23fe03a082 866 subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 867
mbed_official 573:ad23fe03a082 868 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 869 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 870
mbed_official 573:ad23fe03a082 871 /* Configure the Alarm register */
mbed_official 573:ad23fe03a082 872 if(sAlarm->Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 873 {
mbed_official 573:ad23fe03a082 874 /* Disable the Alarm A interrupt */
mbed_official 573:ad23fe03a082 875 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 876
mbed_official 573:ad23fe03a082 877 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 878 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
mbed_official 573:ad23fe03a082 879
mbed_official 573:ad23fe03a082 880 /* Get tick */
mbed_official 573:ad23fe03a082 881 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 882
mbed_official 573:ad23fe03a082 883 /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 884 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 573:ad23fe03a082 885 {
mbed_official 573:ad23fe03a082 886 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 887 {
mbed_official 573:ad23fe03a082 888 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 889 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 890
mbed_official 573:ad23fe03a082 891 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 892
mbed_official 573:ad23fe03a082 893 /* Process Unlocked */
mbed_official 573:ad23fe03a082 894 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 895
mbed_official 573:ad23fe03a082 896 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 897 }
mbed_official 573:ad23fe03a082 898 }
mbed_official 573:ad23fe03a082 899
mbed_official 573:ad23fe03a082 900 hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 901 /* Configure the Alarm A Sub Second register */
mbed_official 573:ad23fe03a082 902 hrtc->Instance->ALRMASSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 903 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 904 __HAL_RTC_ALARMA_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 905 }
mbed_official 573:ad23fe03a082 906 else
mbed_official 573:ad23fe03a082 907 {
mbed_official 573:ad23fe03a082 908 /* Disable the Alarm B interrupt */
mbed_official 573:ad23fe03a082 909 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 910
mbed_official 573:ad23fe03a082 911 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 912 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRB);
mbed_official 573:ad23fe03a082 913
mbed_official 573:ad23fe03a082 914 /* Get tick */
mbed_official 573:ad23fe03a082 915 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 916
mbed_official 573:ad23fe03a082 917 /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 918 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 573:ad23fe03a082 919 {
mbed_official 573:ad23fe03a082 920 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 921 {
mbed_official 573:ad23fe03a082 922 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 923 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 924
mbed_official 573:ad23fe03a082 925 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 926
mbed_official 573:ad23fe03a082 927 /* Process Unlocked */
mbed_official 573:ad23fe03a082 928 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 929
mbed_official 573:ad23fe03a082 930 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 931 }
mbed_official 573:ad23fe03a082 932 }
mbed_official 573:ad23fe03a082 933
mbed_official 573:ad23fe03a082 934 hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 935 /* Configure the Alarm B Sub Second register */
mbed_official 573:ad23fe03a082 936 hrtc->Instance->ALRMBSSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 937 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 938 __HAL_RTC_ALARMB_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 939 }
mbed_official 573:ad23fe03a082 940
mbed_official 573:ad23fe03a082 941 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 942 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 943
mbed_official 573:ad23fe03a082 944 /* Change RTC state */
mbed_official 573:ad23fe03a082 945 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 946
mbed_official 573:ad23fe03a082 947 /* Process Unlocked */
mbed_official 573:ad23fe03a082 948 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 949
mbed_official 573:ad23fe03a082 950 return HAL_OK;
mbed_official 573:ad23fe03a082 951 }
mbed_official 573:ad23fe03a082 952
mbed_official 573:ad23fe03a082 953 /**
mbed_official 573:ad23fe03a082 954 * @brief Sets the specified RTC Alarm with Interrupt
mbed_official 573:ad23fe03a082 955 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 956 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 957 * @param sAlarm: Pointer to Alarm structure
mbed_official 573:ad23fe03a082 958 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 959 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 960 * @arg FORMAT_BIN: Binary data format
mbed_official 573:ad23fe03a082 961 * @arg FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 962 * @note The Alarm register can only be written when the corresponding Alarm
mbed_official 573:ad23fe03a082 963 * is disabled (Use the HAL_RTC_DeactivateAlarm()).
mbed_official 573:ad23fe03a082 964 * @note The HAL_RTC_SetTime() must be called before enabling the Alarm feature.
mbed_official 573:ad23fe03a082 965 * @retval HAL status
mbed_official 573:ad23fe03a082 966 */
mbed_official 573:ad23fe03a082 967 HAL_StatusTypeDef HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
mbed_official 573:ad23fe03a082 968 {
mbed_official 573:ad23fe03a082 969 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 970 uint32_t tmpreg = 0, subsecondtmpreg = 0;
mbed_official 573:ad23fe03a082 971
mbed_official 573:ad23fe03a082 972 /* Check the parameters */
mbed_official 573:ad23fe03a082 973 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 974 assert_param(IS_RTC_ALARM(sAlarm->Alarm));
mbed_official 573:ad23fe03a082 975 assert_param(IS_RTC_ALARM_MASK(sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 976 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
mbed_official 573:ad23fe03a082 977 assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
mbed_official 573:ad23fe03a082 978 assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 979
mbed_official 573:ad23fe03a082 980 /* Process Locked */
mbed_official 573:ad23fe03a082 981 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 982
mbed_official 573:ad23fe03a082 983 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 984
mbed_official 573:ad23fe03a082 985 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 986 {
mbed_official 573:ad23fe03a082 987 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 988 {
mbed_official 573:ad23fe03a082 989 assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 990 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 991 }
mbed_official 573:ad23fe03a082 992 else
mbed_official 573:ad23fe03a082 993 {
mbed_official 573:ad23fe03a082 994 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 995 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
mbed_official 573:ad23fe03a082 996 }
mbed_official 573:ad23fe03a082 997 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
mbed_official 573:ad23fe03a082 998 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
mbed_official 573:ad23fe03a082 999
mbed_official 573:ad23fe03a082 1000 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 1001 {
mbed_official 573:ad23fe03a082 1002 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 1003 }
mbed_official 573:ad23fe03a082 1004 else
mbed_official 573:ad23fe03a082 1005 {
mbed_official 573:ad23fe03a082 1006 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
mbed_official 573:ad23fe03a082 1007 }
mbed_official 573:ad23fe03a082 1008 tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 1009 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 1010 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
mbed_official 573:ad23fe03a082 1011 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 1012 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 1013 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 1014 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 1015 }
mbed_official 573:ad23fe03a082 1016 else
mbed_official 573:ad23fe03a082 1017 {
mbed_official 573:ad23fe03a082 1018 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1019 {
mbed_official 573:ad23fe03a082 1020 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 573:ad23fe03a082 1021 assert_param(IS_RTC_HOUR12(tmpreg));
mbed_official 573:ad23fe03a082 1022 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 573:ad23fe03a082 1023 }
mbed_official 573:ad23fe03a082 1024 else
mbed_official 573:ad23fe03a082 1025 {
mbed_official 573:ad23fe03a082 1026 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 573:ad23fe03a082 1027 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
mbed_official 573:ad23fe03a082 1028 }
mbed_official 573:ad23fe03a082 1029
mbed_official 573:ad23fe03a082 1030 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
mbed_official 573:ad23fe03a082 1031 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
mbed_official 573:ad23fe03a082 1032
mbed_official 573:ad23fe03a082 1033 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 573:ad23fe03a082 1034 {
mbed_official 573:ad23fe03a082 1035 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 1036 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
mbed_official 573:ad23fe03a082 1037 }
mbed_official 573:ad23fe03a082 1038 else
mbed_official 573:ad23fe03a082 1039 {
mbed_official 573:ad23fe03a082 1040 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 1041 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
mbed_official 573:ad23fe03a082 1042 }
mbed_official 573:ad23fe03a082 1043 tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 573:ad23fe03a082 1044 ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 573:ad23fe03a082 1045 ((uint32_t) sAlarm->AlarmTime.Seconds) | \
mbed_official 573:ad23fe03a082 1046 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 573:ad23fe03a082 1047 ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 573:ad23fe03a082 1048 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 573:ad23fe03a082 1049 ((uint32_t)sAlarm->AlarmMask));
mbed_official 573:ad23fe03a082 1050 }
mbed_official 573:ad23fe03a082 1051 /* Configure the Alarm A or Alarm B Sub Second registers */
mbed_official 573:ad23fe03a082 1052 subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
mbed_official 573:ad23fe03a082 1053
mbed_official 573:ad23fe03a082 1054 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1055 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1056
mbed_official 573:ad23fe03a082 1057 /* Configure the Alarm register */
mbed_official 573:ad23fe03a082 1058 if(sAlarm->Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 1059 {
mbed_official 573:ad23fe03a082 1060 /* Disable the Alarm A interrupt */
mbed_official 573:ad23fe03a082 1061 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1062
mbed_official 573:ad23fe03a082 1063 /* Clear flag alarm A */
mbed_official 573:ad23fe03a082 1064 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
mbed_official 573:ad23fe03a082 1065
mbed_official 573:ad23fe03a082 1066 /* Get tick */
mbed_official 573:ad23fe03a082 1067 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1068
mbed_official 573:ad23fe03a082 1069 /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1070 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 573:ad23fe03a082 1071 {
mbed_official 573:ad23fe03a082 1072 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1073 {
mbed_official 573:ad23fe03a082 1074 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1075 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1076
mbed_official 573:ad23fe03a082 1077 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1078
mbed_official 573:ad23fe03a082 1079 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1080 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1081
mbed_official 573:ad23fe03a082 1082 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1083 }
mbed_official 573:ad23fe03a082 1084 }
mbed_official 573:ad23fe03a082 1085
mbed_official 573:ad23fe03a082 1086 hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 1087 /* Configure the Alarm A Sub Second register */
mbed_official 573:ad23fe03a082 1088 hrtc->Instance->ALRMASSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 1089 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 1090 __HAL_RTC_ALARMA_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1091 /* Configure the Alarm interrupt */
mbed_official 573:ad23fe03a082 1092 __HAL_RTC_ALARM_ENABLE_IT(hrtc,RTC_IT_ALRA);
mbed_official 573:ad23fe03a082 1093 }
mbed_official 573:ad23fe03a082 1094 else
mbed_official 573:ad23fe03a082 1095 {
mbed_official 573:ad23fe03a082 1096 /* Disable the Alarm B interrupt */
mbed_official 573:ad23fe03a082 1097 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1098
mbed_official 573:ad23fe03a082 1099 /* Clear flag alarm B */
mbed_official 573:ad23fe03a082 1100 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRBF);
mbed_official 573:ad23fe03a082 1101
mbed_official 573:ad23fe03a082 1102 /* Get tick */
mbed_official 573:ad23fe03a082 1103 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1104
mbed_official 573:ad23fe03a082 1105 /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1106 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 573:ad23fe03a082 1107 {
mbed_official 573:ad23fe03a082 1108 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1109 {
mbed_official 573:ad23fe03a082 1110 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1111 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1112
mbed_official 573:ad23fe03a082 1113 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1114
mbed_official 573:ad23fe03a082 1115 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1116 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1117
mbed_official 573:ad23fe03a082 1118 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1119 }
mbed_official 573:ad23fe03a082 1120 }
mbed_official 573:ad23fe03a082 1121
mbed_official 573:ad23fe03a082 1122 hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
mbed_official 573:ad23fe03a082 1123 /* Configure the Alarm B Sub Second register */
mbed_official 573:ad23fe03a082 1124 hrtc->Instance->ALRMBSSR = subsecondtmpreg;
mbed_official 573:ad23fe03a082 1125 /* Configure the Alarm state: Enable Alarm */
mbed_official 573:ad23fe03a082 1126 __HAL_RTC_ALARMB_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1127 /* Configure the Alarm interrupt */
mbed_official 573:ad23fe03a082 1128 __HAL_RTC_ALARM_ENABLE_IT(hrtc, RTC_IT_ALRB);
mbed_official 573:ad23fe03a082 1129 }
mbed_official 573:ad23fe03a082 1130
mbed_official 573:ad23fe03a082 1131 /* RTC Alarm Interrupt Configuration: EXTI configuration */
mbed_official 573:ad23fe03a082 1132 __HAL_RTC_ALARM_EXTI_ENABLE_IT();
mbed_official 573:ad23fe03a082 1133
mbed_official 573:ad23fe03a082 1134 EXTI->RTSR |= RTC_EXTI_LINE_ALARM_EVENT;
mbed_official 573:ad23fe03a082 1135
mbed_official 573:ad23fe03a082 1136 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1137 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1138
mbed_official 573:ad23fe03a082 1139 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1140
mbed_official 573:ad23fe03a082 1141 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1142 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1143
mbed_official 573:ad23fe03a082 1144 return HAL_OK;
mbed_official 573:ad23fe03a082 1145 }
mbed_official 573:ad23fe03a082 1146
mbed_official 573:ad23fe03a082 1147 /**
mbed_official 573:ad23fe03a082 1148 * @brief Deactive the specified RTC Alarm
mbed_official 573:ad23fe03a082 1149 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1150 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1151 * @param Alarm: Specifies the Alarm.
mbed_official 573:ad23fe03a082 1152 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 1153 * @arg RTC_ALARM_A: AlarmA
mbed_official 573:ad23fe03a082 1154 * @arg RTC_ALARM_B: AlarmB
mbed_official 573:ad23fe03a082 1155 * @retval HAL status
mbed_official 573:ad23fe03a082 1156 */
mbed_official 573:ad23fe03a082 1157 HAL_StatusTypeDef HAL_RTC_DeactivateAlarm(RTC_HandleTypeDef *hrtc, uint32_t Alarm)
mbed_official 573:ad23fe03a082 1158 {
mbed_official 573:ad23fe03a082 1159 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1160
mbed_official 573:ad23fe03a082 1161 /* Check the parameters */
mbed_official 573:ad23fe03a082 1162 assert_param(IS_RTC_ALARM(Alarm));
mbed_official 573:ad23fe03a082 1163
mbed_official 573:ad23fe03a082 1164 /* Process Locked */
mbed_official 573:ad23fe03a082 1165 __HAL_LOCK(hrtc);
mbed_official 573:ad23fe03a082 1166
mbed_official 573:ad23fe03a082 1167 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 573:ad23fe03a082 1168
mbed_official 573:ad23fe03a082 1169 /* Disable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1170 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1171
mbed_official 573:ad23fe03a082 1172 if(Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 1173 {
mbed_official 573:ad23fe03a082 1174 /* AlarmA */
mbed_official 573:ad23fe03a082 1175 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1176
mbed_official 573:ad23fe03a082 1177 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 1178 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
mbed_official 573:ad23fe03a082 1179
mbed_official 573:ad23fe03a082 1180 /* Get tick */
mbed_official 573:ad23fe03a082 1181 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1182
mbed_official 573:ad23fe03a082 1183 /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1184 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 573:ad23fe03a082 1185 {
mbed_official 573:ad23fe03a082 1186 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1187 {
mbed_official 573:ad23fe03a082 1188 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1189 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1190
mbed_official 573:ad23fe03a082 1191 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1192
mbed_official 573:ad23fe03a082 1193 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1194 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1195
mbed_official 573:ad23fe03a082 1196 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1197 }
mbed_official 573:ad23fe03a082 1198 }
mbed_official 573:ad23fe03a082 1199 }
mbed_official 573:ad23fe03a082 1200 else
mbed_official 573:ad23fe03a082 1201 {
mbed_official 573:ad23fe03a082 1202 /* AlarmB */
mbed_official 573:ad23fe03a082 1203 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 573:ad23fe03a082 1204
mbed_official 573:ad23fe03a082 1205 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 573:ad23fe03a082 1206 __HAL_RTC_ALARM_DISABLE_IT(hrtc,RTC_IT_ALRB);
mbed_official 573:ad23fe03a082 1207
mbed_official 573:ad23fe03a082 1208 /* Get tick */
mbed_official 573:ad23fe03a082 1209 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1210
mbed_official 573:ad23fe03a082 1211 /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1212 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 573:ad23fe03a082 1213 {
mbed_official 573:ad23fe03a082 1214 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1215 {
mbed_official 573:ad23fe03a082 1216 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1217 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1218
mbed_official 573:ad23fe03a082 1219 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1220
mbed_official 573:ad23fe03a082 1221 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1222 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1223
mbed_official 573:ad23fe03a082 1224 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1225 }
mbed_official 573:ad23fe03a082 1226 }
mbed_official 573:ad23fe03a082 1227 }
mbed_official 573:ad23fe03a082 1228 /* Enable the write protection for RTC registers */
mbed_official 573:ad23fe03a082 1229 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 573:ad23fe03a082 1230
mbed_official 573:ad23fe03a082 1231 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1232
mbed_official 573:ad23fe03a082 1233 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1234 __HAL_UNLOCK(hrtc);
mbed_official 573:ad23fe03a082 1235
mbed_official 573:ad23fe03a082 1236 return HAL_OK;
mbed_official 573:ad23fe03a082 1237 }
mbed_official 573:ad23fe03a082 1238
mbed_official 573:ad23fe03a082 1239 /**
mbed_official 573:ad23fe03a082 1240 * @brief Gets the RTC Alarm value and masks.
mbed_official 573:ad23fe03a082 1241 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1242 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1243 * @param sAlarm: Pointer to Date structure
mbed_official 573:ad23fe03a082 1244 * @param Alarm: Specifies the Alarm.
mbed_official 573:ad23fe03a082 1245 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 1246 * @arg RTC_ALARM_A: AlarmA
mbed_official 573:ad23fe03a082 1247 * @arg RTC_ALARM_B: AlarmB
mbed_official 573:ad23fe03a082 1248 * @param Format: Specifies the format of the entered parameters.
mbed_official 573:ad23fe03a082 1249 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 1250 * @arg RTC_FORMAT_BIN: Binary data format
mbed_official 610:813dcc80987e 1251 * @arg RTC_FORMAT_BCD: BCD data format
mbed_official 573:ad23fe03a082 1252 * @retval HAL status
mbed_official 573:ad23fe03a082 1253 */
mbed_official 573:ad23fe03a082 1254 HAL_StatusTypeDef HAL_RTC_GetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Alarm, uint32_t Format)
mbed_official 573:ad23fe03a082 1255 {
mbed_official 573:ad23fe03a082 1256 uint32_t tmpreg = 0, subsecondtmpreg = 0;
mbed_official 573:ad23fe03a082 1257
mbed_official 573:ad23fe03a082 1258 /* Check the parameters */
mbed_official 573:ad23fe03a082 1259 assert_param(IS_RTC_FORMAT(Format));
mbed_official 573:ad23fe03a082 1260 assert_param(IS_RTC_ALARM(Alarm));
mbed_official 573:ad23fe03a082 1261
mbed_official 573:ad23fe03a082 1262 if(Alarm == RTC_ALARM_A)
mbed_official 573:ad23fe03a082 1263 {
mbed_official 573:ad23fe03a082 1264 /* AlarmA */
mbed_official 573:ad23fe03a082 1265 sAlarm->Alarm = RTC_ALARM_A;
mbed_official 573:ad23fe03a082 1266
mbed_official 573:ad23fe03a082 1267 tmpreg = (uint32_t)(hrtc->Instance->ALRMAR);
mbed_official 573:ad23fe03a082 1268 subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMASSR ) & RTC_ALRMASSR_SS);
mbed_official 573:ad23fe03a082 1269 }
mbed_official 573:ad23fe03a082 1270 else
mbed_official 573:ad23fe03a082 1271 {
mbed_official 573:ad23fe03a082 1272 sAlarm->Alarm = RTC_ALARM_B;
mbed_official 573:ad23fe03a082 1273
mbed_official 573:ad23fe03a082 1274 tmpreg = (uint32_t)(hrtc->Instance->ALRMBR);
mbed_official 573:ad23fe03a082 1275 subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMBSSR) & RTC_ALRMBSSR_SS);
mbed_official 573:ad23fe03a082 1276 }
mbed_official 573:ad23fe03a082 1277
mbed_official 573:ad23fe03a082 1278 /* Fill the structure with the read parameters */
mbed_official 573:ad23fe03a082 1279 sAlarm->AlarmTime.Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | RTC_ALRMAR_HU)) >> 16);
mbed_official 573:ad23fe03a082 1280 sAlarm->AlarmTime.Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | RTC_ALRMAR_MNU)) >> 8);
mbed_official 573:ad23fe03a082 1281 sAlarm->AlarmTime.Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | RTC_ALRMAR_SU));
mbed_official 573:ad23fe03a082 1282 sAlarm->AlarmTime.TimeFormat = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16);
mbed_official 573:ad23fe03a082 1283 sAlarm->AlarmTime.SubSeconds = (uint32_t) subsecondtmpreg;
mbed_official 573:ad23fe03a082 1284 sAlarm->AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24);
mbed_official 573:ad23fe03a082 1285 sAlarm->AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL);
mbed_official 573:ad23fe03a082 1286 sAlarm->AlarmMask = (uint32_t)(tmpreg & RTC_ALARMMASK_ALL);
mbed_official 573:ad23fe03a082 1287
mbed_official 573:ad23fe03a082 1288 if(Format == RTC_FORMAT_BIN)
mbed_official 573:ad23fe03a082 1289 {
mbed_official 573:ad23fe03a082 1290 sAlarm->AlarmTime.Hours = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 573:ad23fe03a082 1291 sAlarm->AlarmTime.Minutes = RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes);
mbed_official 573:ad23fe03a082 1292 sAlarm->AlarmTime.Seconds = RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds);
mbed_official 573:ad23fe03a082 1293 sAlarm->AlarmDateWeekDay = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 573:ad23fe03a082 1294 }
mbed_official 573:ad23fe03a082 1295
mbed_official 573:ad23fe03a082 1296 return HAL_OK;
mbed_official 573:ad23fe03a082 1297 }
mbed_official 573:ad23fe03a082 1298
mbed_official 573:ad23fe03a082 1299 /**
mbed_official 573:ad23fe03a082 1300 * @brief This function handles Alarm interrupt request.
mbed_official 573:ad23fe03a082 1301 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1302 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1303 * @retval None
mbed_official 573:ad23fe03a082 1304 */
mbed_official 573:ad23fe03a082 1305 void HAL_RTC_AlarmIRQHandler(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1306 {
mbed_official 573:ad23fe03a082 1307 if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRA))
mbed_official 573:ad23fe03a082 1308 {
mbed_official 573:ad23fe03a082 1309 /* Get the status of the Interrupt */
mbed_official 573:ad23fe03a082 1310 if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRA) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1311 {
mbed_official 573:ad23fe03a082 1312 /* AlarmA callback */
mbed_official 573:ad23fe03a082 1313 HAL_RTC_AlarmAEventCallback(hrtc);
mbed_official 573:ad23fe03a082 1314
mbed_official 573:ad23fe03a082 1315 /* Clear the Alarm interrupt pending bit */
mbed_official 573:ad23fe03a082 1316 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRAF);
mbed_official 573:ad23fe03a082 1317 }
mbed_official 573:ad23fe03a082 1318 }
mbed_official 573:ad23fe03a082 1319
mbed_official 573:ad23fe03a082 1320 if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRB))
mbed_official 573:ad23fe03a082 1321 {
mbed_official 573:ad23fe03a082 1322 /* Get the status of the Interrupt */
mbed_official 573:ad23fe03a082 1323 if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRB) != (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1324 {
mbed_official 573:ad23fe03a082 1325 /* AlarmB callback */
mbed_official 573:ad23fe03a082 1326 HAL_RTCEx_AlarmBEventCallback(hrtc);
mbed_official 573:ad23fe03a082 1327
mbed_official 573:ad23fe03a082 1328 /* Clear the Alarm interrupt pending bit */
mbed_official 573:ad23fe03a082 1329 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRBF);
mbed_official 573:ad23fe03a082 1330 }
mbed_official 573:ad23fe03a082 1331 }
mbed_official 573:ad23fe03a082 1332
mbed_official 573:ad23fe03a082 1333 /* Clear the EXTI's line Flag for RTC Alarm */
mbed_official 573:ad23fe03a082 1334 __HAL_RTC_ALARM_EXTI_CLEAR_FLAG();
mbed_official 573:ad23fe03a082 1335
mbed_official 573:ad23fe03a082 1336 /* Change RTC state */
mbed_official 573:ad23fe03a082 1337 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1338 }
mbed_official 573:ad23fe03a082 1339
mbed_official 573:ad23fe03a082 1340 /**
mbed_official 573:ad23fe03a082 1341 * @brief Alarm A callback.
mbed_official 573:ad23fe03a082 1342 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1343 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1344 * @retval None
mbed_official 573:ad23fe03a082 1345 */
mbed_official 573:ad23fe03a082 1346 __weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 573:ad23fe03a082 1347 {
mbed_official 573:ad23fe03a082 1348 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1349 the HAL_RTC_AlarmAEventCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 1350 */
mbed_official 573:ad23fe03a082 1351 }
mbed_official 573:ad23fe03a082 1352
mbed_official 573:ad23fe03a082 1353 /**
mbed_official 573:ad23fe03a082 1354 * @brief This function handles AlarmA Polling request.
mbed_official 573:ad23fe03a082 1355 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1356 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1357 * @param Timeout: Timeout duration
mbed_official 573:ad23fe03a082 1358 * @retval HAL status
mbed_official 573:ad23fe03a082 1359 */
mbed_official 573:ad23fe03a082 1360 HAL_StatusTypeDef HAL_RTC_PollForAlarmAEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 573:ad23fe03a082 1361 {
mbed_official 573:ad23fe03a082 1362 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1363
mbed_official 573:ad23fe03a082 1364 /* Get tick */
mbed_official 573:ad23fe03a082 1365 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1366
mbed_official 573:ad23fe03a082 1367 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) == RESET)
mbed_official 573:ad23fe03a082 1368 {
mbed_official 573:ad23fe03a082 1369 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 1370 {
mbed_official 573:ad23fe03a082 1371 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 573:ad23fe03a082 1372 {
mbed_official 573:ad23fe03a082 1373 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1374 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1375 }
mbed_official 573:ad23fe03a082 1376 }
mbed_official 573:ad23fe03a082 1377 }
mbed_official 573:ad23fe03a082 1378
mbed_official 573:ad23fe03a082 1379 /* Clear the Alarm interrupt pending bit */
mbed_official 573:ad23fe03a082 1380 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
mbed_official 573:ad23fe03a082 1381
mbed_official 573:ad23fe03a082 1382 /* Change RTC state */
mbed_official 573:ad23fe03a082 1383 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 573:ad23fe03a082 1384
mbed_official 573:ad23fe03a082 1385 return HAL_OK;
mbed_official 573:ad23fe03a082 1386 }
mbed_official 573:ad23fe03a082 1387
mbed_official 573:ad23fe03a082 1388 /**
mbed_official 573:ad23fe03a082 1389 * @}
mbed_official 573:ad23fe03a082 1390 */
mbed_official 573:ad23fe03a082 1391
mbed_official 573:ad23fe03a082 1392 /** @defgroup RTC_Group4 Peripheral Control functions
mbed_official 573:ad23fe03a082 1393 * @brief Peripheral Control functions
mbed_official 573:ad23fe03a082 1394 *
mbed_official 573:ad23fe03a082 1395 @verbatim
mbed_official 573:ad23fe03a082 1396 ===============================================================================
mbed_official 573:ad23fe03a082 1397 ##### Peripheral Control functions #####
mbed_official 573:ad23fe03a082 1398 ===============================================================================
mbed_official 573:ad23fe03a082 1399 [..]
mbed_official 573:ad23fe03a082 1400 This subsection provides functions allowing to
mbed_official 573:ad23fe03a082 1401 (+) Wait for RTC Time and Date Synchronization
mbed_official 573:ad23fe03a082 1402
mbed_official 573:ad23fe03a082 1403 @endverbatim
mbed_official 573:ad23fe03a082 1404 * @{
mbed_official 573:ad23fe03a082 1405 */
mbed_official 573:ad23fe03a082 1406
mbed_official 573:ad23fe03a082 1407 /**
mbed_official 573:ad23fe03a082 1408 * @brief Waits until the RTC Time and Date registers (RTC_TR and RTC_DR) are
mbed_official 573:ad23fe03a082 1409 * synchronized with RTC APB clock.
mbed_official 573:ad23fe03a082 1410 * @note The RTC Resynchronization mode is write protected, use the
mbed_official 573:ad23fe03a082 1411 * __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function.
mbed_official 573:ad23fe03a082 1412 * @note To read the calendar through the shadow registers after Calendar
mbed_official 573:ad23fe03a082 1413 * initialization, calendar update or after wakeup from low power modes
mbed_official 573:ad23fe03a082 1414 * the software must first clear the RSF flag.
mbed_official 573:ad23fe03a082 1415 * The software must then wait until it is set again before reading
mbed_official 573:ad23fe03a082 1416 * the calendar, which means that the calendar registers have been
mbed_official 573:ad23fe03a082 1417 * correctly copied into the RTC_TR and RTC_DR shadow registers.
mbed_official 573:ad23fe03a082 1418 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1419 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1420 * @retval HAL status
mbed_official 573:ad23fe03a082 1421 */
mbed_official 573:ad23fe03a082 1422 HAL_StatusTypeDef HAL_RTC_WaitForSynchro(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1423 {
mbed_official 573:ad23fe03a082 1424 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1425
mbed_official 573:ad23fe03a082 1426 /* Clear RSF flag */
mbed_official 573:ad23fe03a082 1427 hrtc->Instance->ISR &= (uint32_t)RTC_RSF_MASK;
mbed_official 573:ad23fe03a082 1428
mbed_official 573:ad23fe03a082 1429 /* Get tick */
mbed_official 573:ad23fe03a082 1430 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1431
mbed_official 573:ad23fe03a082 1432 /* Wait the registers to be synchronised */
mbed_official 573:ad23fe03a082 1433 while((hrtc->Instance->ISR & RTC_ISR_RSF) == (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1434 {
mbed_official 573:ad23fe03a082 1435 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1436 {
mbed_official 573:ad23fe03a082 1437 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1438 }
mbed_official 573:ad23fe03a082 1439 }
mbed_official 573:ad23fe03a082 1440
mbed_official 573:ad23fe03a082 1441 return HAL_OK;
mbed_official 573:ad23fe03a082 1442 }
mbed_official 573:ad23fe03a082 1443
mbed_official 573:ad23fe03a082 1444 /**
mbed_official 573:ad23fe03a082 1445 * @}
mbed_official 573:ad23fe03a082 1446 */
mbed_official 573:ad23fe03a082 1447
mbed_official 573:ad23fe03a082 1448 /** @defgroup RTC_Group5 Peripheral State functions
mbed_official 573:ad23fe03a082 1449 * @brief Peripheral State functions
mbed_official 573:ad23fe03a082 1450 *
mbed_official 573:ad23fe03a082 1451 @verbatim
mbed_official 573:ad23fe03a082 1452 ===============================================================================
mbed_official 573:ad23fe03a082 1453 ##### Peripheral State functions #####
mbed_official 573:ad23fe03a082 1454 ===============================================================================
mbed_official 573:ad23fe03a082 1455 [..]
mbed_official 573:ad23fe03a082 1456 This subsection provides functions allowing to
mbed_official 573:ad23fe03a082 1457 (+) Get RTC state
mbed_official 573:ad23fe03a082 1458
mbed_official 573:ad23fe03a082 1459 @endverbatim
mbed_official 573:ad23fe03a082 1460 * @{
mbed_official 573:ad23fe03a082 1461 */
mbed_official 573:ad23fe03a082 1462 /**
mbed_official 573:ad23fe03a082 1463 * @brief Returns the RTC state.
mbed_official 573:ad23fe03a082 1464 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1465 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1466 * @retval HAL state
mbed_official 573:ad23fe03a082 1467 */
mbed_official 573:ad23fe03a082 1468 HAL_RTCStateTypeDef HAL_RTC_GetState(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1469 {
mbed_official 573:ad23fe03a082 1470 return hrtc->State;
mbed_official 573:ad23fe03a082 1471 }
mbed_official 573:ad23fe03a082 1472
mbed_official 573:ad23fe03a082 1473 /**
mbed_official 573:ad23fe03a082 1474 * @}
mbed_official 573:ad23fe03a082 1475 */
mbed_official 573:ad23fe03a082 1476
mbed_official 573:ad23fe03a082 1477 /**
mbed_official 573:ad23fe03a082 1478 * @brief Enters the RTC Initialization mode.
mbed_official 573:ad23fe03a082 1479 * @note The RTC Initialization mode is write protected, use the
mbed_official 573:ad23fe03a082 1480 * __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function.
mbed_official 573:ad23fe03a082 1481 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1482 * the configuration information for RTC.
mbed_official 573:ad23fe03a082 1483 * @retval HAL status
mbed_official 573:ad23fe03a082 1484 */
mbed_official 573:ad23fe03a082 1485 HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc)
mbed_official 573:ad23fe03a082 1486 {
mbed_official 573:ad23fe03a082 1487 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 1488
mbed_official 573:ad23fe03a082 1489 /* Check if the Initialization mode is set */
mbed_official 573:ad23fe03a082 1490 if((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1491 {
mbed_official 573:ad23fe03a082 1492 /* Set the Initialization mode */
mbed_official 573:ad23fe03a082 1493 hrtc->Instance->ISR = (uint32_t)RTC_INIT_MASK;
mbed_official 573:ad23fe03a082 1494
mbed_official 573:ad23fe03a082 1495 /* Get tick */
mbed_official 573:ad23fe03a082 1496 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1497
mbed_official 573:ad23fe03a082 1498 /* Wait till RTC is in INIT state and if Time out is reached exit */
mbed_official 573:ad23fe03a082 1499 while((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
mbed_official 573:ad23fe03a082 1500 {
mbed_official 573:ad23fe03a082 1501 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 573:ad23fe03a082 1502 {
mbed_official 573:ad23fe03a082 1503 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1504 }
mbed_official 573:ad23fe03a082 1505 }
mbed_official 573:ad23fe03a082 1506 }
mbed_official 573:ad23fe03a082 1507
mbed_official 573:ad23fe03a082 1508 return HAL_OK;
mbed_official 573:ad23fe03a082 1509 }
mbed_official 573:ad23fe03a082 1510
mbed_official 573:ad23fe03a082 1511
mbed_official 573:ad23fe03a082 1512 /**
mbed_official 573:ad23fe03a082 1513 * @brief Converts a 2 digit decimal to BCD format.
mbed_official 573:ad23fe03a082 1514 * @param Value: Byte to be converted
mbed_official 573:ad23fe03a082 1515 * @retval Converted byte
mbed_official 573:ad23fe03a082 1516 */
mbed_official 573:ad23fe03a082 1517 uint8_t RTC_ByteToBcd2(uint8_t Value)
mbed_official 573:ad23fe03a082 1518 {
mbed_official 573:ad23fe03a082 1519 uint32_t bcdhigh = 0;
mbed_official 573:ad23fe03a082 1520
mbed_official 573:ad23fe03a082 1521 while(Value >= 10)
mbed_official 573:ad23fe03a082 1522 {
mbed_official 573:ad23fe03a082 1523 bcdhigh++;
mbed_official 573:ad23fe03a082 1524 Value -= 10;
mbed_official 573:ad23fe03a082 1525 }
mbed_official 573:ad23fe03a082 1526
mbed_official 573:ad23fe03a082 1527 return ((uint8_t)(bcdhigh << 4) | Value);
mbed_official 573:ad23fe03a082 1528 }
mbed_official 573:ad23fe03a082 1529
mbed_official 573:ad23fe03a082 1530 /**
mbed_official 573:ad23fe03a082 1531 * @brief Converts from 2 digit BCD to Binary.
mbed_official 573:ad23fe03a082 1532 * @param Value: BCD value to be converted
mbed_official 573:ad23fe03a082 1533 * @retval Converted word
mbed_official 573:ad23fe03a082 1534 */
mbed_official 573:ad23fe03a082 1535 uint8_t RTC_Bcd2ToByte(uint8_t Value)
mbed_official 573:ad23fe03a082 1536 {
mbed_official 573:ad23fe03a082 1537 uint32_t tmp = 0;
mbed_official 573:ad23fe03a082 1538 tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10;
mbed_official 573:ad23fe03a082 1539 return (tmp + (Value & (uint8_t)0x0F));
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
mbed_official 573:ad23fe03a082 1546 #endif /* HAL_RTC_MODULE_ENABLED */
mbed_official 573:ad23fe03a082 1547 /**
mbed_official 573:ad23fe03a082 1548 * @}
mbed_official 573:ad23fe03a082 1549 */
mbed_official 573:ad23fe03a082 1550
mbed_official 573:ad23fe03a082 1551 /**
mbed_official 573:ad23fe03a082 1552 * @}
mbed_official 573:ad23fe03a082 1553 */
mbed_official 573:ad23fe03a082 1554
mbed_official 573:ad23fe03a082 1555 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/