WebSVN – canSerial – Blame – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_rtc.c

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

Subversion Repositories canSerial

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_rtc.c – Rev 3