mbed-src-kl05 - mbed library sources

Users » shaoziyang » Code » mbed-src-kl05

mbed library sources

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L053R8/stm32l0xx_hal_rtc_ex.c@181:a4cbdfbbd2f4, 2014-05-07 (annotated)

Committer:: mbed_official
Date:: Wed May 07 13:15:08 2014 +0100
Revision:: 181:a4cbdfbbd2f4

Synchronized with git revision 7751e759576c6fd68deccb81ea82bac19ed41745



Full URL: https://github.com/mbedmicro/mbed/commit/7751e759576c6fd68deccb81ea82bac19ed41745/

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	13 Sep 2014
Imports:	4
Forks:	0
Commits:	324
Dependents:	1
Dependencies:	0
Followers:	2

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L053R8/stm32l0xx_hal_rtc_ex.c@181:a4cbdfbbd2f4, 2014-05-07 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning