mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_rtc.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Parent:
573:ad23fe03a082 
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

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****/