shao ziyang / mbed-src-kl05

mbed library sources

Dependents:   frdm_kl05z_gpio_test

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L053R8/stm32l0xx_hal_rtc.c@323:9e901b0a5aa1, 2014-09-13 (annotated)

Committer:
shaoziyang
Date:
Sat Sep 13 14:25:46 2014 +0000
Revision:
323:9e901b0a5aa1
Parent:
181:a4cbdfbbd2f4 
test with CLOCK_SETUP = 0

Who changed what in which revision?

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