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