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