Mercurial > public > ostc4

comparison Common/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_rtc.c @ 128:c78bcbd5deda FlipDisplay

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