Mercurial > public > ostc4
comparison Common/Drivers/STM32F4xx_HAL_DRIVER_v120/Src/stm32f4xx_hal_rtc_ex.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_ex.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) Extension peripheral: | |
10 * + RTC Time Stamp functions | |
11 * + RTC Tamper functions | |
12 * + RTC Wake-up functions | |
13 * + Extension Control functions | |
14 * + Extension RTC features functions | |
15 * | |
16 @verbatim | |
17 ============================================================================== | |
18 ##### How to use this driver ##### | |
19 ============================================================================== | |
20 [..] | |
21 (+) Enable the RTC domain access. | |
22 (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and RTC hour | |
23 format using the HAL_RTC_Init() function. | |
24 | |
25 *** RTC Wake-up configuration *** | |
26 ================================ | |
27 [..] | |
28 (+) To configure the RTC Wake-up Clock source and Counter use the HAL_RTC_SetWakeUpTimer() | |
29 function. You can also configure the RTC Wake-up timer in interrupt mode | |
30 using the HAL_RTC_SetWakeUpTimer_IT() function. | |
31 (+) To read the RTC Wake-up Counter register, use the HAL_RTC_GetWakeUpTimer() | |
32 function. | |
33 | |
34 *** TimeStamp configuration *** | |
35 =============================== | |
36 [..] | |
37 (+) Configure the RTC_AFx trigger and enable the RTC TimeStamp using the | |
38 HAL_RTC_SetTimeStamp() function. You can also configure the RTC TimeStamp with | |
39 interrupt mode using the HAL_RTC_SetTimeStamp_IT() function. | |
40 (+) To read the RTC TimeStamp Time and Date register, use the HAL_RTC_GetTimeStamp() | |
41 function. | |
42 (+) The TIMESTAMP alternate function can be mapped either to RTC_AF1 (PC13) | |
43 or RTC_AF2 (PI8) depending on the value of TSINSEL bit in | |
44 RTC_TAFCR register. The corresponding pin is also selected by HAL_RTC_SetTimeStamp() | |
45 or HAL_RTC_SetTimeStamp_IT() function. | |
46 | |
47 *** Tamper configuration *** | |
48 ============================ | |
49 [..] | |
50 (+) Enable the RTC Tamper and configure the Tamper filter count, trigger Edge | |
51 or Level according to the Tamper filter (if equal to 0 Edge else Level) | |
52 value, sampling frequency, precharge or discharge and Pull-UP using the | |
53 HAL_RTC_SetTamper() function. You can configure RTC Tamper in interrupt | |
54 mode using HAL_RTC_SetTamper_IT() function. | |
55 (+) The TAMPER1 alternate function can be mapped either to RTC_AF1 (PC13) | |
56 or RTC_AF2 (PI8) depending on the value of TAMP1INSEL bit in | |
57 RTC_TAFCR register. The corresponding pin is also selected by HAL_RTC_SetTamper() | |
58 or HAL_RTC_SetTamper_IT() function. | |
59 | |
60 *** Backup Data Registers configuration *** | |
61 =========================================== | |
62 [..] | |
63 (+) To write to the RTC Backup Data registers, use the HAL_RTC_BKUPWrite() | |
64 function. | |
65 (+) To read the RTC Backup Data registers, use the HAL_RTC_BKUPRead() | |
66 function. | |
67 | |
68 @endverbatim | |
69 ****************************************************************************** | |
70 * @attention | |
71 * | |
72 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2> | |
73 * | |
74 * Redistribution and use in source and binary forms, with or without modification, | |
75 * are permitted provided that the following conditions are met: | |
76 * 1. Redistributions of source code must retain the above copyright notice, | |
77 * this list of conditions and the following disclaimer. | |
78 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
79 * this list of conditions and the following disclaimer in the documentation | |
80 * and/or other materials provided with the distribution. | |
81 * 3. Neither the name of STMicroelectronics nor the names of its contributors | |
82 * may be used to endorse or promote products derived from this software | |
83 * without specific prior written permission. | |
84 * | |
85 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
86 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
87 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
88 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
89 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
90 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
91 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
92 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
93 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
94 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
95 * | |
96 ****************************************************************************** | |
97 */ | |
98 | |
99 /* Includes ------------------------------------------------------------------*/ | |
100 #include "stm32f4xx_hal.h" | |
101 | |
102 /** @addtogroup STM32F4xx_HAL_Driver | |
103 * @{ | |
104 */ | |
105 | |
106 /** @defgroup RTCEx RTCEx | |
107 * @brief RTC HAL module driver | |
108 * @{ | |
109 */ | |
110 | |
111 #ifdef HAL_RTC_MODULE_ENABLED | |
112 | |
113 /* Private typedef -----------------------------------------------------------*/ | |
114 /* Private define ------------------------------------------------------------*/ | |
115 /* Private macro -------------------------------------------------------------*/ | |
116 /* Private variables ---------------------------------------------------------*/ | |
117 /* Private function prototypes -----------------------------------------------*/ | |
118 /* Private functions ---------------------------------------------------------*/ | |
119 | |
120 /** @defgroup RTCEx_Exported_Functions RTCEx Exported Functions | |
121 * @{ | |
122 */ | |
123 | |
124 /** @defgroup RTCEx_Exported_Functions_Group1 RTC TimeStamp and Tamper functions | |
125 * @brief RTC TimeStamp and Tamper functions | |
126 * | |
127 @verbatim | |
128 =============================================================================== | |
129 ##### RTC TimeStamp and Tamper functions ##### | |
130 =============================================================================== | |
131 | |
132 [..] This section provides functions allowing to configure TimeStamp feature | |
133 | |
134 @endverbatim | |
135 * @{ | |
136 */ | |
137 | |
138 /** | |
139 * @brief Sets TimeStamp. | |
140 * @note This API must be called before enabling the TimeStamp feature. | |
141 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
142 * the configuration information for RTC. | |
143 * @param TimeStampEdge: Specifies the pin edge on which the TimeStamp is | |
144 * activated. | |
145 * This parameter can be one of the following values: | |
146 * @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the | |
147 * rising edge of the related pin. | |
148 * @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the | |
149 * falling edge of the related pin. | |
150 * @param RTC_TimeStampPin: specifies the RTC TimeStamp Pin. | |
151 * This parameter can be one of the following values: | |
152 * @arg RTC_TIMESTAMPPIN_PC13: PC13 is selected as RTC TimeStamp Pin. | |
153 * @arg RTC_TIMESTAMPPIN_PI8: PI8 is selected as RTC TimeStamp Pin. | |
154 * @retval HAL status | |
155 */ | |
156 HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge, uint32_t RTC_TimeStampPin) | |
157 { | |
158 uint32_t tmpreg = 0; | |
159 | |
160 /* Check the parameters */ | |
161 assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge)); | |
162 assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin)); | |
163 | |
164 /* Process Locked */ | |
165 __HAL_LOCK(hrtc); | |
166 | |
167 hrtc->State = HAL_RTC_STATE_BUSY; | |
168 | |
169 /* Get the RTC_CR register and clear the bits to be configured */ | |
170 tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE)); | |
171 | |
172 tmpreg|= TimeStampEdge; | |
173 | |
174 /* Disable the write protection for RTC registers */ | |
175 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
176 | |
177 hrtc->Instance->TAFCR &= (uint32_t)~RTC_TAFCR_TSINSEL; | |
178 hrtc->Instance->TAFCR |= (uint32_t)(RTC_TimeStampPin); | |
179 | |
180 /* Configure the Time Stamp TSEDGE and Enable bits */ | |
181 hrtc->Instance->CR = (uint32_t)tmpreg; | |
182 | |
183 __HAL_RTC_TIMESTAMP_ENABLE(hrtc); | |
184 | |
185 /* Enable the write protection for RTC registers */ | |
186 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
187 | |
188 /* Change RTC state */ | |
189 hrtc->State = HAL_RTC_STATE_READY; | |
190 | |
191 /* Process Unlocked */ | |
192 __HAL_UNLOCK(hrtc); | |
193 | |
194 return HAL_OK; | |
195 } | |
196 | |
197 /** | |
198 * @brief Sets TimeStamp with Interrupt. | |
199 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
200 * the configuration information for RTC. | |
201 * @note This API must be called before enabling the TimeStamp feature. | |
202 * @param TimeStampEdge: Specifies the pin edge on which the TimeStamp is | |
203 * activated. | |
204 * This parameter can be one of the following values: | |
205 * @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the | |
206 * rising edge of the related pin. | |
207 * @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the | |
208 * falling edge of the related pin. | |
209 * @param RTC_TimeStampPin: Specifies the RTC TimeStamp Pin. | |
210 * This parameter can be one of the following values: | |
211 * @arg RTC_TIMESTAMPPIN_PC13: PC13 is selected as RTC TimeStamp Pin. | |
212 * @arg RTC_TIMESTAMPPIN_PI8: PI8 is selected as RTC TimeStamp Pin. | |
213 * @retval HAL status | |
214 */ | |
215 HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp_IT(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge, uint32_t RTC_TimeStampPin) | |
216 { | |
217 uint32_t tmpreg = 0; | |
218 | |
219 /* Check the parameters */ | |
220 assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge)); | |
221 assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin)); | |
222 | |
223 /* Process Locked */ | |
224 __HAL_LOCK(hrtc); | |
225 | |
226 hrtc->State = HAL_RTC_STATE_BUSY; | |
227 | |
228 /* Get the RTC_CR register and clear the bits to be configured */ | |
229 tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE)); | |
230 | |
231 tmpreg |= TimeStampEdge; | |
232 | |
233 /* Disable the write protection for RTC registers */ | |
234 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
235 | |
236 /* Configure the Time Stamp TSEDGE and Enable bits */ | |
237 hrtc->Instance->CR = (uint32_t)tmpreg; | |
238 | |
239 hrtc->Instance->TAFCR &= (uint32_t)~RTC_TAFCR_TSINSEL; | |
240 hrtc->Instance->TAFCR |= (uint32_t)(RTC_TimeStampPin); | |
241 | |
242 __HAL_RTC_TIMESTAMP_ENABLE(hrtc); | |
243 | |
244 /* Enable IT timestamp */ | |
245 __HAL_RTC_TIMESTAMP_ENABLE_IT(hrtc,RTC_IT_TS); | |
246 | |
247 /* RTC timestamp Interrupt Configuration: EXTI configuration */ | |
248 __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_IT(); | |
249 | |
250 EXTI->RTSR |= RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT; | |
251 | |
252 /* Enable the write protection for RTC registers */ | |
253 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
254 | |
255 hrtc->State = HAL_RTC_STATE_READY; | |
256 | |
257 /* Process Unlocked */ | |
258 __HAL_UNLOCK(hrtc); | |
259 | |
260 return HAL_OK; | |
261 } | |
262 | |
263 /** | |
264 * @brief Deactivates TimeStamp. | |
265 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
266 * the configuration information for RTC. | |
267 * @retval HAL status | |
268 */ | |
269 HAL_StatusTypeDef HAL_RTCEx_DeactivateTimeStamp(RTC_HandleTypeDef *hrtc) | |
270 { | |
271 uint32_t tmpreg = 0; | |
272 | |
273 /* Process Locked */ | |
274 __HAL_LOCK(hrtc); | |
275 | |
276 hrtc->State = HAL_RTC_STATE_BUSY; | |
277 | |
278 /* Disable the write protection for RTC registers */ | |
279 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
280 | |
281 /* In case of interrupt mode is used, the interrupt source must disabled */ | |
282 __HAL_RTC_TIMESTAMP_DISABLE_IT(hrtc, RTC_IT_TS); | |
283 | |
284 /* Get the RTC_CR register and clear the bits to be configured */ | |
285 tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE)); | |
286 | |
287 /* Configure the Time Stamp TSEDGE and Enable bits */ | |
288 hrtc->Instance->CR = (uint32_t)tmpreg; | |
289 | |
290 /* Enable the write protection for RTC registers */ | |
291 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
292 | |
293 hrtc->State = HAL_RTC_STATE_READY; | |
294 | |
295 /* Process Unlocked */ | |
296 __HAL_UNLOCK(hrtc); | |
297 | |
298 return HAL_OK; | |
299 } | |
300 | |
301 /** | |
302 * @brief Gets the RTC TimeStamp value. | |
303 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
304 * the configuration information for RTC. | |
305 * @param sTimeStamp: Pointer to Time structure | |
306 * @param sTimeStampDate: Pointer to Date structure | |
307 * @param Format: specifies the format of the entered parameters. | |
308 * This parameter can be one of the following values: | |
309 * RTC_FORMAT_BIN: Binary data format | |
310 * RTC_FORMAT_BCD: BCD data format | |
311 * @retval HAL status | |
312 */ | |
313 HAL_StatusTypeDef HAL_RTCEx_GetTimeStamp(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef* sTimeStamp, RTC_DateTypeDef* sTimeStampDate, uint32_t Format) | |
314 { | |
315 uint32_t tmptime = 0, tmpdate = 0; | |
316 | |
317 /* Check the parameters */ | |
318 assert_param(IS_RTC_FORMAT(Format)); | |
319 | |
320 /* Get the TimeStamp time and date registers values */ | |
321 tmptime = (uint32_t)(hrtc->Instance->TSTR & RTC_TR_RESERVED_MASK); | |
322 tmpdate = (uint32_t)(hrtc->Instance->TSDR & RTC_DR_RESERVED_MASK); | |
323 | |
324 /* Fill the Time structure fields with the read parameters */ | |
325 sTimeStamp->Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16); | |
326 sTimeStamp->Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8); | |
327 sTimeStamp->Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU)); | |
328 sTimeStamp->TimeFormat = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16); | |
329 sTimeStamp->SubSeconds = (uint32_t) hrtc->Instance->TSSSR; | |
330 | |
331 /* Fill the Date structure fields with the read parameters */ | |
332 sTimeStampDate->Year = 0; | |
333 sTimeStampDate->Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8); | |
334 sTimeStampDate->Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU)); | |
335 sTimeStampDate->WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13); | |
336 | |
337 /* Check the input parameters format */ | |
338 if(Format == RTC_FORMAT_BIN) | |
339 { | |
340 /* Convert the TimeStamp structure parameters to Binary format */ | |
341 sTimeStamp->Hours = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Hours); | |
342 sTimeStamp->Minutes = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Minutes); | |
343 sTimeStamp->Seconds = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Seconds); | |
344 | |
345 /* Convert the DateTimeStamp structure parameters to Binary format */ | |
346 sTimeStampDate->Month = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Month); | |
347 sTimeStampDate->Date = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Date); | |
348 sTimeStampDate->WeekDay = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->WeekDay); | |
349 } | |
350 | |
351 /* Clear the TIMESTAMP Flag */ | |
352 __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSF); | |
353 | |
354 return HAL_OK; | |
355 } | |
356 | |
357 /** | |
358 * @brief Sets Tamper | |
359 * @note By calling this API we disable the tamper interrupt for all tampers. | |
360 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
361 * the configuration information for RTC. | |
362 * @param sTamper: Pointer to Tamper Structure. | |
363 * @retval HAL status | |
364 */ | |
365 HAL_StatusTypeDef HAL_RTCEx_SetTamper(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper) | |
366 { | |
367 uint32_t tmpreg = 0; | |
368 | |
369 /* Check the parameters */ | |
370 assert_param(IS_RTC_TAMPER(sTamper->Tamper)); | |
371 assert_param(IS_RTC_TAMPER_PIN(sTamper->PinSelection)); | |
372 assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger)); | |
373 assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter)); | |
374 assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency)); | |
375 assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration)); | |
376 assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp)); | |
377 assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection)); | |
378 | |
379 /* Process Locked */ | |
380 __HAL_LOCK(hrtc); | |
381 | |
382 hrtc->State = HAL_RTC_STATE_BUSY; | |
383 | |
384 if(sTamper->Trigger != RTC_TAMPERTRIGGER_RISINGEDGE) | |
385 { | |
386 sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1); | |
387 } | |
388 | |
389 tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->PinSelection | (uint32_t)sTamper->Trigger |\ | |
390 (uint32_t)sTamper->Filter | (uint32_t)sTamper->SamplingFrequency | (uint32_t)sTamper->PrechargeDuration |\ | |
391 (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection); | |
392 | |
393 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (uint32_t)RTC_TAFCR_TAMPTS |\ | |
394 (uint32_t)RTC_TAFCR_TAMPFREQ | (uint32_t)RTC_TAFCR_TAMPFLT | (uint32_t)RTC_TAFCR_TAMPPRCH |\ | |
395 (uint32_t)RTC_TAFCR_TAMPPUDIS | (uint32_t)RTC_TAFCR_TAMPINSEL | (uint32_t)RTC_TAFCR_TAMPIE); | |
396 | |
397 hrtc->Instance->TAFCR |= tmpreg; | |
398 | |
399 hrtc->State = HAL_RTC_STATE_READY; | |
400 | |
401 /* Process Unlocked */ | |
402 __HAL_UNLOCK(hrtc); | |
403 | |
404 return HAL_OK; | |
405 } | |
406 | |
407 /** | |
408 * @brief Sets Tamper with interrupt. | |
409 * @note By calling this API we force the tamper interrupt for all tampers. | |
410 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
411 * the configuration information for RTC. | |
412 * @param sTamper: Pointer to RTC Tamper. | |
413 * @retval HAL status | |
414 */ | |
415 HAL_StatusTypeDef HAL_RTCEx_SetTamper_IT(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper) | |
416 { | |
417 uint32_t tmpreg = 0; | |
418 | |
419 /* Check the parameters */ | |
420 assert_param(IS_RTC_TAMPER(sTamper->Tamper)); | |
421 assert_param(IS_RTC_TAMPER_PIN(sTamper->PinSelection)); | |
422 assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger)); | |
423 assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter)); | |
424 assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency)); | |
425 assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration)); | |
426 assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp)); | |
427 assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection)); | |
428 | |
429 /* Process Locked */ | |
430 __HAL_LOCK(hrtc); | |
431 | |
432 hrtc->State = HAL_RTC_STATE_BUSY; | |
433 | |
434 /* Configure the tamper trigger */ | |
435 if(sTamper->Trigger != RTC_TAMPERTRIGGER_RISINGEDGE) | |
436 { | |
437 sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1); | |
438 } | |
439 | |
440 tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->PinSelection | (uint32_t)sTamper->Trigger |\ | |
441 (uint32_t)sTamper->Filter | (uint32_t)sTamper->SamplingFrequency | (uint32_t)sTamper->PrechargeDuration |\ | |
442 (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection); | |
443 | |
444 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (uint32_t)RTC_TAFCR_TAMPTS |\ | |
445 (uint32_t)RTC_TAFCR_TAMPFREQ | (uint32_t)RTC_TAFCR_TAMPFLT | (uint32_t)RTC_TAFCR_TAMPPRCH |\ | |
446 (uint32_t)RTC_TAFCR_TAMPPUDIS | (uint32_t)RTC_TAFCR_TAMPINSEL); | |
447 | |
448 hrtc->Instance->TAFCR |= tmpreg; | |
449 | |
450 /* Configure the Tamper Interrupt in the RTC_TAFCR */ | |
451 hrtc->Instance->TAFCR |= (uint32_t)RTC_TAFCR_TAMPIE; | |
452 | |
453 /* RTC Tamper Interrupt Configuration: EXTI configuration */ | |
454 __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_IT(); | |
455 | |
456 EXTI->RTSR |= RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT; | |
457 | |
458 hrtc->State = HAL_RTC_STATE_READY; | |
459 | |
460 /* Process Unlocked */ | |
461 __HAL_UNLOCK(hrtc); | |
462 | |
463 return HAL_OK; | |
464 } | |
465 | |
466 /** | |
467 * @brief Deactivates Tamper. | |
468 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
469 * the configuration information for RTC. | |
470 * @param Tamper: Selected tamper pin. | |
471 * This parameter can be RTC_Tamper_1 and/or RTC_TAMPER_2. | |
472 * @retval HAL status | |
473 */ | |
474 HAL_StatusTypeDef HAL_RTCEx_DeactivateTamper(RTC_HandleTypeDef *hrtc, uint32_t Tamper) | |
475 { | |
476 assert_param(IS_RTC_TAMPER(Tamper)); | |
477 | |
478 /* Process Locked */ | |
479 __HAL_LOCK(hrtc); | |
480 | |
481 hrtc->State = HAL_RTC_STATE_BUSY; | |
482 | |
483 /* Disable the selected Tamper pin */ | |
484 hrtc->Instance->TAFCR &= (uint32_t)~Tamper; | |
485 | |
486 hrtc->State = HAL_RTC_STATE_READY; | |
487 | |
488 /* Process Unlocked */ | |
489 __HAL_UNLOCK(hrtc); | |
490 | |
491 return HAL_OK; | |
492 } | |
493 | |
494 /** | |
495 * @brief This function handles TimeStamp interrupt request. | |
496 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
497 * the configuration information for RTC. | |
498 * @retval None | |
499 */ | |
500 void HAL_RTCEx_TamperTimeStampIRQHandler(RTC_HandleTypeDef *hrtc) | |
501 { | |
502 if(__HAL_RTC_TIMESTAMP_GET_IT(hrtc, RTC_IT_TS)) | |
503 { | |
504 /* Get the status of the Interrupt */ | |
505 if((uint32_t)(hrtc->Instance->CR & RTC_IT_TS) != (uint32_t)RESET) | |
506 { | |
507 /* TIMESTAMP callback */ | |
508 HAL_RTCEx_TimeStampEventCallback(hrtc); | |
509 | |
510 /* Clear the TIMESTAMP interrupt pending bit */ | |
511 __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc,RTC_FLAG_TSF); | |
512 } | |
513 } | |
514 | |
515 /* Get the status of the Interrupt */ | |
516 if(__HAL_RTC_TAMPER_GET_IT(hrtc,RTC_IT_TAMP1)) | |
517 { | |
518 /* Get the TAMPER Interrupt enable bit and pending bit */ | |
519 if(((hrtc->Instance->TAFCR & (RTC_TAFCR_TAMPIE))) != (uint32_t)RESET) | |
520 { | |
521 /* Tamper callback */ | |
522 HAL_RTCEx_Tamper1EventCallback(hrtc); | |
523 | |
524 /* Clear the Tamper interrupt pending bit */ | |
525 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F); | |
526 } | |
527 } | |
528 | |
529 /* Get the status of the Interrupt */ | |
530 if(__HAL_RTC_TAMPER_GET_IT(hrtc, RTC_IT_TAMP2)) | |
531 { | |
532 /* Get the TAMPER Interrupt enable bit and pending bit */ | |
533 if(((hrtc->Instance->TAFCR & RTC_TAFCR_TAMPIE)) != (uint32_t)RESET) | |
534 { | |
535 /* Tamper callback */ | |
536 HAL_RTCEx_Tamper2EventCallback(hrtc); | |
537 | |
538 /* Clear the Tamper interrupt pending bit */ | |
539 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP2F); | |
540 } | |
541 } | |
542 /* Clear the EXTI's Flag for RTC TimeStamp and Tamper */ | |
543 __HAL_RTC_TAMPER_TIMESTAMP_EXTI_CLEAR_FLAG(); | |
544 | |
545 /* Change RTC state */ | |
546 hrtc->State = HAL_RTC_STATE_READY; | |
547 } | |
548 | |
549 /** | |
550 * @brief TimeStamp callback. | |
551 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
552 * the configuration information for RTC. | |
553 * @retval None | |
554 */ | |
555 __weak void HAL_RTCEx_TimeStampEventCallback(RTC_HandleTypeDef *hrtc) | |
556 { | |
557 /* NOTE : This function Should not be modified, when the callback is needed, | |
558 the HAL_RTC_TimeStampEventCallback could be implemented in the user file | |
559 */ | |
560 } | |
561 | |
562 /** | |
563 * @brief Tamper 1 callback. | |
564 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
565 * the configuration information for RTC. | |
566 * @retval None | |
567 */ | |
568 __weak void HAL_RTCEx_Tamper1EventCallback(RTC_HandleTypeDef *hrtc) | |
569 { | |
570 /* NOTE : This function Should not be modified, when the callback is needed, | |
571 the HAL_RTC_Tamper1EventCallback could be implemented in the user file | |
572 */ | |
573 } | |
574 | |
575 /** | |
576 * @brief Tamper 2 callback. | |
577 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
578 * the configuration information for RTC. | |
579 * @retval None | |
580 */ | |
581 __weak void HAL_RTCEx_Tamper2EventCallback(RTC_HandleTypeDef *hrtc) | |
582 { | |
583 /* NOTE : This function Should not be modified, when the callback is needed, | |
584 the HAL_RTC_Tamper2EventCallback could be implemented in the user file | |
585 */ | |
586 } | |
587 | |
588 /** | |
589 * @brief This function handles TimeStamp polling request. | |
590 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
591 * the configuration information for RTC. | |
592 * @param Timeout: Timeout duration | |
593 * @retval HAL status | |
594 */ | |
595 HAL_StatusTypeDef HAL_RTCEx_PollForTimeStampEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout) | |
596 { | |
597 uint32_t tickstart = 0; | |
598 | |
599 /* Get tick */ | |
600 tickstart = HAL_GetTick(); | |
601 | |
602 while(__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSF) == RESET) | |
603 { | |
604 if(__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSOVF) != RESET) | |
605 { | |
606 /* Clear the TIMESTAMP Overrun Flag */ | |
607 __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSOVF); | |
608 | |
609 /* Change TIMESTAMP state */ | |
610 hrtc->State = HAL_RTC_STATE_ERROR; | |
611 | |
612 return HAL_ERROR; | |
613 } | |
614 | |
615 if(Timeout != HAL_MAX_DELAY) | |
616 { | |
617 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) | |
618 { | |
619 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
620 return HAL_TIMEOUT; | |
621 } | |
622 } | |
623 } | |
624 | |
625 /* Change RTC state */ | |
626 hrtc->State = HAL_RTC_STATE_READY; | |
627 | |
628 return HAL_OK; | |
629 } | |
630 | |
631 /** | |
632 * @brief This function handles Tamper1 Polling. | |
633 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
634 * the configuration information for RTC. | |
635 * @param Timeout: Timeout duration | |
636 * @retval HAL status | |
637 */ | |
638 HAL_StatusTypeDef HAL_RTCEx_PollForTamper1Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout) | |
639 { | |
640 uint32_t tickstart = 0; | |
641 | |
642 /* Get tick */ | |
643 tickstart = HAL_GetTick(); | |
644 | |
645 /* Get the status of the Interrupt */ | |
646 while(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F)== RESET) | |
647 { | |
648 if(Timeout != HAL_MAX_DELAY) | |
649 { | |
650 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) | |
651 { | |
652 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
653 return HAL_TIMEOUT; | |
654 } | |
655 } | |
656 } | |
657 | |
658 /* Clear the Tamper Flag */ | |
659 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F); | |
660 | |
661 /* Change RTC state */ | |
662 hrtc->State = HAL_RTC_STATE_READY; | |
663 | |
664 return HAL_OK; | |
665 } | |
666 | |
667 /** | |
668 * @brief This function handles Tamper2 Polling. | |
669 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
670 * the configuration information for RTC. | |
671 * @param Timeout: Timeout duration | |
672 * @retval HAL status | |
673 */ | |
674 HAL_StatusTypeDef HAL_RTCEx_PollForTamper2Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout) | |
675 { | |
676 uint32_t tickstart = 0; | |
677 | |
678 /* Get tick */ | |
679 tickstart = HAL_GetTick(); | |
680 | |
681 /* Get the status of the Interrupt */ | |
682 while(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP2F) == RESET) | |
683 { | |
684 if(Timeout != HAL_MAX_DELAY) | |
685 { | |
686 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) | |
687 { | |
688 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
689 return HAL_TIMEOUT; | |
690 } | |
691 } | |
692 } | |
693 | |
694 /* Clear the Tamper Flag */ | |
695 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP2F); | |
696 | |
697 /* Change RTC state */ | |
698 hrtc->State = HAL_RTC_STATE_READY; | |
699 | |
700 return HAL_OK; | |
701 } | |
702 | |
703 /** | |
704 * @} | |
705 */ | |
706 | |
707 /** @defgroup RTCEx_Exported_Functions_Group2 RTC Wake-up functions | |
708 * @brief RTC Wake-up functions | |
709 * | |
710 @verbatim | |
711 =============================================================================== | |
712 ##### RTC Wake-up functions ##### | |
713 =============================================================================== | |
714 | |
715 [..] This section provides functions allowing to configure Wake-up feature | |
716 | |
717 @endverbatim | |
718 * @{ | |
719 */ | |
720 | |
721 /** | |
722 * @brief Sets wake up timer. | |
723 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
724 * the configuration information for RTC. | |
725 * @param WakeUpCounter: Wake up counter | |
726 * @param WakeUpClock: Wake up clock | |
727 * @retval HAL status | |
728 */ | |
729 HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock) | |
730 { | |
731 uint32_t tickstart = 0; | |
732 | |
733 /* Check the parameters */ | |
734 assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock)); | |
735 assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter)); | |
736 | |
737 /* Process Locked */ | |
738 __HAL_LOCK(hrtc); | |
739 | |
740 hrtc->State = HAL_RTC_STATE_BUSY; | |
741 | |
742 /* Disable the write protection for RTC registers */ | |
743 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
744 | |
745 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc); | |
746 | |
747 /* Get tick */ | |
748 tickstart = HAL_GetTick(); | |
749 | |
750 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */ | |
751 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET) | |
752 { | |
753 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE) | |
754 { | |
755 /* Enable the write protection for RTC registers */ | |
756 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
757 | |
758 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
759 | |
760 /* Process Unlocked */ | |
761 __HAL_UNLOCK(hrtc); | |
762 | |
763 return HAL_TIMEOUT; | |
764 } | |
765 } | |
766 | |
767 /* Clear the Wake-up Timer clock source bits in CR register */ | |
768 hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL; | |
769 | |
770 /* Configure the clock source */ | |
771 hrtc->Instance->CR |= (uint32_t)WakeUpClock; | |
772 | |
773 /* Configure the Wake-up Timer counter */ | |
774 hrtc->Instance->WUTR = (uint32_t)WakeUpCounter; | |
775 | |
776 /* Enable the Wake-up Timer */ | |
777 __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc); | |
778 | |
779 /* Enable the write protection for RTC registers */ | |
780 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
781 | |
782 hrtc->State = HAL_RTC_STATE_READY; | |
783 | |
784 /* Process Unlocked */ | |
785 __HAL_UNLOCK(hrtc); | |
786 | |
787 return HAL_OK; | |
788 } | |
789 | |
790 /** | |
791 * @brief Sets wake up timer with interrupt | |
792 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
793 * the configuration information for RTC. | |
794 * @param WakeUpCounter: Wake up counter | |
795 * @param WakeUpClock: Wake up clock | |
796 * @retval HAL status | |
797 */ | |
798 HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer_IT(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock) | |
799 { | |
800 uint32_t tickstart = 0; | |
801 | |
802 /* Check the parameters */ | |
803 assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock)); | |
804 assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter)); | |
805 | |
806 /* Process Locked */ | |
807 __HAL_LOCK(hrtc); | |
808 | |
809 hrtc->State = HAL_RTC_STATE_BUSY; | |
810 | |
811 /* Disable the write protection for RTC registers */ | |
812 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
813 | |
814 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc); | |
815 | |
816 /* Get tick */ | |
817 tickstart = HAL_GetTick(); | |
818 | |
819 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */ | |
820 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET) | |
821 { | |
822 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE) | |
823 { | |
824 /* Enable the write protection for RTC registers */ | |
825 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
826 | |
827 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
828 | |
829 /* Process Unlocked */ | |
830 __HAL_UNLOCK(hrtc); | |
831 | |
832 return HAL_TIMEOUT; | |
833 } | |
834 } | |
835 | |
836 /* Configure the Wake-up Timer counter */ | |
837 hrtc->Instance->WUTR = (uint32_t)WakeUpCounter; | |
838 | |
839 /* Clear the Wake-up Timer clock source bits in CR register */ | |
840 hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL; | |
841 | |
842 /* Configure the clock source */ | |
843 hrtc->Instance->CR |= (uint32_t)WakeUpClock; | |
844 | |
845 /* RTC WakeUpTimer Interrupt Configuration: EXTI configuration */ | |
846 __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_IT(); | |
847 | |
848 EXTI->RTSR |= RTC_EXTI_LINE_WAKEUPTIMER_EVENT; | |
849 | |
850 /* Configure the Interrupt in the RTC_CR register */ | |
851 __HAL_RTC_WAKEUPTIMER_ENABLE_IT(hrtc,RTC_IT_WUT); | |
852 | |
853 /* Enable the Wake-up Timer */ | |
854 __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc); | |
855 | |
856 /* Enable the write protection for RTC registers */ | |
857 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
858 | |
859 hrtc->State = HAL_RTC_STATE_READY; | |
860 | |
861 /* Process Unlocked */ | |
862 __HAL_UNLOCK(hrtc); | |
863 | |
864 return HAL_OK; | |
865 } | |
866 | |
867 /** | |
868 * @brief Deactivates wake up timer counter. | |
869 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
870 * the configuration information for RTC. | |
871 * @retval HAL status | |
872 */ | |
873 uint32_t HAL_RTCEx_DeactivateWakeUpTimer(RTC_HandleTypeDef *hrtc) | |
874 { | |
875 uint32_t tickstart = 0; | |
876 | |
877 /* Process Locked */ | |
878 __HAL_LOCK(hrtc); | |
879 | |
880 hrtc->State = HAL_RTC_STATE_BUSY; | |
881 | |
882 /* Disable the write protection for RTC registers */ | |
883 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
884 | |
885 /* Disable the Wake-up Timer */ | |
886 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc); | |
887 | |
888 /* In case of interrupt mode is used, the interrupt source must disabled */ | |
889 __HAL_RTC_WAKEUPTIMER_DISABLE_IT(hrtc,RTC_IT_WUT); | |
890 | |
891 /* Get tick */ | |
892 tickstart = HAL_GetTick(); | |
893 | |
894 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */ | |
895 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET) | |
896 { | |
897 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE) | |
898 { | |
899 /* Enable the write protection for RTC registers */ | |
900 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
901 | |
902 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
903 | |
904 /* Process Unlocked */ | |
905 __HAL_UNLOCK(hrtc); | |
906 | |
907 return HAL_TIMEOUT; | |
908 } | |
909 } | |
910 | |
911 /* Enable the write protection for RTC registers */ | |
912 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
913 | |
914 hrtc->State = HAL_RTC_STATE_READY; | |
915 | |
916 /* Process Unlocked */ | |
917 __HAL_UNLOCK(hrtc); | |
918 | |
919 return HAL_OK; | |
920 } | |
921 | |
922 /** | |
923 * @brief Gets wake up timer counter. | |
924 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
925 * the configuration information for RTC. | |
926 * @retval Counter value | |
927 */ | |
928 uint32_t HAL_RTCEx_GetWakeUpTimer(RTC_HandleTypeDef *hrtc) | |
929 { | |
930 /* Get the counter value */ | |
931 return ((uint32_t)(hrtc->Instance->WUTR & RTC_WUTR_WUT)); | |
932 } | |
933 | |
934 /** | |
935 * @brief This function handles Wake Up Timer interrupt request. | |
936 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
937 * the configuration information for RTC. | |
938 * @retval None | |
939 */ | |
940 void HAL_RTCEx_WakeUpTimerIRQHandler(RTC_HandleTypeDef *hrtc) | |
941 { | |
942 if(__HAL_RTC_WAKEUPTIMER_GET_IT(hrtc, RTC_IT_WUT)) | |
943 { | |
944 /* Get the status of the Interrupt */ | |
945 if((uint32_t)(hrtc->Instance->CR & RTC_IT_WUT) != (uint32_t)RESET) | |
946 { | |
947 /* WAKEUPTIMER callback */ | |
948 HAL_RTCEx_WakeUpTimerEventCallback(hrtc); | |
949 | |
950 /* Clear the WAKEUPTIMER interrupt pending bit */ | |
951 __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF); | |
952 } | |
953 } | |
954 | |
955 /* Clear the EXTI's line Flag for RTC WakeUpTimer */ | |
956 __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG(); | |
957 | |
958 /* Change RTC state */ | |
959 hrtc->State = HAL_RTC_STATE_READY; | |
960 } | |
961 | |
962 /** | |
963 * @brief Wake Up Timer callback. | |
964 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
965 * the configuration information for RTC. | |
966 * @retval None | |
967 */ | |
968 __weak void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc) | |
969 { | |
970 /* NOTE : This function Should not be modified, when the callback is needed, | |
971 the HAL_RTC_WakeUpTimerEventCallback could be implemented in the user file | |
972 */ | |
973 } | |
974 | |
975 /** | |
976 * @brief This function handles Wake Up Timer Polling. | |
977 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
978 * the configuration information for RTC. | |
979 * @param Timeout: Timeout duration | |
980 * @retval HAL status | |
981 */ | |
982 HAL_StatusTypeDef HAL_RTCEx_PollForWakeUpTimerEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout) | |
983 { | |
984 uint32_t tickstart = 0; | |
985 | |
986 /* Get tick */ | |
987 tickstart = HAL_GetTick(); | |
988 | |
989 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) == RESET) | |
990 { | |
991 if(Timeout != HAL_MAX_DELAY) | |
992 { | |
993 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) | |
994 { | |
995 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
996 | |
997 return HAL_TIMEOUT; | |
998 } | |
999 } | |
1000 } | |
1001 | |
1002 /* Clear the WAKEUPTIMER Flag */ | |
1003 __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF); | |
1004 | |
1005 /* Change RTC state */ | |
1006 hrtc->State = HAL_RTC_STATE_READY; | |
1007 | |
1008 return HAL_OK; | |
1009 } | |
1010 | |
1011 /** | |
1012 * @} | |
1013 */ | |
1014 | |
1015 | |
1016 /** @defgroup RTCEx_Exported_Functions_Group3 Extension Peripheral Control functions | |
1017 * @brief Extension Peripheral Control functions | |
1018 * | |
1019 @verbatim | |
1020 =============================================================================== | |
1021 ##### Extension Peripheral Control functions ##### | |
1022 =============================================================================== | |
1023 [..] | |
1024 This subsection provides functions allowing to | |
1025 (+) Write a data in a specified RTC Backup data register | |
1026 (+) Read a data in a specified RTC Backup data register | |
1027 (+) Set the Coarse calibration parameters. | |
1028 (+) Deactivate the Coarse calibration parameters | |
1029 (+) Set the Smooth calibration parameters. | |
1030 (+) Configure the Synchronization Shift Control Settings. | |
1031 (+) Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz). | |
1032 (+) Deactivate the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz). | |
1033 (+) Enable the RTC reference clock detection. | |
1034 (+) Disable the RTC reference clock detection. | |
1035 (+) Enable the Bypass Shadow feature. | |
1036 (+) Disable the Bypass Shadow feature. | |
1037 | |
1038 @endverbatim | |
1039 * @{ | |
1040 */ | |
1041 | |
1042 /** | |
1043 * @brief Writes a data in a specified RTC Backup data register. | |
1044 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1045 * the configuration information for RTC. | |
1046 * @param BackupRegister: RTC Backup data Register number. | |
1047 * This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to | |
1048 * specify the register. | |
1049 * @param Data: Data to be written in the specified RTC Backup data register. | |
1050 * @retval None | |
1051 */ | |
1052 void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data) | |
1053 { | |
1054 uint32_t tmp = 0; | |
1055 | |
1056 /* Check the parameters */ | |
1057 assert_param(IS_RTC_BKP(BackupRegister)); | |
1058 | |
1059 tmp = (uint32_t)&(hrtc->Instance->BKP0R); | |
1060 tmp += (BackupRegister * 4); | |
1061 | |
1062 /* Write the specified register */ | |
1063 *(__IO uint32_t *)tmp = (uint32_t)Data; | |
1064 } | |
1065 | |
1066 /** | |
1067 * @brief Reads data from the specified RTC Backup data Register. | |
1068 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1069 * the configuration information for RTC. | |
1070 * @param BackupRegister: RTC Backup data Register number. | |
1071 * This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to | |
1072 * specify the register. | |
1073 * @retval Read value | |
1074 */ | |
1075 uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister) | |
1076 { | |
1077 uint32_t tmp = 0; | |
1078 | |
1079 /* Check the parameters */ | |
1080 assert_param(IS_RTC_BKP(BackupRegister)); | |
1081 | |
1082 tmp = (uint32_t)&(hrtc->Instance->BKP0R); | |
1083 tmp += (BackupRegister * 4); | |
1084 | |
1085 /* Read the specified register */ | |
1086 return (*(__IO uint32_t *)tmp); | |
1087 } | |
1088 | |
1089 /** | |
1090 * @brief Sets the Coarse calibration parameters. | |
1091 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1092 * the configuration information for RTC. | |
1093 * @param CalibSign: Specifies the sign of the coarse calibration value. | |
1094 * This parameter can be one of the following values : | |
1095 * @arg RTC_CALIBSIGN_POSITIVE: The value sign is positive | |
1096 * @arg RTC_CALIBSIGN_NEGATIVE: The value sign is negative | |
1097 * @param Value: value of coarse calibration expressed in ppm (coded on 5 bits). | |
1098 * | |
1099 * @note This Calibration value should be between 0 and 63 when using negative | |
1100 * sign with a 2-ppm step. | |
1101 * | |
1102 * @note This Calibration value should be between 0 and 126 when using positive | |
1103 * sign with a 4-ppm step. | |
1104 * @retval HAL status | |
1105 */ | |
1106 HAL_StatusTypeDef HAL_RTCEx_SetCoarseCalib(RTC_HandleTypeDef* hrtc, uint32_t CalibSign, uint32_t Value) | |
1107 { | |
1108 /* Check the parameters */ | |
1109 assert_param(IS_RTC_CALIB_SIGN(CalibSign)); | |
1110 assert_param(IS_RTC_CALIB_VALUE(Value)); | |
1111 | |
1112 /* Process Locked */ | |
1113 __HAL_LOCK(hrtc); | |
1114 | |
1115 hrtc->State = HAL_RTC_STATE_BUSY; | |
1116 | |
1117 /* Disable the write protection for RTC registers */ | |
1118 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1119 | |
1120 /* Set Initialization mode */ | |
1121 if(RTC_EnterInitMode(hrtc) != HAL_OK) | |
1122 { | |
1123 /* Enable the write protection for RTC registers */ | |
1124 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1125 | |
1126 /* Set RTC state*/ | |
1127 hrtc->State = HAL_RTC_STATE_ERROR; | |
1128 | |
1129 /* Process Unlocked */ | |
1130 __HAL_UNLOCK(hrtc); | |
1131 | |
1132 return HAL_ERROR; | |
1133 } | |
1134 else | |
1135 { | |
1136 /* Enable the Coarse Calibration */ | |
1137 __HAL_RTC_COARSE_CALIB_ENABLE(hrtc); | |
1138 | |
1139 /* Set the coarse calibration value */ | |
1140 hrtc->Instance->CALIBR = (uint32_t)(CalibSign|Value); | |
1141 | |
1142 /* Exit Initialization mode */ | |
1143 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; | |
1144 } | |
1145 | |
1146 /* Enable the write protection for RTC registers */ | |
1147 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1148 | |
1149 /* Change state */ | |
1150 hrtc->State = HAL_RTC_STATE_READY; | |
1151 | |
1152 /* Process Unlocked */ | |
1153 __HAL_UNLOCK(hrtc); | |
1154 | |
1155 return HAL_OK; | |
1156 } | |
1157 | |
1158 /** | |
1159 * @brief Deactivates the Coarse calibration parameters. | |
1160 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1161 * the configuration information for RTC. | |
1162 * @retval HAL status | |
1163 */ | |
1164 HAL_StatusTypeDef HAL_RTCEx_DeactivateCoarseCalib(RTC_HandleTypeDef* hrtc) | |
1165 { | |
1166 /* Process Locked */ | |
1167 __HAL_LOCK(hrtc); | |
1168 | |
1169 hrtc->State = HAL_RTC_STATE_BUSY; | |
1170 | |
1171 /* Disable the write protection for RTC registers */ | |
1172 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1173 | |
1174 /* Set Initialization mode */ | |
1175 if(RTC_EnterInitMode(hrtc) != HAL_OK) | |
1176 { | |
1177 /* Enable the write protection for RTC registers */ | |
1178 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1179 | |
1180 /* Set RTC state*/ | |
1181 hrtc->State = HAL_RTC_STATE_ERROR; | |
1182 | |
1183 /* Process Unlocked */ | |
1184 __HAL_UNLOCK(hrtc); | |
1185 | |
1186 return HAL_ERROR; | |
1187 } | |
1188 else | |
1189 { | |
1190 /* Enable the Coarse Calibration */ | |
1191 __HAL_RTC_COARSE_CALIB_DISABLE(hrtc); | |
1192 | |
1193 /* Exit Initialization mode */ | |
1194 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; | |
1195 } | |
1196 | |
1197 /* Enable the write protection for RTC registers */ | |
1198 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1199 | |
1200 /* Change state */ | |
1201 hrtc->State = HAL_RTC_STATE_READY; | |
1202 | |
1203 /* Process Unlocked */ | |
1204 __HAL_UNLOCK(hrtc); | |
1205 | |
1206 return HAL_OK; | |
1207 } | |
1208 | |
1209 /** | |
1210 * @brief Sets the Smooth calibration parameters. | |
1211 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1212 * the configuration information for RTC. | |
1213 * @param SmoothCalibPeriod: Select the Smooth Calibration Period. | |
1214 * This parameter can be can be one of the following values : | |
1215 * @arg RTC_SMOOTHCALIB_PERIOD_32SEC: The smooth calibration period is 32s. | |
1216 * @arg RTC_SMOOTHCALIB_PERIOD_16SEC: The smooth calibration period is 16s. | |
1217 * @arg RTC_SMOOTHCALIB_PERIOD_8SEC: The smooth calibration period is 8s. | |
1218 * @param SmoothCalibPlusPulses: Select to Set or reset the CALP bit. | |
1219 * This parameter can be one of the following values: | |
1220 * @arg RTC_SMOOTHCALIB_PLUSPULSES_SET: Add one RTCCLK pulse every 2*11 pulses. | |
1221 * @arg RTC_SMOOTHCALIB_PLUSPULSES_RESET: No RTCCLK pulses are added. | |
1222 * @param SmouthCalibMinusPulsesValue: Select the value of CALM[8:0] bits. | |
1223 * This parameter can be one any value from 0 to 0x000001FF. | |
1224 * @note To deactivate the smooth calibration, the field SmoothCalibPlusPulses | |
1225 * must be equal to SMOOTHCALIB_PLUSPULSES_RESET and the field | |
1226 * SmouthCalibMinusPulsesValue must be equal to 0. | |
1227 * @retval HAL status | |
1228 */ | |
1229 HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef* hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmouthCalibMinusPulsesValue) | |
1230 { | |
1231 uint32_t tickstart = 0; | |
1232 | |
1233 /* Check the parameters */ | |
1234 assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(SmoothCalibPeriod)); | |
1235 assert_param(IS_RTC_SMOOTH_CALIB_PLUS(SmoothCalibPlusPulses)); | |
1236 assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmouthCalibMinusPulsesValue)); | |
1237 | |
1238 /* Process Locked */ | |
1239 __HAL_LOCK(hrtc); | |
1240 | |
1241 hrtc->State = HAL_RTC_STATE_BUSY; | |
1242 | |
1243 /* Disable the write protection for RTC registers */ | |
1244 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1245 | |
1246 /* check if a calibration is pending*/ | |
1247 if((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET) | |
1248 { | |
1249 /* Get tick */ | |
1250 tickstart = HAL_GetTick(); | |
1251 | |
1252 /* check if a calibration is pending*/ | |
1253 while((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET) | |
1254 { | |
1255 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE) | |
1256 { | |
1257 /* Enable the write protection for RTC registers */ | |
1258 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1259 | |
1260 /* Change RTC state */ | |
1261 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
1262 | |
1263 /* Process Unlocked */ | |
1264 __HAL_UNLOCK(hrtc); | |
1265 | |
1266 return HAL_TIMEOUT; | |
1267 } | |
1268 } | |
1269 } | |
1270 | |
1271 /* Configure the Smooth calibration settings */ | |
1272 hrtc->Instance->CALR = (uint32_t)((uint32_t)SmoothCalibPeriod | (uint32_t)SmoothCalibPlusPulses | (uint32_t)SmouthCalibMinusPulsesValue); | |
1273 | |
1274 /* Enable the write protection for RTC registers */ | |
1275 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1276 | |
1277 /* Change RTC state */ | |
1278 hrtc->State = HAL_RTC_STATE_READY; | |
1279 | |
1280 /* Process Unlocked */ | |
1281 __HAL_UNLOCK(hrtc); | |
1282 | |
1283 return HAL_OK; | |
1284 } | |
1285 | |
1286 /** | |
1287 * @brief Configures the Synchronization Shift Control Settings. | |
1288 * @note When REFCKON is set, firmware must not write to Shift control register. | |
1289 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1290 * the configuration information for RTC. | |
1291 * @param ShiftAdd1S: Select to add or not 1 second to the time calendar. | |
1292 * This parameter can be one of the following values : | |
1293 * @arg RTC_SHIFTADD1S_SET: Add one second to the clock calendar. | |
1294 * @arg RTC_SHIFTADD1S_RESET: No effect. | |
1295 * @param ShiftSubFS: Select the number of Second Fractions to substitute. | |
1296 * This parameter can be one any value from 0 to 0x7FFF. | |
1297 * @retval HAL status | |
1298 */ | |
1299 HAL_StatusTypeDef HAL_RTCEx_SetSynchroShift(RTC_HandleTypeDef* hrtc, uint32_t ShiftAdd1S, uint32_t ShiftSubFS) | |
1300 { | |
1301 uint32_t tickstart = 0; | |
1302 | |
1303 /* Check the parameters */ | |
1304 assert_param(IS_RTC_SHIFT_ADD1S(ShiftAdd1S)); | |
1305 assert_param(IS_RTC_SHIFT_SUBFS(ShiftSubFS)); | |
1306 | |
1307 /* Process Locked */ | |
1308 __HAL_LOCK(hrtc); | |
1309 | |
1310 hrtc->State = HAL_RTC_STATE_BUSY; | |
1311 | |
1312 /* Disable the write protection for RTC registers */ | |
1313 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1314 | |
1315 /* Get tick */ | |
1316 tickstart = HAL_GetTick(); | |
1317 | |
1318 /* Wait until the shift is completed*/ | |
1319 while((hrtc->Instance->ISR & RTC_ISR_SHPF) != RESET) | |
1320 { | |
1321 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE) | |
1322 { | |
1323 /* Enable the write protection for RTC registers */ | |
1324 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1325 | |
1326 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
1327 | |
1328 /* Process Unlocked */ | |
1329 __HAL_UNLOCK(hrtc); | |
1330 | |
1331 return HAL_TIMEOUT; | |
1332 } | |
1333 } | |
1334 | |
1335 /* Check if the reference clock detection is disabled */ | |
1336 if((hrtc->Instance->CR & RTC_CR_REFCKON) == RESET) | |
1337 { | |
1338 /* Configure the Shift settings */ | |
1339 hrtc->Instance->SHIFTR = (uint32_t)(uint32_t)(ShiftSubFS) | (uint32_t)(ShiftAdd1S); | |
1340 | |
1341 /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */ | |
1342 if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET) | |
1343 { | |
1344 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK) | |
1345 { | |
1346 /* Enable the write protection for RTC registers */ | |
1347 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1348 | |
1349 hrtc->State = HAL_RTC_STATE_ERROR; | |
1350 | |
1351 /* Process Unlocked */ | |
1352 __HAL_UNLOCK(hrtc); | |
1353 | |
1354 return HAL_ERROR; | |
1355 } | |
1356 } | |
1357 } | |
1358 else | |
1359 { | |
1360 /* Enable the write protection for RTC registers */ | |
1361 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1362 | |
1363 /* Change RTC state */ | |
1364 hrtc->State = HAL_RTC_STATE_ERROR; | |
1365 | |
1366 /* Process Unlocked */ | |
1367 __HAL_UNLOCK(hrtc); | |
1368 | |
1369 return HAL_ERROR; | |
1370 } | |
1371 | |
1372 /* Enable the write protection for RTC registers */ | |
1373 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1374 | |
1375 /* Change RTC state */ | |
1376 hrtc->State = HAL_RTC_STATE_READY; | |
1377 | |
1378 /* Process Unlocked */ | |
1379 __HAL_UNLOCK(hrtc); | |
1380 | |
1381 return HAL_OK; | |
1382 } | |
1383 | |
1384 /** | |
1385 * @brief Configures the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz). | |
1386 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1387 * the configuration information for RTC. | |
1388 * @param CalibOutput: Select the Calibration output Selection . | |
1389 * This parameter can be one of the following values: | |
1390 * @arg RTC_CALIBOUTPUT_512HZ: A signal has a regular waveform at 512Hz. | |
1391 * @arg RTC_CALIBOUTPUT_1HZ: A signal has a regular waveform at 1Hz. | |
1392 * @retval HAL status | |
1393 */ | |
1394 HAL_StatusTypeDef HAL_RTCEx_SetCalibrationOutPut(RTC_HandleTypeDef* hrtc, uint32_t CalibOutput) | |
1395 { | |
1396 /* Check the parameters */ | |
1397 assert_param(IS_RTC_CALIB_OUTPUT(CalibOutput)); | |
1398 | |
1399 /* Process Locked */ | |
1400 __HAL_LOCK(hrtc); | |
1401 | |
1402 hrtc->State = HAL_RTC_STATE_BUSY; | |
1403 | |
1404 /* Disable the write protection for RTC registers */ | |
1405 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1406 | |
1407 /* Clear flags before config */ | |
1408 hrtc->Instance->CR &= (uint32_t)~RTC_CR_COSEL; | |
1409 | |
1410 /* Configure the RTC_CR register */ | |
1411 hrtc->Instance->CR |= (uint32_t)CalibOutput; | |
1412 | |
1413 __HAL_RTC_CALIBRATION_OUTPUT_ENABLE(hrtc); | |
1414 | |
1415 /* Enable the write protection for RTC registers */ | |
1416 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1417 | |
1418 /* Change RTC state */ | |
1419 hrtc->State = HAL_RTC_STATE_READY; | |
1420 | |
1421 /* Process Unlocked */ | |
1422 __HAL_UNLOCK(hrtc); | |
1423 | |
1424 return HAL_OK; | |
1425 } | |
1426 | |
1427 /** | |
1428 * @brief Deactivates the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz). | |
1429 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1430 * the configuration information for RTC. | |
1431 * @retval HAL status | |
1432 */ | |
1433 HAL_StatusTypeDef HAL_RTCEx_DeactivateCalibrationOutPut(RTC_HandleTypeDef* hrtc) | |
1434 { | |
1435 /* Process Locked */ | |
1436 __HAL_LOCK(hrtc); | |
1437 | |
1438 hrtc->State = HAL_RTC_STATE_BUSY; | |
1439 | |
1440 /* Disable the write protection for RTC registers */ | |
1441 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1442 | |
1443 __HAL_RTC_CALIBRATION_OUTPUT_DISABLE(hrtc); | |
1444 | |
1445 /* Enable the write protection for RTC registers */ | |
1446 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1447 | |
1448 /* Change RTC state */ | |
1449 hrtc->State = HAL_RTC_STATE_READY; | |
1450 | |
1451 /* Process Unlocked */ | |
1452 __HAL_UNLOCK(hrtc); | |
1453 | |
1454 return HAL_OK; | |
1455 } | |
1456 | |
1457 /** | |
1458 * @brief Enables the RTC reference clock detection. | |
1459 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1460 * the configuration information for RTC. | |
1461 * @retval HAL status | |
1462 */ | |
1463 HAL_StatusTypeDef HAL_RTCEx_SetRefClock(RTC_HandleTypeDef* hrtc) | |
1464 { | |
1465 /* Process Locked */ | |
1466 __HAL_LOCK(hrtc); | |
1467 | |
1468 hrtc->State = HAL_RTC_STATE_BUSY; | |
1469 | |
1470 /* Disable the write protection for RTC registers */ | |
1471 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1472 | |
1473 /* Set Initialization mode */ | |
1474 if(RTC_EnterInitMode(hrtc) != HAL_OK) | |
1475 { | |
1476 /* Enable the write protection for RTC registers */ | |
1477 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1478 | |
1479 /* Set RTC state*/ | |
1480 hrtc->State = HAL_RTC_STATE_ERROR; | |
1481 | |
1482 /* Process Unlocked */ | |
1483 __HAL_UNLOCK(hrtc); | |
1484 | |
1485 return HAL_ERROR; | |
1486 } | |
1487 else | |
1488 { | |
1489 __HAL_RTC_CLOCKREF_DETECTION_ENABLE(hrtc); | |
1490 | |
1491 /* Exit Initialization mode */ | |
1492 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; | |
1493 } | |
1494 | |
1495 /* Enable the write protection for RTC registers */ | |
1496 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1497 | |
1498 /* Change RTC state */ | |
1499 hrtc->State = HAL_RTC_STATE_READY; | |
1500 | |
1501 /* Process Unlocked */ | |
1502 __HAL_UNLOCK(hrtc); | |
1503 | |
1504 return HAL_OK; | |
1505 } | |
1506 | |
1507 /** | |
1508 * @brief Disable the RTC reference clock detection. | |
1509 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1510 * the configuration information for RTC. | |
1511 * @retval HAL status | |
1512 */ | |
1513 HAL_StatusTypeDef HAL_RTCEx_DeactivateRefClock(RTC_HandleTypeDef* hrtc) | |
1514 { | |
1515 /* Process Locked */ | |
1516 __HAL_LOCK(hrtc); | |
1517 | |
1518 hrtc->State = HAL_RTC_STATE_BUSY; | |
1519 | |
1520 /* Disable the write protection for RTC registers */ | |
1521 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1522 | |
1523 /* Set Initialization mode */ | |
1524 if(RTC_EnterInitMode(hrtc) != HAL_OK) | |
1525 { | |
1526 /* Enable the write protection for RTC registers */ | |
1527 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1528 | |
1529 /* Set RTC state*/ | |
1530 hrtc->State = HAL_RTC_STATE_ERROR; | |
1531 | |
1532 /* Process Unlocked */ | |
1533 __HAL_UNLOCK(hrtc); | |
1534 | |
1535 return HAL_ERROR; | |
1536 } | |
1537 else | |
1538 { | |
1539 __HAL_RTC_CLOCKREF_DETECTION_DISABLE(hrtc); | |
1540 | |
1541 /* Exit Initialization mode */ | |
1542 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; | |
1543 } | |
1544 | |
1545 /* Enable the write protection for RTC registers */ | |
1546 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1547 | |
1548 /* Change RTC state */ | |
1549 hrtc->State = HAL_RTC_STATE_READY; | |
1550 | |
1551 /* Process Unlocked */ | |
1552 __HAL_UNLOCK(hrtc); | |
1553 | |
1554 return HAL_OK; | |
1555 } | |
1556 | |
1557 /** | |
1558 * @brief Enables the Bypass Shadow feature. | |
1559 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1560 * the configuration information for RTC. | |
1561 * @note When the Bypass Shadow is enabled the calendar value are taken | |
1562 * directly from the Calendar counter. | |
1563 * @retval HAL status | |
1564 */ | |
1565 HAL_StatusTypeDef HAL_RTCEx_EnableBypassShadow(RTC_HandleTypeDef* hrtc) | |
1566 { | |
1567 /* Process Locked */ | |
1568 __HAL_LOCK(hrtc); | |
1569 | |
1570 hrtc->State = HAL_RTC_STATE_BUSY; | |
1571 | |
1572 /* Disable the write protection for RTC registers */ | |
1573 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1574 | |
1575 /* Set the BYPSHAD bit */ | |
1576 hrtc->Instance->CR |= (uint8_t)RTC_CR_BYPSHAD; | |
1577 | |
1578 /* Enable the write protection for RTC registers */ | |
1579 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1580 | |
1581 /* Change RTC state */ | |
1582 hrtc->State = HAL_RTC_STATE_READY; | |
1583 | |
1584 /* Process Unlocked */ | |
1585 __HAL_UNLOCK(hrtc); | |
1586 | |
1587 return HAL_OK; | |
1588 } | |
1589 | |
1590 /** | |
1591 * @brief Disables the Bypass Shadow feature. | |
1592 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1593 * the configuration information for RTC. | |
1594 * @note When the Bypass Shadow is enabled the calendar value are taken | |
1595 * directly from the Calendar counter. | |
1596 * @retval HAL status | |
1597 */ | |
1598 HAL_StatusTypeDef HAL_RTCEx_DisableBypassShadow(RTC_HandleTypeDef* hrtc) | |
1599 { | |
1600 /* Process Locked */ | |
1601 __HAL_LOCK(hrtc); | |
1602 | |
1603 hrtc->State = HAL_RTC_STATE_BUSY; | |
1604 | |
1605 /* Disable the write protection for RTC registers */ | |
1606 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); | |
1607 | |
1608 /* Reset the BYPSHAD bit */ | |
1609 hrtc->Instance->CR &= (uint8_t)~RTC_CR_BYPSHAD; | |
1610 | |
1611 /* Enable the write protection for RTC registers */ | |
1612 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); | |
1613 | |
1614 /* Change RTC state */ | |
1615 hrtc->State = HAL_RTC_STATE_READY; | |
1616 | |
1617 /* Process Unlocked */ | |
1618 __HAL_UNLOCK(hrtc); | |
1619 | |
1620 return HAL_OK; | |
1621 } | |
1622 | |
1623 /** | |
1624 * @} | |
1625 */ | |
1626 | |
1627 /** @defgroup RTCEx_Exported_Functions_Group4 Extended features functions | |
1628 * @brief Extended features functions | |
1629 * | |
1630 @verbatim | |
1631 =============================================================================== | |
1632 ##### Extended features functions ##### | |
1633 =============================================================================== | |
1634 [..] This section provides functions allowing to: | |
1635 (+) RTC Alarm B callback | |
1636 (+) RTC Poll for Alarm B request | |
1637 | |
1638 @endverbatim | |
1639 * @{ | |
1640 */ | |
1641 | |
1642 /** | |
1643 * @brief Alarm B callback. | |
1644 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1645 * the configuration information for RTC. | |
1646 * @retval None | |
1647 */ | |
1648 __weak void HAL_RTCEx_AlarmBEventCallback(RTC_HandleTypeDef *hrtc) | |
1649 { | |
1650 /* NOTE : This function Should not be modified, when the callback is needed, | |
1651 the HAL_RTC_AlarmBEventCallback could be implemented in the user file | |
1652 */ | |
1653 } | |
1654 | |
1655 /** | |
1656 * @brief This function handles AlarmB Polling request. | |
1657 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains | |
1658 * the configuration information for RTC. | |
1659 * @param Timeout: Timeout duration | |
1660 * @retval HAL status | |
1661 */ | |
1662 HAL_StatusTypeDef HAL_RTCEx_PollForAlarmBEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout) | |
1663 { | |
1664 uint32_t tickstart = 0; | |
1665 | |
1666 /* Get tick */ | |
1667 tickstart = HAL_GetTick(); | |
1668 | |
1669 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBF) == RESET) | |
1670 { | |
1671 if(Timeout != HAL_MAX_DELAY) | |
1672 { | |
1673 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) | |
1674 { | |
1675 hrtc->State = HAL_RTC_STATE_TIMEOUT; | |
1676 return HAL_TIMEOUT; | |
1677 } | |
1678 } | |
1679 } | |
1680 | |
1681 /* Clear the Alarm Flag */ | |
1682 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRBF); | |
1683 | |
1684 /* Change RTC state */ | |
1685 hrtc->State = HAL_RTC_STATE_READY; | |
1686 | |
1687 return HAL_OK; | |
1688 } | |
1689 | |
1690 /** | |
1691 * @} | |
1692 */ | |
1693 | |
1694 /** | |
1695 * @} | |
1696 */ | |
1697 | |
1698 #endif /* HAL_RTC_MODULE_ENABLED */ | |
1699 /** | |
1700 * @} | |
1701 */ | |
1702 | |
1703 /** | |
1704 * @} | |
1705 */ | |
1706 | |
1707 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |