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_STM32F1/device/stm32f1xx_hal_rtc.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:: AnnaBridge
Date:: Wed Feb 20 22:31:08 2019 +0000
Revision:: 189:f392fc9709a3
Parent:: 188:bcfe06ba3d64

mbed library release version 165

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	144:ef7eb2e8f9f7	1	/**
<>	144:ef7eb2e8f9f7	2	******************************************************************************
<>	144:ef7eb2e8f9f7	3	* @file stm32f1xx_hal_rtc.c
<>	144:ef7eb2e8f9f7	4	* @author MCD Application Team
<>	144:ef7eb2e8f9f7	5	* @brief RTC HAL module driver.
<>	144:ef7eb2e8f9f7	6	* This file provides firmware functions to manage the following
<>	144:ef7eb2e8f9f7	7	* functionalities of the Real Time Clock (RTC) peripheral:
<>	144:ef7eb2e8f9f7	8	* + Initialization and de-initialization functions
<>	144:ef7eb2e8f9f7	9	* + RTC Time and Date functions
<>	144:ef7eb2e8f9f7	10	* + RTC Alarm functions
<>	144:ef7eb2e8f9f7	11	* + Peripheral Control functions
<>	144:ef7eb2e8f9f7	12	* + Peripheral State functions
<>	144:ef7eb2e8f9f7	13	*
<>	144:ef7eb2e8f9f7	14	@verbatim
<>	144:ef7eb2e8f9f7	15	==============================================================================
<>	144:ef7eb2e8f9f7	16	##### How to use this driver #####
<>	144:ef7eb2e8f9f7	17	==================================================================
<>	144:ef7eb2e8f9f7	18	[..]
<>	144:ef7eb2e8f9f7	19	(+) Enable the RTC domain access (see description in the section above).
<>	144:ef7eb2e8f9f7	20	(+) Configure the RTC Prescaler (Asynchronous prescaler to generate RTC 1Hz time base)
<>	144:ef7eb2e8f9f7	21	using the HAL_RTC_Init() function.
<>	144:ef7eb2e8f9f7	22
<>	144:ef7eb2e8f9f7	23	* Time and Date configuration *
<>	144:ef7eb2e8f9f7	24	===================================
<>	144:ef7eb2e8f9f7	25	[..]
<>	144:ef7eb2e8f9f7	26	(+) To configure the RTC Calendar (Time and Date) use the HAL_RTC_SetTime()
<>	144:ef7eb2e8f9f7	27	and HAL_RTC_SetDate() functions.
<>	144:ef7eb2e8f9f7	28	(+) To read the RTC Calendar, use the HAL_RTC_GetTime() and HAL_RTC_GetDate() functions.
<>	144:ef7eb2e8f9f7	29
<>	144:ef7eb2e8f9f7	30	* Alarm configuration *
<>	144:ef7eb2e8f9f7	31	===========================
<>	144:ef7eb2e8f9f7	32	[..]
<>	144:ef7eb2e8f9f7	33	(+) To configure the RTC Alarm use the HAL_RTC_SetAlarm() function.
<>	144:ef7eb2e8f9f7	34	You can also configure the RTC Alarm with interrupt mode using the HAL_RTC_SetAlarm_IT() function.
<>	144:ef7eb2e8f9f7	35	(+) To read the RTC Alarm, use the HAL_RTC_GetAlarm() function.
<>	144:ef7eb2e8f9f7	36
<>	144:ef7eb2e8f9f7	37	* Tamper configuration *
<>	144:ef7eb2e8f9f7	38	============================
<>	144:ef7eb2e8f9f7	39	[..]
<>	144:ef7eb2e8f9f7	40	(+) Enable the RTC Tamper and configure the Tamper Level using the
<>	144:ef7eb2e8f9f7	41	HAL_RTCEx_SetTamper() function. You can configure RTC Tamper with interrupt
<>	144:ef7eb2e8f9f7	42	mode using HAL_RTCEx_SetTamper_IT() function.
<>	144:ef7eb2e8f9f7	43	(+) The TAMPER1 alternate function can be mapped to PC13
<>	144:ef7eb2e8f9f7	44
<>	144:ef7eb2e8f9f7	45	* Backup Data Registers configuration *
<>	144:ef7eb2e8f9f7	46	===========================================
<>	144:ef7eb2e8f9f7	47	[..]
<>	144:ef7eb2e8f9f7	48	(+) To write to the RTC Backup Data registers, use the HAL_RTCEx_BKUPWrite()
<>	144:ef7eb2e8f9f7	49	function.
<>	144:ef7eb2e8f9f7	50	(+) To read the RTC Backup Data registers, use the HAL_RTCEx_BKUPRead()
<>	144:ef7eb2e8f9f7	51	function.
<>	144:ef7eb2e8f9f7	52
<>	144:ef7eb2e8f9f7	53	##### WARNING: Drivers Restrictions #####
<>	144:ef7eb2e8f9f7	54	==================================================================
<>	144:ef7eb2e8f9f7	55	[..] RTC version used on STM32F1 families is version V1. All the features supported by V2
<>	144:ef7eb2e8f9f7	56	(other families) will be not supported on F1.
<>	144:ef7eb2e8f9f7	57	[..] As on V2, main RTC features are managed by HW. But on F1, date feature is completely
<>	144:ef7eb2e8f9f7	58	managed by SW.
<>	144:ef7eb2e8f9f7	59	[..] Then, there are some restrictions compared to other families:
<>	144:ef7eb2e8f9f7	60	(+) Only format 24 hours supported in HAL (format 12 hours not supported)
<>	144:ef7eb2e8f9f7	61	(+) Date is saved in SRAM. Then, when MCU is in STOP or STANDBY mode, date will be lost.
<>	144:ef7eb2e8f9f7	62	User should implement a way to save date before entering in low power mode (an
<>	144:ef7eb2e8f9f7	63	example is provided with firmware package based on backup registers)
<>	144:ef7eb2e8f9f7	64	(+) Date is automatically updated each time a HAL_RTC_GetTime or HAL_RTC_GetDate is called.
<>	144:ef7eb2e8f9f7	65	(+) Alarm detection is limited to 1 day. It will expire only 1 time (no alarm repetition, need
<>	144:ef7eb2e8f9f7	66	to program a new alarm)
<>	144:ef7eb2e8f9f7	67
<>	144:ef7eb2e8f9f7	68	##### Backup Domain Operating Condition #####
<>	144:ef7eb2e8f9f7	69	==============================================================================
<>	144:ef7eb2e8f9f7	70	[..] The real-time clock (RTC) and the RTC backup registers can be powered
<>	144:ef7eb2e8f9f7	71	from the VBAT voltage when the main VDD supply is powered off.
<>	144:ef7eb2e8f9f7	72	To retain the content of the RTC backup registers and supply the RTC
<>	144:ef7eb2e8f9f7	73	when VDD is turned off, VBAT pin can be connected to an optional
<>	144:ef7eb2e8f9f7	74	standby voltage supplied by a battery or by another source.
<>	144:ef7eb2e8f9f7	75
<>	144:ef7eb2e8f9f7	76	[..] To allow the RTC operating even when the main digital supply (VDD) is turned
<>	144:ef7eb2e8f9f7	77	off, the VBAT pin powers the following blocks:
<>	144:ef7eb2e8f9f7	78	(+) The RTC
<>	144:ef7eb2e8f9f7	79	(+) The LSE oscillator
<>	144:ef7eb2e8f9f7	80	(+) PC13 I/O
<>	144:ef7eb2e8f9f7	81
<>	144:ef7eb2e8f9f7	82	[..] When the backup domain is supplied by VDD (analog switch connected to VDD),
<>	144:ef7eb2e8f9f7	83	the following pins are available:
<>	144:ef7eb2e8f9f7	84	(+) PC13 can be used as a Tamper pin
<>	144:ef7eb2e8f9f7	85
<>	144:ef7eb2e8f9f7	86	[..] When the backup domain is supplied by VBAT (analog switch connected to VBAT
<>	144:ef7eb2e8f9f7	87	because VDD is not present), the following pins are available:
<>	144:ef7eb2e8f9f7	88	(+) PC13 can be used as the Tamper pin
<>	144:ef7eb2e8f9f7	89
<>	144:ef7eb2e8f9f7	90	##### Backup Domain Reset #####
<>	144:ef7eb2e8f9f7	91	==================================================================
<>	144:ef7eb2e8f9f7	92	[..] The backup domain reset sets all RTC registers and the RCC_BDCR register
<>	144:ef7eb2e8f9f7	93	to their reset values.
<>	144:ef7eb2e8f9f7	94	[..] A backup domain reset is generated when one of the following events occurs:
<>	144:ef7eb2e8f9f7	95	(#) Software reset, triggered by setting the BDRST bit in the
<>	144:ef7eb2e8f9f7	96	RCC Backup domain control register (RCC_BDCR).
<>	144:ef7eb2e8f9f7	97	(#) VDD or VBAT power on, if both supplies have previously been powered off.
<>	144:ef7eb2e8f9f7	98	(#) Tamper detection event resets all data backup registers.
<>	144:ef7eb2e8f9f7	99
<>	144:ef7eb2e8f9f7	100	##### Backup Domain Access #####
<>	144:ef7eb2e8f9f7	101	==================================================================
<>	144:ef7eb2e8f9f7	102	[..] After reset, the backup domain (RTC registers, RTC backup data
<>	144:ef7eb2e8f9f7	103	registers and backup SRAM) is protected against possible unwanted write
<>	144:ef7eb2e8f9f7	104	accesses.
<>	144:ef7eb2e8f9f7	105	[..] To enable access to the RTC Domain and RTC registers, proceed as follows:
<>	144:ef7eb2e8f9f7	106	(+) Call the function HAL_RCCEx_PeriphCLKConfig in using RCC_PERIPHCLK_RTC for
<>	144:ef7eb2e8f9f7	107	PeriphClockSelection and select RTCClockSelection (LSE, LSI or HSE)
<>	144:ef7eb2e8f9f7	108	(+) Enable the BKP clock in using __HAL_RCC_BKP_CLK_ENABLE()
<>	144:ef7eb2e8f9f7	109
<>	144:ef7eb2e8f9f7	110	##### RTC and low power modes #####
<>	144:ef7eb2e8f9f7	111	==================================================================
<>	144:ef7eb2e8f9f7	112	[..] The MCU can be woken up from a low power mode by an RTC alternate
<>	144:ef7eb2e8f9f7	113	function.
<>	144:ef7eb2e8f9f7	114	[..] The RTC alternate functions are the RTC alarms (Alarm A),
<>	144:ef7eb2e8f9f7	115	and RTC tamper event detection.
<>	144:ef7eb2e8f9f7	116	These RTC alternate functions can wake up the system from the Stop and
<>	144:ef7eb2e8f9f7	117	Standby low power modes.
<>	144:ef7eb2e8f9f7	118	[..] The system can also wake up from low power modes without depending
<>	144:ef7eb2e8f9f7	119	on an external interrupt (Auto-wakeup mode), by using the RTC alarm.
<>	144:ef7eb2e8f9f7	120
<>	144:ef7eb2e8f9f7	121	@endverbatim
<>	144:ef7eb2e8f9f7	122	******************************************************************************
<>	144:ef7eb2e8f9f7	123	* @attention
<>	144:ef7eb2e8f9f7	124	*
<>	144:ef7eb2e8f9f7	125	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<>	144:ef7eb2e8f9f7	126	*
<>	144:ef7eb2e8f9f7	127	* Redistribution and use in source and binary forms, with or without modification,
<>	144:ef7eb2e8f9f7	128	* are permitted provided that the following conditions are met:
<>	144:ef7eb2e8f9f7	129	* 1. Redistributions of source code must retain the above copyright notice,
<>	144:ef7eb2e8f9f7	130	* this list of conditions and the following disclaimer.
<>	144:ef7eb2e8f9f7	131	* 2. Redistributions in binary form must reproduce the above copyright notice,
<>	144:ef7eb2e8f9f7	132	* this list of conditions and the following disclaimer in the documentation
<>	144:ef7eb2e8f9f7	133	* and/or other materials provided with the distribution.
<>	144:ef7eb2e8f9f7	134	* 3. Neither the name of STMicroelectronics nor the names of its contributors
<>	144:ef7eb2e8f9f7	135	* may be used to endorse or promote products derived from this software
<>	144:ef7eb2e8f9f7	136	* without specific prior written permission.
<>	144:ef7eb2e8f9f7	137	*
<>	144:ef7eb2e8f9f7	138	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<>	144:ef7eb2e8f9f7	139	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<>	144:ef7eb2e8f9f7	140	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<>	144:ef7eb2e8f9f7	141	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<>	144:ef7eb2e8f9f7	142	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<>	144:ef7eb2e8f9f7	143	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<>	144:ef7eb2e8f9f7	144	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<>	144:ef7eb2e8f9f7	145	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<>	144:ef7eb2e8f9f7	146	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<>	144:ef7eb2e8f9f7	147	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<>	144:ef7eb2e8f9f7	148	*
<>	144:ef7eb2e8f9f7	149	******************************************************************************
<>	144:ef7eb2e8f9f7	150	*/
<>	144:ef7eb2e8f9f7	151
<>	144:ef7eb2e8f9f7	152	/* Includes ------------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	153	#include "stm32f1xx_hal.h"
<>	144:ef7eb2e8f9f7	154
<>	144:ef7eb2e8f9f7	155	/** @addtogroup STM32F1xx_HAL_Driver
<>	144:ef7eb2e8f9f7	156	* @{
<>	144:ef7eb2e8f9f7	157	*/
<>	144:ef7eb2e8f9f7	158
<>	144:ef7eb2e8f9f7	159	/** @defgroup RTC RTC
<>	144:ef7eb2e8f9f7	160	* @brief RTC HAL module driver
<>	144:ef7eb2e8f9f7	161	* @{
<>	144:ef7eb2e8f9f7	162	*/
<>	144:ef7eb2e8f9f7	163
<>	144:ef7eb2e8f9f7	164	#ifdef HAL_RTC_MODULE_ENABLED
<>	144:ef7eb2e8f9f7	165
<>	144:ef7eb2e8f9f7	166	/* Private typedef -----------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	167	/* Private define ------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	168	/** @defgroup RTC_Private_Constants RTC Private Constants
<>	144:ef7eb2e8f9f7	169	* @{
<>	144:ef7eb2e8f9f7	170	*/
<>	144:ef7eb2e8f9f7	171	#define RTC_ALARM_RESETVALUE_REGISTER (uint16_t)0xFFFF
AnnaBridge	165:e614a9f1c9e2	172	#define RTC_ALARM_RESETVALUE 0xFFFFFFFFU
<>	144:ef7eb2e8f9f7	173
<>	144:ef7eb2e8f9f7	174	/**
<>	144:ef7eb2e8f9f7	175	* @}
<>	144:ef7eb2e8f9f7	176	*/
<>	144:ef7eb2e8f9f7	177
<>	144:ef7eb2e8f9f7	178	/* Private macro -------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	179	/** @defgroup RTC_Private_Macros RTC Private Macros
<>	144:ef7eb2e8f9f7	180	* @{
<>	144:ef7eb2e8f9f7	181	*/
<>	144:ef7eb2e8f9f7	182	/**
<>	144:ef7eb2e8f9f7	183	* @}
<>	144:ef7eb2e8f9f7	184	*/
<>	144:ef7eb2e8f9f7	185
<>	144:ef7eb2e8f9f7	186	/* Private variables ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	187	/* Private function prototypes -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	188	/** @defgroup RTC_Private_Functions RTC Private Functions
<>	144:ef7eb2e8f9f7	189	* @{
<>	144:ef7eb2e8f9f7	190	*/
<>	144:ef7eb2e8f9f7	191	static uint32_t RTC_ReadAlarmCounter(RTC_HandleTypeDef* hrtc);
<>	144:ef7eb2e8f9f7	192	static HAL_StatusTypeDef RTC_WriteAlarmCounter(RTC_HandleTypeDef* hrtc, uint32_t AlarmCounter);
<>	144:ef7eb2e8f9f7	193	static HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc);
<>	144:ef7eb2e8f9f7	194	static HAL_StatusTypeDef RTC_ExitInitMode(RTC_HandleTypeDef* hrtc);
<>	144:ef7eb2e8f9f7	195	static uint8_t RTC_ByteToBcd2(uint8_t Value);
<>	144:ef7eb2e8f9f7	196	static uint8_t RTC_Bcd2ToByte(uint8_t Value);
<>	144:ef7eb2e8f9f7	197	static uint8_t RTC_IsLeapYear(uint16_t nYear);
<>	144:ef7eb2e8f9f7	198	static void RTC_DateUpdate(RTC_HandleTypeDef* hrtc, uint32_t DayElapsed);
<>	144:ef7eb2e8f9f7	199	static uint8_t RTC_WeekDayNum(uint32_t nYear, uint8_t nMonth, uint8_t nDay);
<>	144:ef7eb2e8f9f7	200
<>	144:ef7eb2e8f9f7	201	/**
<>	144:ef7eb2e8f9f7	202	* @}
<>	144:ef7eb2e8f9f7	203	*/
<>	144:ef7eb2e8f9f7	204
<>	144:ef7eb2e8f9f7	205	/* Private functions ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	206	/** @defgroup RTC_Exported_Functions RTC Exported Functions
<>	144:ef7eb2e8f9f7	207	* @{
<>	144:ef7eb2e8f9f7	208	*/
<>	144:ef7eb2e8f9f7	209
<>	144:ef7eb2e8f9f7	210	/** @defgroup RTC_Exported_Functions_Group1 Initialization and de-initialization functions
<>	144:ef7eb2e8f9f7	211	* @brief Initialization and Configuration functions
<>	144:ef7eb2e8f9f7	212	*
<>	144:ef7eb2e8f9f7	213	@verbatim
<>	144:ef7eb2e8f9f7	214	===============================================================================
<>	144:ef7eb2e8f9f7	215	##### Initialization and de-initialization functions #####
<>	144:ef7eb2e8f9f7	216	===============================================================================
<>	144:ef7eb2e8f9f7	217	[..] This section provides functions allowing to initialize and configure the
<>	144:ef7eb2e8f9f7	218	RTC Prescaler (Asynchronous), disable RTC registers Write protection,
<>	144:ef7eb2e8f9f7	219	enter and exit the RTC initialization mode,
<>	144:ef7eb2e8f9f7	220	RTC registers synchronization check and reference clock detection enable.
<>	144:ef7eb2e8f9f7	221	(#) The RTC Prescaler should be programmed to generate the RTC 1Hz time base.
<>	144:ef7eb2e8f9f7	222	(#) All RTC registers are Write protected. Writing to the RTC registers
<>	144:ef7eb2e8f9f7	223	is enabled by setting the CNF bit in the RTC_CRL register.
<>	144:ef7eb2e8f9f7	224	(#) To read the calendar after wakeup from low power modes (Standby or Stop)
<>	144:ef7eb2e8f9f7	225	the software must first wait for the RSF bit (Register Synchronized Flag)
<>	144:ef7eb2e8f9f7	226	in the RTC_CRL register to be set by hardware.
<>	144:ef7eb2e8f9f7	227	The HAL_RTC_WaitForSynchro() function implements the above software
<>	144:ef7eb2e8f9f7	228	sequence (RSF clear and RSF check).
<>	144:ef7eb2e8f9f7	229
<>	144:ef7eb2e8f9f7	230	@endverbatim
<>	144:ef7eb2e8f9f7	231	* @{
<>	144:ef7eb2e8f9f7	232	*/
<>	144:ef7eb2e8f9f7	233
<>	144:ef7eb2e8f9f7	234	/**
<>	144:ef7eb2e8f9f7	235	* @brief Initializes the RTC peripheral
<>	144:ef7eb2e8f9f7	236	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	237	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	238	* @retval HAL status
<>	144:ef7eb2e8f9f7	239	*/
<>	144:ef7eb2e8f9f7	240	HAL_StatusTypeDef HAL_RTC_Init(RTC_HandleTypeDef *hrtc)
<>	144:ef7eb2e8f9f7	241	{
AnnaBridge	165:e614a9f1c9e2	242	uint32_t prescaler = 0U;
<>	144:ef7eb2e8f9f7	243	/* Check input parameters */
<>	144:ef7eb2e8f9f7	244	if(hrtc == NULL)
<>	144:ef7eb2e8f9f7	245	{
<>	144:ef7eb2e8f9f7	246	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	247	}
<>	144:ef7eb2e8f9f7	248
<>	144:ef7eb2e8f9f7	249	/* Check the parameters */
<>	144:ef7eb2e8f9f7	250	assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
<>	144:ef7eb2e8f9f7	251	assert_param(IS_RTC_CALIB_OUTPUT(hrtc->Init.OutPut));
<>	144:ef7eb2e8f9f7	252	assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv));
<>	144:ef7eb2e8f9f7	253
<>	144:ef7eb2e8f9f7	254	if(hrtc->State == HAL_RTC_STATE_RESET)
<>	144:ef7eb2e8f9f7	255	{
<>	144:ef7eb2e8f9f7	256	/* Allocate lock resource and initialize it */
<>	144:ef7eb2e8f9f7	257	hrtc->Lock = HAL_UNLOCKED;
<>	144:ef7eb2e8f9f7	258
<>	144:ef7eb2e8f9f7	259	/* Initialize RTC MSP */
<>	144:ef7eb2e8f9f7	260	HAL_RTC_MspInit(hrtc);
<>	144:ef7eb2e8f9f7	261	}
<>	144:ef7eb2e8f9f7	262
<>	144:ef7eb2e8f9f7	263	/* Set RTC state */
<>	144:ef7eb2e8f9f7	264	hrtc->State = HAL_RTC_STATE_BUSY;
<>	144:ef7eb2e8f9f7	265
<>	144:ef7eb2e8f9f7	266	/* Waiting for synchro */
<>	144:ef7eb2e8f9f7	267	if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	268	{
<>	144:ef7eb2e8f9f7	269	/* Set RTC state */
<>	144:ef7eb2e8f9f7	270	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	271
<>	144:ef7eb2e8f9f7	272	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	273	}
<>	144:ef7eb2e8f9f7	274
<>	144:ef7eb2e8f9f7	275	/* Set Initialization mode */
<>	144:ef7eb2e8f9f7	276	if(RTC_EnterInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	277	{
<>	144:ef7eb2e8f9f7	278	/* Set RTC state */
<>	144:ef7eb2e8f9f7	279	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	280
<>	144:ef7eb2e8f9f7	281	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	282	}
<>	144:ef7eb2e8f9f7	283	else
<>	144:ef7eb2e8f9f7	284	{
<>	144:ef7eb2e8f9f7	285	/* Clear Flags Bits */
<>	144:ef7eb2e8f9f7	286	CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_OW \| RTC_FLAG_ALRAF \| RTC_FLAG_SEC));
<>	144:ef7eb2e8f9f7	287
<>	144:ef7eb2e8f9f7	288	if(hrtc->Init.OutPut != RTC_OUTPUTSOURCE_NONE)
<>	144:ef7eb2e8f9f7	289	{
<>	144:ef7eb2e8f9f7	290	/* Disable the selected Tamper pin */
<>	144:ef7eb2e8f9f7	291	CLEAR_BIT(BKP->CR, BKP_CR_TPE);
<>	144:ef7eb2e8f9f7	292	}
<>	144:ef7eb2e8f9f7	293
<>	144:ef7eb2e8f9f7	294	/* Set the signal which will be routed to RTC Tamper pin*/
<>	144:ef7eb2e8f9f7	295	MODIFY_REG(BKP->RTCCR, (BKP_RTCCR_CCO \| BKP_RTCCR_ASOE \| BKP_RTCCR_ASOS), hrtc->Init.OutPut);
<>	144:ef7eb2e8f9f7	296
<>	144:ef7eb2e8f9f7	297	if (hrtc->Init.AsynchPrediv != RTC_AUTO_1_SECOND)
<>	144:ef7eb2e8f9f7	298	{
<>	144:ef7eb2e8f9f7	299	/* RTC Prescaler provided directly by end-user*/
<>	144:ef7eb2e8f9f7	300	prescaler = hrtc->Init.AsynchPrediv;
<>	144:ef7eb2e8f9f7	301	}
<>	144:ef7eb2e8f9f7	302	else
<>	144:ef7eb2e8f9f7	303	{
<>	144:ef7eb2e8f9f7	304	/* RTC Prescaler will be automatically calculated to get 1 second timebase */
<>	144:ef7eb2e8f9f7	305	/* Get the RTCCLK frequency */
<>	144:ef7eb2e8f9f7	306	prescaler = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_RTC);
<>	144:ef7eb2e8f9f7	307
<>	144:ef7eb2e8f9f7	308	/* Check that RTC clock is enabled*/
AnnaBridge	165:e614a9f1c9e2	309	if (prescaler == 0U)
<>	144:ef7eb2e8f9f7	310	{
<>	144:ef7eb2e8f9f7	311	/* Should not happen. Frequency is not available*/
<>	144:ef7eb2e8f9f7	312	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	313	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	314	}
<>	144:ef7eb2e8f9f7	315	else
<>	144:ef7eb2e8f9f7	316	{
<>	144:ef7eb2e8f9f7	317	/* RTC period = RTCCLK/(RTC_PR + 1) */
AnnaBridge	165:e614a9f1c9e2	318	prescaler = prescaler - 1U;
<>	144:ef7eb2e8f9f7	319	}
<>	144:ef7eb2e8f9f7	320	}
<>	144:ef7eb2e8f9f7	321
<>	144:ef7eb2e8f9f7	322	/* Configure the RTC_PRLH / RTC_PRLL */
AnnaBridge	165:e614a9f1c9e2	323	MODIFY_REG(hrtc->Instance->PRLH, RTC_PRLH_PRL, (prescaler >> 16U));
<>	144:ef7eb2e8f9f7	324	MODIFY_REG(hrtc->Instance->PRLL, RTC_PRLL_PRL, (prescaler & RTC_PRLL_PRL));
<>	144:ef7eb2e8f9f7	325
<>	144:ef7eb2e8f9f7	326	/* Wait for synchro */
<>	144:ef7eb2e8f9f7	327	if(RTC_ExitInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	328	{
<>	144:ef7eb2e8f9f7	329	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	330
<>	144:ef7eb2e8f9f7	331	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	332	}
<>	144:ef7eb2e8f9f7	333
<>	144:ef7eb2e8f9f7	334	/* Initialize date to 1st of January 2000 */
AnnaBridge	165:e614a9f1c9e2	335	hrtc->DateToUpdate.Year = 0x00U;
<>	144:ef7eb2e8f9f7	336	hrtc->DateToUpdate.Month = RTC_MONTH_JANUARY;
AnnaBridge	165:e614a9f1c9e2	337	hrtc->DateToUpdate.Date = 0x01U;
<>	144:ef7eb2e8f9f7	338
<>	144:ef7eb2e8f9f7	339	/* Set RTC state */
<>	144:ef7eb2e8f9f7	340	hrtc->State = HAL_RTC_STATE_READY;
<>	144:ef7eb2e8f9f7	341
<>	144:ef7eb2e8f9f7	342	return HAL_OK;
<>	144:ef7eb2e8f9f7	343	}
<>	144:ef7eb2e8f9f7	344	}
<>	144:ef7eb2e8f9f7	345
<>	144:ef7eb2e8f9f7	346	/**
<>	144:ef7eb2e8f9f7	347	* @brief DeInitializes the RTC peripheral
<>	144:ef7eb2e8f9f7	348	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	349	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	350	* @note This function does not reset the RTC Backup Data registers.
<>	144:ef7eb2e8f9f7	351	* @retval HAL status
<>	144:ef7eb2e8f9f7	352	*/
<>	144:ef7eb2e8f9f7	353	HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)
<>	144:ef7eb2e8f9f7	354	{
<>	144:ef7eb2e8f9f7	355	/* Check input parameters */
<>	144:ef7eb2e8f9f7	356	if(hrtc == NULL)
<>	144:ef7eb2e8f9f7	357	{
<>	144:ef7eb2e8f9f7	358	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	359	}
<>	144:ef7eb2e8f9f7	360
<>	144:ef7eb2e8f9f7	361	/* Check the parameters */
<>	144:ef7eb2e8f9f7	362	assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
<>	144:ef7eb2e8f9f7	363
<>	144:ef7eb2e8f9f7	364	/* Set RTC state */
<>	144:ef7eb2e8f9f7	365	hrtc->State = HAL_RTC_STATE_BUSY;
<>	144:ef7eb2e8f9f7	366
<>	144:ef7eb2e8f9f7	367	/* Set Initialization mode */
<>	144:ef7eb2e8f9f7	368	if(RTC_EnterInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	369	{
<>	144:ef7eb2e8f9f7	370	/* Set RTC state */
<>	144:ef7eb2e8f9f7	371	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	372
<>	144:ef7eb2e8f9f7	373	/* Release Lock */
<>	144:ef7eb2e8f9f7	374	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	375
<>	144:ef7eb2e8f9f7	376	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	377	}
<>	144:ef7eb2e8f9f7	378	else
<>	144:ef7eb2e8f9f7	379	{
<>	144:ef7eb2e8f9f7	380	CLEAR_REG(hrtc->Instance->CNTL);
<>	144:ef7eb2e8f9f7	381	CLEAR_REG(hrtc->Instance->CNTH);
AnnaBridge	165:e614a9f1c9e2	382	WRITE_REG(hrtc->Instance->PRLL, 0x00008000U);
<>	144:ef7eb2e8f9f7	383	CLEAR_REG(hrtc->Instance->PRLH);
<>	144:ef7eb2e8f9f7	384
<>	144:ef7eb2e8f9f7	385	/* Reset All CRH/CRL bits */
<>	144:ef7eb2e8f9f7	386	CLEAR_REG(hrtc->Instance->CRH);
<>	144:ef7eb2e8f9f7	387	CLEAR_REG(hrtc->Instance->CRL);
<>	144:ef7eb2e8f9f7	388
<>	144:ef7eb2e8f9f7	389	if(RTC_ExitInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	390	{
<>	144:ef7eb2e8f9f7	391	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	392
<>	144:ef7eb2e8f9f7	393	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	394	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	395
<>	144:ef7eb2e8f9f7	396	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	397	}
<>	144:ef7eb2e8f9f7	398	}
<>	144:ef7eb2e8f9f7	399
<>	144:ef7eb2e8f9f7	400	/* Wait for synchro*/
<>	144:ef7eb2e8f9f7	401	HAL_RTC_WaitForSynchro(hrtc);
<>	144:ef7eb2e8f9f7	402
<>	144:ef7eb2e8f9f7	403	/* Clear RSF flag */
<>	144:ef7eb2e8f9f7	404	CLEAR_BIT(hrtc->Instance->CRL, RTC_FLAG_RSF);
<>	144:ef7eb2e8f9f7	405
<>	144:ef7eb2e8f9f7	406	/* De-Initialize RTC MSP */
<>	144:ef7eb2e8f9f7	407	HAL_RTC_MspDeInit(hrtc);
<>	144:ef7eb2e8f9f7	408
<>	144:ef7eb2e8f9f7	409	hrtc->State = HAL_RTC_STATE_RESET;
<>	144:ef7eb2e8f9f7	410
<>	144:ef7eb2e8f9f7	411	/* Release Lock */
<>	144:ef7eb2e8f9f7	412	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	413
<>	144:ef7eb2e8f9f7	414	return HAL_OK;
<>	144:ef7eb2e8f9f7	415	}
<>	144:ef7eb2e8f9f7	416
<>	144:ef7eb2e8f9f7	417	/**
<>	144:ef7eb2e8f9f7	418	* @brief Initializes the RTC MSP.
<>	144:ef7eb2e8f9f7	419	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	420	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	421	* @retval None
<>	144:ef7eb2e8f9f7	422	*/
<>	144:ef7eb2e8f9f7	423	__weak void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	424	{
<>	144:ef7eb2e8f9f7	425	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	426	UNUSED(hrtc);
<>	144:ef7eb2e8f9f7	427	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	428	the HAL_RTC_MspInit could be implemented in the user file
<>	144:ef7eb2e8f9f7	429	*/
<>	144:ef7eb2e8f9f7	430	}
<>	144:ef7eb2e8f9f7	431
<>	144:ef7eb2e8f9f7	432	/**
<>	144:ef7eb2e8f9f7	433	* @brief DeInitializes the RTC MSP.
<>	144:ef7eb2e8f9f7	434	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	435	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	436	* @retval None
<>	144:ef7eb2e8f9f7	437	*/
<>	144:ef7eb2e8f9f7	438	__weak void HAL_RTC_MspDeInit(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	439	{
<>	144:ef7eb2e8f9f7	440	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	441	UNUSED(hrtc);
<>	144:ef7eb2e8f9f7	442	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	443	the HAL_RTC_MspDeInit could be implemented in the user file
<>	144:ef7eb2e8f9f7	444	*/
<>	144:ef7eb2e8f9f7	445	}
<>	144:ef7eb2e8f9f7	446
<>	144:ef7eb2e8f9f7	447	/**
<>	144:ef7eb2e8f9f7	448	* @}
<>	144:ef7eb2e8f9f7	449	*/
<>	144:ef7eb2e8f9f7	450
<>	144:ef7eb2e8f9f7	451	/** @defgroup RTC_Exported_Functions_Group2 Time and Date functions
<>	144:ef7eb2e8f9f7	452	* @brief RTC Time and Date functions
<>	144:ef7eb2e8f9f7	453	*
<>	144:ef7eb2e8f9f7	454	@verbatim
<>	144:ef7eb2e8f9f7	455	===============================================================================
<>	144:ef7eb2e8f9f7	456	##### RTC Time and Date functions #####
<>	144:ef7eb2e8f9f7	457	===============================================================================
<>	144:ef7eb2e8f9f7	458
<>	144:ef7eb2e8f9f7	459	[..] This section provides functions allowing to configure Time and Date features
<>	144:ef7eb2e8f9f7	460
<>	144:ef7eb2e8f9f7	461	@endverbatim
<>	144:ef7eb2e8f9f7	462	* @{
<>	144:ef7eb2e8f9f7	463	*/
<>	144:ef7eb2e8f9f7	464
<>	144:ef7eb2e8f9f7	465	/**
<>	144:ef7eb2e8f9f7	466	* @brief Sets RTC current time.
<>	144:ef7eb2e8f9f7	467	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	468	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	469	* @param sTime: Pointer to Time structure
<>	144:ef7eb2e8f9f7	470	* @param Format: Specifies the format of the entered parameters.
<>	144:ef7eb2e8f9f7	471	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	472	* @arg RTC_FORMAT_BIN: Binary data format
<>	144:ef7eb2e8f9f7	473	* @arg RTC_FORMAT_BCD: BCD data format
<>	144:ef7eb2e8f9f7	474	* @retval HAL status
<>	144:ef7eb2e8f9f7	475	*/
<>	144:ef7eb2e8f9f7	476	HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef hrtc, RTC_TimeTypeDef sTime, uint32_t Format)
<>	144:ef7eb2e8f9f7	477	{
AnnaBridge	165:e614a9f1c9e2	478	uint32_t counter_time = 0U, counter_alarm = 0U;
<>	144:ef7eb2e8f9f7	479
<>	144:ef7eb2e8f9f7	480	/* Check input parameters */
<>	144:ef7eb2e8f9f7	481	if((hrtc == NULL) \|\| (sTime == NULL))
<>	144:ef7eb2e8f9f7	482	{
<>	144:ef7eb2e8f9f7	483	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	484	}
<>	144:ef7eb2e8f9f7	485
<>	144:ef7eb2e8f9f7	486	/* Check the parameters */
<>	144:ef7eb2e8f9f7	487	assert_param(IS_RTC_FORMAT(Format));
<>	144:ef7eb2e8f9f7	488
<>	144:ef7eb2e8f9f7	489	/* Process Locked */
<>	144:ef7eb2e8f9f7	490	__HAL_LOCK(hrtc);
<>	144:ef7eb2e8f9f7	491
<>	144:ef7eb2e8f9f7	492	hrtc->State = HAL_RTC_STATE_BUSY;
<>	144:ef7eb2e8f9f7	493
<>	144:ef7eb2e8f9f7	494	if(Format == RTC_FORMAT_BIN)
<>	144:ef7eb2e8f9f7	495	{
<>	144:ef7eb2e8f9f7	496	assert_param(IS_RTC_HOUR24(sTime->Hours));
<>	144:ef7eb2e8f9f7	497	assert_param(IS_RTC_MINUTES(sTime->Minutes));
<>	144:ef7eb2e8f9f7	498	assert_param(IS_RTC_SECONDS(sTime->Seconds));
<>	144:ef7eb2e8f9f7	499
AnnaBridge	165:e614a9f1c9e2	500	counter_time = (uint32_t)(((uint32_t)sTime->Hours * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	501	((uint32_t)sTime->Minutes * 60U) + \
<>	144:ef7eb2e8f9f7	502	((uint32_t)sTime->Seconds));
<>	144:ef7eb2e8f9f7	503	}
<>	144:ef7eb2e8f9f7	504	else
<>	144:ef7eb2e8f9f7	505	{
<>	144:ef7eb2e8f9f7	506	assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours)));
<>	144:ef7eb2e8f9f7	507	assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes)));
<>	144:ef7eb2e8f9f7	508	assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds)));
<>	144:ef7eb2e8f9f7	509
AnnaBridge	165:e614a9f1c9e2	510	counter_time = (((uint32_t)(RTC_Bcd2ToByte(sTime->Hours)) * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	511	((uint32_t)(RTC_Bcd2ToByte(sTime->Minutes)) * 60U) + \
<>	144:ef7eb2e8f9f7	512	((uint32_t)(RTC_Bcd2ToByte(sTime->Seconds))));
<>	144:ef7eb2e8f9f7	513	}
<>	144:ef7eb2e8f9f7	514
<>	144:ef7eb2e8f9f7	515	/* Write time counter in RTC registers */
<>	144:ef7eb2e8f9f7	516	if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
<>	144:ef7eb2e8f9f7	517	{
<>	144:ef7eb2e8f9f7	518	/* Set RTC state */
<>	144:ef7eb2e8f9f7	519	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	520
<>	144:ef7eb2e8f9f7	521	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	522	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	523
<>	144:ef7eb2e8f9f7	524	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	525	}
<>	144:ef7eb2e8f9f7	526	else
<>	144:ef7eb2e8f9f7	527	{
<>	144:ef7eb2e8f9f7	528	/* Clear Second and overflow flags */
<>	144:ef7eb2e8f9f7	529	CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_SEC \| RTC_FLAG_OW));
<>	144:ef7eb2e8f9f7	530
<>	144:ef7eb2e8f9f7	531	/* Read current Alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	532	counter_alarm = RTC_ReadAlarmCounter(hrtc);
<>	144:ef7eb2e8f9f7	533
<>	144:ef7eb2e8f9f7	534	/* Set again alarm to match with new time if enabled */
<>	144:ef7eb2e8f9f7	535	if (counter_alarm != RTC_ALARM_RESETVALUE)
<>	144:ef7eb2e8f9f7	536	{
<>	144:ef7eb2e8f9f7	537	if(counter_alarm < counter_time)
<>	144:ef7eb2e8f9f7	538	{
<>	144:ef7eb2e8f9f7	539	/* Add 1 day to alarm counter*/
AnnaBridge	165:e614a9f1c9e2	540	counter_alarm += (uint32_t)(24U * 3600U);
<>	144:ef7eb2e8f9f7	541
<>	144:ef7eb2e8f9f7	542	/* Write new Alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	543	if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<>	144:ef7eb2e8f9f7	544	{
<>	144:ef7eb2e8f9f7	545	/* Set RTC state */
<>	144:ef7eb2e8f9f7	546	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	547
<>	144:ef7eb2e8f9f7	548	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	549	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	550
<>	144:ef7eb2e8f9f7	551	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	552	}
<>	144:ef7eb2e8f9f7	553	}
<>	144:ef7eb2e8f9f7	554	}
<>	144:ef7eb2e8f9f7	555
<>	144:ef7eb2e8f9f7	556	hrtc->State = HAL_RTC_STATE_READY;
<>	144:ef7eb2e8f9f7	557
<>	144:ef7eb2e8f9f7	558	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	559
<>	144:ef7eb2e8f9f7	560	return HAL_OK;
<>	144:ef7eb2e8f9f7	561	}
<>	144:ef7eb2e8f9f7	562	}
<>	144:ef7eb2e8f9f7	563
<>	144:ef7eb2e8f9f7	564	/**
<>	144:ef7eb2e8f9f7	565	* @brief Gets RTC current time.
<>	144:ef7eb2e8f9f7	566	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	567	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	568	* @param sTime: Pointer to Time structure
<>	144:ef7eb2e8f9f7	569	* @param Format: Specifies the format of the entered parameters.
<>	144:ef7eb2e8f9f7	570	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	571	* @arg RTC_FORMAT_BIN: Binary data format
<>	144:ef7eb2e8f9f7	572	* @arg RTC_FORMAT_BCD: BCD data format
<>	144:ef7eb2e8f9f7	573	* @retval HAL status
<>	144:ef7eb2e8f9f7	574	*/
<>	144:ef7eb2e8f9f7	575	HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef hrtc, RTC_TimeTypeDef sTime, uint32_t Format)
<>	144:ef7eb2e8f9f7	576	{
AnnaBridge	165:e614a9f1c9e2	577	uint32_t counter_time = 0U, counter_alarm = 0U, days_elapsed = 0U, hours = 0U;
<>	144:ef7eb2e8f9f7	578
<>	144:ef7eb2e8f9f7	579	/* Check input parameters */
<>	144:ef7eb2e8f9f7	580	if((hrtc == NULL) \|\| (sTime == NULL))
<>	144:ef7eb2e8f9f7	581	{
<>	144:ef7eb2e8f9f7	582	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	583	}
<>	144:ef7eb2e8f9f7	584
<>	144:ef7eb2e8f9f7	585	/* Check the parameters */
<>	144:ef7eb2e8f9f7	586	assert_param(IS_RTC_FORMAT(Format));
<>	144:ef7eb2e8f9f7	587
<>	144:ef7eb2e8f9f7	588	/* Check if counter overflow occurred */
<>	144:ef7eb2e8f9f7	589	if (__HAL_RTC_OVERFLOW_GET_FLAG(hrtc, RTC_FLAG_OW))
<>	144:ef7eb2e8f9f7	590	{
<>	144:ef7eb2e8f9f7	591	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	592	}
<>	144:ef7eb2e8f9f7	593
<>	144:ef7eb2e8f9f7	594	/* Read the time counter*/
<>	144:ef7eb2e8f9f7	595	counter_time = RTC_ReadTimeCounter(hrtc);
<>	144:ef7eb2e8f9f7	596
<>	144:ef7eb2e8f9f7	597	/* Fill the structure fields with the read parameters */
AnnaBridge	165:e614a9f1c9e2	598	hours = counter_time / 3600U;
AnnaBridge	165:e614a9f1c9e2	599	sTime->Minutes = (uint8_t)((counter_time % 3600U) / 60U);
AnnaBridge	165:e614a9f1c9e2	600	sTime->Seconds = (uint8_t)((counter_time % 3600U) % 60U);
<>	144:ef7eb2e8f9f7	601
AnnaBridge	165:e614a9f1c9e2	602	if (hours >= 24U)
<>	144:ef7eb2e8f9f7	603	{
<>	144:ef7eb2e8f9f7	604	/* Get number of days elapsed from last calculation */
AnnaBridge	165:e614a9f1c9e2	605	days_elapsed = (hours / 24U);
<>	144:ef7eb2e8f9f7	606
<>	144:ef7eb2e8f9f7	607	/* Set Hours in RTC_TimeTypeDef structure*/
AnnaBridge	165:e614a9f1c9e2	608	sTime->Hours = (hours % 24U);
<>	144:ef7eb2e8f9f7	609
<>	144:ef7eb2e8f9f7	610	/* Read Alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	611	counter_alarm = RTC_ReadAlarmCounter(hrtc);
<>	144:ef7eb2e8f9f7	612
<>	144:ef7eb2e8f9f7	613	/* Calculate remaining time to reach alarm (only if set and not yet expired)*/
<>	144:ef7eb2e8f9f7	614	if ((counter_alarm != RTC_ALARM_RESETVALUE) && (counter_alarm > counter_time))
<>	144:ef7eb2e8f9f7	615	{
<>	144:ef7eb2e8f9f7	616	counter_alarm -= counter_time;
<>	144:ef7eb2e8f9f7	617	}
<>	144:ef7eb2e8f9f7	618	else
<>	144:ef7eb2e8f9f7	619	{
<>	144:ef7eb2e8f9f7	620	/* In case of counter_alarm < counter_time */
<>	144:ef7eb2e8f9f7	621	/* Alarm expiration already occurred but alarm not deactivated */
<>	144:ef7eb2e8f9f7	622	counter_alarm = RTC_ALARM_RESETVALUE;
<>	144:ef7eb2e8f9f7	623	}
<>	144:ef7eb2e8f9f7	624
<>	144:ef7eb2e8f9f7	625	/* Set updated time in decreasing counter by number of days elapsed */
AnnaBridge	165:e614a9f1c9e2	626	counter_time -= (days_elapsed * 24U * 3600U);
<>	144:ef7eb2e8f9f7	627
<>	144:ef7eb2e8f9f7	628	/* Write time counter in RTC registers */
<>	144:ef7eb2e8f9f7	629	if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
<>	144:ef7eb2e8f9f7	630	{
<>	144:ef7eb2e8f9f7	631	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	632	}
<>	144:ef7eb2e8f9f7	633
<>	144:ef7eb2e8f9f7	634	/* Set updated alarm to be set */
<>	144:ef7eb2e8f9f7	635	if (counter_alarm != RTC_ALARM_RESETVALUE)
<>	144:ef7eb2e8f9f7	636	{
<>	144:ef7eb2e8f9f7	637	counter_alarm += counter_time;
<>	144:ef7eb2e8f9f7	638
<>	144:ef7eb2e8f9f7	639	/* Write time counter in RTC registers */
<>	144:ef7eb2e8f9f7	640	if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<>	144:ef7eb2e8f9f7	641	{
<>	144:ef7eb2e8f9f7	642	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	643	}
<>	144:ef7eb2e8f9f7	644	}
<>	144:ef7eb2e8f9f7	645	else
<>	144:ef7eb2e8f9f7	646	{
<>	144:ef7eb2e8f9f7	647	/* Alarm already occurred. Set it to reset values to avoid unexpected expiration */
<>	144:ef7eb2e8f9f7	648	if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<>	144:ef7eb2e8f9f7	649	{
<>	144:ef7eb2e8f9f7	650	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	651	}
<>	144:ef7eb2e8f9f7	652	}
<>	144:ef7eb2e8f9f7	653
<>	144:ef7eb2e8f9f7	654	/* Update date */
<>	144:ef7eb2e8f9f7	655	RTC_DateUpdate(hrtc, days_elapsed);
<>	144:ef7eb2e8f9f7	656	}
<>	144:ef7eb2e8f9f7	657	else
<>	144:ef7eb2e8f9f7	658	{
<>	144:ef7eb2e8f9f7	659	sTime->Hours = hours;
<>	144:ef7eb2e8f9f7	660	}
<>	144:ef7eb2e8f9f7	661
<>	144:ef7eb2e8f9f7	662	/* Check the input parameters format */
<>	144:ef7eb2e8f9f7	663	if(Format != RTC_FORMAT_BIN)
<>	144:ef7eb2e8f9f7	664	{
<>	144:ef7eb2e8f9f7	665	/* Convert the time structure parameters to BCD format */
<>	144:ef7eb2e8f9f7	666	sTime->Hours = (uint8_t)RTC_ByteToBcd2(sTime->Hours);
<>	144:ef7eb2e8f9f7	667	sTime->Minutes = (uint8_t)RTC_ByteToBcd2(sTime->Minutes);
<>	144:ef7eb2e8f9f7	668	sTime->Seconds = (uint8_t)RTC_ByteToBcd2(sTime->Seconds);
<>	144:ef7eb2e8f9f7	669	}
<>	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 Sets RTC current date.
<>	144:ef7eb2e8f9f7	677	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	678	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	679	* @param sDate: Pointer to date structure
<>	144:ef7eb2e8f9f7	680	* @param Format: specifies the format of the entered parameters.
<>	144:ef7eb2e8f9f7	681	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	682	* @arg RTC_FORMAT_BIN: Binary data format
<>	144:ef7eb2e8f9f7	683	* @arg RTC_FORMAT_BCD: BCD data format
<>	144:ef7eb2e8f9f7	684	* @retval HAL status
<>	144:ef7eb2e8f9f7	685	*/
<>	144:ef7eb2e8f9f7	686	HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef hrtc, RTC_DateTypeDef sDate, uint32_t Format)
<>	144:ef7eb2e8f9f7	687	{
AnnaBridge	165:e614a9f1c9e2	688	uint32_t counter_time = 0U, counter_alarm = 0U, hours = 0U;
<>	144:ef7eb2e8f9f7	689
<>	144:ef7eb2e8f9f7	690	/* Check input parameters */
<>	144:ef7eb2e8f9f7	691	if((hrtc == NULL) \|\| (sDate == NULL))
<>	144:ef7eb2e8f9f7	692	{
<>	144:ef7eb2e8f9f7	693	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	694	}
<>	144:ef7eb2e8f9f7	695
<>	144:ef7eb2e8f9f7	696	/* Check the parameters */
<>	144:ef7eb2e8f9f7	697	assert_param(IS_RTC_FORMAT(Format));
<>	144:ef7eb2e8f9f7	698
<>	144:ef7eb2e8f9f7	699	/* Process Locked */
<>	144:ef7eb2e8f9f7	700	__HAL_LOCK(hrtc);
<>	144:ef7eb2e8f9f7	701
<>	144:ef7eb2e8f9f7	702	hrtc->State = HAL_RTC_STATE_BUSY;
<>	144:ef7eb2e8f9f7	703
<>	144:ef7eb2e8f9f7	704	if(Format == RTC_FORMAT_BIN)
<>	144:ef7eb2e8f9f7	705	{
<>	144:ef7eb2e8f9f7	706	assert_param(IS_RTC_YEAR(sDate->Year));
<>	144:ef7eb2e8f9f7	707	assert_param(IS_RTC_MONTH(sDate->Month));
<>	144:ef7eb2e8f9f7	708	assert_param(IS_RTC_DATE(sDate->Date));
<>	144:ef7eb2e8f9f7	709
<>	144:ef7eb2e8f9f7	710	/* Change the current date */
<>	144:ef7eb2e8f9f7	711	hrtc->DateToUpdate.Year = sDate->Year;
<>	144:ef7eb2e8f9f7	712	hrtc->DateToUpdate.Month = sDate->Month;
<>	144:ef7eb2e8f9f7	713	hrtc->DateToUpdate.Date = sDate->Date;
<>	144:ef7eb2e8f9f7	714	}
<>	144:ef7eb2e8f9f7	715	else
<>	144:ef7eb2e8f9f7	716	{
<>	144:ef7eb2e8f9f7	717	assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year)));
<>	144:ef7eb2e8f9f7	718	assert_param(IS_RTC_MONTH(RTC_Bcd2ToByte(sDate->Month)));
<>	144:ef7eb2e8f9f7	719	assert_param(IS_RTC_DATE(RTC_Bcd2ToByte(sDate->Date)));
<>	144:ef7eb2e8f9f7	720
<>	144:ef7eb2e8f9f7	721	/* Change the current date */
<>	144:ef7eb2e8f9f7	722	hrtc->DateToUpdate.Year = RTC_Bcd2ToByte(sDate->Year);
<>	144:ef7eb2e8f9f7	723	hrtc->DateToUpdate.Month = RTC_Bcd2ToByte(sDate->Month);
<>	144:ef7eb2e8f9f7	724	hrtc->DateToUpdate.Date = RTC_Bcd2ToByte(sDate->Date);
<>	144:ef7eb2e8f9f7	725	}
<>	144:ef7eb2e8f9f7	726
<>	144:ef7eb2e8f9f7	727	/* WeekDay set by user can be ignored because automatically calculated */
<>	144:ef7eb2e8f9f7	728	hrtc->DateToUpdate.WeekDay = RTC_WeekDayNum(hrtc->DateToUpdate.Year, hrtc->DateToUpdate.Month, hrtc->DateToUpdate.Date);
<>	144:ef7eb2e8f9f7	729	sDate->WeekDay = hrtc->DateToUpdate.WeekDay;
<>	144:ef7eb2e8f9f7	730
<>	144:ef7eb2e8f9f7	731	/* Reset time to be aligned on the same day */
<>	144:ef7eb2e8f9f7	732	/* Read the time counter*/
<>	144:ef7eb2e8f9f7	733	counter_time = RTC_ReadTimeCounter(hrtc);
<>	144:ef7eb2e8f9f7	734
<>	144:ef7eb2e8f9f7	735	/* Fill the structure fields with the read parameters */
AnnaBridge	165:e614a9f1c9e2	736	hours = counter_time / 3600U;
AnnaBridge	165:e614a9f1c9e2	737	if (hours > 24U)
<>	144:ef7eb2e8f9f7	738	{
<>	144:ef7eb2e8f9f7	739	/* Set updated time in decreasing counter by number of days elapsed */
AnnaBridge	165:e614a9f1c9e2	740	counter_time -= ((hours / 24U) * 24U * 3600U);
<>	144:ef7eb2e8f9f7	741	/* Write time counter in RTC registers */
<>	144:ef7eb2e8f9f7	742	if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
<>	144:ef7eb2e8f9f7	743	{
<>	144:ef7eb2e8f9f7	744	/* Set RTC state */
<>	144:ef7eb2e8f9f7	745	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	746
<>	144:ef7eb2e8f9f7	747	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	748	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	749
<>	144:ef7eb2e8f9f7	750	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	751	}
<>	144:ef7eb2e8f9f7	752
<>	144:ef7eb2e8f9f7	753	/* Read current Alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	754	counter_alarm = RTC_ReadAlarmCounter(hrtc);
<>	144:ef7eb2e8f9f7	755
<>	144:ef7eb2e8f9f7	756	/* Set again alarm to match with new time if enabled */
<>	144:ef7eb2e8f9f7	757	if (counter_alarm != RTC_ALARM_RESETVALUE)
<>	144:ef7eb2e8f9f7	758	{
<>	144:ef7eb2e8f9f7	759	if(counter_alarm < counter_time)
<>	144:ef7eb2e8f9f7	760	{
<>	144:ef7eb2e8f9f7	761	/* Add 1 day to alarm counter*/
AnnaBridge	165:e614a9f1c9e2	762	counter_alarm += (uint32_t)(24U * 3600U);
<>	144:ef7eb2e8f9f7	763
<>	144:ef7eb2e8f9f7	764	/* Write new Alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	765	if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<>	144:ef7eb2e8f9f7	766	{
<>	144:ef7eb2e8f9f7	767	/* Set RTC state */
<>	144:ef7eb2e8f9f7	768	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	769
<>	144:ef7eb2e8f9f7	770	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	771	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	772
<>	144:ef7eb2e8f9f7	773	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	774	}
<>	144:ef7eb2e8f9f7	775	}
<>	144:ef7eb2e8f9f7	776	}
<>	144:ef7eb2e8f9f7	777
<>	144:ef7eb2e8f9f7	778
<>	144:ef7eb2e8f9f7	779	}
<>	144:ef7eb2e8f9f7	780
<>	144:ef7eb2e8f9f7	781	hrtc->State = HAL_RTC_STATE_READY ;
<>	144:ef7eb2e8f9f7	782
<>	144:ef7eb2e8f9f7	783	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	784	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	785
<>	144:ef7eb2e8f9f7	786	return HAL_OK;
<>	144:ef7eb2e8f9f7	787	}
<>	144:ef7eb2e8f9f7	788
<>	144:ef7eb2e8f9f7	789	/**
<>	144:ef7eb2e8f9f7	790	* @brief Gets RTC current date.
<>	144:ef7eb2e8f9f7	791	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	792	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	793	* @param sDate: Pointer to Date structure
<>	144:ef7eb2e8f9f7	794	* @param Format: Specifies the format of the entered parameters.
<>	144:ef7eb2e8f9f7	795	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	796	* @arg RTC_FORMAT_BIN: Binary data format
<>	144:ef7eb2e8f9f7	797	* @arg RTC_FORMAT_BCD: BCD data format
<>	144:ef7eb2e8f9f7	798	* @retval HAL status
<>	144:ef7eb2e8f9f7	799	*/
<>	144:ef7eb2e8f9f7	800	HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef hrtc, RTC_DateTypeDef sDate, uint32_t Format)
<>	144:ef7eb2e8f9f7	801	{
AnnaBridge	165:e614a9f1c9e2	802	RTC_TimeTypeDef stime = {0U};
<>	144:ef7eb2e8f9f7	803
<>	144:ef7eb2e8f9f7	804	/* Check input parameters */
<>	144:ef7eb2e8f9f7	805	if((hrtc == NULL) \|\| (sDate == NULL))
<>	144:ef7eb2e8f9f7	806	{
<>	144:ef7eb2e8f9f7	807	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	808	}
<>	144:ef7eb2e8f9f7	809
<>	144:ef7eb2e8f9f7	810	/* Check the parameters */
<>	144:ef7eb2e8f9f7	811	assert_param(IS_RTC_FORMAT(Format));
<>	144:ef7eb2e8f9f7	812
<>	144:ef7eb2e8f9f7	813	/* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
<>	144:ef7eb2e8f9f7	814	if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
<>	144:ef7eb2e8f9f7	815	{
<>	144:ef7eb2e8f9f7	816	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	817	}
<>	144:ef7eb2e8f9f7	818
<>	144:ef7eb2e8f9f7	819	/* Fill the structure fields with the read parameters */
<>	144:ef7eb2e8f9f7	820	sDate->WeekDay = hrtc->DateToUpdate.WeekDay;
<>	144:ef7eb2e8f9f7	821	sDate->Year = hrtc->DateToUpdate.Year;
<>	144:ef7eb2e8f9f7	822	sDate->Month = hrtc->DateToUpdate.Month;
<>	144:ef7eb2e8f9f7	823	sDate->Date = hrtc->DateToUpdate.Date;
<>	144:ef7eb2e8f9f7	824
<>	144:ef7eb2e8f9f7	825	/* Check the input parameters format */
<>	144:ef7eb2e8f9f7	826	if(Format != RTC_FORMAT_BIN)
<>	144:ef7eb2e8f9f7	827	{
<>	144:ef7eb2e8f9f7	828	/* Convert the date structure parameters to BCD format */
<>	144:ef7eb2e8f9f7	829	sDate->Year = (uint8_t)RTC_ByteToBcd2(sDate->Year);
<>	144:ef7eb2e8f9f7	830	sDate->Month = (uint8_t)RTC_ByteToBcd2(sDate->Month);
<>	144:ef7eb2e8f9f7	831	sDate->Date = (uint8_t)RTC_ByteToBcd2(sDate->Date);
<>	144:ef7eb2e8f9f7	832	}
<>	144:ef7eb2e8f9f7	833	return HAL_OK;
<>	144:ef7eb2e8f9f7	834	}
<>	144:ef7eb2e8f9f7	835
<>	144:ef7eb2e8f9f7	836	/**
<>	144:ef7eb2e8f9f7	837	* @}
<>	144:ef7eb2e8f9f7	838	*/
<>	144:ef7eb2e8f9f7	839
<>	144:ef7eb2e8f9f7	840	/** @defgroup RTC_Exported_Functions_Group3 Alarm functions
<>	144:ef7eb2e8f9f7	841	* @brief RTC Alarm functions
<>	144:ef7eb2e8f9f7	842	*
<>	144:ef7eb2e8f9f7	843	@verbatim
<>	144:ef7eb2e8f9f7	844	===============================================================================
<>	144:ef7eb2e8f9f7	845	##### RTC Alarm functions #####
<>	144:ef7eb2e8f9f7	846	===============================================================================
<>	144:ef7eb2e8f9f7	847
<>	144:ef7eb2e8f9f7	848	[..] This section provides functions allowing to configure Alarm feature
<>	144:ef7eb2e8f9f7	849
<>	144:ef7eb2e8f9f7	850	@endverbatim
<>	144:ef7eb2e8f9f7	851	* @{
<>	144:ef7eb2e8f9f7	852	*/
<>	144:ef7eb2e8f9f7	853
<>	144:ef7eb2e8f9f7	854	/**
<>	144:ef7eb2e8f9f7	855	* @brief Sets the specified RTC Alarm.
<>	144:ef7eb2e8f9f7	856	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	857	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	858	* @param sAlarm: Pointer to Alarm structure
<>	144:ef7eb2e8f9f7	859	* @param Format: Specifies the format of the entered parameters.
<>	144:ef7eb2e8f9f7	860	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	861	* @arg RTC_FORMAT_BIN: Binary data format
<>	144:ef7eb2e8f9f7	862	* @arg RTC_FORMAT_BCD: BCD data format
<>	144:ef7eb2e8f9f7	863	* @retval HAL status
<>	144:ef7eb2e8f9f7	864	*/
<>	144:ef7eb2e8f9f7	865	HAL_StatusTypeDef HAL_RTC_SetAlarm(RTC_HandleTypeDef hrtc, RTC_AlarmTypeDef sAlarm, uint32_t Format)
<>	144:ef7eb2e8f9f7	866	{
AnnaBridge	165:e614a9f1c9e2	867	uint32_t counter_alarm = 0U, counter_time;
AnnaBridge	165:e614a9f1c9e2	868	RTC_TimeTypeDef stime = {0U};
<>	144:ef7eb2e8f9f7	869
<>	144:ef7eb2e8f9f7	870	/* Check input parameters */
<>	144:ef7eb2e8f9f7	871	if((hrtc == NULL) \|\| (sAlarm == NULL))
<>	144:ef7eb2e8f9f7	872	{
<>	144:ef7eb2e8f9f7	873	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	874	}
<>	144:ef7eb2e8f9f7	875
<>	144:ef7eb2e8f9f7	876	/* Check the parameters */
<>	144:ef7eb2e8f9f7	877	assert_param(IS_RTC_FORMAT(Format));
<>	144:ef7eb2e8f9f7	878	assert_param(IS_RTC_ALARM(sAlarm->Alarm));
<>	144:ef7eb2e8f9f7	879
<>	144:ef7eb2e8f9f7	880	/* Process Locked */
<>	144:ef7eb2e8f9f7	881	__HAL_LOCK(hrtc);
<>	144:ef7eb2e8f9f7	882
<>	144:ef7eb2e8f9f7	883	hrtc->State = HAL_RTC_STATE_BUSY;
<>	144:ef7eb2e8f9f7	884
<>	144:ef7eb2e8f9f7	885	/* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
<>	144:ef7eb2e8f9f7	886	if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
<>	144:ef7eb2e8f9f7	887	{
<>	144:ef7eb2e8f9f7	888	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	889	}
<>	144:ef7eb2e8f9f7	890
<>	144:ef7eb2e8f9f7	891	/* Convert time in seconds */
AnnaBridge	165:e614a9f1c9e2	892	counter_time = (uint32_t)(((uint32_t)stime.Hours * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	893	((uint32_t)stime.Minutes * 60U) + \
<>	144:ef7eb2e8f9f7	894	((uint32_t)stime.Seconds));
<>	144:ef7eb2e8f9f7	895
<>	144:ef7eb2e8f9f7	896	if(Format == RTC_FORMAT_BIN)
<>	144:ef7eb2e8f9f7	897	{
<>	144:ef7eb2e8f9f7	898	assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
<>	144:ef7eb2e8f9f7	899	assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
<>	144:ef7eb2e8f9f7	900	assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
<>	144:ef7eb2e8f9f7	901
AnnaBridge	165:e614a9f1c9e2	902	counter_alarm = (uint32_t)(((uint32_t)sAlarm->AlarmTime.Hours * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	903	((uint32_t)sAlarm->AlarmTime.Minutes * 60U) + \
<>	144:ef7eb2e8f9f7	904	((uint32_t)sAlarm->AlarmTime.Seconds));
<>	144:ef7eb2e8f9f7	905	}
<>	144:ef7eb2e8f9f7	906	else
<>	144:ef7eb2e8f9f7	907	{
<>	144:ef7eb2e8f9f7	908	assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
<>	144:ef7eb2e8f9f7	909	assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
<>	144:ef7eb2e8f9f7	910	assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<>	144:ef7eb2e8f9f7	911
AnnaBridge	165:e614a9f1c9e2	912	counter_alarm = (((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)) * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	913	((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)) * 60U) + \
<>	144:ef7eb2e8f9f7	914	((uint32_t)RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<>	144:ef7eb2e8f9f7	915	}
<>	144:ef7eb2e8f9f7	916
<>	144:ef7eb2e8f9f7	917	/* Check that requested alarm should expire in the same day (otherwise add 1 day) */
<>	144:ef7eb2e8f9f7	918	if (counter_alarm < counter_time)
<>	144:ef7eb2e8f9f7	919	{
<>	144:ef7eb2e8f9f7	920	/* Add 1 day to alarm counter*/
AnnaBridge	165:e614a9f1c9e2	921	counter_alarm += (uint32_t)(24U * 3600U);
<>	144:ef7eb2e8f9f7	922	}
<>	144:ef7eb2e8f9f7	923
<>	144:ef7eb2e8f9f7	924	/* Write Alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	925	if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<>	144:ef7eb2e8f9f7	926	{
<>	144:ef7eb2e8f9f7	927	/* Set RTC state */
<>	144:ef7eb2e8f9f7	928	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	929
<>	144:ef7eb2e8f9f7	930	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	931	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	932
<>	144:ef7eb2e8f9f7	933	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	934	}
<>	144:ef7eb2e8f9f7	935	else
<>	144:ef7eb2e8f9f7	936	{
<>	144:ef7eb2e8f9f7	937	hrtc->State = HAL_RTC_STATE_READY;
<>	144:ef7eb2e8f9f7	938
<>	144:ef7eb2e8f9f7	939	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	940
<>	144:ef7eb2e8f9f7	941	return HAL_OK;
<>	144:ef7eb2e8f9f7	942	}
<>	144:ef7eb2e8f9f7	943	}
<>	144:ef7eb2e8f9f7	944
<>	144:ef7eb2e8f9f7	945	/**
<>	144:ef7eb2e8f9f7	946	* @brief Sets the specified RTC Alarm with Interrupt
<>	144:ef7eb2e8f9f7	947	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	948	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	949	* @param sAlarm: Pointer to Alarm structure
<>	144:ef7eb2e8f9f7	950	* @param Format: Specifies the format of the entered parameters.
<>	144:ef7eb2e8f9f7	951	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	952	* @arg RTC_FORMAT_BIN: Binary data format
<>	144:ef7eb2e8f9f7	953	* @arg RTC_FORMAT_BCD: BCD data format
<>	144:ef7eb2e8f9f7	954	* @note The HAL_RTC_SetTime() must be called before enabling the Alarm feature.
<>	144:ef7eb2e8f9f7	955	* @retval HAL status
<>	144:ef7eb2e8f9f7	956	*/
<>	144:ef7eb2e8f9f7	957	HAL_StatusTypeDef HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef hrtc, RTC_AlarmTypeDef sAlarm, uint32_t Format)
<>	144:ef7eb2e8f9f7	958	{
AnnaBridge	165:e614a9f1c9e2	959	uint32_t counter_alarm = 0U, counter_time;
AnnaBridge	165:e614a9f1c9e2	960	RTC_TimeTypeDef stime = {0U};
<>	144:ef7eb2e8f9f7	961
<>	144:ef7eb2e8f9f7	962	/* Check input parameters */
<>	144:ef7eb2e8f9f7	963	if((hrtc == NULL) \|\| (sAlarm == NULL))
<>	144:ef7eb2e8f9f7	964	{
<>	144:ef7eb2e8f9f7	965	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	966	}
<>	144:ef7eb2e8f9f7	967
<>	144:ef7eb2e8f9f7	968	/* Check the parameters */
<>	144:ef7eb2e8f9f7	969	assert_param(IS_RTC_FORMAT(Format));
<>	144:ef7eb2e8f9f7	970	assert_param(IS_RTC_ALARM(sAlarm->Alarm));
<>	144:ef7eb2e8f9f7	971
<>	144:ef7eb2e8f9f7	972	/* Process Locked */
<>	144:ef7eb2e8f9f7	973	__HAL_LOCK(hrtc);
<>	144:ef7eb2e8f9f7	974
<>	144:ef7eb2e8f9f7	975	hrtc->State = HAL_RTC_STATE_BUSY;
<>	144:ef7eb2e8f9f7	976
<>	144:ef7eb2e8f9f7	977	/* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
<>	144:ef7eb2e8f9f7	978	if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
<>	144:ef7eb2e8f9f7	979	{
<>	144:ef7eb2e8f9f7	980	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	981	}
<>	144:ef7eb2e8f9f7	982
<>	144:ef7eb2e8f9f7	983	/* Convert time in seconds */
AnnaBridge	165:e614a9f1c9e2	984	counter_time = (uint32_t)(((uint32_t)stime.Hours * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	985	((uint32_t)stime.Minutes * 60U) + \
<>	144:ef7eb2e8f9f7	986	((uint32_t)stime.Seconds));
<>	144:ef7eb2e8f9f7	987
<>	144:ef7eb2e8f9f7	988	if(Format == RTC_FORMAT_BIN)
<>	144:ef7eb2e8f9f7	989	{
<>	144:ef7eb2e8f9f7	990	assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
<>	144:ef7eb2e8f9f7	991	assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
<>	144:ef7eb2e8f9f7	992	assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
<>	144:ef7eb2e8f9f7	993
AnnaBridge	165:e614a9f1c9e2	994	counter_alarm = (uint32_t)(((uint32_t)sAlarm->AlarmTime.Hours * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	995	((uint32_t)sAlarm->AlarmTime.Minutes * 60U) + \
<>	144:ef7eb2e8f9f7	996	((uint32_t)sAlarm->AlarmTime.Seconds));
<>	144:ef7eb2e8f9f7	997	}
<>	144:ef7eb2e8f9f7	998	else
<>	144:ef7eb2e8f9f7	999	{
<>	144:ef7eb2e8f9f7	1000	assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
<>	144:ef7eb2e8f9f7	1001	assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
<>	144:ef7eb2e8f9f7	1002	assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<>	144:ef7eb2e8f9f7	1003
AnnaBridge	165:e614a9f1c9e2	1004	counter_alarm = (((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)) * 3600U) + \
AnnaBridge	165:e614a9f1c9e2	1005	((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)) * 60U) + \
AnnaBridge	165:e614a9f1c9e2	1006	((uint32_t)RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
<>	144:ef7eb2e8f9f7	1007	}
<>	144:ef7eb2e8f9f7	1008
<>	144:ef7eb2e8f9f7	1009	/* Check that requested alarm should expire in the same day (otherwise add 1 day) */
<>	144:ef7eb2e8f9f7	1010	if (counter_alarm < counter_time)
<>	144:ef7eb2e8f9f7	1011	{
<>	144:ef7eb2e8f9f7	1012	/* Add 1 day to alarm counter*/
AnnaBridge	165:e614a9f1c9e2	1013	counter_alarm += (uint32_t)(24U * 3600U);
<>	144:ef7eb2e8f9f7	1014	}
<>	144:ef7eb2e8f9f7	1015
<>	144:ef7eb2e8f9f7	1016	/* Write alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	1017	if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
<>	144:ef7eb2e8f9f7	1018	{
<>	144:ef7eb2e8f9f7	1019	/* Set RTC state */
<>	144:ef7eb2e8f9f7	1020	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	1021
<>	144:ef7eb2e8f9f7	1022	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1023	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	1024
<>	144:ef7eb2e8f9f7	1025	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	1026	}
<>	144:ef7eb2e8f9f7	1027	else
<>	144:ef7eb2e8f9f7	1028	{
<>	144:ef7eb2e8f9f7	1029	/* Clear flag alarm A */
<>	144:ef7eb2e8f9f7	1030	__HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
<>	144:ef7eb2e8f9f7	1031
<>	144:ef7eb2e8f9f7	1032	/* Configure the Alarm interrupt */
<>	144:ef7eb2e8f9f7	1033	__HAL_RTC_ALARM_ENABLE_IT(hrtc,RTC_IT_ALRA);
<>	144:ef7eb2e8f9f7	1034
<>	144:ef7eb2e8f9f7	1035	/* RTC Alarm Interrupt Configuration: EXTI configuration */
<>	144:ef7eb2e8f9f7	1036	__HAL_RTC_ALARM_EXTI_ENABLE_IT();
<>	144:ef7eb2e8f9f7	1037
<>	144:ef7eb2e8f9f7	1038	__HAL_RTC_ALARM_EXTI_ENABLE_RISING_EDGE();
<>	144:ef7eb2e8f9f7	1039
<>	144:ef7eb2e8f9f7	1040	hrtc->State = HAL_RTC_STATE_READY;
<>	144:ef7eb2e8f9f7	1041
<>	144:ef7eb2e8f9f7	1042	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	1043
<>	144:ef7eb2e8f9f7	1044	return HAL_OK;
<>	144:ef7eb2e8f9f7	1045	}
<>	144:ef7eb2e8f9f7	1046	}
<>	144:ef7eb2e8f9f7	1047
<>	144:ef7eb2e8f9f7	1048	/**
<>	144:ef7eb2e8f9f7	1049	* @brief Gets the RTC Alarm value and masks.
<>	144:ef7eb2e8f9f7	1050	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1051	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1052	* @param sAlarm: Pointer to Date structure
<>	144:ef7eb2e8f9f7	1053	* @param Alarm: Specifies the Alarm.
<>	144:ef7eb2e8f9f7	1054	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	1055	* @arg RTC_ALARM_A: Alarm
<>	144:ef7eb2e8f9f7	1056	* @param Format: Specifies the format of the entered parameters.
<>	144:ef7eb2e8f9f7	1057	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	1058	* @arg RTC_FORMAT_BIN: Binary data format
<>	144:ef7eb2e8f9f7	1059	* @arg RTC_FORMAT_BCD: BCD data format
<>	144:ef7eb2e8f9f7	1060	* @retval HAL status
<>	144:ef7eb2e8f9f7	1061	*/
<>	144:ef7eb2e8f9f7	1062	HAL_StatusTypeDef HAL_RTC_GetAlarm(RTC_HandleTypeDef hrtc, RTC_AlarmTypeDef sAlarm, uint32_t Alarm, uint32_t Format)
<>	144:ef7eb2e8f9f7	1063	{
AnnaBridge	165:e614a9f1c9e2	1064	uint32_t counter_alarm = 0U;
AnnaBridge	165:e614a9f1c9e2	1065
AnnaBridge	165:e614a9f1c9e2	1066	/* Prevent unused argument(s) compilation warning */
AnnaBridge	165:e614a9f1c9e2	1067	UNUSED(Alarm);
<>	144:ef7eb2e8f9f7	1068
<>	144:ef7eb2e8f9f7	1069	/* Check input parameters */
<>	144:ef7eb2e8f9f7	1070	if((hrtc == NULL) \|\| (sAlarm == NULL))
<>	144:ef7eb2e8f9f7	1071	{
AnnaBridge	165:e614a9f1c9e2	1072	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	1073	}
<>	144:ef7eb2e8f9f7	1074
<>	144:ef7eb2e8f9f7	1075	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1076	assert_param(IS_RTC_FORMAT(Format));
<>	144:ef7eb2e8f9f7	1077	assert_param(IS_RTC_ALARM(Alarm));
<>	144:ef7eb2e8f9f7	1078
<>	144:ef7eb2e8f9f7	1079	/* Read Alarm counter in RTC registers */
<>	144:ef7eb2e8f9f7	1080	counter_alarm = RTC_ReadAlarmCounter(hrtc);
<>	144:ef7eb2e8f9f7	1081
<>	144:ef7eb2e8f9f7	1082	/* Fill the structure with the read parameters */
<>	144:ef7eb2e8f9f7	1083	/* Set hours in a day range (between 0 to 24)*/
AnnaBridge	165:e614a9f1c9e2	1084	sAlarm->AlarmTime.Hours = (uint32_t)((counter_alarm / 3600U) % 24U);
AnnaBridge	165:e614a9f1c9e2	1085	sAlarm->AlarmTime.Minutes = (uint32_t)((counter_alarm % 3600U) / 60U);
AnnaBridge	165:e614a9f1c9e2	1086	sAlarm->AlarmTime.Seconds = (uint32_t)((counter_alarm % 3600U) % 60U);
<>	144:ef7eb2e8f9f7	1087
<>	144:ef7eb2e8f9f7	1088	if(Format != RTC_FORMAT_BIN)
<>	144:ef7eb2e8f9f7	1089	{
<>	144:ef7eb2e8f9f7	1090	sAlarm->AlarmTime.Hours = RTC_ByteToBcd2(sAlarm->AlarmTime.Hours);
<>	144:ef7eb2e8f9f7	1091	sAlarm->AlarmTime.Minutes = RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes);
<>	144:ef7eb2e8f9f7	1092	sAlarm->AlarmTime.Seconds = RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds);
<>	144:ef7eb2e8f9f7	1093	}
<>	144:ef7eb2e8f9f7	1094
<>	144:ef7eb2e8f9f7	1095	return HAL_OK;
<>	144:ef7eb2e8f9f7	1096	}
<>	144:ef7eb2e8f9f7	1097
<>	144:ef7eb2e8f9f7	1098	/**
<>	144:ef7eb2e8f9f7	1099	* @brief Deactive the specified RTC Alarm
<>	144:ef7eb2e8f9f7	1100	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1101	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1102	* @param Alarm: Specifies the Alarm.
<>	144:ef7eb2e8f9f7	1103	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	1104	* @arg RTC_ALARM_A: AlarmA
<>	144:ef7eb2e8f9f7	1105	* @retval HAL status
<>	144:ef7eb2e8f9f7	1106	*/
<>	144:ef7eb2e8f9f7	1107	HAL_StatusTypeDef HAL_RTC_DeactivateAlarm(RTC_HandleTypeDef *hrtc, uint32_t Alarm)
<>	144:ef7eb2e8f9f7	1108	{
AnnaBridge	165:e614a9f1c9e2	1109	/* Prevent unused argument(s) compilation warning */
AnnaBridge	165:e614a9f1c9e2	1110	UNUSED(Alarm);
AnnaBridge	165:e614a9f1c9e2	1111
<>	144:ef7eb2e8f9f7	1112	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1113	assert_param(IS_RTC_ALARM(Alarm));
<>	144:ef7eb2e8f9f7	1114
<>	144:ef7eb2e8f9f7	1115	/* Check input parameters */
<>	144:ef7eb2e8f9f7	1116	if(hrtc == NULL)
<>	144:ef7eb2e8f9f7	1117	{
<>	144:ef7eb2e8f9f7	1118	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	1119	}
<>	144:ef7eb2e8f9f7	1120
<>	144:ef7eb2e8f9f7	1121	/* Process Locked */
<>	144:ef7eb2e8f9f7	1122	__HAL_LOCK(hrtc);
<>	144:ef7eb2e8f9f7	1123
<>	144:ef7eb2e8f9f7	1124	hrtc->State = HAL_RTC_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1125
<>	144:ef7eb2e8f9f7	1126	/* In case of interrupt mode is used, the interrupt source must disabled */
<>	144:ef7eb2e8f9f7	1127	__HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
<>	144:ef7eb2e8f9f7	1128
<>	144:ef7eb2e8f9f7	1129	/* Set Initialization mode */
<>	144:ef7eb2e8f9f7	1130	if(RTC_EnterInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	1131	{
<>	144:ef7eb2e8f9f7	1132	/* Set RTC state */
<>	144:ef7eb2e8f9f7	1133	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	1134
<>	144:ef7eb2e8f9f7	1135	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1136	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	1137
<>	144:ef7eb2e8f9f7	1138	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	1139	}
<>	144:ef7eb2e8f9f7	1140	else
<>	144:ef7eb2e8f9f7	1141	{
<>	144:ef7eb2e8f9f7	1142	/* Clear flag alarm A */
<>	144:ef7eb2e8f9f7	1143	__HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
<>	144:ef7eb2e8f9f7	1144
<>	144:ef7eb2e8f9f7	1145	/* Set to default values ALRH & ALRL registers */
<>	144:ef7eb2e8f9f7	1146	WRITE_REG(hrtc->Instance->ALRH, RTC_ALARM_RESETVALUE_REGISTER);
<>	144:ef7eb2e8f9f7	1147	WRITE_REG(hrtc->Instance->ALRL, RTC_ALARM_RESETVALUE_REGISTER);
<>	144:ef7eb2e8f9f7	1148
<>	144:ef7eb2e8f9f7	1149	/* RTC Alarm Interrupt Configuration: Disable EXTI configuration */
<>	144:ef7eb2e8f9f7	1150	__HAL_RTC_ALARM_EXTI_DISABLE_IT();
<>	144:ef7eb2e8f9f7	1151
<>	144:ef7eb2e8f9f7	1152	/* Wait for synchro */
<>	144:ef7eb2e8f9f7	1153	if(RTC_ExitInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	1154	{
<>	144:ef7eb2e8f9f7	1155	hrtc->State = HAL_RTC_STATE_ERROR;
<>	144:ef7eb2e8f9f7	1156
<>	144:ef7eb2e8f9f7	1157	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1158	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	1159
<>	144:ef7eb2e8f9f7	1160	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	1161	}
<>	144:ef7eb2e8f9f7	1162	}
<>	144:ef7eb2e8f9f7	1163	hrtc->State = HAL_RTC_STATE_READY;
<>	144:ef7eb2e8f9f7	1164
<>	144:ef7eb2e8f9f7	1165	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1166	__HAL_UNLOCK(hrtc);
<>	144:ef7eb2e8f9f7	1167
<>	144:ef7eb2e8f9f7	1168	return HAL_OK;
<>	144:ef7eb2e8f9f7	1169	}
<>	144:ef7eb2e8f9f7	1170
<>	144:ef7eb2e8f9f7	1171	/**
<>	144:ef7eb2e8f9f7	1172	* @brief This function handles Alarm interrupt request.
<>	144:ef7eb2e8f9f7	1173	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1174	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1175	* @retval None
<>	144:ef7eb2e8f9f7	1176	*/
<>	144:ef7eb2e8f9f7	1177	void HAL_RTC_AlarmIRQHandler(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	1178	{
<>	144:ef7eb2e8f9f7	1179	if(__HAL_RTC_ALARM_GET_IT_SOURCE(hrtc, RTC_IT_ALRA))
<>	144:ef7eb2e8f9f7	1180	{
<>	144:ef7eb2e8f9f7	1181	/* Get the status of the Interrupt */
<>	144:ef7eb2e8f9f7	1182	if(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) != (uint32_t)RESET)
<>	144:ef7eb2e8f9f7	1183	{
<>	144:ef7eb2e8f9f7	1184	/* AlarmA callback */
<>	144:ef7eb2e8f9f7	1185	HAL_RTC_AlarmAEventCallback(hrtc);
<>	144:ef7eb2e8f9f7	1186
<>	144:ef7eb2e8f9f7	1187	/* Clear the Alarm interrupt pending bit */
<>	144:ef7eb2e8f9f7	1188	__HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRAF);
<>	144:ef7eb2e8f9f7	1189	}
<>	144:ef7eb2e8f9f7	1190	}
<>	144:ef7eb2e8f9f7	1191
<>	144:ef7eb2e8f9f7	1192	/* Clear the EXTI's line Flag for RTC Alarm */
<>	144:ef7eb2e8f9f7	1193	__HAL_RTC_ALARM_EXTI_CLEAR_FLAG();
<>	144:ef7eb2e8f9f7	1194
<>	144:ef7eb2e8f9f7	1195	/* Change RTC state */
<>	144:ef7eb2e8f9f7	1196	hrtc->State = HAL_RTC_STATE_READY;
<>	144:ef7eb2e8f9f7	1197	}
<>	144:ef7eb2e8f9f7	1198
<>	144:ef7eb2e8f9f7	1199	/**
<>	144:ef7eb2e8f9f7	1200	* @brief Alarm A callback.
<>	144:ef7eb2e8f9f7	1201	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1202	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1203	* @retval None
<>	144:ef7eb2e8f9f7	1204	*/
<>	144:ef7eb2e8f9f7	1205	__weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
<>	144:ef7eb2e8f9f7	1206	{
<>	144:ef7eb2e8f9f7	1207	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1208	UNUSED(hrtc);
<>	144:ef7eb2e8f9f7	1209	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1210	the HAL_RTC_AlarmAEventCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1211	*/
<>	144:ef7eb2e8f9f7	1212	}
<>	144:ef7eb2e8f9f7	1213
<>	144:ef7eb2e8f9f7	1214	/**
<>	144:ef7eb2e8f9f7	1215	* @brief This function handles AlarmA Polling request.
<>	144:ef7eb2e8f9f7	1216	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1217	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1218	* @param Timeout: Timeout duration
<>	144:ef7eb2e8f9f7	1219	* @retval HAL status
<>	144:ef7eb2e8f9f7	1220	*/
<>	144:ef7eb2e8f9f7	1221	HAL_StatusTypeDef HAL_RTC_PollForAlarmAEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	1222	{
<>	144:ef7eb2e8f9f7	1223	uint32_t tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1224
<>	144:ef7eb2e8f9f7	1225	/* Check input parameters */
<>	144:ef7eb2e8f9f7	1226	if(hrtc == NULL)
<>	144:ef7eb2e8f9f7	1227	{
<>	144:ef7eb2e8f9f7	1228	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	1229	}
<>	144:ef7eb2e8f9f7	1230
<>	144:ef7eb2e8f9f7	1231	while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) == RESET)
<>	144:ef7eb2e8f9f7	1232	{
<>	144:ef7eb2e8f9f7	1233	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	1234	{
<>	144:ef7eb2e8f9f7	1235	if((Timeout == 0)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	1236	{
<>	144:ef7eb2e8f9f7	1237	hrtc->State = HAL_RTC_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1238	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1239	}
<>	144:ef7eb2e8f9f7	1240	}
<>	144:ef7eb2e8f9f7	1241	}
<>	144:ef7eb2e8f9f7	1242
<>	144:ef7eb2e8f9f7	1243	/* Clear the Alarm interrupt pending bit */
<>	144:ef7eb2e8f9f7	1244	__HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
<>	144:ef7eb2e8f9f7	1245
<>	144:ef7eb2e8f9f7	1246	/* Change RTC state */
<>	144:ef7eb2e8f9f7	1247	hrtc->State = HAL_RTC_STATE_READY;
<>	144:ef7eb2e8f9f7	1248
<>	144:ef7eb2e8f9f7	1249	return HAL_OK;
<>	144:ef7eb2e8f9f7	1250	}
<>	144:ef7eb2e8f9f7	1251
<>	144:ef7eb2e8f9f7	1252	/**
<>	144:ef7eb2e8f9f7	1253	* @}
<>	144:ef7eb2e8f9f7	1254	*/
<>	144:ef7eb2e8f9f7	1255
<>	144:ef7eb2e8f9f7	1256	/** @defgroup RTC_Exported_Functions_Group4 Peripheral State functions
<>	144:ef7eb2e8f9f7	1257	* @brief Peripheral State functions
<>	144:ef7eb2e8f9f7	1258	*
<>	144:ef7eb2e8f9f7	1259	@verbatim
<>	144:ef7eb2e8f9f7	1260	===============================================================================
<>	144:ef7eb2e8f9f7	1261	##### Peripheral State functions #####
<>	144:ef7eb2e8f9f7	1262	===============================================================================
<>	144:ef7eb2e8f9f7	1263	[..]
<>	144:ef7eb2e8f9f7	1264	This subsection provides functions allowing to
<>	144:ef7eb2e8f9f7	1265	(+) Get RTC state
<>	144:ef7eb2e8f9f7	1266
<>	144:ef7eb2e8f9f7	1267	@endverbatim
<>	144:ef7eb2e8f9f7	1268	* @{
<>	144:ef7eb2e8f9f7	1269	*/
<>	144:ef7eb2e8f9f7	1270	/**
<>	144:ef7eb2e8f9f7	1271	* @brief Returns the RTC state.
<>	144:ef7eb2e8f9f7	1272	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1273	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1274	* @retval HAL state
<>	144:ef7eb2e8f9f7	1275	*/
<>	144:ef7eb2e8f9f7	1276	HAL_RTCStateTypeDef HAL_RTC_GetState(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	1277	{
<>	144:ef7eb2e8f9f7	1278	return hrtc->State;
<>	144:ef7eb2e8f9f7	1279	}
<>	144:ef7eb2e8f9f7	1280
<>	144:ef7eb2e8f9f7	1281	/**
<>	144:ef7eb2e8f9f7	1282	* @}
<>	144:ef7eb2e8f9f7	1283	*/
<>	144:ef7eb2e8f9f7	1284
<>	144:ef7eb2e8f9f7	1285	/** @defgroup RTC_Exported_Functions_Group5 Peripheral Control functions
<>	144:ef7eb2e8f9f7	1286	* @brief Peripheral Control functions
<>	144:ef7eb2e8f9f7	1287	*
<>	144:ef7eb2e8f9f7	1288	@verbatim
<>	144:ef7eb2e8f9f7	1289	===============================================================================
<>	144:ef7eb2e8f9f7	1290	##### Peripheral Control functions #####
<>	144:ef7eb2e8f9f7	1291	===============================================================================
<>	144:ef7eb2e8f9f7	1292	[..]
<>	144:ef7eb2e8f9f7	1293	This subsection provides functions allowing to
<>	144:ef7eb2e8f9f7	1294	(+) Wait for RTC Time and Date Synchronization
<>	144:ef7eb2e8f9f7	1295
<>	144:ef7eb2e8f9f7	1296	@endverbatim
<>	144:ef7eb2e8f9f7	1297	* @{
<>	144:ef7eb2e8f9f7	1298	*/
<>	144:ef7eb2e8f9f7	1299
<>	144:ef7eb2e8f9f7	1300	/**
<>	144:ef7eb2e8f9f7	1301	* @brief Waits until the RTC registers (RTC_CNT, RTC_ALR and RTC_PRL)
<>	144:ef7eb2e8f9f7	1302	* are synchronized with RTC APB clock.
<>	144:ef7eb2e8f9f7	1303	* @note This function must be called before any read operation after an APB reset
<>	144:ef7eb2e8f9f7	1304	* or an APB clock stop.
<>	144:ef7eb2e8f9f7	1305	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1306	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1307	* @retval HAL status
<>	144:ef7eb2e8f9f7	1308	*/
<>	144:ef7eb2e8f9f7	1309	HAL_StatusTypeDef HAL_RTC_WaitForSynchro(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	1310	{
AnnaBridge	165:e614a9f1c9e2	1311	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1312
<>	144:ef7eb2e8f9f7	1313	/* Check input parameters */
<>	144:ef7eb2e8f9f7	1314	if(hrtc == NULL)
<>	144:ef7eb2e8f9f7	1315	{
<>	144:ef7eb2e8f9f7	1316	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	1317	}
<>	144:ef7eb2e8f9f7	1318
<>	144:ef7eb2e8f9f7	1319	/* Clear RSF flag */
<>	144:ef7eb2e8f9f7	1320	CLEAR_BIT(hrtc->Instance->CRL, RTC_FLAG_RSF);
<>	144:ef7eb2e8f9f7	1321
<>	144:ef7eb2e8f9f7	1322	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1323
<>	144:ef7eb2e8f9f7	1324	/* Wait the registers to be synchronised */
<>	144:ef7eb2e8f9f7	1325	while((hrtc->Instance->CRL & RTC_FLAG_RSF) == (uint32_t)RESET)
<>	144:ef7eb2e8f9f7	1326	{
<>	144:ef7eb2e8f9f7	1327	if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1328	{
<>	144:ef7eb2e8f9f7	1329	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1330	}
<>	144:ef7eb2e8f9f7	1331	}
<>	144:ef7eb2e8f9f7	1332
<>	144:ef7eb2e8f9f7	1333	return HAL_OK;
<>	144:ef7eb2e8f9f7	1334	}
<>	144:ef7eb2e8f9f7	1335
<>	144:ef7eb2e8f9f7	1336	/**
<>	144:ef7eb2e8f9f7	1337	* @}
<>	144:ef7eb2e8f9f7	1338	*/
<>	144:ef7eb2e8f9f7	1339
<>	144:ef7eb2e8f9f7	1340
<>	144:ef7eb2e8f9f7	1341	/**
<>	144:ef7eb2e8f9f7	1342	* @}
<>	144:ef7eb2e8f9f7	1343	*/
<>	144:ef7eb2e8f9f7	1344
<>	144:ef7eb2e8f9f7	1345	/** @addtogroup RTC_Private_Functions
<>	144:ef7eb2e8f9f7	1346	* @{
<>	144:ef7eb2e8f9f7	1347	*/
<>	144:ef7eb2e8f9f7	1348
<>	144:ef7eb2e8f9f7	1349
<>	144:ef7eb2e8f9f7	1350	/**
<>	144:ef7eb2e8f9f7	1351	* @brief Read the time counter available in RTC_CNT registers.
<>	144:ef7eb2e8f9f7	1352	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1353	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1354	* @retval Time counter
<>	144:ef7eb2e8f9f7	1355	*/
AnnaBridge	188:bcfe06ba3d64	1356	uint32_t RTC_ReadTimeCounter(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	1357	{
AnnaBridge	165:e614a9f1c9e2	1358	uint16_t high1 = 0U, high2 = 0U, low = 0U;
AnnaBridge	165:e614a9f1c9e2	1359	uint32_t timecounter = 0U;
<>	144:ef7eb2e8f9f7	1360
<>	144:ef7eb2e8f9f7	1361	high1 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
<>	144:ef7eb2e8f9f7	1362	low = READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT);
<>	144:ef7eb2e8f9f7	1363	high2 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
<>	144:ef7eb2e8f9f7	1364
<>	144:ef7eb2e8f9f7	1365	if (high1 != high2)
<>	144:ef7eb2e8f9f7	1366	{ /* In this case the counter roll over during reading of CNTL and CNTH registers,
<>	144:ef7eb2e8f9f7	1367	read again CNTL register then return the counter value */
AnnaBridge	165:e614a9f1c9e2	1368	timecounter = (((uint32_t) high2 << 16U) \| READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT));
<>	144:ef7eb2e8f9f7	1369	}
<>	144:ef7eb2e8f9f7	1370	else
<>	144:ef7eb2e8f9f7	1371	{ /* No counter roll over during reading of CNTL and CNTH registers, counter
<>	144:ef7eb2e8f9f7	1372	value is equal to first value of CNTL and CNTH */
AnnaBridge	165:e614a9f1c9e2	1373	timecounter = (((uint32_t) high1 << 16U) \| low);
<>	144:ef7eb2e8f9f7	1374	}
<>	144:ef7eb2e8f9f7	1375
<>	144:ef7eb2e8f9f7	1376	return timecounter;
<>	144:ef7eb2e8f9f7	1377	}
<>	144:ef7eb2e8f9f7	1378
<>	144:ef7eb2e8f9f7	1379	/**
<>	144:ef7eb2e8f9f7	1380	* @brief Write the time counter in RTC_CNT registers.
<>	144:ef7eb2e8f9f7	1381	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1382	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1383	* @param TimeCounter: Counter to write in RTC_CNT registers
<>	144:ef7eb2e8f9f7	1384	* @retval HAL status
<>	144:ef7eb2e8f9f7	1385	*/
AnnaBridge	188:bcfe06ba3d64	1386	HAL_StatusTypeDef RTC_WriteTimeCounter(RTC_HandleTypeDef* hrtc, uint32_t TimeCounter)
<>	144:ef7eb2e8f9f7	1387	{
<>	144:ef7eb2e8f9f7	1388	HAL_StatusTypeDef status = HAL_OK;
AnnaBridge	188:bcfe06ba3d64	1389
<>	144:ef7eb2e8f9f7	1390	/* Set Initialization mode */
<>	144:ef7eb2e8f9f7	1391	if(RTC_EnterInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	1392	{
<>	144:ef7eb2e8f9f7	1393	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	1394	}
<>	144:ef7eb2e8f9f7	1395	else
<>	144:ef7eb2e8f9f7	1396	{
<>	144:ef7eb2e8f9f7	1397	/* Set RTC COUNTER MSB word */
AnnaBridge	165:e614a9f1c9e2	1398	WRITE_REG(hrtc->Instance->CNTH, (TimeCounter >> 16U));
<>	144:ef7eb2e8f9f7	1399	/* Set RTC COUNTER LSB word */
<>	144:ef7eb2e8f9f7	1400	WRITE_REG(hrtc->Instance->CNTL, (TimeCounter & RTC_CNTL_RTC_CNT));
<>	144:ef7eb2e8f9f7	1401
<>	144:ef7eb2e8f9f7	1402	/* Wait for synchro */
<>	144:ef7eb2e8f9f7	1403	if(RTC_ExitInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	1404	{
<>	144:ef7eb2e8f9f7	1405	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	1406	}
<>	144:ef7eb2e8f9f7	1407	}
<>	144:ef7eb2e8f9f7	1408
<>	144:ef7eb2e8f9f7	1409	return status;
<>	144:ef7eb2e8f9f7	1410	}
<>	144:ef7eb2e8f9f7	1411
<>	144:ef7eb2e8f9f7	1412	/**
<>	144:ef7eb2e8f9f7	1413	* @brief Read the time counter available in RTC_ALR registers.
<>	144:ef7eb2e8f9f7	1414	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1415	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1416	* @retval Time counter
<>	144:ef7eb2e8f9f7	1417	*/
<>	144:ef7eb2e8f9f7	1418	static uint32_t RTC_ReadAlarmCounter(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	1419	{
AnnaBridge	165:e614a9f1c9e2	1420	uint16_t high1 = 0U, low = 0U;
<>	144:ef7eb2e8f9f7	1421
<>	144:ef7eb2e8f9f7	1422	high1 = READ_REG(hrtc->Instance->ALRH & RTC_CNTH_RTC_CNT);
<>	144:ef7eb2e8f9f7	1423	low = READ_REG(hrtc->Instance->ALRL & RTC_CNTL_RTC_CNT);
<>	144:ef7eb2e8f9f7	1424
AnnaBridge	165:e614a9f1c9e2	1425	return (((uint32_t) high1 << 16U) \| low);
<>	144:ef7eb2e8f9f7	1426	}
<>	144:ef7eb2e8f9f7	1427
<>	144:ef7eb2e8f9f7	1428	/**
<>	144:ef7eb2e8f9f7	1429	* @brief Write the time counter in RTC_ALR registers.
<>	144:ef7eb2e8f9f7	1430	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1431	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1432	* @param AlarmCounter: Counter to write in RTC_ALR registers
<>	144:ef7eb2e8f9f7	1433	* @retval HAL status
<>	144:ef7eb2e8f9f7	1434	*/
<>	144:ef7eb2e8f9f7	1435	static HAL_StatusTypeDef RTC_WriteAlarmCounter(RTC_HandleTypeDef* hrtc, uint32_t AlarmCounter)
<>	144:ef7eb2e8f9f7	1436	{
<>	144:ef7eb2e8f9f7	1437	HAL_StatusTypeDef status = HAL_OK;
<>	144:ef7eb2e8f9f7	1438
<>	144:ef7eb2e8f9f7	1439	/* Set Initialization mode */
<>	144:ef7eb2e8f9f7	1440	if(RTC_EnterInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	1441	{
<>	144:ef7eb2e8f9f7	1442	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	1443	}
<>	144:ef7eb2e8f9f7	1444	else
<>	144:ef7eb2e8f9f7	1445	{
<>	144:ef7eb2e8f9f7	1446	/* Set RTC COUNTER MSB word */
AnnaBridge	165:e614a9f1c9e2	1447	WRITE_REG(hrtc->Instance->ALRH, (AlarmCounter >> 16U));
<>	144:ef7eb2e8f9f7	1448	/* Set RTC COUNTER LSB word */
<>	144:ef7eb2e8f9f7	1449	WRITE_REG(hrtc->Instance->ALRL, (AlarmCounter & RTC_ALRL_RTC_ALR));
<>	144:ef7eb2e8f9f7	1450
<>	144:ef7eb2e8f9f7	1451	/* Wait for synchro */
<>	144:ef7eb2e8f9f7	1452	if(RTC_ExitInitMode(hrtc) != HAL_OK)
<>	144:ef7eb2e8f9f7	1453	{
<>	144:ef7eb2e8f9f7	1454	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	1455	}
<>	144:ef7eb2e8f9f7	1456	}
<>	144:ef7eb2e8f9f7	1457
<>	144:ef7eb2e8f9f7	1458	return status;
<>	144:ef7eb2e8f9f7	1459	}
<>	144:ef7eb2e8f9f7	1460
<>	144:ef7eb2e8f9f7	1461	/**
<>	144:ef7eb2e8f9f7	1462	* @brief Enters the RTC Initialization mode.
<>	144:ef7eb2e8f9f7	1463	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1464	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1465	* @retval HAL status
<>	144:ef7eb2e8f9f7	1466	*/
<>	144:ef7eb2e8f9f7	1467	static HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	1468	{
AnnaBridge	165:e614a9f1c9e2	1469	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1470
<>	144:ef7eb2e8f9f7	1471	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1472	/* Wait till RTC is in INIT state and if Time out is reached exit */
<>	144:ef7eb2e8f9f7	1473	while((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
<>	144:ef7eb2e8f9f7	1474	{
<>	144:ef7eb2e8f9f7	1475	if((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1476	{
<>	144:ef7eb2e8f9f7	1477	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1478	}
<>	144:ef7eb2e8f9f7	1479	}
<>	144:ef7eb2e8f9f7	1480
<>	144:ef7eb2e8f9f7	1481	/* Disable the write protection for RTC registers */
<>	144:ef7eb2e8f9f7	1482	__HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
<>	144:ef7eb2e8f9f7	1483
<>	144:ef7eb2e8f9f7	1484
<>	144:ef7eb2e8f9f7	1485	return HAL_OK;
<>	144:ef7eb2e8f9f7	1486	}
<>	144:ef7eb2e8f9f7	1487
<>	144:ef7eb2e8f9f7	1488	/**
<>	144:ef7eb2e8f9f7	1489	* @brief Exit the RTC Initialization mode.
<>	144:ef7eb2e8f9f7	1490	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1491	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1492	* @retval HAL status
<>	144:ef7eb2e8f9f7	1493	*/
<>	144:ef7eb2e8f9f7	1494	static HAL_StatusTypeDef RTC_ExitInitMode(RTC_HandleTypeDef* hrtc)
<>	144:ef7eb2e8f9f7	1495	{
AnnaBridge	165:e614a9f1c9e2	1496	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1497
<>	144:ef7eb2e8f9f7	1498	/* Disable the write protection for RTC registers */
<>	144:ef7eb2e8f9f7	1499	__HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
<>	144:ef7eb2e8f9f7	1500
<>	144:ef7eb2e8f9f7	1501	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1502	/* Wait till RTC is in INIT state and if Time out is reached exit */
<>	144:ef7eb2e8f9f7	1503	while((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
<>	144:ef7eb2e8f9f7	1504	{
<>	144:ef7eb2e8f9f7	1505	if((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1506	{
<>	144:ef7eb2e8f9f7	1507	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1508	}
<>	144:ef7eb2e8f9f7	1509	}
<>	144:ef7eb2e8f9f7	1510
<>	144:ef7eb2e8f9f7	1511	return HAL_OK;
<>	144:ef7eb2e8f9f7	1512	}
<>	144:ef7eb2e8f9f7	1513
<>	144:ef7eb2e8f9f7	1514	/**
<>	144:ef7eb2e8f9f7	1515	* @brief Converts a 2 digit decimal to BCD format.
<>	144:ef7eb2e8f9f7	1516	* @param Value: Byte to be converted
<>	144:ef7eb2e8f9f7	1517	* @retval Converted byte
<>	144:ef7eb2e8f9f7	1518	*/
<>	144:ef7eb2e8f9f7	1519	static uint8_t RTC_ByteToBcd2(uint8_t Value)
<>	144:ef7eb2e8f9f7	1520	{
AnnaBridge	165:e614a9f1c9e2	1521	uint32_t bcdhigh = 0U;
<>	144:ef7eb2e8f9f7	1522
AnnaBridge	165:e614a9f1c9e2	1523	while(Value >= 10U)
<>	144:ef7eb2e8f9f7	1524	{
<>	144:ef7eb2e8f9f7	1525	bcdhigh++;
AnnaBridge	165:e614a9f1c9e2	1526	Value -= 10U;
<>	144:ef7eb2e8f9f7	1527	}
<>	144:ef7eb2e8f9f7	1528
AnnaBridge	165:e614a9f1c9e2	1529	return ((uint8_t)(bcdhigh << 4U) \| Value);
<>	144:ef7eb2e8f9f7	1530	}
<>	144:ef7eb2e8f9f7	1531
<>	144:ef7eb2e8f9f7	1532	/**
<>	144:ef7eb2e8f9f7	1533	* @brief Converts from 2 digit BCD to Binary.
<>	144:ef7eb2e8f9f7	1534	* @param Value: BCD value to be converted
<>	144:ef7eb2e8f9f7	1535	* @retval Converted word
<>	144:ef7eb2e8f9f7	1536	*/
<>	144:ef7eb2e8f9f7	1537	static uint8_t RTC_Bcd2ToByte(uint8_t Value)
<>	144:ef7eb2e8f9f7	1538	{
AnnaBridge	165:e614a9f1c9e2	1539	uint32_t tmp = 0U;
AnnaBridge	165:e614a9f1c9e2	1540	tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10U;
<>	144:ef7eb2e8f9f7	1541	return (tmp + (Value & (uint8_t)0x0F));
<>	144:ef7eb2e8f9f7	1542	}
<>	144:ef7eb2e8f9f7	1543
<>	144:ef7eb2e8f9f7	1544	/**
<>	144:ef7eb2e8f9f7	1545	* @brief Updates date when time is 23:59:59.
<>	144:ef7eb2e8f9f7	1546	* @param hrtc pointer to a RTC_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1547	* the configuration information for RTC.
<>	144:ef7eb2e8f9f7	1548	* @param DayElapsed: Number of days elapsed from last date update
<>	144:ef7eb2e8f9f7	1549	* @retval None
<>	144:ef7eb2e8f9f7	1550	*/
<>	144:ef7eb2e8f9f7	1551	static void RTC_DateUpdate(RTC_HandleTypeDef* hrtc, uint32_t DayElapsed)
<>	144:ef7eb2e8f9f7	1552	{
AnnaBridge	165:e614a9f1c9e2	1553	uint32_t year = 0U, month = 0U, day = 0U;
AnnaBridge	165:e614a9f1c9e2	1554	uint32_t loop = 0U;
<>	144:ef7eb2e8f9f7	1555
<>	144:ef7eb2e8f9f7	1556	/* Get the current year*/
<>	144:ef7eb2e8f9f7	1557	year = hrtc->DateToUpdate.Year;
<>	144:ef7eb2e8f9f7	1558
<>	144:ef7eb2e8f9f7	1559	/* Get the current month and day */
<>	144:ef7eb2e8f9f7	1560	month = hrtc->DateToUpdate.Month;
<>	144:ef7eb2e8f9f7	1561	day = hrtc->DateToUpdate.Date;
<>	144:ef7eb2e8f9f7	1562
AnnaBridge	165:e614a9f1c9e2	1563	for (loop = 0U; loop < DayElapsed; loop++)
<>	144:ef7eb2e8f9f7	1564	{
AnnaBridge	165:e614a9f1c9e2	1565	if((month == 1U) \|\| (month == 3U) \|\| (month == 5U) \|\| (month == 7U) \|\| \
AnnaBridge	165:e614a9f1c9e2	1566	(month == 8U) \|\| (month == 10U) \|\| (month == 12U))
<>	144:ef7eb2e8f9f7	1567	{
AnnaBridge	165:e614a9f1c9e2	1568	if(day < 31U)
<>	144:ef7eb2e8f9f7	1569	{
<>	144:ef7eb2e8f9f7	1570	day++;
<>	144:ef7eb2e8f9f7	1571	}
<>	144:ef7eb2e8f9f7	1572	/* Date structure member: day = 31 */
<>	144:ef7eb2e8f9f7	1573	else
<>	144:ef7eb2e8f9f7	1574	{
AnnaBridge	165:e614a9f1c9e2	1575	if(month != 12U)
<>	144:ef7eb2e8f9f7	1576	{
<>	144:ef7eb2e8f9f7	1577	month++;
AnnaBridge	165:e614a9f1c9e2	1578	day = 1U;
<>	144:ef7eb2e8f9f7	1579	}
<>	144:ef7eb2e8f9f7	1580	/* Date structure member: day = 31 & month =12 */
<>	144:ef7eb2e8f9f7	1581	else
<>	144:ef7eb2e8f9f7	1582	{
AnnaBridge	165:e614a9f1c9e2	1583	month = 1U;
AnnaBridge	165:e614a9f1c9e2	1584	day = 1U;
<>	144:ef7eb2e8f9f7	1585	year++;
<>	144:ef7eb2e8f9f7	1586	}
<>	144:ef7eb2e8f9f7	1587	}
<>	144:ef7eb2e8f9f7	1588	}
AnnaBridge	165:e614a9f1c9e2	1589	else if((month == 4U) \|\| (month == 6U) \|\| (month == 9U) \|\| (month == 11U))
<>	144:ef7eb2e8f9f7	1590	{
AnnaBridge	165:e614a9f1c9e2	1591	if(day < 30U)
<>	144:ef7eb2e8f9f7	1592	{
<>	144:ef7eb2e8f9f7	1593	day++;
<>	144:ef7eb2e8f9f7	1594	}
<>	144:ef7eb2e8f9f7	1595	/* Date structure member: day = 30 */
<>	144:ef7eb2e8f9f7	1596	else
<>	144:ef7eb2e8f9f7	1597	{
<>	144:ef7eb2e8f9f7	1598	month++;
AnnaBridge	165:e614a9f1c9e2	1599	day = 1U;
<>	144:ef7eb2e8f9f7	1600	}
<>	144:ef7eb2e8f9f7	1601	}
AnnaBridge	165:e614a9f1c9e2	1602	else if(month == 2U)
<>	144:ef7eb2e8f9f7	1603	{
AnnaBridge	165:e614a9f1c9e2	1604	if(day < 28U)
<>	144:ef7eb2e8f9f7	1605	{
<>	144:ef7eb2e8f9f7	1606	day++;
<>	144:ef7eb2e8f9f7	1607	}
AnnaBridge	165:e614a9f1c9e2	1608	else if(day == 28U)
<>	144:ef7eb2e8f9f7	1609	{
<>	144:ef7eb2e8f9f7	1610	/* Leap year */
<>	144:ef7eb2e8f9f7	1611	if(RTC_IsLeapYear(year))
<>	144:ef7eb2e8f9f7	1612	{
<>	144:ef7eb2e8f9f7	1613	day++;
<>	144:ef7eb2e8f9f7	1614	}
<>	144:ef7eb2e8f9f7	1615	else
<>	144:ef7eb2e8f9f7	1616	{
<>	144:ef7eb2e8f9f7	1617	month++;
AnnaBridge	165:e614a9f1c9e2	1618	day = 1U;
<>	144:ef7eb2e8f9f7	1619	}
<>	144:ef7eb2e8f9f7	1620	}
AnnaBridge	165:e614a9f1c9e2	1621	else if(day == 29U)
<>	144:ef7eb2e8f9f7	1622	{
<>	144:ef7eb2e8f9f7	1623	month++;
AnnaBridge	165:e614a9f1c9e2	1624	day = 1U;
<>	144:ef7eb2e8f9f7	1625	}
<>	144:ef7eb2e8f9f7	1626	}
<>	144:ef7eb2e8f9f7	1627	}
<>	144:ef7eb2e8f9f7	1628
<>	144:ef7eb2e8f9f7	1629	/* Update year */
<>	144:ef7eb2e8f9f7	1630	hrtc->DateToUpdate.Year = year;
<>	144:ef7eb2e8f9f7	1631
<>	144:ef7eb2e8f9f7	1632	/* Update day and month */
<>	144:ef7eb2e8f9f7	1633	hrtc->DateToUpdate.Month = month;
<>	144:ef7eb2e8f9f7	1634	hrtc->DateToUpdate.Date = day;
<>	144:ef7eb2e8f9f7	1635
<>	144:ef7eb2e8f9f7	1636	/* Update day of the week */
<>	144:ef7eb2e8f9f7	1637	hrtc->DateToUpdate.WeekDay = RTC_WeekDayNum(year, month, day);
<>	144:ef7eb2e8f9f7	1638	}
<>	144:ef7eb2e8f9f7	1639
<>	144:ef7eb2e8f9f7	1640	/**
<>	144:ef7eb2e8f9f7	1641	* @brief Check whether the passed year is Leap or not.
<>	144:ef7eb2e8f9f7	1642	* @param nYear year to check
<>	144:ef7eb2e8f9f7	1643	* @retval 1: leap year
<>	144:ef7eb2e8f9f7	1644	* 0: not leap year
<>	144:ef7eb2e8f9f7	1645	*/
<>	144:ef7eb2e8f9f7	1646	static uint8_t RTC_IsLeapYear(uint16_t nYear)
<>	144:ef7eb2e8f9f7	1647	{
AnnaBridge	165:e614a9f1c9e2	1648	if((nYear % 4U) != 0U)
<>	144:ef7eb2e8f9f7	1649	{
AnnaBridge	165:e614a9f1c9e2	1650	return 0U;
<>	144:ef7eb2e8f9f7	1651	}
<>	144:ef7eb2e8f9f7	1652
AnnaBridge	165:e614a9f1c9e2	1653	if((nYear % 100U) != 0U)
<>	144:ef7eb2e8f9f7	1654	{
AnnaBridge	165:e614a9f1c9e2	1655	return 1U;
<>	144:ef7eb2e8f9f7	1656	}
<>	144:ef7eb2e8f9f7	1657
AnnaBridge	165:e614a9f1c9e2	1658	if((nYear % 400U) == 0U)
<>	144:ef7eb2e8f9f7	1659	{
AnnaBridge	165:e614a9f1c9e2	1660	return 1U;
<>	144:ef7eb2e8f9f7	1661	}
<>	144:ef7eb2e8f9f7	1662	else
<>	144:ef7eb2e8f9f7	1663	{
AnnaBridge	165:e614a9f1c9e2	1664	return 0U;
<>	144:ef7eb2e8f9f7	1665	}
<>	144:ef7eb2e8f9f7	1666	}
<>	144:ef7eb2e8f9f7	1667
<>	144:ef7eb2e8f9f7	1668	/**
<>	144:ef7eb2e8f9f7	1669	* @brief Determines the week number, the day number and the week day number.
<>	144:ef7eb2e8f9f7	1670	* @param nYear year to check
<>	144:ef7eb2e8f9f7	1671	* @param nMonth Month to check
<>	144:ef7eb2e8f9f7	1672	* @param nDay Day to check
<>	144:ef7eb2e8f9f7	1673	* @note Day is calculated with hypothesis that year > 2000
<>	144:ef7eb2e8f9f7	1674	* @retval Value which can take one of the following parameters:
<>	144:ef7eb2e8f9f7	1675	* @arg RTC_WEEKDAY_MONDAY
<>	144:ef7eb2e8f9f7	1676	* @arg RTC_WEEKDAY_TUESDAY
<>	144:ef7eb2e8f9f7	1677	* @arg RTC_WEEKDAY_WEDNESDAY
<>	144:ef7eb2e8f9f7	1678	* @arg RTC_WEEKDAY_THURSDAY
<>	144:ef7eb2e8f9f7	1679	* @arg RTC_WEEKDAY_FRIDAY
<>	144:ef7eb2e8f9f7	1680	* @arg RTC_WEEKDAY_SATURDAY
<>	144:ef7eb2e8f9f7	1681	* @arg RTC_WEEKDAY_SUNDAY
<>	144:ef7eb2e8f9f7	1682	*/
<>	144:ef7eb2e8f9f7	1683	static uint8_t RTC_WeekDayNum(uint32_t nYear, uint8_t nMonth, uint8_t nDay)
<>	144:ef7eb2e8f9f7	1684	{
AnnaBridge	165:e614a9f1c9e2	1685	uint32_t year = 0U, weekday = 0U;
<>	144:ef7eb2e8f9f7	1686
AnnaBridge	165:e614a9f1c9e2	1687	year = 2000U + nYear;
<>	144:ef7eb2e8f9f7	1688
AnnaBridge	165:e614a9f1c9e2	1689	if(nMonth < 3U)
<>	144:ef7eb2e8f9f7	1690	{
<>	144:ef7eb2e8f9f7	1691	/D = { [(23 x month)/9] + day + 4 + year + [(year-1)/4] - [(year-1)/100] + [(year-1)/400] } mod 7/
AnnaBridge	165:e614a9f1c9e2	1692	weekday = (((23U * nMonth)/9U) + nDay + 4U + year + ((year-1U)/4U) - ((year-1U)/100U) + ((year-1U)/400U)) % 7U;
<>	144:ef7eb2e8f9f7	1693	}
<>	144:ef7eb2e8f9f7	1694	else
<>	144:ef7eb2e8f9f7	1695	{
<>	144:ef7eb2e8f9f7	1696	/D = { [(23 x month)/9] + day + 4 + year + [year/4] - [year/100] + [year/400] - 2 } mod 7/
AnnaBridge	165:e614a9f1c9e2	1697	weekday = (((23U * nMonth)/9U) + nDay + 4U + year + (year/4U) - (year/100U) + (year/400U) - 2U ) % 7U;
<>	144:ef7eb2e8f9f7	1698	}
<>	144:ef7eb2e8f9f7	1699
<>	144:ef7eb2e8f9f7	1700	return (uint8_t)weekday;
<>	144:ef7eb2e8f9f7	1701	}
<>	144:ef7eb2e8f9f7	1702
<>	144:ef7eb2e8f9f7	1703	/**
<>	144:ef7eb2e8f9f7	1704	* @}
<>	144:ef7eb2e8f9f7	1705	*/
<>	144:ef7eb2e8f9f7	1706
<>	144:ef7eb2e8f9f7	1707	#endif /* HAL_RTC_MODULE_ENABLED */
<>	144:ef7eb2e8f9f7	1708	/**
<>	144:ef7eb2e8f9f7	1709	* @}
<>	144:ef7eb2e8f9f7	1710	*/
<>	144:ef7eb2e8f9f7	1711
<>	144:ef7eb2e8f9f7	1712	/**
<>	144:ef7eb2e8f9f7	1713	* @}
<>	144:ef7eb2e8f9f7	1714	*/
<>	144:ef7eb2e8f9f7	1715
<>	144:ef7eb2e8f9f7	1716	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/