Fawwaz Nadzmy / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-dev by mbed official

targets/TARGET_STM/TARGET_STM32F1/device/stm32f1xx_hal_rtc.c@153:da99e106a1c2, 2016-12-21 (annotated)

Committer:
fwndz
Date:
Wed Dec 21 13:29:33 2016 +0000
Revision:
153:da99e106a1c2
Parent:
149:156823d33999 
init

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f1xx_hal_rtc.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @version V1.0.4
<> 144:ef7eb2e8f9f7 6 * @date 29-April-2016
<> 144:ef7eb2e8f9f7 7 * @brief RTC HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 9 * functionalities of the Real Time Clock (RTC) peripheral:
<> 144:ef7eb2e8f9f7 10 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 11 * + RTC Time and Date functions
<> 144:ef7eb2e8f9f7 12 * + RTC Alarm functions
<> 144:ef7eb2e8f9f7 13 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 14 * + Peripheral State functions
<> 144:ef7eb2e8f9f7 15 *
<> 144:ef7eb2e8f9f7 16 @verbatim
<> 144:ef7eb2e8f9f7 17 ==============================================================================
<> 144:ef7eb2e8f9f7 18 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 19 ==================================================================
<> 144:ef7eb2e8f9f7 20 [..]
<> 144:ef7eb2e8f9f7 21 (+) Enable the RTC domain access (see description in the section above).
<> 144:ef7eb2e8f9f7 22 (+) Configure the RTC Prescaler (Asynchronous prescaler to generate RTC 1Hz time base)
<> 144:ef7eb2e8f9f7 23 using the HAL_RTC_Init() function.
<> 144:ef7eb2e8f9f7 24
<> 144:ef7eb2e8f9f7 25 *** Time and Date configuration ***
<> 144:ef7eb2e8f9f7 26 ===================================
<> 144:ef7eb2e8f9f7 27 [..]
<> 144:ef7eb2e8f9f7 28 (+) To configure the RTC Calendar (Time and Date) use the HAL_RTC_SetTime()
<> 144:ef7eb2e8f9f7 29 and HAL_RTC_SetDate() functions.
<> 144:ef7eb2e8f9f7 30 (+) To read the RTC Calendar, use the HAL_RTC_GetTime() and HAL_RTC_GetDate() functions.
<> 144:ef7eb2e8f9f7 31
<> 144:ef7eb2e8f9f7 32 *** Alarm configuration ***
<> 144:ef7eb2e8f9f7 33 ===========================
<> 144:ef7eb2e8f9f7 34 [..]
<> 144:ef7eb2e8f9f7 35 (+) To configure the RTC Alarm use the HAL_RTC_SetAlarm() function.
<> 144:ef7eb2e8f9f7 36 You can also configure the RTC Alarm with interrupt mode using the HAL_RTC_SetAlarm_IT() function.
<> 144:ef7eb2e8f9f7 37 (+) To read the RTC Alarm, use the HAL_RTC_GetAlarm() function.
<> 144:ef7eb2e8f9f7 38
<> 144:ef7eb2e8f9f7 39 *** Tamper configuration ***
<> 144:ef7eb2e8f9f7 40 ============================
<> 144:ef7eb2e8f9f7 41 [..]
<> 144:ef7eb2e8f9f7 42 (+) Enable the RTC Tamper and configure the Tamper Level using the
<> 144:ef7eb2e8f9f7 43 HAL_RTCEx_SetTamper() function. You can configure RTC Tamper with interrupt
<> 144:ef7eb2e8f9f7 44 mode using HAL_RTCEx_SetTamper_IT() function.
<> 144:ef7eb2e8f9f7 45 (+) The TAMPER1 alternate function can be mapped to PC13
<> 144:ef7eb2e8f9f7 46
<> 144:ef7eb2e8f9f7 47 *** Backup Data Registers configuration ***
<> 144:ef7eb2e8f9f7 48 ===========================================
<> 144:ef7eb2e8f9f7 49 [..]
<> 144:ef7eb2e8f9f7 50 (+) To write to the RTC Backup Data registers, use the HAL_RTCEx_BKUPWrite()
<> 144:ef7eb2e8f9f7 51 function.
<> 144:ef7eb2e8f9f7 52 (+) To read the RTC Backup Data registers, use the HAL_RTCEx_BKUPRead()
<> 144:ef7eb2e8f9f7 53 function.
<> 144:ef7eb2e8f9f7 54
<> 144:ef7eb2e8f9f7 55 ##### WARNING: Drivers Restrictions #####
<> 144:ef7eb2e8f9f7 56 ==================================================================
<> 144:ef7eb2e8f9f7 57 [..] RTC version used on STM32F1 families is version V1. All the features supported by V2
<> 144:ef7eb2e8f9f7 58 (other families) will be not supported on F1.
<> 144:ef7eb2e8f9f7 59 [..] As on V2, main RTC features are managed by HW. But on F1, date feature is completely
<> 144:ef7eb2e8f9f7 60 managed by SW.
<> 144:ef7eb2e8f9f7 61 [..] Then, there are some restrictions compared to other families:
<> 144:ef7eb2e8f9f7 62 (+) Only format 24 hours supported in HAL (format 12 hours not supported)
<> 144:ef7eb2e8f9f7 63 (+) Date is saved in SRAM. Then, when MCU is in STOP or STANDBY mode, date will be lost.
<> 144:ef7eb2e8f9f7 64 User should implement a way to save date before entering in low power mode (an
<> 144:ef7eb2e8f9f7 65 example is provided with firmware package based on backup registers)
<> 144:ef7eb2e8f9f7 66 (+) Date is automatically updated each time a HAL_RTC_GetTime or HAL_RTC_GetDate is called.
<> 144:ef7eb2e8f9f7 67 (+) Alarm detection is limited to 1 day. It will expire only 1 time (no alarm repetition, need
<> 144:ef7eb2e8f9f7 68 to program a new alarm)
<> 144:ef7eb2e8f9f7 69
<> 144:ef7eb2e8f9f7 70 ##### Backup Domain Operating Condition #####
<> 144:ef7eb2e8f9f7 71 ==============================================================================
<> 144:ef7eb2e8f9f7 72 [..] The real-time clock (RTC) and the RTC backup registers can be powered
<> 144:ef7eb2e8f9f7 73 from the VBAT voltage when the main VDD supply is powered off.
<> 144:ef7eb2e8f9f7 74 To retain the content of the RTC backup registers and supply the RTC
<> 144:ef7eb2e8f9f7 75 when VDD is turned off, VBAT pin can be connected to an optional
<> 144:ef7eb2e8f9f7 76 standby voltage supplied by a battery or by another source.
<> 144:ef7eb2e8f9f7 77
<> 144:ef7eb2e8f9f7 78 [..] To allow the RTC operating even when the main digital supply (VDD) is turned
<> 144:ef7eb2e8f9f7 79 off, the VBAT pin powers the following blocks:
<> 144:ef7eb2e8f9f7 80 (+) The RTC
<> 144:ef7eb2e8f9f7 81 (+) The LSE oscillator
<> 144:ef7eb2e8f9f7 82 (+) PC13 I/O
<> 144:ef7eb2e8f9f7 83
<> 144:ef7eb2e8f9f7 84 [..] When the backup domain is supplied by VDD (analog switch connected to VDD),
<> 144:ef7eb2e8f9f7 85 the following pins are available:
<> 144:ef7eb2e8f9f7 86 (+) PC13 can be used as a Tamper pin
<> 144:ef7eb2e8f9f7 87
<> 144:ef7eb2e8f9f7 88 [..] When the backup domain is supplied by VBAT (analog switch connected to VBAT
<> 144:ef7eb2e8f9f7 89 because VDD is not present), the following pins are available:
<> 144:ef7eb2e8f9f7 90 (+) PC13 can be used as the Tamper pin
<> 144:ef7eb2e8f9f7 91
<> 144:ef7eb2e8f9f7 92 ##### Backup Domain Reset #####
<> 144:ef7eb2e8f9f7 93 ==================================================================
<> 144:ef7eb2e8f9f7 94 [..] The backup domain reset sets all RTC registers and the RCC_BDCR register
<> 144:ef7eb2e8f9f7 95 to their reset values.
<> 144:ef7eb2e8f9f7 96 [..] A backup domain reset is generated when one of the following events occurs:
<> 144:ef7eb2e8f9f7 97 (#) Software reset, triggered by setting the BDRST bit in the
<> 144:ef7eb2e8f9f7 98 RCC Backup domain control register (RCC_BDCR).
<> 144:ef7eb2e8f9f7 99 (#) VDD or VBAT power on, if both supplies have previously been powered off.
<> 144:ef7eb2e8f9f7 100 (#) Tamper detection event resets all data backup registers.
<> 144:ef7eb2e8f9f7 101
<> 144:ef7eb2e8f9f7 102 ##### Backup Domain Access #####
<> 144:ef7eb2e8f9f7 103 ==================================================================
<> 144:ef7eb2e8f9f7 104 [..] After reset, the backup domain (RTC registers, RTC backup data
<> 144:ef7eb2e8f9f7 105 registers and backup SRAM) is protected against possible unwanted write
<> 144:ef7eb2e8f9f7 106 accesses.
<> 144:ef7eb2e8f9f7 107 [..] To enable access to the RTC Domain and RTC registers, proceed as follows:
<> 144:ef7eb2e8f9f7 108 (+) Call the function HAL_RCCEx_PeriphCLKConfig in using RCC_PERIPHCLK_RTC for
<> 144:ef7eb2e8f9f7 109 PeriphClockSelection and select RTCClockSelection (LSE, LSI or HSE)
<> 144:ef7eb2e8f9f7 110 (+) Enable the BKP clock in using __HAL_RCC_BKP_CLK_ENABLE()
<> 144:ef7eb2e8f9f7 111
<> 144:ef7eb2e8f9f7 112 ##### RTC and low power modes #####
<> 144:ef7eb2e8f9f7 113 ==================================================================
<> 144:ef7eb2e8f9f7 114 [..] The MCU can be woken up from a low power mode by an RTC alternate
<> 144:ef7eb2e8f9f7 115 function.
<> 144:ef7eb2e8f9f7 116 [..] The RTC alternate functions are the RTC alarms (Alarm A),
<> 144:ef7eb2e8f9f7 117 and RTC tamper event detection.
<> 144:ef7eb2e8f9f7 118 These RTC alternate functions can wake up the system from the Stop and
<> 144:ef7eb2e8f9f7 119 Standby low power modes.
<> 144:ef7eb2e8f9f7 120 [..] The system can also wake up from low power modes without depending
<> 144:ef7eb2e8f9f7 121 on an external interrupt (Auto-wakeup mode), by using the RTC alarm.
<> 144:ef7eb2e8f9f7 122
<> 144:ef7eb2e8f9f7 123 @endverbatim
<> 144:ef7eb2e8f9f7 124 ******************************************************************************
<> 144:ef7eb2e8f9f7 125 * @attention
<> 144:ef7eb2e8f9f7 126 *
<> 144:ef7eb2e8f9f7 127 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 128 *
<> 144:ef7eb2e8f9f7 129 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 130 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 131 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 132 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 133 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 134 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 135 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 136 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 137 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 138 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 139 *
<> 144:ef7eb2e8f9f7 140 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 141 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 142 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 143 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 144 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 145 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 146 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 147 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 148 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 149 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 150 *
<> 144:ef7eb2e8f9f7 151 ******************************************************************************
<> 144:ef7eb2e8f9f7 152 */
<> 144:ef7eb2e8f9f7 153
<> 144:ef7eb2e8f9f7 154 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 155 #include "stm32f1xx_hal.h"
<> 144:ef7eb2e8f9f7 156
<> 144:ef7eb2e8f9f7 157 /** @addtogroup STM32F1xx_HAL_Driver
<> 144:ef7eb2e8f9f7 158 * @{
<> 144:ef7eb2e8f9f7 159 */
<> 144:ef7eb2e8f9f7 160
<> 144:ef7eb2e8f9f7 161 /** @defgroup RTC RTC
<> 144:ef7eb2e8f9f7 162 * @brief RTC HAL module driver
<> 144:ef7eb2e8f9f7 163 * @{
<> 144:ef7eb2e8f9f7 164 */
<> 144:ef7eb2e8f9f7 165
<> 144:ef7eb2e8f9f7 166 #ifdef HAL_RTC_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 167
<> 144:ef7eb2e8f9f7 168 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 169 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 170 /** @defgroup RTC_Private_Constants RTC Private Constants
<> 144:ef7eb2e8f9f7 171 * @{
<> 144:ef7eb2e8f9f7 172 */
<> 144:ef7eb2e8f9f7 173 #define RTC_ALARM_RESETVALUE_REGISTER (uint16_t)0xFFFF
<> 144:ef7eb2e8f9f7 174 #define RTC_ALARM_RESETVALUE (uint32_t)0xFFFFFFFF
<> 144:ef7eb2e8f9f7 175
<> 144:ef7eb2e8f9f7 176 /**
<> 144:ef7eb2e8f9f7 177 * @}
<> 144:ef7eb2e8f9f7 178 */
<> 144:ef7eb2e8f9f7 179
<> 144:ef7eb2e8f9f7 180 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 181 /** @defgroup RTC_Private_Macros RTC Private Macros
<> 144:ef7eb2e8f9f7 182 * @{
<> 144:ef7eb2e8f9f7 183 */
<> 144:ef7eb2e8f9f7 184 /**
<> 144:ef7eb2e8f9f7 185 * @}
<> 144:ef7eb2e8f9f7 186 */
<> 144:ef7eb2e8f9f7 187
<> 144:ef7eb2e8f9f7 188 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 189 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 190 /** @defgroup RTC_Private_Functions RTC Private Functions
<> 144:ef7eb2e8f9f7 191 * @{
<> 144:ef7eb2e8f9f7 192 */
<> 144:ef7eb2e8f9f7 193 static uint32_t RTC_ReadTimeCounter(RTC_HandleTypeDef* hrtc);
<> 144:ef7eb2e8f9f7 194 static HAL_StatusTypeDef RTC_WriteTimeCounter(RTC_HandleTypeDef* hrtc, uint32_t TimeCounter);
<> 144:ef7eb2e8f9f7 195 static uint32_t RTC_ReadAlarmCounter(RTC_HandleTypeDef* hrtc);
<> 144:ef7eb2e8f9f7 196 static HAL_StatusTypeDef RTC_WriteAlarmCounter(RTC_HandleTypeDef* hrtc, uint32_t AlarmCounter);
<> 144:ef7eb2e8f9f7 197 static HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc);
<> 144:ef7eb2e8f9f7 198 static HAL_StatusTypeDef RTC_ExitInitMode(RTC_HandleTypeDef* hrtc);
<> 144:ef7eb2e8f9f7 199 static uint8_t RTC_ByteToBcd2(uint8_t Value);
<> 144:ef7eb2e8f9f7 200 static uint8_t RTC_Bcd2ToByte(uint8_t Value);
<> 144:ef7eb2e8f9f7 201 static uint8_t RTC_IsLeapYear(uint16_t nYear);
<> 144:ef7eb2e8f9f7 202 static void RTC_DateUpdate(RTC_HandleTypeDef* hrtc, uint32_t DayElapsed);
<> 144:ef7eb2e8f9f7 203 static uint8_t RTC_WeekDayNum(uint32_t nYear, uint8_t nMonth, uint8_t nDay);
<> 144:ef7eb2e8f9f7 204
<> 144:ef7eb2e8f9f7 205 /**
<> 144:ef7eb2e8f9f7 206 * @}
<> 144:ef7eb2e8f9f7 207 */
<> 144:ef7eb2e8f9f7 208
<> 144:ef7eb2e8f9f7 209 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 210 /** @defgroup RTC_Exported_Functions RTC Exported Functions
<> 144:ef7eb2e8f9f7 211 * @{
<> 144:ef7eb2e8f9f7 212 */
<> 144:ef7eb2e8f9f7 213
<> 144:ef7eb2e8f9f7 214 /** @defgroup RTC_Exported_Functions_Group1 Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 215 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 216 *
<> 144:ef7eb2e8f9f7 217 @verbatim
<> 144:ef7eb2e8f9f7 218 ===============================================================================
<> 144:ef7eb2e8f9f7 219 ##### Initialization and de-initialization functions #####
<> 144:ef7eb2e8f9f7 220 ===============================================================================
<> 144:ef7eb2e8f9f7 221 [..] This section provides functions allowing to initialize and configure the
<> 144:ef7eb2e8f9f7 222 RTC Prescaler (Asynchronous), disable RTC registers Write protection,
<> 144:ef7eb2e8f9f7 223 enter and exit the RTC initialization mode,
<> 144:ef7eb2e8f9f7 224 RTC registers synchronization check and reference clock detection enable.
<> 144:ef7eb2e8f9f7 225 (#) The RTC Prescaler should be programmed to generate the RTC 1Hz time base.
<> 144:ef7eb2e8f9f7 226 (#) All RTC registers are Write protected. Writing to the RTC registers
<> 144:ef7eb2e8f9f7 227 is enabled by setting the CNF bit in the RTC_CRL register.
<> 144:ef7eb2e8f9f7 228 (#) To read the calendar after wakeup from low power modes (Standby or Stop)
<> 144:ef7eb2e8f9f7 229 the software must first wait for the RSF bit (Register Synchronized Flag)
<> 144:ef7eb2e8f9f7 230 in the RTC_CRL register to be set by hardware.
<> 144:ef7eb2e8f9f7 231 The HAL_RTC_WaitForSynchro() function implements the above software
<> 144:ef7eb2e8f9f7 232 sequence (RSF clear and RSF check).
<> 144:ef7eb2e8f9f7 233
<> 144:ef7eb2e8f9f7 234 @endverbatim
<> 144:ef7eb2e8f9f7 235 * @{
<> 144:ef7eb2e8f9f7 236 */
<> 144:ef7eb2e8f9f7 237
<> 144:ef7eb2e8f9f7 238 /**
<> 144:ef7eb2e8f9f7 239 * @brief Initializes the RTC peripheral
<> 144:ef7eb2e8f9f7 240 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 241 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 242 * @retval HAL status
<> 144:ef7eb2e8f9f7 243 */
<> 144:ef7eb2e8f9f7 244 HAL_StatusTypeDef HAL_RTC_Init(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 245 {
<> 144:ef7eb2e8f9f7 246 uint32_t prescaler = 0;
<> 144:ef7eb2e8f9f7 247 /* Check input parameters */
<> 144:ef7eb2e8f9f7 248 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 249 {
<> 144:ef7eb2e8f9f7 250 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 251 }
<> 144:ef7eb2e8f9f7 252
<> 144:ef7eb2e8f9f7 253 /* Check the parameters */
<> 144:ef7eb2e8f9f7 254 assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
<> 144:ef7eb2e8f9f7 255 assert_param(IS_RTC_CALIB_OUTPUT(hrtc->Init.OutPut));
<> 144:ef7eb2e8f9f7 256 assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv));
<> 144:ef7eb2e8f9f7 257
<> 144:ef7eb2e8f9f7 258 if(hrtc->State == HAL_RTC_STATE_RESET)
<> 144:ef7eb2e8f9f7 259 {
<> 144:ef7eb2e8f9f7 260 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 261 hrtc->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 262
<> 144:ef7eb2e8f9f7 263 /* Initialize RTC MSP */
<> 144:ef7eb2e8f9f7 264 HAL_RTC_MspInit(hrtc);
<> 144:ef7eb2e8f9f7 265 }
<> 144:ef7eb2e8f9f7 266
<> 144:ef7eb2e8f9f7 267 /* Set RTC state */
<> 144:ef7eb2e8f9f7 268 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 269
<> 144:ef7eb2e8f9f7 270 /* Waiting for synchro */
<> 144:ef7eb2e8f9f7 271 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 272 {
<> 144:ef7eb2e8f9f7 273 /* Set RTC state */
<> 144:ef7eb2e8f9f7 274 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 275
<> 144:ef7eb2e8f9f7 276 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 277 }
<> 144:ef7eb2e8f9f7 278
<> 144:ef7eb2e8f9f7 279 /* Set Initialization mode */
<> 144:ef7eb2e8f9f7 280 if(RTC_EnterInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 281 {
<> 144:ef7eb2e8f9f7 282 /* Set RTC state */
<> 144:ef7eb2e8f9f7 283 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 284
<> 144:ef7eb2e8f9f7 285 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 286 }
<> 144:ef7eb2e8f9f7 287 else
<> 144:ef7eb2e8f9f7 288 {
<> 144:ef7eb2e8f9f7 289 /* Clear Flags Bits */
<> 144:ef7eb2e8f9f7 290 CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_OW | RTC_FLAG_ALRAF | RTC_FLAG_SEC));
<> 144:ef7eb2e8f9f7 291
<> 144:ef7eb2e8f9f7 292 if(hrtc->Init.OutPut != RTC_OUTPUTSOURCE_NONE)
<> 144:ef7eb2e8f9f7 293 {
<> 144:ef7eb2e8f9f7 294 /* Disable the selected Tamper pin */
<> 144:ef7eb2e8f9f7 295 CLEAR_BIT(BKP->CR, BKP_CR_TPE);
<> 144:ef7eb2e8f9f7 296 }
<> 144:ef7eb2e8f9f7 297
<> 144:ef7eb2e8f9f7 298 /* Set the signal which will be routed to RTC Tamper pin*/
<> 144:ef7eb2e8f9f7 299 MODIFY_REG(BKP->RTCCR, (BKP_RTCCR_CCO | BKP_RTCCR_ASOE | BKP_RTCCR_ASOS), hrtc->Init.OutPut);
<> 144:ef7eb2e8f9f7 300
<> 144:ef7eb2e8f9f7 301 if (hrtc->Init.AsynchPrediv != RTC_AUTO_1_SECOND)
<> 144:ef7eb2e8f9f7 302 {
<> 144:ef7eb2e8f9f7 303 /* RTC Prescaler provided directly by end-user*/
<> 144:ef7eb2e8f9f7 304 prescaler = hrtc->Init.AsynchPrediv;
<> 144:ef7eb2e8f9f7 305 }
<> 144:ef7eb2e8f9f7 306 else
<> 144:ef7eb2e8f9f7 307 {
<> 144:ef7eb2e8f9f7 308 /* RTC Prescaler will be automatically calculated to get 1 second timebase */
<> 144:ef7eb2e8f9f7 309 /* Get the RTCCLK frequency */
<> 144:ef7eb2e8f9f7 310 prescaler = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_RTC);
<> 144:ef7eb2e8f9f7 311
<> 144:ef7eb2e8f9f7 312 /* Check that RTC clock is enabled*/
<> 144:ef7eb2e8f9f7 313 if (prescaler == 0)
<> 144:ef7eb2e8f9f7 314 {
<> 144:ef7eb2e8f9f7 315 /* Should not happen. Frequency is not available*/
<> 144:ef7eb2e8f9f7 316 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 317 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 318 }
<> 144:ef7eb2e8f9f7 319 else
<> 144:ef7eb2e8f9f7 320 {
<> 144:ef7eb2e8f9f7 321 /* RTC period = RTCCLK/(RTC_PR + 1) */
<> 144:ef7eb2e8f9f7 322 prescaler = prescaler - 1;
<> 144:ef7eb2e8f9f7 323 }
<> 144:ef7eb2e8f9f7 324 }
<> 144:ef7eb2e8f9f7 325
<> 144:ef7eb2e8f9f7 326 /* Configure the RTC_PRLH / RTC_PRLL */
<> 144:ef7eb2e8f9f7 327 MODIFY_REG(hrtc->Instance->PRLH, RTC_PRLH_PRL, (prescaler >> 16));
<> 144:ef7eb2e8f9f7 328 MODIFY_REG(hrtc->Instance->PRLL, RTC_PRLL_PRL, (prescaler & RTC_PRLL_PRL));
<> 144:ef7eb2e8f9f7 329
<> 144:ef7eb2e8f9f7 330 /* Wait for synchro */
<> 144:ef7eb2e8f9f7 331 if(RTC_ExitInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 332 {
<> 144:ef7eb2e8f9f7 333 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 334
<> 144:ef7eb2e8f9f7 335 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 336 }
<> 144:ef7eb2e8f9f7 337
<> 144:ef7eb2e8f9f7 338 /* Initialize date to 1st of January 2000 */
<> 144:ef7eb2e8f9f7 339 hrtc->DateToUpdate.Year = 0x00;
<> 144:ef7eb2e8f9f7 340 hrtc->DateToUpdate.Month = RTC_MONTH_JANUARY;
<> 144:ef7eb2e8f9f7 341 hrtc->DateToUpdate.Date = 0x01;
<> 144:ef7eb2e8f9f7 342
<> 144:ef7eb2e8f9f7 343 /* Set RTC state */
<> 144:ef7eb2e8f9f7 344 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 345
<> 144:ef7eb2e8f9f7 346 return HAL_OK;
<> 144:ef7eb2e8f9f7 347 }
<> 144:ef7eb2e8f9f7 348 }
<> 144:ef7eb2e8f9f7 349
<> 144:ef7eb2e8f9f7 350 /**
<> 144:ef7eb2e8f9f7 351 * @brief DeInitializes the RTC peripheral
<> 144:ef7eb2e8f9f7 352 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 353 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 354 * @note This function does not reset the RTC Backup Data registers.
<> 144:ef7eb2e8f9f7 355 * @retval HAL status
<> 144:ef7eb2e8f9f7 356 */
<> 144:ef7eb2e8f9f7 357 HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 358 {
<> 144:ef7eb2e8f9f7 359 /* Check input parameters */
<> 144:ef7eb2e8f9f7 360 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 361 {
<> 144:ef7eb2e8f9f7 362 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 363 }
<> 144:ef7eb2e8f9f7 364
<> 144:ef7eb2e8f9f7 365 /* Check the parameters */
<> 144:ef7eb2e8f9f7 366 assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
<> 144:ef7eb2e8f9f7 367
<> 144:ef7eb2e8f9f7 368 /* Set RTC state */
<> 144:ef7eb2e8f9f7 369 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 370
<> 144:ef7eb2e8f9f7 371 /* Set Initialization mode */
<> 144:ef7eb2e8f9f7 372 if(RTC_EnterInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 373 {
<> 144:ef7eb2e8f9f7 374 /* Set RTC state */
<> 144:ef7eb2e8f9f7 375 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 376
<> 144:ef7eb2e8f9f7 377 /* Release Lock */
<> 144:ef7eb2e8f9f7 378 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 379
<> 144:ef7eb2e8f9f7 380 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 381 }
<> 144:ef7eb2e8f9f7 382 else
<> 144:ef7eb2e8f9f7 383 {
<> 144:ef7eb2e8f9f7 384 CLEAR_REG(hrtc->Instance->CNTL);
<> 144:ef7eb2e8f9f7 385 CLEAR_REG(hrtc->Instance->CNTH);
<> 144:ef7eb2e8f9f7 386 WRITE_REG(hrtc->Instance->PRLL, 0x00008000);
<> 144:ef7eb2e8f9f7 387 CLEAR_REG(hrtc->Instance->PRLH);
<> 144:ef7eb2e8f9f7 388
<> 144:ef7eb2e8f9f7 389 /* Reset All CRH/CRL bits */
<> 144:ef7eb2e8f9f7 390 CLEAR_REG(hrtc->Instance->CRH);
<> 144:ef7eb2e8f9f7 391 CLEAR_REG(hrtc->Instance->CRL);
<> 144:ef7eb2e8f9f7 392
<> 144:ef7eb2e8f9f7 393 if(RTC_ExitInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 394 {
<> 144:ef7eb2e8f9f7 395 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 396
<> 144:ef7eb2e8f9f7 397 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 398 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 399
<> 144:ef7eb2e8f9f7 400 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 401 }
<> 144:ef7eb2e8f9f7 402 }
<> 144:ef7eb2e8f9f7 403
<> 144:ef7eb2e8f9f7 404 /* Wait for synchro*/
<> 144:ef7eb2e8f9f7 405 HAL_RTC_WaitForSynchro(hrtc);
<> 144:ef7eb2e8f9f7 406
<> 144:ef7eb2e8f9f7 407 /* Clear RSF flag */
<> 144:ef7eb2e8f9f7 408 CLEAR_BIT(hrtc->Instance->CRL, RTC_FLAG_RSF);
<> 144:ef7eb2e8f9f7 409
<> 144:ef7eb2e8f9f7 410 /* De-Initialize RTC MSP */
<> 144:ef7eb2e8f9f7 411 HAL_RTC_MspDeInit(hrtc);
<> 144:ef7eb2e8f9f7 412
<> 144:ef7eb2e8f9f7 413 hrtc->State = HAL_RTC_STATE_RESET;
<> 144:ef7eb2e8f9f7 414
<> 144:ef7eb2e8f9f7 415 /* Release Lock */
<> 144:ef7eb2e8f9f7 416 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 417
<> 144:ef7eb2e8f9f7 418 return HAL_OK;
<> 144:ef7eb2e8f9f7 419 }
<> 144:ef7eb2e8f9f7 420
<> 144:ef7eb2e8f9f7 421 /**
<> 144:ef7eb2e8f9f7 422 * @brief Initializes the RTC MSP.
<> 144:ef7eb2e8f9f7 423 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 424 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 425 * @retval None
<> 144:ef7eb2e8f9f7 426 */
<> 144:ef7eb2e8f9f7 427 __weak void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 428 {
<> 144:ef7eb2e8f9f7 429 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 430 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 431 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 432 the HAL_RTC_MspInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 433 */
<> 144:ef7eb2e8f9f7 434 }
<> 144:ef7eb2e8f9f7 435
<> 144:ef7eb2e8f9f7 436 /**
<> 144:ef7eb2e8f9f7 437 * @brief DeInitializes the RTC MSP.
<> 144:ef7eb2e8f9f7 438 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 439 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 440 * @retval None
<> 144:ef7eb2e8f9f7 441 */
<> 144:ef7eb2e8f9f7 442 __weak void HAL_RTC_MspDeInit(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 443 {
<> 144:ef7eb2e8f9f7 444 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 445 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 446 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 447 the HAL_RTC_MspDeInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 448 */
<> 144:ef7eb2e8f9f7 449 }
<> 144:ef7eb2e8f9f7 450
<> 144:ef7eb2e8f9f7 451 /**
<> 144:ef7eb2e8f9f7 452 * @}
<> 144:ef7eb2e8f9f7 453 */
<> 144:ef7eb2e8f9f7 454
<> 144:ef7eb2e8f9f7 455 /** @defgroup RTC_Exported_Functions_Group2 Time and Date functions
<> 144:ef7eb2e8f9f7 456 * @brief RTC Time and Date functions
<> 144:ef7eb2e8f9f7 457 *
<> 144:ef7eb2e8f9f7 458 @verbatim
<> 144:ef7eb2e8f9f7 459 ===============================================================================
<> 144:ef7eb2e8f9f7 460 ##### RTC Time and Date functions #####
<> 144:ef7eb2e8f9f7 461 ===============================================================================
<> 144:ef7eb2e8f9f7 462
<> 144:ef7eb2e8f9f7 463 [..] This section provides functions allowing to configure Time and Date features
<> 144:ef7eb2e8f9f7 464
<> 144:ef7eb2e8f9f7 465 @endverbatim
<> 144:ef7eb2e8f9f7 466 * @{
<> 144:ef7eb2e8f9f7 467 */
<> 144:ef7eb2e8f9f7 468
<> 144:ef7eb2e8f9f7 469 /**
<> 144:ef7eb2e8f9f7 470 * @brief Sets RTC current time.
<> 144:ef7eb2e8f9f7 471 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 472 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 473 * @param sTime: Pointer to Time structure
<> 144:ef7eb2e8f9f7 474 * @param Format: Specifies the format of the entered parameters.
<> 144:ef7eb2e8f9f7 475 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 476 * @arg RTC_FORMAT_BIN: Binary data format
<> 144:ef7eb2e8f9f7 477 * @arg RTC_FORMAT_BCD: BCD data format
<> 144:ef7eb2e8f9f7 478 * @retval HAL status
<> 144:ef7eb2e8f9f7 479 */
<> 144:ef7eb2e8f9f7 480 HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
<> 144:ef7eb2e8f9f7 481 {
<> 144:ef7eb2e8f9f7 482 uint32_t counter_time = 0, counter_alarm = 0;
<> 144:ef7eb2e8f9f7 483
<> 144:ef7eb2e8f9f7 484 /* Check input parameters */
<> 144:ef7eb2e8f9f7 485 if((hrtc == NULL) || (sTime == NULL))
<> 144:ef7eb2e8f9f7 486 {
<> 144:ef7eb2e8f9f7 487 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 488 }
<> 144:ef7eb2e8f9f7 489
<> 144:ef7eb2e8f9f7 490 /* Check the parameters */
<> 144:ef7eb2e8f9f7 491 assert_param(IS_RTC_FORMAT(Format));
<> 144:ef7eb2e8f9f7 492
<> 144:ef7eb2e8f9f7 493 /* Process Locked */
<> 144:ef7eb2e8f9f7 494 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 497
<> 144:ef7eb2e8f9f7 498 if(Format == RTC_FORMAT_BIN)
<> 144:ef7eb2e8f9f7 499 {
<> 144:ef7eb2e8f9f7 500 assert_param(IS_RTC_HOUR24(sTime->Hours));
<> 144:ef7eb2e8f9f7 501 assert_param(IS_RTC_MINUTES(sTime->Minutes));
<> 144:ef7eb2e8f9f7 502 assert_param(IS_RTC_SECONDS(sTime->Seconds));
<> 144:ef7eb2e8f9f7 503
<> 144:ef7eb2e8f9f7 504 counter_time = (uint32_t)(((uint32_t)sTime->Hours * 3600) + \
<> 144:ef7eb2e8f9f7 505 ((uint32_t)sTime->Minutes * 60) + \
<> 144:ef7eb2e8f9f7 506 ((uint32_t)sTime->Seconds));
<> 144:ef7eb2e8f9f7 507 }
<> 144:ef7eb2e8f9f7 508 else
<> 144:ef7eb2e8f9f7 509 {
<> 144:ef7eb2e8f9f7 510 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours)));
<> 144:ef7eb2e8f9f7 511 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes)));
<> 144:ef7eb2e8f9f7 512 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds)));
<> 144:ef7eb2e8f9f7 513
<> 144:ef7eb2e8f9f7 514 counter_time = (((uint32_t)(RTC_Bcd2ToByte(sTime->Hours)) * 3600) + \
<> 144:ef7eb2e8f9f7 515 ((uint32_t)(RTC_Bcd2ToByte(sTime->Minutes)) * 60) + \
<> 144:ef7eb2e8f9f7 516 ((uint32_t)(RTC_Bcd2ToByte(sTime->Seconds))));
<> 144:ef7eb2e8f9f7 517 }
<> 144:ef7eb2e8f9f7 518
<> 144:ef7eb2e8f9f7 519 /* Write time counter in RTC registers */
<> 144:ef7eb2e8f9f7 520 if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
<> 144:ef7eb2e8f9f7 521 {
<> 144:ef7eb2e8f9f7 522 /* Set RTC state */
<> 144:ef7eb2e8f9f7 523 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 524
<> 144:ef7eb2e8f9f7 525 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 526 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 527
<> 144:ef7eb2e8f9f7 528 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 529 }
<> 144:ef7eb2e8f9f7 530 else
<> 144:ef7eb2e8f9f7 531 {
<> 144:ef7eb2e8f9f7 532 /* Clear Second and overflow flags */
<> 144:ef7eb2e8f9f7 533 CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_SEC | RTC_FLAG_OW));
<> 144:ef7eb2e8f9f7 534
<> 144:ef7eb2e8f9f7 535 /* Read current Alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 536 counter_alarm = RTC_ReadAlarmCounter(hrtc);
<> 144:ef7eb2e8f9f7 537
<> 144:ef7eb2e8f9f7 538 /* Set again alarm to match with new time if enabled */
<> 144:ef7eb2e8f9f7 539 if (counter_alarm != RTC_ALARM_RESETVALUE)
<> 144:ef7eb2e8f9f7 540 {
<> 144:ef7eb2e8f9f7 541 if(counter_alarm < counter_time)
<> 144:ef7eb2e8f9f7 542 {
<> 144:ef7eb2e8f9f7 543 /* Add 1 day to alarm counter*/
<> 144:ef7eb2e8f9f7 544 counter_alarm += (uint32_t)(24 * 3600);
<> 144:ef7eb2e8f9f7 545
<> 144:ef7eb2e8f9f7 546 /* Write new Alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 547 if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<> 144:ef7eb2e8f9f7 548 {
<> 144:ef7eb2e8f9f7 549 /* Set RTC state */
<> 144:ef7eb2e8f9f7 550 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 551
<> 144:ef7eb2e8f9f7 552 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 553 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 554
<> 144:ef7eb2e8f9f7 555 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 556 }
<> 144:ef7eb2e8f9f7 557 }
<> 144:ef7eb2e8f9f7 558 }
<> 144:ef7eb2e8f9f7 559
<> 144:ef7eb2e8f9f7 560 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 561
<> 144:ef7eb2e8f9f7 562 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 563
<> 144:ef7eb2e8f9f7 564 return HAL_OK;
<> 144:ef7eb2e8f9f7 565 }
<> 144:ef7eb2e8f9f7 566 }
<> 144:ef7eb2e8f9f7 567
<> 144:ef7eb2e8f9f7 568 /**
<> 144:ef7eb2e8f9f7 569 * @brief Gets RTC current time.
<> 144:ef7eb2e8f9f7 570 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 571 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 572 * @param sTime: Pointer to Time structure
<> 144:ef7eb2e8f9f7 573 * @param Format: Specifies the format of the entered parameters.
<> 144:ef7eb2e8f9f7 574 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 575 * @arg RTC_FORMAT_BIN: Binary data format
<> 144:ef7eb2e8f9f7 576 * @arg RTC_FORMAT_BCD: BCD data format
<> 144:ef7eb2e8f9f7 577 * @retval HAL status
<> 144:ef7eb2e8f9f7 578 */
<> 144:ef7eb2e8f9f7 579 HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
<> 144:ef7eb2e8f9f7 580 {
<> 144:ef7eb2e8f9f7 581 uint32_t counter_time = 0, counter_alarm = 0, days_elapsed = 0, hours = 0;
<> 144:ef7eb2e8f9f7 582
<> 144:ef7eb2e8f9f7 583 /* Check input parameters */
<> 144:ef7eb2e8f9f7 584 if((hrtc == NULL) || (sTime == NULL))
<> 144:ef7eb2e8f9f7 585 {
<> 144:ef7eb2e8f9f7 586 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 587 }
<> 144:ef7eb2e8f9f7 588
<> 144:ef7eb2e8f9f7 589 /* Check the parameters */
<> 144:ef7eb2e8f9f7 590 assert_param(IS_RTC_FORMAT(Format));
<> 144:ef7eb2e8f9f7 591
<> 144:ef7eb2e8f9f7 592 /* Check if counter overflow occurred */
<> 144:ef7eb2e8f9f7 593 if (__HAL_RTC_OVERFLOW_GET_FLAG(hrtc, RTC_FLAG_OW))
<> 144:ef7eb2e8f9f7 594 {
<> 144:ef7eb2e8f9f7 595 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 596 }
<> 144:ef7eb2e8f9f7 597
<> 144:ef7eb2e8f9f7 598 /* Read the time counter*/
<> 144:ef7eb2e8f9f7 599 counter_time = RTC_ReadTimeCounter(hrtc);
<> 144:ef7eb2e8f9f7 600
<> 144:ef7eb2e8f9f7 601 /* Fill the structure fields with the read parameters */
<> 144:ef7eb2e8f9f7 602 hours = counter_time / 3600;
<> 144:ef7eb2e8f9f7 603 sTime->Minutes = (uint8_t)((counter_time % 3600) / 60);
<> 144:ef7eb2e8f9f7 604 sTime->Seconds = (uint8_t)((counter_time % 3600) % 60);
<> 144:ef7eb2e8f9f7 605
<> 144:ef7eb2e8f9f7 606 if (hours >= 24)
<> 144:ef7eb2e8f9f7 607 {
<> 144:ef7eb2e8f9f7 608 /* Get number of days elapsed from last calculation */
<> 144:ef7eb2e8f9f7 609 days_elapsed = (hours / 24);
<> 144:ef7eb2e8f9f7 610
<> 144:ef7eb2e8f9f7 611 /* Set Hours in RTC_TimeTypeDef structure*/
<> 144:ef7eb2e8f9f7 612 sTime->Hours = (hours % 24);
<> 144:ef7eb2e8f9f7 613
<> 144:ef7eb2e8f9f7 614 /* Read Alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 615 counter_alarm = RTC_ReadAlarmCounter(hrtc);
<> 144:ef7eb2e8f9f7 616
<> 144:ef7eb2e8f9f7 617 /* Calculate remaining time to reach alarm (only if set and not yet expired)*/
<> 144:ef7eb2e8f9f7 618 if ((counter_alarm != RTC_ALARM_RESETVALUE) && (counter_alarm > counter_time))
<> 144:ef7eb2e8f9f7 619 {
<> 144:ef7eb2e8f9f7 620 counter_alarm -= counter_time;
<> 144:ef7eb2e8f9f7 621 }
<> 144:ef7eb2e8f9f7 622 else
<> 144:ef7eb2e8f9f7 623 {
<> 144:ef7eb2e8f9f7 624 /* In case of counter_alarm < counter_time */
<> 144:ef7eb2e8f9f7 625 /* Alarm expiration already occurred but alarm not deactivated */
<> 144:ef7eb2e8f9f7 626 counter_alarm = RTC_ALARM_RESETVALUE;
<> 144:ef7eb2e8f9f7 627 }
<> 144:ef7eb2e8f9f7 628
<> 144:ef7eb2e8f9f7 629 /* Set updated time in decreasing counter by number of days elapsed */
<> 144:ef7eb2e8f9f7 630 counter_time -= (days_elapsed * 24 * 3600);
<> 144:ef7eb2e8f9f7 631
<> 144:ef7eb2e8f9f7 632 /* Write time counter in RTC registers */
<> 144:ef7eb2e8f9f7 633 if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
<> 144:ef7eb2e8f9f7 634 {
<> 144:ef7eb2e8f9f7 635 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 636 }
<> 144:ef7eb2e8f9f7 637
<> 144:ef7eb2e8f9f7 638 /* Set updated alarm to be set */
<> 144:ef7eb2e8f9f7 639 if (counter_alarm != RTC_ALARM_RESETVALUE)
<> 144:ef7eb2e8f9f7 640 {
<> 144:ef7eb2e8f9f7 641 counter_alarm += counter_time;
<> 144:ef7eb2e8f9f7 642
<> 144:ef7eb2e8f9f7 643 /* Write time counter in RTC registers */
<> 144:ef7eb2e8f9f7 644 if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<> 144:ef7eb2e8f9f7 645 {
<> 144:ef7eb2e8f9f7 646 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 647 }
<> 144:ef7eb2e8f9f7 648 }
<> 144:ef7eb2e8f9f7 649 else
<> 144:ef7eb2e8f9f7 650 {
<> 144:ef7eb2e8f9f7 651 /* Alarm already occurred. Set it to reset values to avoid unexpected expiration */
<> 144:ef7eb2e8f9f7 652 if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<> 144:ef7eb2e8f9f7 653 {
<> 144:ef7eb2e8f9f7 654 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 655 }
<> 144:ef7eb2e8f9f7 656 }
<> 144:ef7eb2e8f9f7 657
<> 144:ef7eb2e8f9f7 658 /* Update date */
<> 144:ef7eb2e8f9f7 659 RTC_DateUpdate(hrtc, days_elapsed);
<> 144:ef7eb2e8f9f7 660 }
<> 144:ef7eb2e8f9f7 661 else
<> 144:ef7eb2e8f9f7 662 {
<> 144:ef7eb2e8f9f7 663 sTime->Hours = hours;
<> 144:ef7eb2e8f9f7 664 }
<> 144:ef7eb2e8f9f7 665
<> 144:ef7eb2e8f9f7 666 /* Check the input parameters format */
<> 144:ef7eb2e8f9f7 667 if(Format != RTC_FORMAT_BIN)
<> 144:ef7eb2e8f9f7 668 {
<> 144:ef7eb2e8f9f7 669 /* Convert the time structure parameters to BCD format */
<> 144:ef7eb2e8f9f7 670 sTime->Hours = (uint8_t)RTC_ByteToBcd2(sTime->Hours);
<> 144:ef7eb2e8f9f7 671 sTime->Minutes = (uint8_t)RTC_ByteToBcd2(sTime->Minutes);
<> 144:ef7eb2e8f9f7 672 sTime->Seconds = (uint8_t)RTC_ByteToBcd2(sTime->Seconds);
<> 144:ef7eb2e8f9f7 673 }
<> 144:ef7eb2e8f9f7 674
<> 144:ef7eb2e8f9f7 675 return HAL_OK;
<> 144:ef7eb2e8f9f7 676 }
<> 144:ef7eb2e8f9f7 677
<> 144:ef7eb2e8f9f7 678
<> 144:ef7eb2e8f9f7 679 /**
<> 144:ef7eb2e8f9f7 680 * @brief Sets RTC current date.
<> 144:ef7eb2e8f9f7 681 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 682 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 683 * @param sDate: Pointer to date structure
<> 144:ef7eb2e8f9f7 684 * @param Format: specifies the format of the entered parameters.
<> 144:ef7eb2e8f9f7 685 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 686 * @arg RTC_FORMAT_BIN: Binary data format
<> 144:ef7eb2e8f9f7 687 * @arg RTC_FORMAT_BCD: BCD data format
<> 144:ef7eb2e8f9f7 688 * @retval HAL status
<> 144:ef7eb2e8f9f7 689 */
<> 144:ef7eb2e8f9f7 690 HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
<> 144:ef7eb2e8f9f7 691 {
<> 144:ef7eb2e8f9f7 692 uint32_t counter_time = 0, counter_alarm = 0, hours = 0;
<> 144:ef7eb2e8f9f7 693
<> 144:ef7eb2e8f9f7 694 /* Check input parameters */
<> 144:ef7eb2e8f9f7 695 if((hrtc == NULL) || (sDate == NULL))
<> 144:ef7eb2e8f9f7 696 {
<> 144:ef7eb2e8f9f7 697 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 698 }
<> 144:ef7eb2e8f9f7 699
<> 144:ef7eb2e8f9f7 700 /* Check the parameters */
<> 144:ef7eb2e8f9f7 701 assert_param(IS_RTC_FORMAT(Format));
<> 144:ef7eb2e8f9f7 702
<> 144:ef7eb2e8f9f7 703 /* Process Locked */
<> 144:ef7eb2e8f9f7 704 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 705
<> 144:ef7eb2e8f9f7 706 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 707
<> 144:ef7eb2e8f9f7 708 if(Format == RTC_FORMAT_BIN)
<> 144:ef7eb2e8f9f7 709 {
<> 144:ef7eb2e8f9f7 710 assert_param(IS_RTC_YEAR(sDate->Year));
<> 144:ef7eb2e8f9f7 711 assert_param(IS_RTC_MONTH(sDate->Month));
<> 144:ef7eb2e8f9f7 712 assert_param(IS_RTC_DATE(sDate->Date));
<> 144:ef7eb2e8f9f7 713
<> 144:ef7eb2e8f9f7 714 /* Change the current date */
<> 144:ef7eb2e8f9f7 715 hrtc->DateToUpdate.Year = sDate->Year;
<> 144:ef7eb2e8f9f7 716 hrtc->DateToUpdate.Month = sDate->Month;
<> 144:ef7eb2e8f9f7 717 hrtc->DateToUpdate.Date = sDate->Date;
<> 144:ef7eb2e8f9f7 718 }
<> 144:ef7eb2e8f9f7 719 else
<> 144:ef7eb2e8f9f7 720 {
<> 144:ef7eb2e8f9f7 721 assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year)));
<> 144:ef7eb2e8f9f7 722 assert_param(IS_RTC_MONTH(RTC_Bcd2ToByte(sDate->Month)));
<> 144:ef7eb2e8f9f7 723 assert_param(IS_RTC_DATE(RTC_Bcd2ToByte(sDate->Date)));
<> 144:ef7eb2e8f9f7 724
<> 144:ef7eb2e8f9f7 725 /* Change the current date */
<> 144:ef7eb2e8f9f7 726 hrtc->DateToUpdate.Year = RTC_Bcd2ToByte(sDate->Year);
<> 144:ef7eb2e8f9f7 727 hrtc->DateToUpdate.Month = RTC_Bcd2ToByte(sDate->Month);
<> 144:ef7eb2e8f9f7 728 hrtc->DateToUpdate.Date = RTC_Bcd2ToByte(sDate->Date);
<> 144:ef7eb2e8f9f7 729 }
<> 144:ef7eb2e8f9f7 730
<> 144:ef7eb2e8f9f7 731 /* WeekDay set by user can be ignored because automatically calculated */
<> 144:ef7eb2e8f9f7 732 hrtc->DateToUpdate.WeekDay = RTC_WeekDayNum(hrtc->DateToUpdate.Year, hrtc->DateToUpdate.Month, hrtc->DateToUpdate.Date);
<> 144:ef7eb2e8f9f7 733 sDate->WeekDay = hrtc->DateToUpdate.WeekDay;
<> 144:ef7eb2e8f9f7 734
<> 144:ef7eb2e8f9f7 735 /* Reset time to be aligned on the same day */
<> 144:ef7eb2e8f9f7 736 /* Read the time counter*/
<> 144:ef7eb2e8f9f7 737 counter_time = RTC_ReadTimeCounter(hrtc);
<> 144:ef7eb2e8f9f7 738
<> 144:ef7eb2e8f9f7 739 /* Fill the structure fields with the read parameters */
<> 144:ef7eb2e8f9f7 740 hours = counter_time / 3600;
<> 144:ef7eb2e8f9f7 741 if (hours > 24)
<> 144:ef7eb2e8f9f7 742 {
<> 144:ef7eb2e8f9f7 743 /* Set updated time in decreasing counter by number of days elapsed */
<> 144:ef7eb2e8f9f7 744 counter_time -= ((hours / 24) * 24 * 3600);
<> 144:ef7eb2e8f9f7 745 /* Write time counter in RTC registers */
<> 144:ef7eb2e8f9f7 746 if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
<> 144:ef7eb2e8f9f7 747 {
<> 144:ef7eb2e8f9f7 748 /* Set RTC state */
<> 144:ef7eb2e8f9f7 749 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 750
<> 144:ef7eb2e8f9f7 751 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 752 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 753
<> 144:ef7eb2e8f9f7 754 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 755 }
<> 144:ef7eb2e8f9f7 756
<> 144:ef7eb2e8f9f7 757 /* Read current Alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 758 counter_alarm = RTC_ReadAlarmCounter(hrtc);
<> 144:ef7eb2e8f9f7 759
<> 144:ef7eb2e8f9f7 760 /* Set again alarm to match with new time if enabled */
<> 144:ef7eb2e8f9f7 761 if (counter_alarm != RTC_ALARM_RESETVALUE)
<> 144:ef7eb2e8f9f7 762 {
<> 144:ef7eb2e8f9f7 763 if(counter_alarm < counter_time)
<> 144:ef7eb2e8f9f7 764 {
<> 144:ef7eb2e8f9f7 765 /* Add 1 day to alarm counter*/
<> 144:ef7eb2e8f9f7 766 counter_alarm += (uint32_t)(24 * 3600);
<> 144:ef7eb2e8f9f7 767
<> 144:ef7eb2e8f9f7 768 /* Write new Alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 769 if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<> 144:ef7eb2e8f9f7 770 {
<> 144:ef7eb2e8f9f7 771 /* Set RTC state */
<> 144:ef7eb2e8f9f7 772 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 773
<> 144:ef7eb2e8f9f7 774 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 775 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 776
<> 144:ef7eb2e8f9f7 777 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 778 }
<> 144:ef7eb2e8f9f7 779 }
<> 144:ef7eb2e8f9f7 780 }
<> 144:ef7eb2e8f9f7 781
<> 144:ef7eb2e8f9f7 782
<> 144:ef7eb2e8f9f7 783 }
<> 144:ef7eb2e8f9f7 784
<> 144:ef7eb2e8f9f7 785 hrtc->State = HAL_RTC_STATE_READY ;
<> 144:ef7eb2e8f9f7 786
<> 144:ef7eb2e8f9f7 787 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 788 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 789
<> 144:ef7eb2e8f9f7 790 return HAL_OK;
<> 144:ef7eb2e8f9f7 791 }
<> 144:ef7eb2e8f9f7 792
<> 144:ef7eb2e8f9f7 793 /**
<> 144:ef7eb2e8f9f7 794 * @brief Gets RTC current date.
<> 144:ef7eb2e8f9f7 795 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 796 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 797 * @param sDate: Pointer to Date structure
<> 144:ef7eb2e8f9f7 798 * @param Format: Specifies the format of the entered parameters.
<> 144:ef7eb2e8f9f7 799 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 800 * @arg RTC_FORMAT_BIN: Binary data format
<> 144:ef7eb2e8f9f7 801 * @arg RTC_FORMAT_BCD: BCD data format
<> 144:ef7eb2e8f9f7 802 * @retval HAL status
<> 144:ef7eb2e8f9f7 803 */
<> 144:ef7eb2e8f9f7 804 HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
<> 144:ef7eb2e8f9f7 805 {
<> 144:ef7eb2e8f9f7 806 RTC_TimeTypeDef stime = {0};
<> 144:ef7eb2e8f9f7 807
<> 144:ef7eb2e8f9f7 808 /* Check input parameters */
<> 144:ef7eb2e8f9f7 809 if((hrtc == NULL) || (sDate == NULL))
<> 144:ef7eb2e8f9f7 810 {
<> 144:ef7eb2e8f9f7 811 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 812 }
<> 144:ef7eb2e8f9f7 813
<> 144:ef7eb2e8f9f7 814 /* Check the parameters */
<> 144:ef7eb2e8f9f7 815 assert_param(IS_RTC_FORMAT(Format));
<> 144:ef7eb2e8f9f7 816
<> 144:ef7eb2e8f9f7 817 /* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
<> 144:ef7eb2e8f9f7 818 if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
<> 144:ef7eb2e8f9f7 819 {
<> 144:ef7eb2e8f9f7 820 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 821 }
<> 144:ef7eb2e8f9f7 822
<> 144:ef7eb2e8f9f7 823 /* Fill the structure fields with the read parameters */
<> 144:ef7eb2e8f9f7 824 sDate->WeekDay = hrtc->DateToUpdate.WeekDay;
<> 144:ef7eb2e8f9f7 825 sDate->Year = hrtc->DateToUpdate.Year;
<> 144:ef7eb2e8f9f7 826 sDate->Month = hrtc->DateToUpdate.Month;
<> 144:ef7eb2e8f9f7 827 sDate->Date = hrtc->DateToUpdate.Date;
<> 144:ef7eb2e8f9f7 828
<> 144:ef7eb2e8f9f7 829 /* Check the input parameters format */
<> 144:ef7eb2e8f9f7 830 if(Format != RTC_FORMAT_BIN)
<> 144:ef7eb2e8f9f7 831 {
<> 144:ef7eb2e8f9f7 832 /* Convert the date structure parameters to BCD format */
<> 144:ef7eb2e8f9f7 833 sDate->Year = (uint8_t)RTC_ByteToBcd2(sDate->Year);
<> 144:ef7eb2e8f9f7 834 sDate->Month = (uint8_t)RTC_ByteToBcd2(sDate->Month);
<> 144:ef7eb2e8f9f7 835 sDate->Date = (uint8_t)RTC_ByteToBcd2(sDate->Date);
<> 144:ef7eb2e8f9f7 836 }
<> 144:ef7eb2e8f9f7 837 return HAL_OK;
<> 144:ef7eb2e8f9f7 838 }
<> 144:ef7eb2e8f9f7 839
<> 144:ef7eb2e8f9f7 840 /**
<> 144:ef7eb2e8f9f7 841 * @}
<> 144:ef7eb2e8f9f7 842 */
<> 144:ef7eb2e8f9f7 843
<> 144:ef7eb2e8f9f7 844 /** @defgroup RTC_Exported_Functions_Group3 Alarm functions
<> 144:ef7eb2e8f9f7 845 * @brief RTC Alarm functions
<> 144:ef7eb2e8f9f7 846 *
<> 144:ef7eb2e8f9f7 847 @verbatim
<> 144:ef7eb2e8f9f7 848 ===============================================================================
<> 144:ef7eb2e8f9f7 849 ##### RTC Alarm functions #####
<> 144:ef7eb2e8f9f7 850 ===============================================================================
<> 144:ef7eb2e8f9f7 851
<> 144:ef7eb2e8f9f7 852 [..] This section provides functions allowing to configure Alarm feature
<> 144:ef7eb2e8f9f7 853
<> 144:ef7eb2e8f9f7 854 @endverbatim
<> 144:ef7eb2e8f9f7 855 * @{
<> 144:ef7eb2e8f9f7 856 */
<> 144:ef7eb2e8f9f7 857
<> 144:ef7eb2e8f9f7 858 /**
<> 144:ef7eb2e8f9f7 859 * @brief Sets the specified RTC Alarm.
<> 144:ef7eb2e8f9f7 860 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 861 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 862 * @param sAlarm: Pointer to Alarm structure
<> 144:ef7eb2e8f9f7 863 * @param Format: Specifies the format of the entered parameters.
<> 144:ef7eb2e8f9f7 864 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 865 * @arg RTC_FORMAT_BIN: Binary data format
<> 144:ef7eb2e8f9f7 866 * @arg RTC_FORMAT_BCD: BCD data format
<> 144:ef7eb2e8f9f7 867 * @retval HAL status
<> 144:ef7eb2e8f9f7 868 */
<> 144:ef7eb2e8f9f7 869 HAL_StatusTypeDef HAL_RTC_SetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
<> 144:ef7eb2e8f9f7 870 {
<> 144:ef7eb2e8f9f7 871 uint32_t counter_alarm = 0, counter_time;
<> 144:ef7eb2e8f9f7 872 RTC_TimeTypeDef stime = {0};
<> 144:ef7eb2e8f9f7 873
<> 144:ef7eb2e8f9f7 874 /* Check input parameters */
<> 144:ef7eb2e8f9f7 875 if((hrtc == NULL) || (sAlarm == NULL))
<> 144:ef7eb2e8f9f7 876 {
<> 144:ef7eb2e8f9f7 877 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 878 }
<> 144:ef7eb2e8f9f7 879
<> 144:ef7eb2e8f9f7 880 /* Check the parameters */
<> 144:ef7eb2e8f9f7 881 assert_param(IS_RTC_FORMAT(Format));
<> 144:ef7eb2e8f9f7 882 assert_param(IS_RTC_ALARM(sAlarm->Alarm));
<> 144:ef7eb2e8f9f7 883
<> 144:ef7eb2e8f9f7 884 /* Process Locked */
<> 144:ef7eb2e8f9f7 885 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 886
<> 144:ef7eb2e8f9f7 887 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 888
<> 144:ef7eb2e8f9f7 889 /* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
<> 144:ef7eb2e8f9f7 890 if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
<> 144:ef7eb2e8f9f7 891 {
<> 144:ef7eb2e8f9f7 892 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 893 }
<> 144:ef7eb2e8f9f7 894
<> 144:ef7eb2e8f9f7 895 /* Convert time in seconds */
<> 144:ef7eb2e8f9f7 896 counter_time = (uint32_t)(((uint32_t)stime.Hours * 3600) + \
<> 144:ef7eb2e8f9f7 897 ((uint32_t)stime.Minutes * 60) + \
<> 144:ef7eb2e8f9f7 898 ((uint32_t)stime.Seconds));
<> 144:ef7eb2e8f9f7 899
<> 144:ef7eb2e8f9f7 900 if(Format == RTC_FORMAT_BIN)
<> 144:ef7eb2e8f9f7 901 {
<> 144:ef7eb2e8f9f7 902 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
<> 144:ef7eb2e8f9f7 903 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
<> 144:ef7eb2e8f9f7 904 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
<> 144:ef7eb2e8f9f7 905
<> 144:ef7eb2e8f9f7 906 counter_alarm = (uint32_t)(((uint32_t)sAlarm->AlarmTime.Hours * 3600) + \
<> 144:ef7eb2e8f9f7 907 ((uint32_t)sAlarm->AlarmTime.Minutes * 60) + \
<> 144:ef7eb2e8f9f7 908 ((uint32_t)sAlarm->AlarmTime.Seconds));
<> 144:ef7eb2e8f9f7 909 }
<> 144:ef7eb2e8f9f7 910 else
<> 144:ef7eb2e8f9f7 911 {
<> 144:ef7eb2e8f9f7 912 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
<> 144:ef7eb2e8f9f7 913 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
<> 144:ef7eb2e8f9f7 914 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<> 144:ef7eb2e8f9f7 915
<> 144:ef7eb2e8f9f7 916 counter_alarm = (((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)) * 3600) + \
<> 144:ef7eb2e8f9f7 917 ((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)) * 60) + \
<> 144:ef7eb2e8f9f7 918 ((uint32_t)RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<> 144:ef7eb2e8f9f7 919 }
<> 144:ef7eb2e8f9f7 920
<> 144:ef7eb2e8f9f7 921 /* Check that requested alarm should expire in the same day (otherwise add 1 day) */
<> 144:ef7eb2e8f9f7 922 if (counter_alarm < counter_time)
<> 144:ef7eb2e8f9f7 923 {
<> 144:ef7eb2e8f9f7 924 /* Add 1 day to alarm counter*/
<> 144:ef7eb2e8f9f7 925 counter_alarm += (uint32_t)(24 * 3600);
<> 144:ef7eb2e8f9f7 926 }
<> 144:ef7eb2e8f9f7 927
<> 144:ef7eb2e8f9f7 928 /* Write Alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 929 if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<> 144:ef7eb2e8f9f7 930 {
<> 144:ef7eb2e8f9f7 931 /* Set RTC state */
<> 144:ef7eb2e8f9f7 932 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 933
<> 144:ef7eb2e8f9f7 934 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 935 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 936
<> 144:ef7eb2e8f9f7 937 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 938 }
<> 144:ef7eb2e8f9f7 939 else
<> 144:ef7eb2e8f9f7 940 {
<> 144:ef7eb2e8f9f7 941 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 942
<> 144:ef7eb2e8f9f7 943 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 944
<> 144:ef7eb2e8f9f7 945 return HAL_OK;
<> 144:ef7eb2e8f9f7 946 }
<> 144:ef7eb2e8f9f7 947 }
<> 144:ef7eb2e8f9f7 948
<> 144:ef7eb2e8f9f7 949 /**
<> 144:ef7eb2e8f9f7 950 * @brief Sets the specified RTC Alarm with Interrupt
<> 144:ef7eb2e8f9f7 951 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 952 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 953 * @param sAlarm: Pointer to Alarm structure
<> 144:ef7eb2e8f9f7 954 * @param Format: Specifies the format of the entered parameters.
<> 144:ef7eb2e8f9f7 955 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 956 * @arg RTC_FORMAT_BIN: Binary data format
<> 144:ef7eb2e8f9f7 957 * @arg RTC_FORMAT_BCD: BCD data format
<> 144:ef7eb2e8f9f7 958 * @note The HAL_RTC_SetTime() must be called before enabling the Alarm feature.
<> 144:ef7eb2e8f9f7 959 * @retval HAL status
<> 144:ef7eb2e8f9f7 960 */
<> 144:ef7eb2e8f9f7 961 HAL_StatusTypeDef HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
<> 144:ef7eb2e8f9f7 962 {
<> 144:ef7eb2e8f9f7 963 uint32_t counter_alarm = 0, counter_time;
<> 144:ef7eb2e8f9f7 964 RTC_TimeTypeDef stime = {0};
<> 144:ef7eb2e8f9f7 965
<> 144:ef7eb2e8f9f7 966 /* Check input parameters */
<> 144:ef7eb2e8f9f7 967 if((hrtc == NULL) || (sAlarm == NULL))
<> 144:ef7eb2e8f9f7 968 {
<> 144:ef7eb2e8f9f7 969 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 970 }
<> 144:ef7eb2e8f9f7 971
<> 144:ef7eb2e8f9f7 972 /* Check the parameters */
<> 144:ef7eb2e8f9f7 973 assert_param(IS_RTC_FORMAT(Format));
<> 144:ef7eb2e8f9f7 974 assert_param(IS_RTC_ALARM(sAlarm->Alarm));
<> 144:ef7eb2e8f9f7 975
<> 144:ef7eb2e8f9f7 976 /* Process Locked */
<> 144:ef7eb2e8f9f7 977 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 978
<> 144:ef7eb2e8f9f7 979 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 980
<> 144:ef7eb2e8f9f7 981 /* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
<> 144:ef7eb2e8f9f7 982 if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
<> 144:ef7eb2e8f9f7 983 {
<> 144:ef7eb2e8f9f7 984 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 985 }
<> 144:ef7eb2e8f9f7 986
<> 144:ef7eb2e8f9f7 987 /* Convert time in seconds */
<> 144:ef7eb2e8f9f7 988 counter_time = (uint32_t)(((uint32_t)stime.Hours * 3600) + \
<> 144:ef7eb2e8f9f7 989 ((uint32_t)stime.Minutes * 60) + \
<> 144:ef7eb2e8f9f7 990 ((uint32_t)stime.Seconds));
<> 144:ef7eb2e8f9f7 991
<> 144:ef7eb2e8f9f7 992 if(Format == RTC_FORMAT_BIN)
<> 144:ef7eb2e8f9f7 993 {
<> 144:ef7eb2e8f9f7 994 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
<> 144:ef7eb2e8f9f7 995 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
<> 144:ef7eb2e8f9f7 996 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
<> 144:ef7eb2e8f9f7 997
<> 144:ef7eb2e8f9f7 998 counter_alarm = (uint32_t)(((uint32_t)sAlarm->AlarmTime.Hours * 3600) + \
<> 144:ef7eb2e8f9f7 999 ((uint32_t)sAlarm->AlarmTime.Minutes * 60) + \
<> 144:ef7eb2e8f9f7 1000 ((uint32_t)sAlarm->AlarmTime.Seconds));
<> 144:ef7eb2e8f9f7 1001 }
<> 144:ef7eb2e8f9f7 1002 else
<> 144:ef7eb2e8f9f7 1003 {
<> 144:ef7eb2e8f9f7 1004 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
<> 144:ef7eb2e8f9f7 1005 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
<> 144:ef7eb2e8f9f7 1006 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<> 144:ef7eb2e8f9f7 1007
<> 144:ef7eb2e8f9f7 1008 counter_alarm = (((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)) * 3600) + \
<> 144:ef7eb2e8f9f7 1009 ((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)) * 60) + \
<> 144:ef7eb2e8f9f7 1010 ((uint32_t)RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<> 144:ef7eb2e8f9f7 1011 }
<> 144:ef7eb2e8f9f7 1012
<> 144:ef7eb2e8f9f7 1013 /* Check that requested alarm should expire in the same day (otherwise add 1 day) */
<> 144:ef7eb2e8f9f7 1014 if (counter_alarm < counter_time)
<> 144:ef7eb2e8f9f7 1015 {
<> 144:ef7eb2e8f9f7 1016 /* Add 1 day to alarm counter*/
<> 144:ef7eb2e8f9f7 1017 counter_alarm += (uint32_t)(24 * 3600);
<> 144:ef7eb2e8f9f7 1018 }
<> 144:ef7eb2e8f9f7 1019
<> 144:ef7eb2e8f9f7 1020 /* Write alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 1021 if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<> 144:ef7eb2e8f9f7 1022 {
<> 144:ef7eb2e8f9f7 1023 /* Set RTC state */
<> 144:ef7eb2e8f9f7 1024 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 1025
<> 144:ef7eb2e8f9f7 1026 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1027 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1028
<> 144:ef7eb2e8f9f7 1029 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1030 }
<> 144:ef7eb2e8f9f7 1031 else
<> 144:ef7eb2e8f9f7 1032 {
<> 144:ef7eb2e8f9f7 1033 /* Clear flag alarm A */
<> 144:ef7eb2e8f9f7 1034 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
<> 144:ef7eb2e8f9f7 1035
<> 144:ef7eb2e8f9f7 1036 /* Configure the Alarm interrupt */
<> 144:ef7eb2e8f9f7 1037 __HAL_RTC_ALARM_ENABLE_IT(hrtc,RTC_IT_ALRA);
<> 144:ef7eb2e8f9f7 1038
<> 144:ef7eb2e8f9f7 1039 /* RTC Alarm Interrupt Configuration: EXTI configuration */
<> 144:ef7eb2e8f9f7 1040 __HAL_RTC_ALARM_EXTI_ENABLE_IT();
<> 144:ef7eb2e8f9f7 1041
<> 144:ef7eb2e8f9f7 1042 __HAL_RTC_ALARM_EXTI_ENABLE_RISING_EDGE();
<> 144:ef7eb2e8f9f7 1043
<> 144:ef7eb2e8f9f7 1044 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1045
<> 144:ef7eb2e8f9f7 1046 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1047
<> 144:ef7eb2e8f9f7 1048 return HAL_OK;
<> 144:ef7eb2e8f9f7 1049 }
<> 144:ef7eb2e8f9f7 1050 }
<> 144:ef7eb2e8f9f7 1051
<> 144:ef7eb2e8f9f7 1052 /**
<> 144:ef7eb2e8f9f7 1053 * @brief Gets the RTC Alarm value and masks.
<> 144:ef7eb2e8f9f7 1054 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1055 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1056 * @param sAlarm: Pointer to Date structure
<> 144:ef7eb2e8f9f7 1057 * @param Alarm: Specifies the Alarm.
<> 144:ef7eb2e8f9f7 1058 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1059 * @arg RTC_ALARM_A: Alarm
<> 144:ef7eb2e8f9f7 1060 * @param Format: Specifies the format of the entered parameters.
<> 144:ef7eb2e8f9f7 1061 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1062 * @arg RTC_FORMAT_BIN: Binary data format
<> 144:ef7eb2e8f9f7 1063 * @arg RTC_FORMAT_BCD: BCD data format
<> 144:ef7eb2e8f9f7 1064 * @retval HAL status
<> 144:ef7eb2e8f9f7 1065 */
<> 144:ef7eb2e8f9f7 1066 HAL_StatusTypeDef HAL_RTC_GetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Alarm, uint32_t Format)
<> 144:ef7eb2e8f9f7 1067 {
<> 144:ef7eb2e8f9f7 1068 uint32_t counter_alarm = 0;
<> 144:ef7eb2e8f9f7 1069
<> 144:ef7eb2e8f9f7 1070 /* Check input parameters */
<> 144:ef7eb2e8f9f7 1071 if((hrtc == NULL) || (sAlarm == NULL))
<> 144:ef7eb2e8f9f7 1072 {
<> 144:ef7eb2e8f9f7 1073 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1074 }
<> 144:ef7eb2e8f9f7 1075
<> 144:ef7eb2e8f9f7 1076 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1077 assert_param(IS_RTC_FORMAT(Format));
<> 144:ef7eb2e8f9f7 1078 assert_param(IS_RTC_ALARM(Alarm));
<> 144:ef7eb2e8f9f7 1079
<> 144:ef7eb2e8f9f7 1080 /* Read Alarm counter in RTC registers */
<> 144:ef7eb2e8f9f7 1081 counter_alarm = RTC_ReadAlarmCounter(hrtc);
<> 144:ef7eb2e8f9f7 1082
<> 144:ef7eb2e8f9f7 1083 /* Fill the structure with the read parameters */
<> 144:ef7eb2e8f9f7 1084 /* Set hours in a day range (between 0 to 24)*/
<> 144:ef7eb2e8f9f7 1085 sAlarm->AlarmTime.Hours = (uint32_t)((counter_alarm / 3600) % 24);
<> 144:ef7eb2e8f9f7 1086 sAlarm->AlarmTime.Minutes = (uint32_t)((counter_alarm % 3600) / 60);
<> 144:ef7eb2e8f9f7 1087 sAlarm->AlarmTime.Seconds = (uint32_t)((counter_alarm % 3600) % 60);
<> 144:ef7eb2e8f9f7 1088
<> 144:ef7eb2e8f9f7 1089 if(Format != RTC_FORMAT_BIN)
<> 144:ef7eb2e8f9f7 1090 {
<> 144:ef7eb2e8f9f7 1091 sAlarm->AlarmTime.Hours = RTC_ByteToBcd2(sAlarm->AlarmTime.Hours);
<> 144:ef7eb2e8f9f7 1092 sAlarm->AlarmTime.Minutes = RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes);
<> 144:ef7eb2e8f9f7 1093 sAlarm->AlarmTime.Seconds = RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds);
<> 144:ef7eb2e8f9f7 1094 }
<> 144:ef7eb2e8f9f7 1095
<> 144:ef7eb2e8f9f7 1096 return HAL_OK;
<> 144:ef7eb2e8f9f7 1097 }
<> 144:ef7eb2e8f9f7 1098
<> 144:ef7eb2e8f9f7 1099 /**
<> 144:ef7eb2e8f9f7 1100 * @brief Deactive the specified RTC Alarm
<> 144:ef7eb2e8f9f7 1101 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1102 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1103 * @param Alarm: Specifies the Alarm.
<> 144:ef7eb2e8f9f7 1104 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1105 * @arg RTC_ALARM_A: AlarmA
<> 144:ef7eb2e8f9f7 1106 * @retval HAL status
<> 144:ef7eb2e8f9f7 1107 */
<> 144:ef7eb2e8f9f7 1108 HAL_StatusTypeDef HAL_RTC_DeactivateAlarm(RTC_HandleTypeDef *hrtc, uint32_t Alarm)
<> 144:ef7eb2e8f9f7 1109 {
<> 144:ef7eb2e8f9f7 1110 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1111 assert_param(IS_RTC_ALARM(Alarm));
<> 144:ef7eb2e8f9f7 1112
<> 144:ef7eb2e8f9f7 1113 /* Check input parameters */
<> 144:ef7eb2e8f9f7 1114 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 1115 {
<> 144:ef7eb2e8f9f7 1116 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1117 }
<> 144:ef7eb2e8f9f7 1118
<> 144:ef7eb2e8f9f7 1119 /* Process Locked */
<> 144:ef7eb2e8f9f7 1120 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 1121
<> 144:ef7eb2e8f9f7 1122 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1123
<> 144:ef7eb2e8f9f7 1124 /* In case of interrupt mode is used, the interrupt source must disabled */
<> 144:ef7eb2e8f9f7 1125 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
<> 144:ef7eb2e8f9f7 1126
<> 144:ef7eb2e8f9f7 1127 /* Set Initialization mode */
<> 144:ef7eb2e8f9f7 1128 if(RTC_EnterInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1129 {
<> 144:ef7eb2e8f9f7 1130 /* Set RTC state */
<> 144:ef7eb2e8f9f7 1131 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 1132
<> 144:ef7eb2e8f9f7 1133 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1134 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1135
<> 144:ef7eb2e8f9f7 1136 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1137 }
<> 144:ef7eb2e8f9f7 1138 else
<> 144:ef7eb2e8f9f7 1139 {
<> 144:ef7eb2e8f9f7 1140 /* Clear flag alarm A */
<> 144:ef7eb2e8f9f7 1141 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
<> 144:ef7eb2e8f9f7 1142
<> 144:ef7eb2e8f9f7 1143 /* Set to default values ALRH & ALRL registers */
<> 144:ef7eb2e8f9f7 1144 WRITE_REG(hrtc->Instance->ALRH, RTC_ALARM_RESETVALUE_REGISTER);
<> 144:ef7eb2e8f9f7 1145 WRITE_REG(hrtc->Instance->ALRL, RTC_ALARM_RESETVALUE_REGISTER);
<> 144:ef7eb2e8f9f7 1146
<> 144:ef7eb2e8f9f7 1147 /* RTC Alarm Interrupt Configuration: Disable EXTI configuration */
<> 144:ef7eb2e8f9f7 1148 __HAL_RTC_ALARM_EXTI_DISABLE_IT();
<> 144:ef7eb2e8f9f7 1149
<> 144:ef7eb2e8f9f7 1150 /* Wait for synchro */
<> 144:ef7eb2e8f9f7 1151 if(RTC_ExitInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1152 {
<> 144:ef7eb2e8f9f7 1153 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 1154
<> 144:ef7eb2e8f9f7 1155 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1156 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1157
<> 144:ef7eb2e8f9f7 1158 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1159 }
<> 144:ef7eb2e8f9f7 1160 }
<> 144:ef7eb2e8f9f7 1161 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1162
<> 144:ef7eb2e8f9f7 1163 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1164 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 1165
<> 144:ef7eb2e8f9f7 1166 return HAL_OK;
<> 144:ef7eb2e8f9f7 1167 }
<> 144:ef7eb2e8f9f7 1168
<> 144:ef7eb2e8f9f7 1169 /**
<> 144:ef7eb2e8f9f7 1170 * @brief This function handles Alarm interrupt request.
<> 144:ef7eb2e8f9f7 1171 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1172 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1173 * @retval None
<> 144:ef7eb2e8f9f7 1174 */
<> 144:ef7eb2e8f9f7 1175 void HAL_RTC_AlarmIRQHandler(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1176 {
<> 144:ef7eb2e8f9f7 1177 if(__HAL_RTC_ALARM_GET_IT_SOURCE(hrtc, RTC_IT_ALRA))
<> 144:ef7eb2e8f9f7 1178 {
<> 144:ef7eb2e8f9f7 1179 /* Get the status of the Interrupt */
<> 144:ef7eb2e8f9f7 1180 if(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) != (uint32_t)RESET)
<> 144:ef7eb2e8f9f7 1181 {
<> 144:ef7eb2e8f9f7 1182 /* AlarmA callback */
<> 144:ef7eb2e8f9f7 1183 HAL_RTC_AlarmAEventCallback(hrtc);
<> 144:ef7eb2e8f9f7 1184
<> 144:ef7eb2e8f9f7 1185 /* Clear the Alarm interrupt pending bit */
<> 144:ef7eb2e8f9f7 1186 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRAF);
<> 144:ef7eb2e8f9f7 1187 }
<> 144:ef7eb2e8f9f7 1188 }
<> 144:ef7eb2e8f9f7 1189
<> 144:ef7eb2e8f9f7 1190 /* Clear the EXTI's line Flag for RTC Alarm */
<> 144:ef7eb2e8f9f7 1191 __HAL_RTC_ALARM_EXTI_CLEAR_FLAG();
<> 144:ef7eb2e8f9f7 1192
<> 144:ef7eb2e8f9f7 1193 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1194 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1195 }
<> 144:ef7eb2e8f9f7 1196
<> 144:ef7eb2e8f9f7 1197 /**
<> 144:ef7eb2e8f9f7 1198 * @brief Alarm A callback.
<> 144:ef7eb2e8f9f7 1199 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1200 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1201 * @retval None
<> 144:ef7eb2e8f9f7 1202 */
<> 144:ef7eb2e8f9f7 1203 __weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 1204 {
<> 144:ef7eb2e8f9f7 1205 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1206 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 1207 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1208 the HAL_RTC_AlarmAEventCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1209 */
<> 144:ef7eb2e8f9f7 1210 }
<> 144:ef7eb2e8f9f7 1211
<> 144:ef7eb2e8f9f7 1212 /**
<> 144:ef7eb2e8f9f7 1213 * @brief This function handles AlarmA Polling request.
<> 144:ef7eb2e8f9f7 1214 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1215 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1216 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 1217 * @retval HAL status
<> 144:ef7eb2e8f9f7 1218 */
<> 144:ef7eb2e8f9f7 1219 HAL_StatusTypeDef HAL_RTC_PollForAlarmAEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 1220 {
<> 144:ef7eb2e8f9f7 1221 uint32_t tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1222
<> 144:ef7eb2e8f9f7 1223 /* Check input parameters */
<> 144:ef7eb2e8f9f7 1224 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 1225 {
<> 144:ef7eb2e8f9f7 1226 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1227 }
<> 144:ef7eb2e8f9f7 1228
<> 144:ef7eb2e8f9f7 1229 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) == RESET)
<> 144:ef7eb2e8f9f7 1230 {
<> 144:ef7eb2e8f9f7 1231 if(Timeout != HAL_MAX_DELAY)
<> 144:ef7eb2e8f9f7 1232 {
<> 144:ef7eb2e8f9f7 1233 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
<> 144:ef7eb2e8f9f7 1234 {
<> 144:ef7eb2e8f9f7 1235 hrtc->State = HAL_RTC_STATE_TIMEOUT;
<> 144:ef7eb2e8f9f7 1236 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1237 }
<> 144:ef7eb2e8f9f7 1238 }
<> 144:ef7eb2e8f9f7 1239 }
<> 144:ef7eb2e8f9f7 1240
<> 144:ef7eb2e8f9f7 1241 /* Clear the Alarm interrupt pending bit */
<> 144:ef7eb2e8f9f7 1242 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
<> 144:ef7eb2e8f9f7 1243
<> 144:ef7eb2e8f9f7 1244 /* Change RTC state */
<> 144:ef7eb2e8f9f7 1245 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 1246
<> 144:ef7eb2e8f9f7 1247 return HAL_OK;
<> 144:ef7eb2e8f9f7 1248 }
<> 144:ef7eb2e8f9f7 1249
<> 144:ef7eb2e8f9f7 1250 /**
<> 144:ef7eb2e8f9f7 1251 * @}
<> 144:ef7eb2e8f9f7 1252 */
<> 144:ef7eb2e8f9f7 1253
<> 144:ef7eb2e8f9f7 1254 /** @defgroup RTC_Exported_Functions_Group4 Peripheral State functions
<> 144:ef7eb2e8f9f7 1255 * @brief Peripheral State functions
<> 144:ef7eb2e8f9f7 1256 *
<> 144:ef7eb2e8f9f7 1257 @verbatim
<> 144:ef7eb2e8f9f7 1258 ===============================================================================
<> 144:ef7eb2e8f9f7 1259 ##### Peripheral State functions #####
<> 144:ef7eb2e8f9f7 1260 ===============================================================================
<> 144:ef7eb2e8f9f7 1261 [..]
<> 144:ef7eb2e8f9f7 1262 This subsection provides functions allowing to
<> 144:ef7eb2e8f9f7 1263 (+) Get RTC state
<> 144:ef7eb2e8f9f7 1264
<> 144:ef7eb2e8f9f7 1265 @endverbatim
<> 144:ef7eb2e8f9f7 1266 * @{
<> 144:ef7eb2e8f9f7 1267 */
<> 144:ef7eb2e8f9f7 1268 /**
<> 144:ef7eb2e8f9f7 1269 * @brief Returns the RTC state.
<> 144:ef7eb2e8f9f7 1270 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1271 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1272 * @retval HAL state
<> 144:ef7eb2e8f9f7 1273 */
<> 144:ef7eb2e8f9f7 1274 HAL_RTCStateTypeDef HAL_RTC_GetState(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1275 {
<> 144:ef7eb2e8f9f7 1276 return hrtc->State;
<> 144:ef7eb2e8f9f7 1277 }
<> 144:ef7eb2e8f9f7 1278
<> 144:ef7eb2e8f9f7 1279 /**
<> 144:ef7eb2e8f9f7 1280 * @}
<> 144:ef7eb2e8f9f7 1281 */
<> 144:ef7eb2e8f9f7 1282
<> 144:ef7eb2e8f9f7 1283 /** @defgroup RTC_Exported_Functions_Group5 Peripheral Control functions
<> 144:ef7eb2e8f9f7 1284 * @brief Peripheral Control functions
<> 144:ef7eb2e8f9f7 1285 *
<> 144:ef7eb2e8f9f7 1286 @verbatim
<> 144:ef7eb2e8f9f7 1287 ===============================================================================
<> 144:ef7eb2e8f9f7 1288 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 1289 ===============================================================================
<> 144:ef7eb2e8f9f7 1290 [..]
<> 144:ef7eb2e8f9f7 1291 This subsection provides functions allowing to
<> 144:ef7eb2e8f9f7 1292 (+) Wait for RTC Time and Date Synchronization
<> 144:ef7eb2e8f9f7 1293
<> 144:ef7eb2e8f9f7 1294 @endverbatim
<> 144:ef7eb2e8f9f7 1295 * @{
<> 144:ef7eb2e8f9f7 1296 */
<> 144:ef7eb2e8f9f7 1297
<> 144:ef7eb2e8f9f7 1298 /**
<> 144:ef7eb2e8f9f7 1299 * @brief Waits until the RTC registers (RTC_CNT, RTC_ALR and RTC_PRL)
<> 144:ef7eb2e8f9f7 1300 * are synchronized with RTC APB clock.
<> 144:ef7eb2e8f9f7 1301 * @note This function must be called before any read operation after an APB reset
<> 144:ef7eb2e8f9f7 1302 * or an APB clock stop.
<> 144:ef7eb2e8f9f7 1303 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1304 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1305 * @retval HAL status
<> 144:ef7eb2e8f9f7 1306 */
<> 144:ef7eb2e8f9f7 1307 HAL_StatusTypeDef HAL_RTC_WaitForSynchro(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1308 {
<> 144:ef7eb2e8f9f7 1309 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1310
<> 144:ef7eb2e8f9f7 1311 /* Check input parameters */
<> 144:ef7eb2e8f9f7 1312 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 1313 {
<> 144:ef7eb2e8f9f7 1314 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 1315 }
<> 144:ef7eb2e8f9f7 1316
<> 144:ef7eb2e8f9f7 1317 /* Clear RSF flag */
<> 144:ef7eb2e8f9f7 1318 CLEAR_BIT(hrtc->Instance->CRL, RTC_FLAG_RSF);
<> 144:ef7eb2e8f9f7 1319
<> 144:ef7eb2e8f9f7 1320 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1321
<> 144:ef7eb2e8f9f7 1322 /* Wait the registers to be synchronised */
<> 144:ef7eb2e8f9f7 1323 while((hrtc->Instance->CRL & RTC_FLAG_RSF) == (uint32_t)RESET)
<> 144:ef7eb2e8f9f7 1324 {
<> 144:ef7eb2e8f9f7 1325 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1326 {
<> 144:ef7eb2e8f9f7 1327 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1328 }
<> 144:ef7eb2e8f9f7 1329 }
<> 144:ef7eb2e8f9f7 1330
<> 144:ef7eb2e8f9f7 1331 return HAL_OK;
<> 144:ef7eb2e8f9f7 1332 }
<> 144:ef7eb2e8f9f7 1333
<> 144:ef7eb2e8f9f7 1334 /**
<> 144:ef7eb2e8f9f7 1335 * @}
<> 144:ef7eb2e8f9f7 1336 */
<> 144:ef7eb2e8f9f7 1337
<> 144:ef7eb2e8f9f7 1338
<> 144:ef7eb2e8f9f7 1339 /**
<> 144:ef7eb2e8f9f7 1340 * @}
<> 144:ef7eb2e8f9f7 1341 */
<> 144:ef7eb2e8f9f7 1342
<> 144:ef7eb2e8f9f7 1343 /** @addtogroup RTC_Private_Functions
<> 144:ef7eb2e8f9f7 1344 * @{
<> 144:ef7eb2e8f9f7 1345 */
<> 144:ef7eb2e8f9f7 1346
<> 144:ef7eb2e8f9f7 1347
<> 144:ef7eb2e8f9f7 1348 /**
<> 144:ef7eb2e8f9f7 1349 * @brief Read the time counter available in RTC_CNT registers.
<> 144:ef7eb2e8f9f7 1350 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1351 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1352 * @retval Time counter
<> 144:ef7eb2e8f9f7 1353 */
<> 144:ef7eb2e8f9f7 1354 static uint32_t RTC_ReadTimeCounter(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1355 {
<> 144:ef7eb2e8f9f7 1356 uint16_t high1 = 0, high2 = 0, low = 0;
<> 144:ef7eb2e8f9f7 1357 uint32_t timecounter = 0;
<> 144:ef7eb2e8f9f7 1358
<> 144:ef7eb2e8f9f7 1359 high1 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
<> 144:ef7eb2e8f9f7 1360 low = READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT);
<> 144:ef7eb2e8f9f7 1361 high2 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
<> 144:ef7eb2e8f9f7 1362
<> 144:ef7eb2e8f9f7 1363 if (high1 != high2)
<> 144:ef7eb2e8f9f7 1364 { /* In this case the counter roll over during reading of CNTL and CNTH registers,
<> 144:ef7eb2e8f9f7 1365 read again CNTL register then return the counter value */
<> 144:ef7eb2e8f9f7 1366 timecounter = (((uint32_t) high2 << 16 ) | READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT));
<> 144:ef7eb2e8f9f7 1367 }
<> 144:ef7eb2e8f9f7 1368 else
<> 144:ef7eb2e8f9f7 1369 { /* No counter roll over during reading of CNTL and CNTH registers, counter
<> 144:ef7eb2e8f9f7 1370 value is equal to first value of CNTL and CNTH */
<> 144:ef7eb2e8f9f7 1371 timecounter = (((uint32_t) high1 << 16 ) | low);
<> 144:ef7eb2e8f9f7 1372 }
<> 144:ef7eb2e8f9f7 1373
<> 144:ef7eb2e8f9f7 1374 return timecounter;
<> 144:ef7eb2e8f9f7 1375 }
<> 144:ef7eb2e8f9f7 1376
<> 144:ef7eb2e8f9f7 1377 /**
<> 144:ef7eb2e8f9f7 1378 * @brief Write the time counter in RTC_CNT registers.
<> 144:ef7eb2e8f9f7 1379 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1380 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1381 * @param TimeCounter: Counter to write in RTC_CNT registers
<> 144:ef7eb2e8f9f7 1382 * @retval HAL status
<> 144:ef7eb2e8f9f7 1383 */
<> 144:ef7eb2e8f9f7 1384 static HAL_StatusTypeDef RTC_WriteTimeCounter(RTC_HandleTypeDef* hrtc, uint32_t TimeCounter)
<> 144:ef7eb2e8f9f7 1385 {
<> 144:ef7eb2e8f9f7 1386 HAL_StatusTypeDef status = HAL_OK;
<> 144:ef7eb2e8f9f7 1387
<> 144:ef7eb2e8f9f7 1388 /* Set Initialization mode */
<> 144:ef7eb2e8f9f7 1389 if(RTC_EnterInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1390 {
<> 144:ef7eb2e8f9f7 1391 status = HAL_ERROR;
<> 144:ef7eb2e8f9f7 1392 }
<> 144:ef7eb2e8f9f7 1393 else
<> 144:ef7eb2e8f9f7 1394 {
<> 144:ef7eb2e8f9f7 1395 /* Set RTC COUNTER MSB word */
<> 144:ef7eb2e8f9f7 1396 WRITE_REG(hrtc->Instance->CNTH, (TimeCounter >> 16));
<> 144:ef7eb2e8f9f7 1397 /* Set RTC COUNTER LSB word */
<> 144:ef7eb2e8f9f7 1398 WRITE_REG(hrtc->Instance->CNTL, (TimeCounter & RTC_CNTL_RTC_CNT));
<> 144:ef7eb2e8f9f7 1399
<> 144:ef7eb2e8f9f7 1400 /* Wait for synchro */
<> 144:ef7eb2e8f9f7 1401 if(RTC_ExitInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1402 {
<> 144:ef7eb2e8f9f7 1403 status = HAL_ERROR;
<> 144:ef7eb2e8f9f7 1404 }
<> 144:ef7eb2e8f9f7 1405 }
<> 144:ef7eb2e8f9f7 1406
<> 144:ef7eb2e8f9f7 1407 return status;
<> 144:ef7eb2e8f9f7 1408 }
<> 144:ef7eb2e8f9f7 1409
<> 144:ef7eb2e8f9f7 1410 /**
<> 144:ef7eb2e8f9f7 1411 * @brief Read the time counter available in RTC_ALR registers.
<> 144:ef7eb2e8f9f7 1412 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1413 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1414 * @retval Time counter
<> 144:ef7eb2e8f9f7 1415 */
<> 144:ef7eb2e8f9f7 1416 static uint32_t RTC_ReadAlarmCounter(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1417 {
<> 144:ef7eb2e8f9f7 1418 uint16_t high1 = 0, low = 0;
<> 144:ef7eb2e8f9f7 1419
<> 144:ef7eb2e8f9f7 1420 high1 = READ_REG(hrtc->Instance->ALRH & RTC_CNTH_RTC_CNT);
<> 144:ef7eb2e8f9f7 1421 low = READ_REG(hrtc->Instance->ALRL & RTC_CNTL_RTC_CNT);
<> 144:ef7eb2e8f9f7 1422
<> 144:ef7eb2e8f9f7 1423 return (((uint32_t) high1 << 16 ) | low);
<> 144:ef7eb2e8f9f7 1424 }
<> 144:ef7eb2e8f9f7 1425
<> 144:ef7eb2e8f9f7 1426 /**
<> 144:ef7eb2e8f9f7 1427 * @brief Write the time counter in RTC_ALR registers.
<> 144:ef7eb2e8f9f7 1428 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1429 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1430 * @param AlarmCounter: Counter to write in RTC_ALR registers
<> 144:ef7eb2e8f9f7 1431 * @retval HAL status
<> 144:ef7eb2e8f9f7 1432 */
<> 144:ef7eb2e8f9f7 1433 static HAL_StatusTypeDef RTC_WriteAlarmCounter(RTC_HandleTypeDef* hrtc, uint32_t AlarmCounter)
<> 144:ef7eb2e8f9f7 1434 {
<> 144:ef7eb2e8f9f7 1435 HAL_StatusTypeDef status = HAL_OK;
<> 144:ef7eb2e8f9f7 1436
<> 144:ef7eb2e8f9f7 1437 /* Set Initialization mode */
<> 144:ef7eb2e8f9f7 1438 if(RTC_EnterInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1439 {
<> 144:ef7eb2e8f9f7 1440 status = HAL_ERROR;
<> 144:ef7eb2e8f9f7 1441 }
<> 144:ef7eb2e8f9f7 1442 else
<> 144:ef7eb2e8f9f7 1443 {
<> 144:ef7eb2e8f9f7 1444 /* Set RTC COUNTER MSB word */
<> 144:ef7eb2e8f9f7 1445 WRITE_REG(hrtc->Instance->ALRH, (AlarmCounter >> 16));
<> 144:ef7eb2e8f9f7 1446 /* Set RTC COUNTER LSB word */
<> 144:ef7eb2e8f9f7 1447 WRITE_REG(hrtc->Instance->ALRL, (AlarmCounter & RTC_ALRL_RTC_ALR));
<> 144:ef7eb2e8f9f7 1448
<> 144:ef7eb2e8f9f7 1449 /* Wait for synchro */
<> 144:ef7eb2e8f9f7 1450 if(RTC_ExitInitMode(hrtc) != HAL_OK)
<> 144:ef7eb2e8f9f7 1451 {
<> 144:ef7eb2e8f9f7 1452 status = HAL_ERROR;
<> 144:ef7eb2e8f9f7 1453 }
<> 144:ef7eb2e8f9f7 1454 }
<> 144:ef7eb2e8f9f7 1455
<> 144:ef7eb2e8f9f7 1456 return status;
<> 144:ef7eb2e8f9f7 1457 }
<> 144:ef7eb2e8f9f7 1458
<> 144:ef7eb2e8f9f7 1459 /**
<> 144:ef7eb2e8f9f7 1460 * @brief Enters the RTC Initialization mode.
<> 144:ef7eb2e8f9f7 1461 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1462 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1463 * @retval HAL status
<> 144:ef7eb2e8f9f7 1464 */
<> 144:ef7eb2e8f9f7 1465 static HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1466 {
<> 144:ef7eb2e8f9f7 1467 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1468
<> 144:ef7eb2e8f9f7 1469 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1470 /* Wait till RTC is in INIT state and if Time out is reached exit */
<> 144:ef7eb2e8f9f7 1471 while((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
<> 144:ef7eb2e8f9f7 1472 {
<> 144:ef7eb2e8f9f7 1473 if((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1474 {
<> 144:ef7eb2e8f9f7 1475 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1476 }
<> 144:ef7eb2e8f9f7 1477 }
<> 144:ef7eb2e8f9f7 1478
<> 144:ef7eb2e8f9f7 1479 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1480 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<> 144:ef7eb2e8f9f7 1481
<> 144:ef7eb2e8f9f7 1482
<> 144:ef7eb2e8f9f7 1483 return HAL_OK;
<> 144:ef7eb2e8f9f7 1484 }
<> 144:ef7eb2e8f9f7 1485
<> 144:ef7eb2e8f9f7 1486 /**
<> 144:ef7eb2e8f9f7 1487 * @brief Exit the RTC Initialization mode.
<> 144:ef7eb2e8f9f7 1488 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1489 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1490 * @retval HAL status
<> 144:ef7eb2e8f9f7 1491 */
<> 144:ef7eb2e8f9f7 1492 static HAL_StatusTypeDef RTC_ExitInitMode(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 1493 {
<> 144:ef7eb2e8f9f7 1494 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1495
<> 144:ef7eb2e8f9f7 1496 /* Disable the write protection for RTC registers */
<> 144:ef7eb2e8f9f7 1497 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<> 144:ef7eb2e8f9f7 1498
<> 144:ef7eb2e8f9f7 1499 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1500 /* Wait till RTC is in INIT state and if Time out is reached exit */
<> 144:ef7eb2e8f9f7 1501 while((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
<> 144:ef7eb2e8f9f7 1502 {
<> 144:ef7eb2e8f9f7 1503 if((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 1504 {
<> 144:ef7eb2e8f9f7 1505 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1506 }
<> 144:ef7eb2e8f9f7 1507 }
<> 144:ef7eb2e8f9f7 1508
<> 144:ef7eb2e8f9f7 1509 return HAL_OK;
<> 144:ef7eb2e8f9f7 1510 }
<> 144:ef7eb2e8f9f7 1511
<> 144:ef7eb2e8f9f7 1512 /**
<> 144:ef7eb2e8f9f7 1513 * @brief Converts a 2 digit decimal to BCD format.
<> 144:ef7eb2e8f9f7 1514 * @param Value: Byte to be converted
<> 144:ef7eb2e8f9f7 1515 * @retval Converted byte
<> 144:ef7eb2e8f9f7 1516 */
<> 144:ef7eb2e8f9f7 1517 static uint8_t RTC_ByteToBcd2(uint8_t Value)
<> 144:ef7eb2e8f9f7 1518 {
<> 144:ef7eb2e8f9f7 1519 uint32_t bcdhigh = 0;
<> 144:ef7eb2e8f9f7 1520
<> 144:ef7eb2e8f9f7 1521 while(Value >= 10)
<> 144:ef7eb2e8f9f7 1522 {
<> 144:ef7eb2e8f9f7 1523 bcdhigh++;
<> 144:ef7eb2e8f9f7 1524 Value -= 10;
<> 144:ef7eb2e8f9f7 1525 }
<> 144:ef7eb2e8f9f7 1526
<> 144:ef7eb2e8f9f7 1527 return ((uint8_t)(bcdhigh << 4) | Value);
<> 144:ef7eb2e8f9f7 1528 }
<> 144:ef7eb2e8f9f7 1529
<> 144:ef7eb2e8f9f7 1530 /**
<> 144:ef7eb2e8f9f7 1531 * @brief Converts from 2 digit BCD to Binary.
<> 144:ef7eb2e8f9f7 1532 * @param Value: BCD value to be converted
<> 144:ef7eb2e8f9f7 1533 * @retval Converted word
<> 144:ef7eb2e8f9f7 1534 */
<> 144:ef7eb2e8f9f7 1535 static uint8_t RTC_Bcd2ToByte(uint8_t Value)
<> 144:ef7eb2e8f9f7 1536 {
<> 144:ef7eb2e8f9f7 1537 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 1538 tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10;
<> 144:ef7eb2e8f9f7 1539 return (tmp + (Value & (uint8_t)0x0F));
<> 144:ef7eb2e8f9f7 1540 }
<> 144:ef7eb2e8f9f7 1541
<> 144:ef7eb2e8f9f7 1542 /**
<> 144:ef7eb2e8f9f7 1543 * @brief Updates date when time is 23:59:59.
<> 144:ef7eb2e8f9f7 1544 * @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1545 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 1546 * @param DayElapsed: Number of days elapsed from last date update
<> 144:ef7eb2e8f9f7 1547 * @retval None
<> 144:ef7eb2e8f9f7 1548 */
<> 144:ef7eb2e8f9f7 1549 static void RTC_DateUpdate(RTC_HandleTypeDef* hrtc, uint32_t DayElapsed)
<> 144:ef7eb2e8f9f7 1550 {
<> 144:ef7eb2e8f9f7 1551 uint32_t year = 0, month = 0, day = 0;
<> 144:ef7eb2e8f9f7 1552 uint32_t loop = 0;
<> 144:ef7eb2e8f9f7 1553
<> 144:ef7eb2e8f9f7 1554 /* Get the current year*/
<> 144:ef7eb2e8f9f7 1555 year = hrtc->DateToUpdate.Year;
<> 144:ef7eb2e8f9f7 1556
<> 144:ef7eb2e8f9f7 1557 /* Get the current month and day */
<> 144:ef7eb2e8f9f7 1558 month = hrtc->DateToUpdate.Month;
<> 144:ef7eb2e8f9f7 1559 day = hrtc->DateToUpdate.Date;
<> 144:ef7eb2e8f9f7 1560
<> 144:ef7eb2e8f9f7 1561 for (loop = 0; loop < DayElapsed; loop++)
<> 144:ef7eb2e8f9f7 1562 {
<> 144:ef7eb2e8f9f7 1563 if((month == 1) || (month == 3) || (month == 5) || (month == 7) || \
<> 144:ef7eb2e8f9f7 1564 (month == 8) || (month == 10) || (month == 12))
<> 144:ef7eb2e8f9f7 1565 {
<> 144:ef7eb2e8f9f7 1566 if(day < 31)
<> 144:ef7eb2e8f9f7 1567 {
<> 144:ef7eb2e8f9f7 1568 day++;
<> 144:ef7eb2e8f9f7 1569 }
<> 144:ef7eb2e8f9f7 1570 /* Date structure member: day = 31 */
<> 144:ef7eb2e8f9f7 1571 else
<> 144:ef7eb2e8f9f7 1572 {
<> 144:ef7eb2e8f9f7 1573 if(month != 12)
<> 144:ef7eb2e8f9f7 1574 {
<> 144:ef7eb2e8f9f7 1575 month++;
<> 144:ef7eb2e8f9f7 1576 day = 1;
<> 144:ef7eb2e8f9f7 1577 }
<> 144:ef7eb2e8f9f7 1578 /* Date structure member: day = 31 & month =12 */
<> 144:ef7eb2e8f9f7 1579 else
<> 144:ef7eb2e8f9f7 1580 {
<> 144:ef7eb2e8f9f7 1581 month = 1;
<> 144:ef7eb2e8f9f7 1582 day = 1;
<> 144:ef7eb2e8f9f7 1583 year++;
<> 144:ef7eb2e8f9f7 1584 }
<> 144:ef7eb2e8f9f7 1585 }
<> 144:ef7eb2e8f9f7 1586 }
<> 144:ef7eb2e8f9f7 1587 else if((month == 4) || (month == 6) || (month == 9) || (month == 11))
<> 144:ef7eb2e8f9f7 1588 {
<> 144:ef7eb2e8f9f7 1589 if(day < 30)
<> 144:ef7eb2e8f9f7 1590 {
<> 144:ef7eb2e8f9f7 1591 day++;
<> 144:ef7eb2e8f9f7 1592 }
<> 144:ef7eb2e8f9f7 1593 /* Date structure member: day = 30 */
<> 144:ef7eb2e8f9f7 1594 else
<> 144:ef7eb2e8f9f7 1595 {
<> 144:ef7eb2e8f9f7 1596 month++;
<> 144:ef7eb2e8f9f7 1597 day = 1;
<> 144:ef7eb2e8f9f7 1598 }
<> 144:ef7eb2e8f9f7 1599 }
<> 144:ef7eb2e8f9f7 1600 else if(month == 2)
<> 144:ef7eb2e8f9f7 1601 {
<> 144:ef7eb2e8f9f7 1602 if(day < 28)
<> 144:ef7eb2e8f9f7 1603 {
<> 144:ef7eb2e8f9f7 1604 day++;
<> 144:ef7eb2e8f9f7 1605 }
<> 144:ef7eb2e8f9f7 1606 else if(day == 28)
<> 144:ef7eb2e8f9f7 1607 {
<> 144:ef7eb2e8f9f7 1608 /* Leap year */
<> 144:ef7eb2e8f9f7 1609 if(RTC_IsLeapYear(year))
<> 144:ef7eb2e8f9f7 1610 {
<> 144:ef7eb2e8f9f7 1611 day++;
<> 144:ef7eb2e8f9f7 1612 }
<> 144:ef7eb2e8f9f7 1613 else
<> 144:ef7eb2e8f9f7 1614 {
<> 144:ef7eb2e8f9f7 1615 month++;
<> 144:ef7eb2e8f9f7 1616 day = 1;
<> 144:ef7eb2e8f9f7 1617 }
<> 144:ef7eb2e8f9f7 1618 }
<> 144:ef7eb2e8f9f7 1619 else if(day == 29)
<> 144:ef7eb2e8f9f7 1620 {
<> 144:ef7eb2e8f9f7 1621 month++;
<> 144:ef7eb2e8f9f7 1622 day = 1;
<> 144:ef7eb2e8f9f7 1623 }
<> 144:ef7eb2e8f9f7 1624 }
<> 144:ef7eb2e8f9f7 1625 }
<> 144:ef7eb2e8f9f7 1626
<> 144:ef7eb2e8f9f7 1627 /* Update year */
<> 144:ef7eb2e8f9f7 1628 hrtc->DateToUpdate.Year = year;
<> 144:ef7eb2e8f9f7 1629
<> 144:ef7eb2e8f9f7 1630 /* Update day and month */
<> 144:ef7eb2e8f9f7 1631 hrtc->DateToUpdate.Month = month;
<> 144:ef7eb2e8f9f7 1632 hrtc->DateToUpdate.Date = day;
<> 144:ef7eb2e8f9f7 1633
<> 144:ef7eb2e8f9f7 1634 /* Update day of the week */
<> 144:ef7eb2e8f9f7 1635 hrtc->DateToUpdate.WeekDay = RTC_WeekDayNum(year, month, day);
<> 144:ef7eb2e8f9f7 1636 }
<> 144:ef7eb2e8f9f7 1637
<> 144:ef7eb2e8f9f7 1638 /**
<> 144:ef7eb2e8f9f7 1639 * @brief Check whether the passed year is Leap or not.
<> 144:ef7eb2e8f9f7 1640 * @param nYear year to check
<> 144:ef7eb2e8f9f7 1641 * @retval 1: leap year
<> 144:ef7eb2e8f9f7 1642 * 0: not leap year
<> 144:ef7eb2e8f9f7 1643 */
<> 144:ef7eb2e8f9f7 1644 static uint8_t RTC_IsLeapYear(uint16_t nYear)
<> 144:ef7eb2e8f9f7 1645 {
<> 144:ef7eb2e8f9f7 1646 if((nYear % 4) != 0)
<> 144:ef7eb2e8f9f7 1647 {
<> 144:ef7eb2e8f9f7 1648 return 0;
<> 144:ef7eb2e8f9f7 1649 }
<> 144:ef7eb2e8f9f7 1650
<> 144:ef7eb2e8f9f7 1651 if((nYear % 100) != 0)
<> 144:ef7eb2e8f9f7 1652 {
<> 144:ef7eb2e8f9f7 1653 return 1;
<> 144:ef7eb2e8f9f7 1654 }
<> 144:ef7eb2e8f9f7 1655
<> 144:ef7eb2e8f9f7 1656 if((nYear % 400) == 0)
<> 144:ef7eb2e8f9f7 1657 {
<> 144:ef7eb2e8f9f7 1658 return 1;
<> 144:ef7eb2e8f9f7 1659 }
<> 144:ef7eb2e8f9f7 1660 else
<> 144:ef7eb2e8f9f7 1661 {
<> 144:ef7eb2e8f9f7 1662 return 0;
<> 144:ef7eb2e8f9f7 1663 }
<> 144:ef7eb2e8f9f7 1664 }
<> 144:ef7eb2e8f9f7 1665
<> 144:ef7eb2e8f9f7 1666 /**
<> 144:ef7eb2e8f9f7 1667 * @brief Determines the week number, the day number and the week day number.
<> 144:ef7eb2e8f9f7 1668 * @param nYear year to check
<> 144:ef7eb2e8f9f7 1669 * @param nMonth Month to check
<> 144:ef7eb2e8f9f7 1670 * @param nDay Day to check
<> 144:ef7eb2e8f9f7 1671 * @note Day is calculated with hypothesis that year > 2000
<> 144:ef7eb2e8f9f7 1672 * @retval Value which can take one of the following parameters:
<> 144:ef7eb2e8f9f7 1673 * @arg RTC_WEEKDAY_MONDAY
<> 144:ef7eb2e8f9f7 1674 * @arg RTC_WEEKDAY_TUESDAY
<> 144:ef7eb2e8f9f7 1675 * @arg RTC_WEEKDAY_WEDNESDAY
<> 144:ef7eb2e8f9f7 1676 * @arg RTC_WEEKDAY_THURSDAY
<> 144:ef7eb2e8f9f7 1677 * @arg RTC_WEEKDAY_FRIDAY
<> 144:ef7eb2e8f9f7 1678 * @arg RTC_WEEKDAY_SATURDAY
<> 144:ef7eb2e8f9f7 1679 * @arg RTC_WEEKDAY_SUNDAY
<> 144:ef7eb2e8f9f7 1680 */
<> 144:ef7eb2e8f9f7 1681 static uint8_t RTC_WeekDayNum(uint32_t nYear, uint8_t nMonth, uint8_t nDay)
<> 144:ef7eb2e8f9f7 1682 {
<> 144:ef7eb2e8f9f7 1683 uint32_t year = 0, weekday = 0;
<> 144:ef7eb2e8f9f7 1684
<> 144:ef7eb2e8f9f7 1685 year = 2000 + nYear;
<> 144:ef7eb2e8f9f7 1686
<> 144:ef7eb2e8f9f7 1687 if(nMonth < 3)
<> 144:ef7eb2e8f9f7 1688 {
<> 144:ef7eb2e8f9f7 1689 /*D = { [(23 x month)/9] + day + 4 + year + [(year-1)/4] - [(year-1)/100] + [(year-1)/400] } mod 7*/
<> 144:ef7eb2e8f9f7 1690 weekday = (((23 * nMonth)/9) + nDay + 4 + year + ((year-1)/4) - ((year-1)/100) + ((year-1)/400)) % 7;
<> 144:ef7eb2e8f9f7 1691 }
<> 144:ef7eb2e8f9f7 1692 else
<> 144:ef7eb2e8f9f7 1693 {
<> 144:ef7eb2e8f9f7 1694 /*D = { [(23 x month)/9] + day + 4 + year + [year/4] - [year/100] + [year/400] - 2 } mod 7*/
<> 144:ef7eb2e8f9f7 1695 weekday = (((23 * nMonth)/9) + nDay + 4 + year + (year/4) - (year/100) + (year/400) - 2 ) % 7;
<> 144:ef7eb2e8f9f7 1696 }
<> 144:ef7eb2e8f9f7 1697
<> 144:ef7eb2e8f9f7 1698 return (uint8_t)weekday;
<> 144:ef7eb2e8f9f7 1699 }
<> 144:ef7eb2e8f9f7 1700
<> 144:ef7eb2e8f9f7 1701 /**
<> 144:ef7eb2e8f9f7 1702 * @}
<> 144:ef7eb2e8f9f7 1703 */
<> 144:ef7eb2e8f9f7 1704
<> 144:ef7eb2e8f9f7 1705 #endif /* HAL_RTC_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 1706 /**
<> 144:ef7eb2e8f9f7 1707 * @}
<> 144:ef7eb2e8f9f7 1708 */
<> 144:ef7eb2e8f9f7 1709
<> 144:ef7eb2e8f9f7 1710 /**
<> 144:ef7eb2e8f9f7 1711 * @}
<> 144:ef7eb2e8f9f7 1712 */
<> 144:ef7eb2e8f9f7 1713
<> 144:ef7eb2e8f9f7 1714 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/