maxim-dev | Mbed

Users » switches » Code » maxim-dev

Dependents: MAX34417_demo MAXREFDES1265 MAXREFDES1265

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_rtc_ex.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:: <>
Date:: Fri Sep 02 15:07:44 2016 +0100
Revision:: 144:ef7eb2e8f9f7
Parent:: 0:9b334a45a8ff

This updates the lib to the mbed lib v125

Who changed what in which revision?

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

Repository toolbox

Repository details

Type:	Library
Created:	08 Mar 2017
Imports:	12
Forks:	0
Commits:	165
Dependents:	3
Dependencies:	0
Followers:	5

This repository is Public (Unlisted).

Developers

Greg Steiert

Jesse Marroquin

Important changes to repositories hosted on mbed.com

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_rtc_ex.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Developers

Important Information for this Arm website

Important changes to repositories hosted on mbed.com

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_rtc_ex.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Developers

Important Information for this Arm website

Access Warning