mbed-dev | Mbed

SilentSensors » Code » mbed-dev

targets/TARGET_STM/TARGET_STM32F7/device/stm32f7xx_hal_rtc_ex.c@161:2cc1468da177, 2017-03-30 (annotated)

Committer:: <>
Date:: Thu Mar 30 13:45:57 2017 +0100
Revision:: 161:2cc1468da177
Parent:: 157:ff67d9f36b67
Child:: 168:9672193075cf

This updates the lib to the mbed lib v139

Who changed what in which revision?

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

Repository toolbox

Repository details

Type:	Library
Created:	20 Sep 2018
Imports:	0
Forks:	0
Commits:	189
Dependents:	0
Dependencies:	0
Followers:	5

Important changes to repositories hosted on mbed.com

targets/TARGET_STM/TARGET_STM32F7/device/stm32f7xx_hal_rtc_ex.c@161:2cc1468da177, 2017-03-30 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Important changes to repositories hosted on mbed.com

targets/TARGET_STM/TARGET_STM32F7/device/stm32f7xx_hal_rtc_ex.c@161:2cc1468da177, 2017-03-30 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning