mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32L0/device/stm32l0xx_hal_rtc.c@151:5eaa88a5bcc7, 2016-11-24 (annotated)

Committer:: <>
Date:: Thu Nov 24 17:03:03 2016 +0000
Revision:: 151:5eaa88a5bcc7
Parent:: 149:156823d33999
Child:: 186:707f6e361f3e

This updates the lib to the mbed lib v130

Who changed what in which revision?

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