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

Users » mbed_official » Code » mbed-dev

mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

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

targets/TARGET_STM/TARGET_STM32F0/device/stm32f0xx_hal_rtc.c@149:156823d33999, 2016-10-28 (annotated)

Committer:: <>
Date:: Fri Oct 28 11:17:30 2016 +0100
Revision:: 149:156823d33999
Parent:: targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_rtc.c@144:ef7eb2e8f9f7
Child:: 156:95d6b41a828b

This updates the lib to the mbed lib v128

NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

Who changed what in which revision?

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