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